ExtensionsForBoostTest/BoostDefaultTestEnvironment.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \defgroup GrpEnvironmentForBoostTest Using TestEnvironmentForBoost
/// @{
/// \ingroup GrpTestUtils 
/// \brief
/// Provides tools to support several test problems when running tests
///  based on Boost.Test library.
///
/// \n The supported features are:
/// 
/// - synchronisation of test execution running within
///   several threads
/// 
/// - automatic verification of asynchronously occured events
///   which may be in fixed or non deterministic order
/// 
/// - catching and verifying error objects emitted from the
///   system under test, support for filtering and error trees
///
/// \sa BoostDefaultTestEnvironment.h (File documentation)
/// \sa TestToolBox::AutoSetupDefaultTestEnv (class documentation)
/// \sa TestToolBox::AutoSetupTestEnvWithErrors (class documentation)
/// \sa GrpTestExtensionsForBoostTest (unit test using boost.Test and ErrorEvents)
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

#include "TestToolBox/SynchronizerImpl.h"
#include "TestToolBox/EnvironmentImpl.h"
#include "TestToolBox/TestEventsImpl.h"
#include "TestToolBox/ErrorEventsImpl.h"
#include "TestToolBox/ProtocolImpl.h"
#include "TestToolBox/TestTimeImpl.h"
#include "TestToolBox/ExtensionsForBoostTest/BoostEventReceiverForSynchronizer.h"
#include "TestToolBox/ExtensionsForBoostTest/BoostEventReceiverForTestEvents.h"

#include <iostream>

#include <boost/thread.hpp>

namespace TestToolBox
{


/// Test environment with support for synchronisation and asynchronous test events
class AutoSetupDefaultTestEnv
{
///\cond

public:

    // Default constructor, always using (possibly already existing) protocol file
    AutoSetupDefaultTestEnv()
    : m_cleanupTestEvents (true)
    , m_cleanupProtocol   (true)
    {
            Synchronizer::Get()->
            ConnectWithEventReceiver(&m_eventReceiverForSynchronizer);
        TestEvents::Get()->
            ConnectWithEventReceiver(&m_eventReceiverForTestEvents);
        TestEvents::Get()->
            ConnectWithProtocol (Protocol::Get());
    }

    /// Constructor allowing use of externally controlled protocol file
    /// with possibly longer lifetime than the DefaultTestEnvironment
    AutoSetupDefaultTestEnv(
        IProtocol* in_pProtocol)
    : m_cleanupTestEvents (true)
    , m_cleanupProtocol   (false)
    {
            Synchronizer::Get()->
            ConnectWithEventReceiver(&m_eventReceiverForSynchronizer);
        TestEvents::Get()->
            ConnectWithEventReceiver(&m_eventReceiverForTestEvents);
        if (in_pProtocol)
        {
            TestEvents::Get()->
                ConnectWithProtocol (in_pProtocol);
        }
    }

    virtual ~AutoSetupDefaultTestEnv()
    {
        if (m_cleanupTestEvents)
        {
            TestEvents::Cleanup();
        }
        Synchronizer::Cleanup();
        Environment::Cleanup();

        if (m_cleanupProtocol)
        {
            Protocol::Cleanup();
        }
    }
protected:

    bool m_cleanupProtocol;
    bool m_cleanupTestEvents;

    BoostEventReceiverForSynchronizer m_eventReceiverForSynchronizer;
    BoostEventReceiverForTestEvents   m_eventReceiverForTestEvents;
///\endcond

};



///\cond

// First you have to adjust the template error class to the specific
// types you are using in your project

// example how to define an enum range as error category:
// enum MyCategory {GENERAL, CONTROL, USER, COMMUNICATION};
// typedef ErrorEvents<MyCategory,long> MyErrorEvents;
// but often the default settings may be sufficient, i.e. error category
// and error id are defined as long, error severity is enum DefaultSeverity
typedef ErrorEvents<> MyErrorEvents;

__declspec(selectany) MyErrorEvents* MyErrorEvents::s_pErrorEvents = 0;
///\endcond

/*
/// extended test environemnt also supporting errors catched from the system under test
class AutoSetupTestEnvWithErrors : public AutoSetupDefaultTestEnv
{
public:
///\cond
    AutoSetupTestEnvWithErrors()
    {
        MyErrorEvents::Get(); // assure that singleton is created before concurrent
                              // accesses may occur

        // TODO:
        // Define reactions for the severity values which should not be treated
        // like default (=regular error, reported as test event, test case is continued)
    }
    ~AutoSetupTestEnvWithErrors()
    {
        MyErrorEvents::Cleanup();
    }
///\endcond

};
*/

class AutoTestCase
{
public:
    explicit AutoTestCase(
        std::string const & in_testCaseDescription,
        char const *        in_file = 0,
        int const           in_line = 0)
    : m_file(in_file)
    , m_line (in_line)
    {
        TestEvents::Get()->StartNewTestCase(in_testCaseDescription);
    }
    ~AutoTestCase(void)
    {
        TestToolBox::TestEvents::Get()->CheckForUnexpectedEvents  ("~AutoTestCase", m_file,m_line);
        BOOST_CHECK(TestToolBox::TestEvents::Get()->CurTestIsStillOk());
    }
    private:
        char const * m_file;
        int const    m_line;
};


class FinalCleanup
{
public:
    virtual ~FinalCleanup (void)
    {
        Synchronizer::Cleanup();
        TestEvents::Cleanup();
        MyErrorEvents::Cleanup();
        Protocol::Cleanup();
        TestTime::Cleanup();
        Environment::Cleanup();
    }
};

class DefaultSettingsForBoostAndTTB : public FinalCleanup
{
public:
    DefaultSettingsForBoostAndTTB (
        unsigned char in_protocolMode = OutputMode::M_STDOUT | OutputMode::M_OUTFILE  | OutputMode::M_RPTFILE,
        bool          in_detailedLog  = true)
    {
        //-----  Create components of test environment  -----

//        unsigned char protocolMode = OutputMode::M_STDOUT | OutputMode::M_OUTFILE  | OutputMode::M_RPTFILE;
        Protocol::Get(in_protocolMode); // activates output to stdout, test protocol and test reprot (recommended!)

        Synchronizer::Get();
        TestEvents::Get();
        MyErrorEvents::Get();

        // Automatically remove errors which have been reported as TestEvents (recommended!)
        MyErrorEvents::Get()->DeleteStoredErrorsAfterReport(true);

        if (in_protocolMode == OutputMode::M_NULL) // i.e. no protocol file
        {
            // Connect with Boost macros (only recommended if not connected to Protocol/TestEvents!)
                Synchronizer::Get()->
                ConnectWithEventReceiver(&m_eventReceiverForSynchronizer);
            TestEvents::Get()->
                ConnectWithEventReceiver(&m_eventReceiverForTestEvents);
        }
        else // prefer usage of Protocol and TestEvents
        { 
                Synchronizer::Get()->
                ConnectWithEventReceiver(TestEvents::Get());

            // Connect with test protocol (recommended!)
            // (additional connection to BOOST macros is not needed)
            TestEvents::Get()->
                ConnectWithProtocol (Protocol::Get());
        }

        TestEvents::Get()->SetDetailedLog(in_detailedLog);
    }

protected:
    BoostEventReceiverForSynchronizer m_eventReceiverForSynchronizer;
    BoostEventReceiverForTestEvents   m_eventReceiverForTestEvents;
};


#define TTB_AUTO_TEST_CASE(DESC) AutoTestCase autoTestCase(DESC,__FILE__,__LINE__)

#define TTB_TEST_CASE(DESC)                                                                          \
    TestToolBox::TestEvents::Get()->CheckForUnexpectedEvents  ("next test case", __FILE__,__LINE__); \
    BOOST_CHECK(TestToolBox::TestEvents::Get()->CurTestIsStillOk());                                 \
    TestToolBox::TestEvents::Get()->StartNewTestCase(DESC);

#define TTB_BOOST_CHECK_FOR_TEST_EVENTS()                       \
    BOOST_CHECK(TestToolBox::TestEvents::Get()->AllTestsHaveSucceeded());



inline void DummyFunction(){}

class WorkAroundBoostThreadMemLeak
{
public:
    WorkAroundBoostThreadMemLeak ()
    {
        _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF /*| _CRTDBG_LEAK_CHECK_DF */);
        _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_DEBUG );
        _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_DEBUG );
        _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_DEBUG );
        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);

        // Use leaky boost methods before storing memory state
        {
             // onetime initialization causes
             // memory leak because there is no cleanup on exit program
             boost::thread t(DummyFunction);
             t.join();
        }
        // From now on we are sensible to memleaks
        // Reporting is done to stdout
        _CrtMemCheckpoint(&memStateStartup);
    }
    ~WorkAroundBoostThreadMemLeak ()
    {
        cout << "MEMLEAK REPORT (Workaround Boost thread memleak / run with --detect_memory_leak=0)" << endl;
        _CrtMemCheckpoint(&memStateShutdown);
#ifdef _DEBUG
        // only used in debug builds
        _CrtMemState diffState;
#endif
        if (_CrtMemDifference(&diffState,&memStateStartup,&memStateShutdown))
        {
            _CrtMemDumpStatistics(&diffState);
            _CrtMemDumpAllObjectsSince(&memStateStartup);
            cout << "MEMLEAK REPORT: End of leaks report!" << endl;
        } 
        else
        {
            cout << "MEMLEAK REPORT: No leaks detected!" << endl;
        }
        //_CrtMemDumpAllObjectsSince(&memStateStartup);
    }

private:
    _CrtMemState memStateStartup;
    _CrtMemState memStateShutdown;

};

}; // namespace TestToolBox

/// @} // GrpTestEnvironmentForBoost

---