CheckerForMultipleSequences.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \sa CheckerForMultipleSequences.h (File documentation)
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once


//************************************************************************
//      P r e c o m p i l e r   I n c l u d e   D i r e c t i v e s
//************************************************************************

#include <string>

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

namespace TestToolBox
{
    // forward declarations
    class CheckerForMultipleSequences;
    class TestEvents;

    /// Class which checks if the set of recorded events matches with the expectations
    /// concerning several sequences of events which may interfere one another
    class CheckerForMultipleSequences
    {
    public:

        CheckerForMultipleSequences(TestEvents & in_rTestEvents);

        /// \brief Define and select a sequence for which expected events may follow
        /// in the expected order.
        void DefineSequence (std::string const & in_nameSequence);

        /// Define the next expected event for the currently selected sequence
        void StoreExpectedEventWithinSelectedSequence(
            std::string const & in_expectedEvent,
            const char*         in_fileName,
            const long          in_lineNum);

        /// \brief Check if the event sequences defined by DefineSequence() and subsequent
        /// calls to TTB_EXP()/StoreExpectedEventWithinSelectedSequence() match with the
        /// sequence of recorded events
        void CheckDefinedSequences (
            const char* in_fileName = 0,
            const long  in_lineNum  = 0);

        /// Clear all stored sequences
        void ResetAll();

        /// Log results of checking multiple sequences even when check was successful
        void SetDetailedLog (bool in_detailedLog)
        {m_detailedLog = in_detailedLog;}

    private:
        struct SequenceEntry;
        struct EventEntry
        {
            EventEntry(
                std::string const & in_eventTxt,
                int                 in_idxSequence,
                int                 in_idxEvent,
                const char*         in_fileName,
                const long          in_lineNum)
                : m_eventTxt      (in_eventTxt)
                , m_eventPosition (-1)
                , m_idxSequence   (in_idxSequence)
                , m_idxEvent      (in_idxEvent)
                , m_fileName      (const_cast<char*>(in_fileName))
                , m_lineNum       (in_lineNum)
            {}

            /// textual contents of the event
            std::string    m_eventTxt;

            /// \brief  found position of the defined event within the vector
            /// of recorded events
            int            m_eventPosition;

            /// index of the sequence within which the event is defined
            int            m_idxSequence;

            /// index of the event within the corresponding sequence
            int            m_idxEvent;

            /// file location where the event was defined for the sequence
            char*          m_fileName;
            long           m_lineNum;
        };
        typedef std::vector<EventEntry> EventEntries;

        struct SequenceEntry
        {
            SequenceEntry (std::string const & in_nameSequence)
                : m_name (in_nameSequence)
            {}
            ~SequenceEntry()
            {
            }

            /// name of the sequence
            std::string m_name;

            /// vector of events
            EventEntries m_events;
        };

        typedef std::vector<SequenceEntry> SequenceEntries;

        struct SearchInfo
        {
            SearchInfo()
                : idxSequence     (0)
                , idxEvent        (0)
                , eventPos        (0)
                , searchSucceeded (false)
                , searchFailed    (false)
                , undoLastMatch   (false)
            {}

            /// Index of the sequence to be checked as next
            int idxSequence;

            /// Index of the event to be checked as next
            int idxEvent;

            /// continue searching at this position within vector of recorded events
            int eventPos;

            /// flag indicating whether for all sequences a match was found
            bool searchSucceeded;

            /// flag indicating whether there is no match existing
            bool searchFailed;

            /// \brief flag indiocating whether the last match has to be cleared to try
            /// for other matches
            bool undoLastMatch;
        };

        /// Access to controlling instance of TestEvents
        TestEvents& m_rTestEvents;

        /// \brief Defined sequences of events to be checked
        /// for sequential order
        SequenceEntries m_sequences;

        //*** Used for trying all combinations:

        /// \brief Indices of recorded events which have already been reserved for possible
        /// matches to defined sequence events
        std::set<int> m_attachedIndices;

        /// Correlation from recorded events to possible match within sequence events
        std::vector<EventEntry*> m_recEv2SeqEv;

        // in case of error the best matches (those with the highest number of matching events)
        // are written to protocol
        SequenceEntries m_sequencesBestMatch;
        std::vector<EventEntry*> m_recEv2SeqEvBestMatch;
        int m_numBestMatches;

        // flag indicating whether positive matches are written to protocol
        bool m_detailedLog;

    private:

        void CheckNextMatch (SearchInfo & io_searchInfo);
        void UndoLastMatch (SearchInfo & io_searchInfo);
        void MarkRecordedEventsAsChecked (void);
        int FindNextUncheckedPos (int in_startPos);
        bool FindFirstUnmatchedEvent(
            std::string & out_eventText,
            std::string & out_fileName,
            long &        out_lineNum);
        void LogCheckResult(std::string const & in_headLine);

    }; // class CheckerForMultipleSequences

}; // namespace TestToolBox


#pragma warning( pop )

/// @} // endGrpTestEvents

---