CheckerForMultipleSequencesImpl.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \brief
/// Implementation of class CheckerForMultipleSequences
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

#include <set>
#include <vector>
#include <iostream>
#include <iomanip>
using namespace std;

#include "TestToolBox/CheckerForMultipleSequences.h"
#include "TestToolBox/TestEvents.h"
#include "TestToolBox/IEventReceiver.h"
#include "TestToolBox/IProtocol.h"

#pragma warning( push )
#pragma warning( disable : 4996 ) // vsprintf declared deprecated

///\cond do not document

// Switch to use as inline code (to be included in each cpp file)
// or as regular functions to be compiled within a lib or e.g. within stdafx.cpp
#ifdef TTB_NOT_INLINE
    #define TTB_INLINE
#else
    #define TTB_INLINE inline
#endif

namespace TestToolBox
{
    // Width for entries of the form SomeSequEv-12
    const int WIDTH_SEQUENTIAL_ID = 15;
    const char* SEQUENTIAL_ID_EMPTY = "               ";

    class TestEvents;


//************************************************************************
//************************************************************************


TTB_INLINE CheckerForMultipleSequences::CheckerForMultipleSequences(
    TestEvents & in_rTestEvents)
    : m_rTestEvents    (in_rTestEvents)
    , m_numBestMatches (0)
    , m_detailedLog    (true)
{}


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::DefineSequence (
    std::string const & in_nameSequence)
{
    m_sequences.push_back(SequenceEntry(in_nameSequence));

} // CheckerForMultipleSequences::DefineSequence


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::StoreExpectedEventWithinSelectedSequence(
    std::string const & in_expectedEvent,
    const char*         in_fileName,
    const long          in_lineNum)
{
    m_sequences.back().m_events.push_back(EventEntry(
        in_expectedEvent,
        LastIndex(m_sequences), NumElements(m_sequences.back().m_events),
        in_fileName, in_lineNum));
}


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::CheckDefinedSequences (
        const char* in_fileName,
        const long  in_lineNum)
{
    AutoLock o (&m_rTestEvents); // synchronize with insertion of new events

    SearchInfo searchInfo;

    // Init control vector with 0
    m_recEv2SeqEv.resize(m_rTestEvents.m_events.size(),0);

    // Try all combinations until failure or success is detected
    while (!searchInfo.searchSucceeded && !searchInfo.searchFailed)
    {
        CheckNextMatch(searchInfo);
        if (searchInfo.searchFailed) break;

        if (searchInfo.undoLastMatch)
        {
            UndoLastMatch(searchInfo);
        }
    }

    if (searchInfo.searchSucceeded)
    {
        MarkRecordedEventsAsChecked();
    }

    if (searchInfo.searchFailed)
    {
        // build final error message

        std::ostringstream fullInfoStr;

        // Set best matches to show possible problems
        m_sequences = m_sequencesBestMatch;
        m_recEv2SeqEv = m_recEv2SeqEvBestMatch;

        std::string eventTxt;
        std::string fileName;
        long lineNum;
        if (FindFirstUnmatchedEvent(eventTxt, fileName, lineNum))
        {
            fullInfoStr << "\nNo match found for:\n" << eventTxt << endl;
            AddFileNameAndLineNumber (fullInfoStr, fileName.c_str(), lineNum);
            fullInfoStr << " (call location of error)" << endl;
        }

        fullInfoStr << "\nCheckForMultipleSequences failed:" << endl;
        AddFileNameAndLineNumber (fullInfoStr, in_fileName, in_lineNum);
        fullInfoStr << " (call location of error)" << endl;

        if (m_rTestEvents.m_pIEventReceiver)
        {
                    m_rTestEvents.m_pIEventReceiver->Event (fullInfoStr. str());
        }

        // Write to protocol if protocol exists
        if (m_rTestEvents.m_pIProtocol)
        {
            m_rTestEvents.m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL,
                "\n!!Error - CheckForMultipleSequences\n" + fullInfoStr. str());
        }
        m_rTestEvents.m_active = false; // suppress further error messages for the test case
        m_rTestEvents.StoreError (fullInfoStr.str(), "");
    }

    if (searchInfo.searchFailed || m_detailedLog)
    {
        LogCheckResult(searchInfo.searchFailed
            ? "\nTestEvents with best match of multiple sequences:"
            : std::string(in_fileName) + " (" + ToString(in_lineNum) + ")\n"
              + "CheckForMultipleSequences - Found all matches:");
    }

    ResetAll();

} // CheckerForMultipleSequences::CheckDefinedSequences


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::ResetAll (void)
{
    m_sequences.clear();
    m_attachedIndices.clear();
    m_recEv2SeqEv.clear();
    m_sequencesBestMatch.clear();
    m_recEv2SeqEvBestMatch.clear();
    m_numBestMatches = 0;

} // CheckerForMultipleSequences::ResetAll


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::CheckNextMatch (
    SearchInfo & io_searchInfo)
{
    // Start index where to start searching within recorded events
    int startPos = io_searchInfo.eventPos;

    if (startPos >= static_cast<int>(NumElements(m_rTestEvents.m_events)))
    {
        if ((io_searchInfo.idxSequence == 0) && (io_searchInfo.idxEvent == 0))
        {
            // event could not be found after eventPos
            io_searchInfo.searchFailed = true;
        }
        else
        {
            io_searchInfo.searchSucceeded = false;
            io_searchInfo.undoLastMatch = true;
        }
        return;
    }

    // Search next item which is not checked and which
    // is identical to the defined sequence event
    int curPos = startPos;
    bool entryFound = false;
    curPos = FindNextUncheckedPos(curPos);

    while (!entryFound && curPos < NumElements(m_rTestEvents.m_events))
    {
        if (m_rTestEvents.m_events[curPos].second == m_sequences[io_searchInfo.idxSequence].
            m_events[io_searchInfo.idxEvent].m_eventTxt)
        {
            entryFound = true;

            m_attachedIndices.insert(curPos);
            m_recEv2SeqEv[curPos]=&m_sequences[io_searchInfo.idxSequence].
                 m_events[io_searchInfo.idxEvent];
            m_sequences[io_searchInfo.idxSequence].
                m_events[io_searchInfo.idxEvent].m_eventPosition = curPos;

            // next match must be found after the current position
            io_searchInfo.eventPos = curPos+1;

            if (m_numBestMatches < NumElements(m_attachedIndices))
            {
                m_numBestMatches = NumElements(m_attachedIndices);
                m_sequencesBestMatch = m_sequences;
                m_recEv2SeqEvBestMatch = m_recEv2SeqEv;
            }
        }
        else // try next position
        {
            curPos = FindNextUncheckedPos(curPos+1);
        }
    }

    if (entryFound)
    {
        io_searchInfo.idxEvent++;
        if (io_searchInfo.idxEvent >= NumElements(m_sequences[io_searchInfo.idxSequence].m_events))
        {
            // switch to next sequence
            io_searchInfo.idxSequence++;
            io_searchInfo.idxEvent = 0;
            io_searchInfo.eventPos = 0; // next sequence may start at beginning of events

            if (io_searchInfo.idxSequence >= NumElements(m_sequences))
            {
                // we have reached the end of all sequences
                io_searchInfo.searchSucceeded = true;
            }
        }
    }
    else // try to cancel preceding attachments to check for other combinations
    {
        io_searchInfo.undoLastMatch = true;
    }

} // CheckerForMultipleSequences::CheckNextMatch


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::UndoLastMatch (SearchInfo & io_searchInfo)
{
    // Roll back one step
    if ((io_searchInfo.idxSequence == 0) && (io_searchInfo.idxEvent == 0))
    {
        // there is no rollback possible, we are at the first entry
        io_searchInfo.searchFailed = true;
    }
    else
    {
        if (io_searchInfo.idxEvent > 0)
        {
            --io_searchInfo.idxEvent;
        }
        else // switch back to last entry of preceding sequence
        {
            --io_searchInfo.idxSequence;  
            io_searchInfo.idxEvent = LastIndex(m_sequences[io_searchInfo.idxSequence].m_events);
        }

        // Now undo found matches for this entry
        int attachedIdx = m_sequences[io_searchInfo.idxSequence].
              m_events[io_searchInfo.idxEvent].m_eventPosition;

        m_attachedIndices.erase(attachedIdx);
        m_recEv2SeqEv[attachedIdx] = 0;
        m_sequences[io_searchInfo.idxSequence].
          m_events[io_searchInfo.idxEvent].m_eventPosition = -1;

        // continue searching starting with the next position
        io_searchInfo.eventPos = attachedIdx +1;
    }

    io_searchInfo.undoLastMatch = false;

} // CheckerForMultipleSequences::UndoLastMatch


//************************************************************************
//************************************************************************


TTB_INLINE int CheckerForMultipleSequences::FindNextUncheckedPos (int in_startPos)
{
    int curPos = in_startPos;

    while (    (curPos < NumElements(m_rTestEvents.m_events))
            && (    (m_rTestEvents.m_events [curPos]. first) // already checked by other means
                 || (m_attachedIndices.count(curPos))))      // already attached by check for multiple sequences
        ++curPos;

    return curPos;

} // CheckerForMultipleSequences::FindNextUncheckedPos


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::MarkRecordedEventsAsChecked (void)
{
    AutoLock o (&m_rTestEvents);

    int idxRecordedEvents = 0;

    for (SequenceEntries::iterator itSeq = m_sequences.begin();
        itSeq != m_sequences.end(); ++itSeq)
    {
        for (EventEntries::iterator itEv = itSeq->m_events.begin();
            itEv != itSeq->m_events.end(); ++itEv)
        {
            // Mark the event as successfully checked
            m_rTestEvents.m_events[itEv->m_eventPosition].first = true;
        }
    }

}  // CheckerForMultipleSequences::LogCheckResult


//************************************************************************
//************************************************************************


TTB_INLINE bool CheckerForMultipleSequences::FindFirstUnmatchedEvent(
    std::string & out_eventText,
    std::string & out_fileName,
    long &        out_lineNum)
{
    out_eventText = "";
    out_fileName = "";
    out_lineNum = 0;

    for (SequenceEntries::iterator itSeq = m_sequences.begin();
        itSeq != m_sequences.end(); ++itSeq)
    {
        for (EventEntries::iterator itEv = itSeq->m_events.begin();
            itEv != itSeq->m_events.end(); ++itEv)
        {
            if (itEv->m_eventPosition < 0)
            {
                out_eventText = "Sequence: " + itSeq->m_name 
                              + "\nEvent   : " + itEv->m_eventTxt;
                out_fileName = itEv->m_fileName;
                out_lineNum = itEv->m_lineNum;
                return true;
            }
        }
    }
    return false;

} // CheckerForMultipleSequences::FindFirstUnmatchedEvent


//************************************************************************
//************************************************************************


TTB_INLINE void CheckerForMultipleSequences::LogCheckResult (std::string const & in_headLine)
{
    AutoLock o (&m_rTestEvents);

    std::ostringstream outStr;

    outStr <<  in_headLine << std::endl << std::endl;

    for (int idxRecEv = 0; idxRecEv < NumElements(m_rTestEvents.m_events); ++idxRecEv)
    {
        EventEntry* pSeqEv = m_recEv2SeqEv[idxRecEv];
        if (pSeqEv) // there is an atteched sequential event
        {
            std::ostringstream seqIdStr;
            seqIdStr << m_sequences[pSeqEv->m_idxSequence].m_name << "-" << pSeqEv->m_idxEvent;
            outStr << std::left << std::setw(WIDTH_SEQUENTIAL_ID) << seqIdStr.str();
            m_rTestEvents.WriteEventEntry(idxRecEv, outStr);
        }
        else // no attached sequential event
        {
            m_rTestEvents.WriteEventEntry(idxRecEv, outStr, SEQUENTIAL_ID_EMPTY);
        }
    }

    if (m_rTestEvents.m_pIEventReceiver)
    {
            m_rTestEvents.m_pIEventReceiver->Event (TestToolBox::CTX_INFO, outStr. str());
    }

    // Write to protocol if protocol exists
    if (m_rTestEvents.m_pIProtocol)
    {
        m_rTestEvents.m_pIProtocol->SetMode(OutputMode::M_OUTFILE);
        m_rTestEvents.m_pIProtocol->Writeln();
        m_rTestEvents.m_pIProtocol->Writeln(outStr. str());
    }

}  // CheckerForMultipleSequences::LogCheckResult


//************************************************************************
//************************************************************************


}; // namespace TestToolBox

///\endcond

// end of file CheckerForMultipleSequencesImpl.h

#pragma warning( pop )

---