iutest_core_impl.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_CORE_IMPL_HPP_D5ABC7DE_C751_4AC0_922F_547880163891_
#define INCG_IRIS_IUTEST_CORE_IMPL_HPP_D5ABC7DE_C751_4AC0_922F_547880163891_
 
//======================================================================
// include
#include "iutest_internal.hpp"
#include "iutest_option_message.hpp"
#include "../iutest_case.hpp"
 
namespace iutest
{
 
//======================================================================
// class
class UnitTestImpl
{
protected:
#if IUTEST_USE_OWN_LIST
    typedef detail::iu_list<TestCase>   iuTestCases;
#else
    typedef ::std::vector<TestCase*>    iuTestCases;
#endif
    typedef ::std::vector<Environment*> iuEnvironmentList;
protected:
    UnitTestImpl() : m_total_test_num(0), m_disable_num(0), m_should_run_num(0)
        , m_current_testcase(NULL), m_elapsedmsec(0)
    {
        ptr() = this;
    }
    ~UnitTestImpl() { TerminateImpl(); }
 
public:
    static TestResult* current_test_result();
 
public:
    static bool ValidateTestPropertyName(const ::std::string& name)
    {
        const char* ban[] = {
            "name", "tests", "failures", "disabled", "skip", "errors", "time", "timestamp", "random_seed"
        };
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
        return TestProperty::ValidateName(name, ban);
#else
        return TestProperty::ValidateName(name, ban, ban+IUTEST_PP_COUNTOF(ban));
#endif
    }
 
public:
    template<typename T>
    TestCase* AddTestCase(const ::std::string& testcase_name, TestTypeId id
        , SetUpMethod setup, TearDownMethod teardown IUTEST_APPEND_EXPLICIT_TEMPLATE_TYPE_(T) )
    {
        TestCase* p = FindTestCase(testcase_name, id);
        if( p == NULL )
        {
            p = new T (testcase_name, id, setup, teardown);
            m_testcases.push_back(p);
        }
        return p;
    }
    void AddTestInfo(TestCase* pCase, TestInfo* pInfo);
    static bool SkipTest();
 
protected:
    int Listup() const;
 
    int ListupWithWhere() const;
 
    bool PreRunner();
 
    void ClearNonAdHocTestResult();
 
    void ClearAdHocTestResult()
    {
        m_ad_hoc_testresult.Clear();
    }
 
private:
    static void RecordProperty(const TestProperty& prop);
 
    TestCase* FindTestCase(const ::std::string& testcase_name, TestTypeId id);
 
    bool DoInfoOptions();
 
private:
    void InitializeImpl();
    void TerminateImpl();
 
private:
#if IUTEST_HAS_INVALID_PARAMETER_HANDLER
 
IUTEST_PRAGMA_CRT_SECURE_WARN_DISABLE_BEGIN()
 
    // _invalid_parameter_handler
    static void OnInvalidParameter(const wchar_t * expression, const wchar_t * function
        , const wchar_t * file, unsigned int line, uintptr_t pReserved);
 
IUTEST_PRAGMA_CRT_SECURE_WARN_DISABLE_END()
 
#endif
 
private:
    static UnitTestImpl*& ptr() IUTEST_CXX_NOEXCEPT_SPEC
    {
        static UnitTestImpl* ptr = NULL;
        return ptr;
    }
protected:
    friend class UnitTestSource;
    friend class Test::TestRecordPropertyHelper;
 
    int             m_total_test_num;   
    int             m_disable_num;      
    int             m_should_run_num;   
    TestCase*       m_current_testcase; 
    TimeInMillisec  m_elapsedmsec;      
    iuTestCases     m_testcases;        
    TestResult      m_ad_hoc_testresult;    
};
 
namespace detail
{
 
::std::string MakeIndexName(size_t index);
 
::std::string MakeIndexTestName(const char* basename, size_t index);
 
::std::string MakeParamTestName(const ::std::string& basename, const ::std::string& parame_name);
 
template<typename T>
::std::string MakeIndexTypedTestName(const char* basename, size_t index)
{
#if IUTEST_HAS_RTTI
    ::std::string name = MakeIndexTestName(basename, index);
    name += "/";
    name += GetTypeNameProxy<T>::GetTypeNameProxy();
    return name;
#else
    return MakeIndexTestName(basename, index);
#endif
}
 
::std::string MakePrefixedIndexTestName(const char* prefix, const char* basename, size_t index);
 
template<typename T>
::std::string MakePrefixedIndexTypedTestName(const char* prefix, const char* basename, size_t index)
{
#if IUTEST_HAS_RTTI
    ::std::string name = prefix;
    if( !name.empty() )
    {
        name += "/";
    }
    name += MakeIndexTypedTestName<T>(basename, index);
    return name;
#else
    return MakePrefixedIndexTestName(prefix, basename, index);
#endif
}
 
}   // end of namespace detail
 
}   // end of namespace iutest
 
#if !IUTEST_HAS_LIB
#  include "../impl/iutest_core_impl.ipp"
#endif
 
#endif // INCG_IRIS_IUTEST_CORE_IMPL_HPP_D5ABC7DE_C751_4AC0_922F_547880163891_