ErrorEventsImpl.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \brief
/// Implementation of class ErrorEvents.
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

#include "TestToolBox/ErrorEvents.h"
#include "TestToolBox/Synchronizer.h"

///\cond do not document

namespace TestToolBox
{


//************************************************************************
// Implementation of class ErrorEvent
//************************************************************************


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvent<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::ReportChildError (int in_indentation)
{
    ErrorList::iterator it;
    for (ErrorList::iterator it = m_listOfChildErrors.begin();
         it != m_listOfChildErrors.end(); ++it)
    {
        HandlingInstruction instruct =
            ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::Get()->GetHandlingInstruction (*it);
        if (instruct.m_notificationAction != ACTION_IGNORE)
        {
            std::string errInfoTxt;
            for (int i = 1; i<= in_indentation; ++i)
                errInfoTxt += " ";
            errInfoTxt += (*it).GetDescription();
            TestEvents::Get()->Act(errInfoTxt);
        }

        (*it).ReportChildError(in_indentation+2);
    }
}



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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
bool ErrorEvent<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::FindExtErrorId (
    ErrorId                       inExtErrorId,
    typename ErrorList::iterator& out_rIt,
    ErrorList*&                   out_rpErrorList)
{
    bool found = false;
    for (ErrorList::iterator it = m_listOfChildErrors.begin();
        it != m_listOfChildErrors.end(); ++it)
    {
        if ((*it).m_externalErrorId == inExtErrorId)
        {
            out_rIt = it;
            out_rpErrorList = &m_listOfChildErrors;
            found = true;
            break;
        }
    }

    if (!found) // search within child errors
    {
        for (ErrorList::iterator it = m_listOfChildErrors.begin();
            it != m_listOfChildErrors.end(); ++it)
        {
            found =(*it).FindExtErrorId(inExtErrorId, out_rIt, out_rpErrorList);
            if (found) break;
        }
    }
    return found;
}


//************************************************************************
// Implementation of class ErrorEvents
//************************************************************************

template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::ErrorEvents (void)
    :
    m_errorList                     (),
    m_immediateLog                  (true),
    m_syncOnError                   (false),
    m_deleteStoredErrorsAfterReport (true),
    m_defaultHandlingInstruction    (ACTION_ERROR_CONTINUE_TEST_CASE)
    {}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::SetNotificationActionForErrorMsgNum (
        long               in_errorMsgNum,
        NotificationAction in_notificationAction)
{
    AutoLock o (this);
    m_instructionForErrorMsgNum[in_errorMsgNum].m_notificationAction= in_notificationAction;
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::IgnoreErrorContainingTextPattern (
        std::string const & in_text)
{
    AutoLock o (this);
    m_errorTextPatternsToIgnore.insert(in_text);
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::ClearStoredTextPatterns (void)
{
    AutoLock o (this);
    m_errorTextPatternsToIgnore.clear();
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::CreateError (
    std::string const & in_rDescription,
    long                in_errMsgNum    = 0,
    ErrorId             in_extErrorId   = ErrorId(),
    long                in_intErrorId   = 0,
    Category            in_category     = Category(),
    Severity            in_severity     = Severity())
{
    AutoLock o (this);

    ErrorEventType error (in_rDescription,in_errMsgNum,
        in_extErrorId, in_intErrorId, in_category, in_severity);
    m_errorList.push_back(error);

    HandlingInstruction instruct =
        GetHandlingInstruction (error);
    // Process error if not to ignore
    if (instruct.m_notificationAction != ACTION_IGNORE)
    {
        // Generate immediate log entry if configured
        if (m_immediateLog)
        {
            TestEvents::Get()->Info("Error-Info: " + error.GetDescription());
        }

        // Generate sync event if configured
        if (m_syncOnError)
        {
                TTB_SYNC();
        }
    }
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::AddAsChildError (
    ErrorId inExtErrorIdParent,
    ErrorId inExtErrorIdChild)
{
    AutoLock o (this);

    ErrorEventType childError;
    // Extract child error from where ever it is stored
    // first search within the first level errors
    typename ErrorList::iterator itChild;
    ErrorList* pErrorListChild;

    if (FindExtErrorId(inExtErrorIdChild, itChild,pErrorListChild))
    {
        childError = *itChild;
        pErrorListChild->erase(itChild);

        typename ErrorList::iterator itParent;
        ErrorList* pErrorListParent;
        if (FindExtErrorId(inExtErrorIdParent, itParent,pErrorListParent))
        {
            itParent->m_listOfChildErrors.push_back(childError);
        }
    }
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::ReportStoredErrors (void)
{
    AutoLock o (this);

    if (m_errorList.empty())
    {
        TestEvents::Get()->Act("No errors stored");
    }
    else // there are stored errors
    {
        ErrorList::iterator it;
        for (ErrorList::iterator it = m_errorList.begin();
             it != m_errorList.end(); ++it)
        {
            HandlingInstruction instruct =
                GetHandlingInstruction (*it);
            if (instruct.m_notificationAction != ACTION_IGNORE)
            {
// Weitere unterscheidung nach Art der Aufzeichnung/Abbruch des Testfalles hier ergänzen!!!!!!!!!!!
                TestEvents::Get()->Act((*it).GetDescription());
            }
            (*it).ReportChildError(2);
        }

        if (m_deleteStoredErrorsAfterReport)
        {
            m_errorList.clear();
        }

    }
}

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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
void ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::DeleteStoredErrors (void)
{
    AutoLock o (this);
    m_errorList.clear();
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
bool ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::ErrorOk (
    T_ERROR_ID in_extErrorId)
{
    if (in_extErrorId == T_ERROR_ID()) // no error
    {
        return true;
    }
    else // error detected
    {
        AutoLock o (this);
        ErrorList::iterator itErrList;
        ErrorList* pErrorList;
        bool found = FindExtErrorId(in_extErrorId, itErrList, pErrorList);
        if (found)
        {
            TestEvents::Get()->Act((*itErrList).GetDescription());
            (*itErrList).ReportChildError(2);
        }
        return false;
    }
}


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


template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
bool ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::FindExtErrorId (
    ErrorId                       inExtErrorId,
    typename ErrorList::iterator& out_rIt,
    ErrorList*&                   out_rpErrorList)
{
    bool found = false;
    for (ErrorList::iterator it = m_errorList.begin();
        it != m_errorList.end(); ++it)
    {
        if ((*it).m_externalErrorId == inExtErrorId)
        {
            out_rIt = it;
            out_rpErrorList = &m_errorList;
            found = true;
            break;
        }
    }

    if (!found) // search within child errors
    {
        for (ErrorList::iterator it = m_errorList.begin();
            it != m_errorList.end(); ++it)
        {
            found =(*it).FindExtErrorId(inExtErrorId, out_rIt, out_rpErrorList);
            if (found) break;
        }
    }

    return found;
}


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

template<typename T_CATEGORY, typename T_ERROR_ID,typename T_SEVERITY>
HandlingInstruction ErrorEvents<T_CATEGORY,T_ERROR_ID,T_SEVERITY>::GetHandlingInstruction (
        typename ErrorEventType const & in_rErrorEvent)
{
    HandlingInstruction instructionErrorId;
    HandlingInstruction instructionCategory;
    HandlingInstruction instructionSeverity;

    // Check for error text pattern
    for (std::set<std::string>::iterator itPattern = m_errorTextPatternsToIgnore.begin();
        itPattern != m_errorTextPatternsToIgnore.end(); ++itPattern)
    {
        if (in_rErrorEvent.m_description.find(*itPattern)!=std::string::npos)
        {
            // error contains defined text pattern
            return HandlingInstruction(ACTION_IGNORE);
        }
    }
    
    // Check for error message numbers
    std::map<long,HandlingInstruction>::iterator posErrorMsgNum
        = m_instructionForErrorMsgNum.find(in_rErrorEvent.m_errorMsgNum);
    if (posErrorMsgNum != m_instructionForErrorMsgNum.end())
    {
        instructionErrorId = m_instructionForErrorMsgNum[in_rErrorEvent.m_errorMsgNum];
        return instructionErrorId;
    }

    // Hier noch ergänzen: Abfrage Category/Severity, resultierendes Handling ermitteln

    return m_defaultHandlingInstruction;
}

}; // namespace TestToolBox

///\endcond

// end of file ErrorEvents.cpp

---