cUnitTest.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cUnitTest_H
#define _INC_cUnitTest_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cUnitTestDecl.h"
#include "StrConst.h"
#include "StrArg.h"
#include "FileName.h"
#include "cLogLevel.h"
#include "cLogMgr.h"
#include "cDebugAssert.h"
#include "cSingleton.h"
#include "cArray.h"
#include "cFilePath.h"
#include "cAppState.h"
#include "cOSModImpl.h"
 
namespace Gray
{
        class cLogProcessor;
 
        enum UNITTEST_LEVEL_TYPE
        {
                UNITTEST_LEVEL_None = 0,
                UNITTEST_LEVEL_Crit,    
                UNITTEST_LEVEL_Core,    
                UNITTEST_LEVEL_Lib,             
                UNITTEST_LEVEL_Common,  
                UNITTEST_LEVEL_Slow,    
                UNITTEST_LEVEL_All,             
                UNITTEST_LEVEL_Off,             
        };
 
        class cUnitTestRegister;
 
        struct GRAYCORE_LINK cUnitTestCur       // static
        {
 
                static int sm_nCreatedUnitTests;                
                static const FILECHAR_t* k_TestFiles;   // a sub directory under m_sTestOutDir containing all the test files.
 
                // Sample Test const data.
                static const StrLen_t k_TEXTBLOB_LEN = 566;     
                static const cStrConst k_sTextBlob;                     
                static const StrLen_t k_TEXTLINES_QTY = 18;     
                static const cStrConst k_asTextLines[k_TEXTLINES_QTY + 1];              
 
                static bool GRAYCALL TestTypes();
        };
 
        class GRAYCORE_LINK cUnitTest : public cUnitTestCur
        {
 
        public:
                cUnitTest();
                virtual ~cUnitTest() noexcept(false);   // M$ test force use of noexcept(false); 
 
                const FILECHAR_t* get_TestInpDir() const;
 
                virtual void RunUnitTest() = 0;  
        };
 
        class GRAYCORE_LINK cUnitTestRegister
        {
        public:
                const LOGCHAR_t* m_pszTestName;                 
                const UNITTEST_LEVEL_TYPE m_nTestLevel; 
        protected:
                cUnitTestRegister(const LOGCHAR_t* pszTestName, UNITTEST_LEVEL_TYPE nTestLevel = UNITTEST_LEVEL_Core);
                virtual ~cUnitTestRegister();
                virtual cUnitTest* CreateUnitTest() = 0;        
        public:
                void RunUnitTest();     
        };
 
        template <class T = cUnitTest>
        class cUnitTestRegisterT : public cUnitTestRegister, public cSingletonStatic< cUnitTestRegisterT<T> >
        {
        public:
                cUnitTestRegisterT(const LOGCHAR_t* pszTestName, UNITTEST_LEVEL_TYPE nTestLevel = UNITTEST_LEVEL_Core)
                        : cUnitTestRegister(pszTestName, nTestLevel)
                        , cSingletonStatic< cUnitTestRegisterT<T> >(this)
                {
                }
                virtual cUnitTest* CreateUnitTest() override
                {
                        return new T();
                }
        };
 
        class GRAYCORE_LINK cUnitTestAppState
        {
        private:
                cAppState& m_AppState;                          
                APPSTATE_TYPE_ m_eAppStatePrev;         
                THREADID_t m_nMainThreadPrev;           
 
        public:
                cUnitTestAppState()
                        : m_AppState(cAppState::I())
                {
                        // called for M$ tests.
                        m_eAppStatePrev = m_AppState.get_AppState();
                        m_nMainThreadPrev = m_AppState.get_MainThreadId();
                        m_AppState.InitAppState();      // set to APPSTATE_Run
                }
 
                ~cUnitTestAppState() noexcept
                {
                        m_AppState.put_AppState(m_eAppStatePrev);       // destructors should be called next.
                        m_AppState.m_nMainThreadId = m_nMainThreadPrev;
                }
        };
 
        class GRAYCORE_LINK cUnitTests : public cSingleton<cUnitTests>, public cUnitTestCur
        {
 
                friend class cUnitTestRegister;
 
        public:
                cArrayPtr<cUnitTestRegister> m_aUnitTests;      
                static AssertCallback_t UnitTest_AssertCallback;        
                AssertCallback_t* m_pAssertOrig;                        
                
                UNITTEST_LEVEL_TYPE m_nTestLevel;               
                cArrayString<LOGCHAR_t> m_aTestNames;   // just run these tests.
 
                cStringF m_sTestInpDir;                         
                cStringF m_sTestOutDir;                         
 
                cLogProcessor* m_pLog;                  
 
                bool m_bRunning;                                
                int m_iFailures;                                
 
        public:
                cUnitTests();
 
                HRESULT InitTestOutDir();
                bool RegisterUnitTest(cUnitTestRegister* pTest);
 
                void SetTestLevel(UNITTEST_LEVEL_TYPE nTestLevel);
                bool TestActive(const cUnitTestRegister* pUnitTest, bool remove);
 
                cUnitTestRegister* FindUnitTest(const char* pszName) const;
 
                bool IsTestInteractive() const noexcept;
                bool TestInteractivePrompt(const char* pszMsg) noexcept;
 
                const FILECHAR_t* get_TestInpDir() const;
                const FILECHAR_t* get_TestOutDir() const;
 
                void RunInitialize();
                void RunCleanup();
 
                HRESULT RunUnitTests(UNITTEST_LEVEL_TYPE nTestLevel = UNITTEST_LEVEL_Common, const LOGCHAR_t* pszTestNameMatch = nullptr);
 
                CHEAPOBJECT_IMPL;       // dynamic singleton
        };
 
#define UNITTEST_TRUE(x)                ASSERT(x)       // UNITTEST_TRUE is different from a normal ASSERT ?
#define UNITTEST_TRUE2(x,d)             ASSERT(x)       // UNITTEST_TRUE with a description
 
        // Deprecate all below in favor of UNITTEST2_*
 
#define UNITTEST_REGISTER_NAME(n)       g_UnitTest_##n
#define UNITTEST_REGISTER(n,l)          ::Gray::cUnitTestRegisterT< UNITTEST_N(n) > UNITTEST_REGISTER_NAME(n)( #n, l ); // instantiate to register cUnitTest  .
 
        // Allow an external hard link. optional.
#define UNITTEST_EXT_NAME(n)            g_pUnitTest_##n         
#define UNITTEST_EXT_DEF(n)                     cUnitTestRegister* UNITTEST_EXT_NAME(n) = &UNITTEST_REGISTER_NAME(n);
 
}       // namespace
 
using namespace Gray;   // Since this header is typically only included right before the unit test.
 
#endif  // _INC_cUnitTest_H