testmgr.h

Go to the documentation of this file.

/*
 *              testmgr.h
 *
 *      Copyright 2003 - 2017 Brenton Ross
 *
 *      This class is the base class from which application specific
 *              test harnesses should be derived. Those derived classes must
 *              be made friends of the class that they are testing.
 *
 *
 *      This file is part of SASSY.
 *
 *   SASSY is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   SASSY is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with SASSY.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CDI_TESTMGR_H
#define CDI_TESTMGR_H


#include "stringy.h"
#include "sx.h"
#include "log.h"
#include "test.h"
#include <map>
#include <list>
#include <set>
#include <fstream>
#include <mutex>
#include <condition_variable>
#include <chrono>

// -----------------------------------------------------------------


namespace SASSY
{


namespace cdi
{

// -----------------------------------------------------------------
// The intent is that the concrete versions of the following classes
// contain the tests, their constructors set things up and their
// destructors do the tidying up after the testing.
// This means that the Tester needs to construct and destroy the
// concrete versions of these objects as it runs the tests.
// Hence it needs to have factory objects for each that can instantiate
// these concrete objects.
//
class AbstractTest;
class AbstractScenario;
class AbstractTestCase;

// Bases for the factory classes
class TestFactory;
class ScenarioFactory;
class TestCaseFactory;

class ScenarioResults;


class Tester
{
protected:
        Tester();                                               
        std::string nameOfTest;                 
        std::string logName;                    
        bool failed;                                    
        void title();                                   
        void installDefaults();                 

        std::map< std::string, std::map< std::string, TestCaseFactory *> > tests;

        std::map< std::string, ScenarioFactory * > scenarios;

        std::map< std::string, ScenarioResults * > results;

        TestFactory *theTest;

        AbstractTest *absTest;

        AbstractScenario *absScenario;


        void testScenario( csr scenario, ScenarioFactory *scn );
public:

        void configure ( csr testName );


        csr getTestName() { return nameOfTest; }


        static Tester & instance();

        virtual ~Tester(){}


        cfi::logstream & log();


        void addTestCase( csr name, csr scenario, TestCaseFactory *tcf );

        void runTestCase( csr scenarioName, csr testCaseName, ScenarioResults *);

        void getTestCases( csr scenarioName, std::set< std::string > &testCases );


        void addScenario( csr scenario, ScenarioFactory *sf);


        void setTest( TestFactory *t) { theTest = t; }


        AbstractTest * getTest() { return absTest; }


        AbstractScenario *getScenario() { return absScenario; }

        virtual void runTests();


        bool summary();
};

// -----------------------------------------------------------------


class test_exception : public sx
{
public:
        test_exception() : sx(Warning) {}
};


class scenario_exception : public sx
{
public:
        scenario_exception() : sx(Warning) {}
};

// -----------------------------------------------------------------


class TestEvent
{
private:
        std::string mId;
public:

        TestEvent( const std::string & s) : mId(s) {}


        const std::string & id() { return mId; }
};


class TestEventQueue
{
protected:
        TestEventQueue();

public:
        std::mutex eventMx;                                             
        std::list< TestEvent * > events;                
        std::set< std::string > runningEvents;  
        std::mutex functionsMx;                                 
        std::condition_variable eventCV;                

public:

        static TestEventQueue & instance();

        ~TestEventQueue();


        static void event( csr id );



        void enqueueEvent( TestEvent * );
};

// -----------------------------------------------------------------


class TestFactory
{
public:
        virtual ~TestFactory(){}


        virtual AbstractTest * make() = 0;
};


template < class T >
class TestFT : public TestFactory
{
public:

        AbstractTest * make() { return new T; }
};


class AbstractTest
{
public:
        virtual ~AbstractTest(){}
};


template < class T >
class TestT : public AbstractTest
{
public:
        static void install()
        {
                Tester::instance().setTest(new TestFT<T> );
        }
};


class DefaultTest : public TestT<DefaultTest>
{
public:
        DefaultTest(){}

        ~DefaultTest(){}
};

// -----------------------------------------------------------------


class ScenarioFactory
{
public:
        ScenarioFactory(){}

        virtual ~ScenarioFactory(){}

        virtual AbstractScenario * make(csr name) = 0;
};


template < class T >
class ScenarioFT : public ScenarioFactory
{
public:

        AbstractScenario * make(csr name) { return new T(name); }
};


struct ScenarioResults
{
        int mNumTests;          
        int mNumErrors;         
        bool failure;           

        ScenarioResults(): mNumTests(0), mNumErrors(0), failure(false) {}
};


class AbstractScenario
{
protected:
        std::string scenarioName;
public:

        explicit AbstractScenario(csr name) : scenarioName(name) {}

        virtual ~AbstractScenario(){}

        virtual bool willRunTests() { return false; }

        virtual void runTests(csr scenarioName, ScenarioResults *) {}
};


template < class T >
class ScenarioT : public AbstractScenario
{
public:

        explicit ScenarioT(csr name) : AbstractScenario(name) {}


        static void install( csr nm )
        {
                Tester::instance().addScenario(nm, new ScenarioFT<T>);
        }
};


class DefaultScenario : public ScenarioT<DefaultScenario>
{
public:
        explicit DefaultScenario(csr name) : ScenarioT<DefaultScenario>(name) {}

        DefaultScenario() :ScenarioT<DefaultScenario>("Default-Scenario") {}

        ~DefaultScenario(){}
};

// -----------------------------------------------------------------


class TestCaseFactory
{
public:
        virtual ~TestCaseFactory(){}


        virtual AbstractTestCase * make(csr nm) = 0;
};


template < class T >
class TestCaseFT : public TestCaseFactory
{
public:

        AbstractTestCase * make(csr nm) { return new T(nm); }
};


class AbstractTestCase
{
protected:
        std::string name;


        bool test( bool cond, csr testMsg, bool expected = false );


        virtual bool runTest() = 0;

        ScenarioResults *scenario;              // reference
public:

        explicit AbstractTestCase(csr nm) : name(nm), scenario(0) {}


        virtual ~AbstractTestCase(){}


        virtual bool operator()(ScenarioResults *);

        static const bool EXPECTED = true;
};


template < class T >
class TestCaseT : public AbstractTestCase
{
public:

        TestCaseT(csr nm) : AbstractTestCase(nm) {}


        static void install( csr nm, csr scn )
        {
                Tester::instance().addTestCase(nm, scn, new TestCaseFT<T> );
        }
};

// -----------------------------------------------------------------


class AsyncTestCase : public AbstractTestCase
{
private:
        SASSY::AsyncTestEventFn fn;
        virtual bool runTest();
        void testThread();
protected:

        virtual void initTest() = 0;


        virtual void handleEvent( TestEvent *ev ) = 0;


        virtual void timedOut() = 0;

        // when the last expected event occurs
        bool done;

        std::chrono::steady_clock::time_point startTime;

        std::chrono::steady_clock::duration timeOut;
public:

        AsyncTestCase(csr name);
        ~AsyncTestCase();
};

template < class T >
class AsyncTestCaseT : public AsyncTestCase
{
public:

        AsyncTestCaseT(csr nm) : AsyncTestCase(nm) {}


        static void install( csr nm, csr scn )
        {
                Tester::instance().addTestCase(nm, scn, new TestCaseFT<T> );
        }
};

} // end namespace cdi

} // end namespace SASSY

#endif /* TESTMGR_H_ */