TestEventsImpl.h

Go to the documentation of this file.

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

#pragma once

#include "assert.h"
#include <set>
#include <vector>
#include <iostream>
#include <iomanip>
using namespace std;

#include "TestToolBox/TestEvents.h"
#include "TestToolBox/CheckerForMultipleSequences.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
{
    class TestEvents;


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


TTB_INLINE TestEvents::TestEvents():
    m_firstError                (),
    m_events                    (),
    m_curCheckPos               (0),
    m_active                    (true),
    m_curTestStillOk            (true),
    m_numPerformedTests         (0),
    m_numFailedTests            (0),
    m_descCurrentTest           (),
    m_detailedLog               (false),
    m_detailedCheckLog          (false),
    m_pIEventReceiver           (0),
    m_pIProtocol                (0),
    m_checkType                 (CheckType::eNOT_SET),
    m_doublePrecision           (6),
    m_checkForUnexpected        (true),
    m_widthCommandNameInLogFile (20),
    S_UNEXPECTED_EVENTS         ("Unexpected Events"),
    S_EVENT_NOT_FOUND           ("Event not found: "),
    S_EXPECTED                  ("Expected : "),
    S_FOUND                     ("Found    : "),
    S_SEPARATOR_LINE_1          ("================================================================================"),
    S_SEPARATOR_LINE_2          ("------------------------------------------------------------------------")
{
    m_pCheckerForMultipleSequences = new CheckerForMultipleSequences(*this);

} // TestEvents::TestEvents


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


TTB_INLINE TestEvents::~TestEvents()
{
    TRCF("TestEvents::~TestEvents");
    TRC(TL_DEBUG, "Destructor");
    CheckForUnexpectedEvents("Context: automatic check within ~TestEvents");

    if (m_pIProtocol)
    {
        m_pIProtocol->WriteFooter();

        long numTests;
        long numFailedTests;
        std::string result1, result2;
        GetTestResult (numTests, numFailedTests, result1, result2);

        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_ALL);
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_ALL, "Tests performed : " + ToString(numTests));
        m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, "Tests failed    : " + ToString(numFailedTests));
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_ALL);

        if (numFailedTests > 0)
        {
            m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, "First error in  : ");
            if (!result1.empty())
            {
                m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, result1);
            }

            if (!result2.empty())
            {
                m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, result2);
            }
        }
        else
        {
            m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, "No error detected!");
        }
    }

    m_pIEventReceiver = 0;
    delete m_pCheckerForMultipleSequences;

} // TestEvents::~TestEvents


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


TTB_INLINE void TestEvents::Act (const char* in_actualEvent, ...)
{
    UTIL_GET_FORMATTED_LINE_NO_NEWLINE (in_actualEvent);
    std::string eventStr = formattedLine;
    if (!m_eventPrefix.empty())
    {
        eventStr = m_eventPrefix + "(" + eventStr + ");";
    }
    TestEvents::Get()->AddTestEvent(eventStr);

} // TestEvents::Act


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


TTB_INLINE void TestEvents::ActualResult (const char* in_actualEvent, ...)
{
    UTIL_GET_FORMATTED_LINE_NO_NEWLINE (in_actualEvent);
    TestEvents::Get()->AddTestEvent(formattedLine);

} // TestEvents::ActualResult


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


TTB_INLINE EventPosition TestEvents::ExpectResult(
    const char* in_fileName,
    const long  in_lineNum,
    const char* in_expectedEvent, ...)
{
    // Format string with expected results
    UTIL_GET_FORMATTED_LINE_NO_NEWLINE (in_expectedEvent);

    return ExpectResultInternal(in_fileName, in_lineNum, formattedLine,
        m_checkType != CheckType::eNOT_SET
        ? m_checkType
        : CheckType::eSTRICT);

} // TestEvents::ExpectResult


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


TTB_INLINE EventPosition TestEvents::ExpectResultSequential(
    const char* in_fileName,
    const long  in_lineNum,
    const char* in_expectedEvent, ...)
{
    // Format string with expected results
    UTIL_GET_FORMATTED_LINE_NO_NEWLINE (in_expectedEvent);

    return ExpectResultInternal(in_fileName, in_lineNum, formattedLine, CheckType::eSEQUENTIAL);

} // TestEvents::ExpectResultSequential


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


TTB_INLINE EventPosition TestEvents::ExpectResultVariable(
    const char* in_fileName,
    const long  in_lineNum,
    const char* in_expectedEvent, ...)
{
    // Format string with expected results
    UTIL_GET_FORMATTED_LINE_NO_NEWLINE (in_expectedEvent);

    return ExpectResultInternal(in_fileName, in_lineNum, formattedLine, CheckType::eVARIABLE);

} // TestEvents::ExpectResultVariable


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


TTB_INLINE void TestEvents::CheckForUnexpectedEvents (
    const char* in_context,
    const char* in_fileName,
    const long  in_lineNum)
{
    AutoLock o (this);

    if (!m_checkForUnexpected) return; // check is executed only once!
    m_checkForUnexpected = false;

    std::string errMsg;
    if (!CheckForUnexpectedEvents (errMsg))
    {
        std::ostringstream fullInfoStr;

        fullInfoStr << "\n!!" << S_UNEXPECTED_EVENTS << std::endl;
        // Format location information to support automatic jumping to source
        // code within Visual Studio.
        AddFileNameAndLineNumber (fullInfoStr, in_fileName, in_lineNum);

        fullInfoStr << " (" << in_context << ") " ;
        fullInfoStr << errMsg <<std::endl;

        if (m_pIEventReceiver)
        {
                    m_pIEventReceiver->Event (TestToolBox::CTX_UNEXPECTED_EVENTS, fullInfoStr. str());
        }

        // Write to protocol if protocol exists
        if (m_pIProtocol)
        {
            m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, fullInfoStr. str());
        }

        // in case of error generate full list of stored elements
        ListAllStoredEvents();
    }

} // TestEvents::CheckForUnexpectedEvents


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


TTB_INLINE void TestEvents::ResetCurrentCheckPosition (void)
{
    m_curCheckPos = 0;
    IncrementCurPos();
}

TTB_INLINE void TestEvents::SetCurrentCheckPosition (
    int in_newPos)
{
    m_curCheckPos = static_cast<Events::size_type>(in_newPos);
    IncrementCurPos();
}

TTB_INLINE int TestEvents::GetCurrentCheckPosition (void)
{
    return static_cast<int>(m_curCheckPos);
}

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


TTB_INLINE void TestEvents::ListAllStoredEvents (
    const char*     in_fileName,
    const long      in_lineNum,
    CheckType::Enum in_checkType)
{
    AutoLock o (this);

    std::ostringstream outStr;

    outStr << "List of stored TestEvents (current check position = "
        << m_curCheckPos;
    if (in_checkType == CheckType::eNOT_SET)
    {
        outStr << ", for checkType see last EXP macro, m_checkType=" << GetCheckTypeAsText(m_checkType) << ") ";
    }
    else
    {
        outStr << ", used checkType = " << GetCheckTypeAsText(in_checkType) << ") " << endl;
    }

    // Format location information to support automatic jumping to source
    // code within Visual Studio.
    if (in_fileName)
    {
        AddFileNameAndLineNumber (outStr, in_fileName, in_lineNum);
        outStr << " (call location)" << endl;
    }

    std::string eventList;
    ListAllStoredEvents(eventList);
    outStr << eventList;

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

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

} // TestEvents::ListAllStoredEvents


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


TTB_INLINE void TestEvents::ClearAllStoredEvents (void)
{
    m_events.clear();

} // TestEvents::ClearAllStoredEvents


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


TTB_INLINE std::string TestEvents::GetCheckTypeAsText (CheckType::Enum in_checkType)
{
    switch (in_checkType)
    {
        case CheckType::eNOT_SET:
            return "eNOT_SET";
            break;
        case CheckType::eSTRICT:
            return "eSTRICT";
            break;
        case CheckType::eSEQUENTIAL:
            return "eSEQUENTIAL";
            break;
        case CheckType::eVARIABLE:
            return "eVARIABLE";
            break;
        default:
            return "unknown";
            break;
    }

} // TestEvents::GetCheckTypeAsText


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


TTB_INLINE void TestEvents::DefineSequence (std::string const & in_nameSequence)
{
    SetCheckType(CheckType::eMULTIPLE_SEQUENCES);
    m_pCheckerForMultipleSequences->DefineSequence(in_nameSequence);
}

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

TTB_INLINE void TestEvents::StoreExpectedEventWithinSelectedSequence(
    std::string const & in_expectedEvent,
    const char*         in_fileName,
    const long          in_lineNum)
{
    m_pCheckerForMultipleSequences->StoreExpectedEventWithinSelectedSequence(
        in_expectedEvent, in_fileName, in_lineNum);
}

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

TTB_INLINE void TestEvents::CheckDefinedSequences(
    const char* in_fileName,
    const long  in_lineNum)
{
    m_pCheckerForMultipleSequences->CheckDefinedSequences(in_fileName, in_lineNum);
    SetCheckType(CheckType::eNOT_SET);
}

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

TTB_INLINE void TestEvents::SetDetailedLogSequences (
    bool in_detailedLog)
{
    m_pCheckerForMultipleSequences->SetDetailedLog(in_detailedLog);
}

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


TTB_INLINE bool TestEvents::CheckCondition (
    const char*         in_fileName,
    const long          in_lineNum,
    std::string const & in_expressionAsText,
    bool                in_expressionValue)
{
    bool errorFound = !in_expressionValue;

    DisplayCheckInfo (
        in_fileName, in_lineNum,
        "CheckCondition", errorFound,
        in_expressionAsText, ToString(in_expressionValue));

    return errorFound;

} // TestEvents::CheckCondition


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


TTB_INLINE bool TestEvents::CheckEqual(
    const char* in_fileName,
    const long  in_lineNum,
    std::string const & leftAsText,
    double const &   left,
    std::string const & rightAsText,
    double const &   right)
{
    // format double to string and compare the resulting strings
    std::ostringstream leftStr;
    std::ostringstream rightStr;

    leftStr << std::fixed << std::setprecision(m_doublePrecision) << left;
    rightStr << std::fixed << std::setprecision(m_doublePrecision) << right;

    std::string leftValAsText = leftStr.str();
    std::string rightValAsText = rightStr.str();

    bool errorFound = (leftValAsText != rightValAsText);

    DisplayCheckInfo (in_fileName, in_lineNum,
        "CheckEqual", errorFound,
        leftAsText, leftValAsText, rightAsText, rightValAsText,
        "==",
        "specialization for double, precision is " + ToString (m_doublePrecision));

    return errorFound;

} // TestEvents::CheckEqual<double>


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


TTB_INLINE void TestEvents::StartNewTestCase (
    const std::string& in_rDescTestCase)
{
    AutoLock o (this);

    // Increment test counter
    ++m_numPerformedTests;

    TRCF("TestEvents::StartNewTestCase");
    TRC(TL_PROD, "=================================================="
                  "==============================");
    TRC(TL_PROD, "Test %d: %s", m_numPerformedTests,
                   in_rDescTestCase.c_str());
    TRC(TL_PROD, "=================================================="
                  "==============================");
    if (m_pIProtocol)
    {
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_OUTFILE);
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_OUTFILE, S_SEPARATOR_LINE_1);
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_ALL, "Test: " + in_rDescTestCase); // also write to stdout and report file
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_OUTFILE, S_SEPARATOR_LINE_1);
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_OUTFILE);
    }

    // Store test description
    m_descCurrentTest = in_rDescTestCase;

    // Clear events array
    m_events.clear();

    // Reset position
    m_curCheckPos = 0;

    // Reactivate verification
    m_active = true;

    // Currently no error has been detected within this test case
    m_curTestStillOk = true;

} // TestEvents::StartNewTestCase


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


TTB_INLINE void TestEvents::Command (
    std::string const & in_cmd,
    std::string const & in_params)
{
    if (m_detailedLog)
    {
        if (m_pIEventReceiver)
        {
            std::string cmdStr = in_cmd;
            if (!in_params.empty())
            {
                cmdStr += " " + in_params;
            }
            m_pIEventReceiver->Event (CTX_INFO, "Cmd: " + cmdStr);
        }

        // Write to protocol if protocol exists
        if (m_pIProtocol)
        {
            std::ostringstream oss;
            oss << std::setw(m_widthCommandNameInLogFile) << std::left << in_cmd;
            if (!in_params.empty())
            {
                oss << " " << in_params;
            }

            m_pIProtocol->SetMode(OutputMode::M_OUTFILE);
            m_pIProtocol->Writeln();
            m_pIProtocol->Writeln("<" + oss.str());
        }
    }

} // TestEvents::Command


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


TTB_INLINE void TestEvents::Info (
    std::string const & in_info)
{
    if (m_detailedLog)
    {
        if (m_pIEventReceiver)
        {
            m_pIEventReceiver->Event (CTX_INFO, in_info);
        }

        // Write to protocol if protocol exists
        if (m_pIProtocol)
        {
            m_pIProtocol->SetMode(OutputMode::M_OUTFILE);
            m_pIProtocol->Writeln(in_info);
        }
    }

} // TestEvents::Info


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

    
TTB_INLINE void TestEvents::Section (
    std::string const & in_sectionName)
{
    if (m_detailedLog)
    {
        if (m_pIEventReceiver)
        {
            m_pIEventReceiver->Event (CTX_INFO, "Section: " + in_sectionName);
        }

        // Write to protocol if protocol exists
        if (m_pIProtocol)
        {
            m_pIProtocol->SetMode(OutputMode::M_OUTFILE);
            m_pIProtocol->Writeln();
            m_pIProtocol->Writeln(S_SEPARATOR_LINE_2);
            m_pIProtocol->Writeln("Section: " + in_sectionName);
            m_pIProtocol->Writeln(S_SEPARATOR_LINE_2);
        }
    }

} // TestEvents::Section


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


TTB_INLINE void TestEvents::GenerateErrorMessage (
    const char*         in_fileName,
    const long          in_lineNum,
    std::string const & in_errorInfo)
{
    std::ostringstream fullInfoStr;

    // Format location information to support automatic jumping to source
    // code within Visual Studio.
    AddFileNameAndLineNumber (fullInfoStr, in_fileName, in_lineNum);
    fullInfoStr << " (call location of error)" << std::endl;
    fullInfoStr << in_errorInfo;
    if (m_pIEventReceiver)
    {
        m_pIEventReceiver->Event (fullInfoStr. str());
    }

    // Write to protocol if protocol exists
    if (m_pIProtocol)
    {
        m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, "\n!!Error at location\n" + fullInfoStr. str());
    }
    StoreError (in_errorInfo, "");

} // TestEvents::GenerateErrorMessage


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


TTB_INLINE bool TestEvents::CheckForUnexpectedEvents (
    std::string&      out_rResult)
{
    AutoLock o (this);

    bool unexpectedEventFound = false;
    out_rResult               = "";

    // Check for unexpected test events only if verification is still
    // active for this test case (i.e. no error has been found in test
    // case)
    if (m_active)
    {
        for (Events::iterator i = m_events.begin(); i < m_events .end();
             ++i)
        {
            if (!i->first) // event was not expected
            {
                if (!unexpectedEventFound)
                {
                    unexpectedEventFound = true;
                    out_rResult = "unexpected events:";
                }
                out_rResult += '\n';
                out_rResult += i->second;
            }
        }
    }

    if (unexpectedEventFound)
    {
        StoreError (out_rResult, "");
    }

    return !unexpectedEventFound;

} // TestEvents::CheckForUnexpectedEvents


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


TTB_INLINE void TestEvents::ListAllStoredEvents (
    std::string&       out_rListOfEvents)
{
    out_rListOfEvents = "";
 
    // Check for unexpected test events only if verification is still
    // active for this test case (i.e. no error has been found in test
    // case)
    std::ostringstream outListStr;
    if (m_events.empty())
    {
        outListStr << "No TestEvents stored!" << endl;
    }

    for (Events::iterator i = m_events.begin(); i < m_events .end();
         ++i)
    {
        int eventIdx = static_cast<int>(std::distance(m_events.begin(), i));
        WriteEventEntry(eventIdx, outListStr);
    }
    if (m_curCheckPos >= m_events.size())
    {
        outListStr << "##" << std::endl;
    }
    outListStr << std::endl;

    out_rListOfEvents = outListStr.str();

} // TestEvents::ListAllStoredEvents


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


TTB_INLINE void TestEvents::AddTestEvent(
    const std::string& in_rEvent)
{
    AutoLock o (this);

    m_events.push_back (std::make_pair (false, in_rEvent));

    if (m_detailedLog)
    {
        std::ostringstream outStr;

        if (!m_actLogPrefix.empty())
            outStr << m_actLogPrefix + "(\"";

        outStr << in_rEvent;

        if (!m_actLogPrefix.empty())
            outStr << "\");";

        // write to some other target (e.g. BOOST macro)
        if (m_pIEventReceiver)
        {
                    m_pIEventReceiver->Event (TestToolBox::CTX_INFO, "Act: " + outStr. str());
        }

        // Write to protocol if protocol exists
        if (m_pIProtocol)
        {
            m_pIProtocol->SetMode(OutputMode::M_OUTFILE);
            if (m_actLogPrefix.empty())
            {
                m_pIProtocol->Writeln(">" + outStr. str());
            }
            else
            {
                m_pIProtocol->Writeln(outStr. str());
            }
        }
    }

    // After adding a new event entry another check may be useful
    m_checkForUnexpected = true;

} // TestEvents::AddEvent();


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


TTB_INLINE EventPosition TestEvents::CheckForTestEvent(
    const std::string& in_rEvent,
    std::string&       out_rResult1,
    std::string&       out_rResult2)
{
    AutoLock o (this);

    m_positionOfLastEvent.Reset();
    bool errorFound = true;
    out_rResult1    = "";
    out_rResult2    = "";

    if (!m_active)
    {
        // skip verification of this event, but assume correct behaviour
        errorFound = false;
        m_positionOfLastEvent = EventPosition(99999);  // invalid pos signalling no additional error
        return m_positionOfLastEvent;
    }
    else if (m_curCheckPos >= m_events .size()) // no more entries available
    {
        out_rResult1 = S_EVENT_NOT_FOUND + in_rEvent;
    }
    else // entry is available
    {
        if (m_events [m_curCheckPos]. first) // marked as expected from
        {                               // preceeding compare
            out_rResult1 = "Internal error (compare algorithm "
                "has an error). Expected: " + in_rEvent;
        }
        else // not yet marked as expected
        {
            if (m_events [m_curCheckPos] .second == in_rEvent) // no differences
            {
                // mark as expected
                m_events [m_curCheckPos] .first = true;
                m_positionOfLastEvent = m_curCheckPos;

                IncrementCurPos();

                // no error found
                errorFound = false;
            }
            else // differences found
            {
                out_rResult1 = S_EXPECTED + in_rEvent;
                out_rResult2 = S_FOUND + m_events [m_curCheckPos] .second;
            }
        }
    }

    // After an error has been found deactivate verification of following
    // test events
    if (errorFound)
    {
        m_active = false;
        StoreError (out_rResult1, out_rResult2);
    }

    return m_positionOfLastEvent;

} // TestEvents::CheckForTestEvent


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


TTB_INLINE EventPosition TestEvents::CheckForTestEventSequential (
    const std::string& in_rEvent,
    std::string&       out_rResult1,
    std::string&       out_rResult2)
{
    AutoLock o (this);

    m_positionOfLastEvent.Reset();
    bool errorFound = true;
    out_rResult1    = "";
    out_rResult2    = "";

    if (!m_active)
    {
        // skip verification of this event, assume correct behaviour
        errorFound = false;
        m_positionOfLastEvent = EventPosition(99999); // invalid pos signalling no additional error
        return m_positionOfLastEvent;
    }
    else // search the event in the whole event array after the current position
    {
        Events::size_type pos        = m_curCheckPos;
        bool              eventFound = false;
        while ((!eventFound) && pos < m_events .size())
        {
            if    ((!m_events [pos] .first) // entry not used in
                                            // former compares
               && (m_events [pos] .second == in_rEvent))
            {                               // expected event found
                eventFound = true;

                // mark as expected
                m_events [pos] .first = true;
                m_positionOfLastEvent = pos;

                // increment current position because following sequential
                // checks are related to the found position
                m_curCheckPos = pos;
                IncrementCurPos();
            }
            else
            {
                ++pos;
            }
        }

        if (eventFound)
        {
            // no error found
            errorFound = false;
        }
        else
        {
            out_rResult1 = S_EVENT_NOT_FOUND + in_rEvent;
        }

    }

    // After an error has been found dectivate verification of following
    // test events
    if (errorFound)
    {
        m_active = false;
        StoreError (out_rResult1, out_rResult2);
    }

    return m_positionOfLastEvent;

} // TestEvents::CheckForTestEventSequential


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


TTB_INLINE EventPosition TestEvents::CheckForTestEventVariable (
    const std::string& in_rEvent,
    std::string&       out_rResult1,
    std::string&       out_rResult2)
{
    AutoLock o (this);

    m_positionOfLastEvent.Reset();
    bool errorFound = true;
    out_rResult1    = "";
    out_rResult2    = "";

    if (!m_active)
    {
        // skip verification of this event, assume correct behaviour
        errorFound = false;
        m_positionOfLastEvent = EventPosition(99999); // invalid pos signalling no additional error
        return m_positionOfLastEvent;
    }
    else // search the event in the whole event array
    {
        Events::size_type pos        = 0;
        bool              eventFound = false;
        while ((!eventFound) && pos < m_events .size())
        {
            if    ((!m_events [pos] .first) // entry not used in
                                            // former compares
               && (m_events [pos] .second == in_rEvent))
            {                               // expected event found
                eventFound = true;

                // mark as expected
                m_events [pos] .first = true;

                m_positionOfLastEvent = pos;
            }
            else
            {
                ++pos;
            }
        }

        if (eventFound)
        {
            // no error found
            errorFound = false;

            // increment current position if the entry was found at the
            // position which is used for regular compares with
            // CheckForTestEvent.
            if (pos == m_curCheckPos)
            {
                IncrementCurPos();
            }
        }
        else
        {
            out_rResult1 = S_EVENT_NOT_FOUND + in_rEvent;
        }

    }

    // After an error has been found dectivate verification of following
    // test events
    if (errorFound)
    {
        m_active = false;
        StoreError (out_rResult1, out_rResult2);
    }

    return m_positionOfLastEvent;

} // TestEvents::CheckForTestEventVariable


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


TTB_INLINE bool TestEvents::GetTestResult (
    long&        out_rNumPerformedTests,
    long&        out_rNumFailedTests,
    std::string& out_rDescFirstFailedTest,
    std::string& out_rDescError)
{
    AutoLock o (this);

    out_rNumPerformedTests = m_numPerformedTests;
    out_rNumFailedTests    = m_numFailedTests;

    if (m_firstError .m_exists)
    {
        // Get string representation for index of first failed test
        std::ostringstream tmpStr;
        tmpStr << m_firstError .m_idxFirstFailedTest;
        out_rDescFirstFailedTest = "Test " + tmpStr. str();

        // Add test description
        out_rDescFirstFailedTest += " / " +
            m_firstError .m_descFirstFailedTest;

        // Get error description
        out_rDescError = m_firstError .m_descError;
    }

    return out_rNumFailedTests == 0;

} // TestEvents::GetTestResult


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


TTB_INLINE void TestEvents::Reset (void)
{
    AutoLock o (this);

    // Initially there is no error
    m_firstError.m_exists = false;
    
    // Clear events array
    m_events.clear();

    // Reset position
    m_curCheckPos = 0;

    // Reactivate verification
    m_active = true;

    // Currently no error has been detected within this test case
    m_curTestStillOk = true;

    // Reset number of tests
    m_numPerformedTests = 0;
    m_numFailedTests    = 0;

    // Reset test description
    m_descCurrentTest = "";

    m_checkForUnexpected = true;

} // TestEvents::Reset


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


TTB_INLINE void TestEvents::IncrementCurPos (void)
{
    AutoLock o (this);

    // This position may already have been checked with use
    // of CheckForTestEventVariable. Therefore search next
    // item which is not checked.
    while (    (m_curCheckPos < m_events .size())
            && (m_events [m_curCheckPos]. first))
        ++m_curCheckPos;

} // TestEvents::IncrementCurPos


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


TTB_INLINE void TestEvents::StoreError (
    const std::string& in_rErrStr1,
    const std::string& in_rErrStr2)
{
    // Store the description of the first error
    if (!m_firstError. m_exists)
    {
        m_firstError. m_exists = true;
        m_firstError. m_idxFirstFailedTest  = m_numPerformedTests;
        m_firstError. m_descFirstFailedTest = m_descCurrentTest;
        m_firstError. m_descError = in_rErrStr1; 
        if (!in_rErrStr2 .empty())
        {
            m_firstError. m_descError += '\n' + in_rErrStr2;
        }
    }

    // Increment the number of failed tests
    if (m_curTestStillOk)
    {
        m_curTestStillOk = false;
        ++m_numFailedTests;
    }

} // TestEvents::StoreError


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


TTB_INLINE EventPosition TestEvents::ExpectResultInternal(
    const char*     in_fileName,
    const long      in_lineNum,
    const char*     in_formattedResult,
    CheckType::Enum in_checkType)
{
    AutoLock o (this);

    EventPosition eventPos;
    std::string result1, result2;
    bool testOk = false;
    switch (in_checkType)
    {
        case CheckType::eSTRICT:
            eventPos = CheckForTestEvent (in_formattedResult, result1, result2);
            break;
        case CheckType::eSEQUENTIAL:
            eventPos = CheckForTestEventSequential (in_formattedResult, result1, result2);
            break;
        case CheckType::eMULTIPLE_SEQUENCES:
            StoreExpectedEventWithinSelectedSequence (in_formattedResult, in_fileName, in_lineNum);
            eventPos = 0; // simulate successful check; real check will follow later;
            break;
        case CheckType::eVARIABLE:
            eventPos = CheckForTestEventVariable (in_formattedResult, result1, result2);
            break;
    }

    testOk = eventPos.IsOk();

    // output only in case of error
    if (!testOk)
    {
        std::ostringstream fullInfoStr;

        // Format location information to support automatic jumping to source
        // code within Visual Studio.
        AddFileNameAndLineNumber (fullInfoStr, in_fileName, in_lineNum);
        fullInfoStr << " (call location of error)" << endl;

        if (!result1.empty())
        {
            fullInfoStr << result1  << endl;
        }
        if (!result2.empty())
        {
            fullInfoStr << result2;
        }
                if (m_pIEventReceiver)
        {
                    m_pIEventReceiver->Event (fullInfoStr. str());
        }

        // Write to protocol if protocol exists
        if (m_pIProtocol)
        {
            m_pIProtocol->Writeln(OutputLevel::eERROR, OutputMode::M_ALL, "\n!!Error at location\n" + fullInfoStr. str());
        }

        // in case of error generate full list of stored elements
        ListAllStoredEvents(0, 0, in_checkType);
    }

    return eventPos;

} // TestEvents::ExpectResultInternal


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


TTB_INLINE void TestEvents::DisplayCheckInfo (
    const char*         in_fileName,
    const long          in_lineNum,
    std::string const & in_checkType,
    bool                in_checkFailed,
    std::string const & in_paramLeftAsText,
    std::string const & in_paramValLeftAsText,
    std::string const & in_paramRightAsText,
    std::string const & in_paramValRightAsText,
    std::string const & in_compareOpAsText,
    std::string const & in_paramTypeAsText)
{
    std::ostringstream infoStr;
    infoStr << in_checkType
        << (in_checkFailed ? " NOT OK: "  : " Ok:  ")
        << in_paramLeftAsText << " (=" << in_paramValLeftAsText << ")";

    if (!in_compareOpAsText.empty())
    {
        infoStr << "  " << in_compareOpAsText;
    }
    if (!in_paramValRightAsText.empty())
    {
        infoStr << "  " << in_paramRightAsText << " (=" << in_paramValRightAsText << ")";
    }

    if (!in_paramTypeAsText.empty())
    {
        infoStr
            << ",  used type: "
            << in_paramTypeAsText;
    }
    infoStr << std::endl;

    if (in_checkFailed)
    {
        if (!in_paramValRightAsText.empty())
        {
            // in case of error repeat param values for better comparing
            infoStr
                << "left : " << std::setw(15) << in_paramValLeftAsText << std::setw(15) << "  (" << in_paramLeftAsText << ")"  << std::endl
                << "right: " << std::setw(15) << in_paramValRightAsText << std::setw(15) << "  (" << in_paramRightAsText << ")" << std::endl;
        }
        GenerateErrorMessage (in_fileName, in_lineNum, infoStr.str());
    }
    else if (m_detailedCheckLog && m_pIProtocol)
    {
        m_pIProtocol->Writeln(OutputLevel::eREGULAR, OutputMode::M_OUTFILE, infoStr. str());
    }

} // TestEvents::DisplayCheckInfo


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


TTB_INLINE void TestEvents::WriteEventEntry (
    int                  in_idxEvent,
    std::ostringstream & io_stream,
    std::string const &  in_prefix)
{
    io_stream << in_prefix;

    if (in_idxEvent == m_curCheckPos)
    {
        io_stream << "## ";
    }
    else
    {
        io_stream << "   ";
    }
    io_stream
        << (m_events[in_idxEvent].first ? "Ok " : " ? " ) 
        << std::setw(3) << in_idxEvent
        << ": " << m_events[in_idxEvent].second << endl;

} // TestEvents::WriteEventEntry


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

}; // namespace TestToolBox

#include "TestToolBox\CheckerForMultipleSequencesImpl.h"

///\endcond

// end of file TestEventsImpl.h

#pragma warning( pop )

---