iutest_info.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_INFO_HPP_764A79A8_E822_4C0F_8CB7_82C635BA28BA_
#define INCG_IRIS_IUTEST_INFO_HPP_764A79A8_E822_4C0F_8CB7_82C635BA28BA_
 
//======================================================================
// include
#include "iutest_body.hpp"
#include "internal/iutest_factory.hpp"
 
namespace iutest
{
 
//======================================================================
// class
class TestInfo
#if IUTEST_USE_OWN_LIST
    : public detail::iu_list_node<TestInfo>
#endif
{
public:
    TestInfo(detail::iuITestCaseMediator* testcase, const ::std::string& name, detail::iuFactoryBase* factory)
        : m_testname(name)
        , m_factory(factory)
        , m_testcase(testcase)
        , m_should_run(true)
        , m_ran(false)
        , m_disable(detail::IsDisableTestName(name))
        , m_skip(false)
        , m_matches_filter(true)
    {
        m_mediator.SetPointer(this);
    }
 
public:
    const   char*   test_case_name()    const { return m_testcase->test_case_name(); }
    const   char*   name()              const { return m_testname.c_str(); }
    bool            should_run()        const IUTEST_CXX_NOEXCEPT_SPEC { return m_should_run; }
    bool            is_ran()            const IUTEST_CXX_NOEXCEPT_SPEC { return m_ran; }
    bool            is_disabled_test()  const IUTEST_CXX_NOEXCEPT_SPEC { return m_disable; }
    bool            is_skipped()        const IUTEST_CXX_NOEXCEPT_SPEC { return m_skip || m_test_result.Skipped(); }
    bool            is_reportable()     const IUTEST_CXX_NOEXCEPT_SPEC { return m_matches_filter; }
    TimeInMillisec  elapsed_time()      const { return m_test_result.elapsed_time(); }
    const TestResult*   result()        const IUTEST_CXX_NOEXCEPT_SPEC { return &m_test_result; }
 
    const   char*   value_param()       const { return m_value_param.empty() ? NULL : m_value_param.c_str(); }
    const   char*   type_param()        const { return m_testcase->type_param(); }
 
    ::std::string testcase_name_with_default_package_name() const
    {
        return TestEnv::AddDefaultPackageName(test_case_name());
    }
public:
    bool    HasFatalFailure() const
    {
        return m_test_result.HasFatalFailure();
    }
 
    bool    HasNonfatalFailure() const
    {
        return m_test_result.HasNonfatalFailure();
    }
 
    bool    HasFailure() const
    {
        return m_test_result.Failed();
    }
 
    bool    HasWarning() const
    {
        return m_test_result.HasWarning();
    }
 
    bool    Passed() const
    {
        if( is_skipped() )
        {
            return false;
        }
        return m_test_result.Passed();
    }
 
public:
    ::std::string test_full_name() const
    {
        ::std::string fullname = test_case_name();
        fullname += ".";
        fullname += name();
        return fullname;
    }
 
    ::std::string test_name_with_where() const
    {
        ::std::string str = m_testname;
        if( value_param() != NULL )
        {
            str += ", where GetParam() = ";
            str += m_value_param;
        }
        return str;
    }
 
public:
    static bool ValidateTestPropertyName(const ::std::string& name)
    {
        const char* ban[] = { "name", "status", "time", "classname", "type_param", "value_param" };
#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:
    void set_value_param(const char* str) { m_value_param = str; }
 
private:
    bool Run();
 
private:
    void RunImpl();
 
#if IUTEST_HAS_SEH && IUTEST_HAS_EXCEPTIONS
#if IUTEST_HAS_MINIDUMP
    void MiniDump(_EXCEPTION_POINTERS* ep);
#endif
    void RunOnMSC(Test* test);
#endif
 
private:
    void clear();
 
    /*
     * @brief   テストのフィルタリング
     * @return  実行する場合は真
    */
    bool filter();
 
    void skip() { m_skip = true; }
 
private:
    class Mediator IUTEST_CXX_FINAL : public detail::iuITestInfoMediator
    {
    public:
        explicit Mediator(TestInfo* p=NULL) IUTEST_CXX_NOEXCEPT_SPEC : iuITestInfoMediator(p) {}
    public:
        virtual bool HasFatalFailure() const IUTEST_CXX_OVERRIDE
        {
            return ptr()->HasFatalFailure();
        }
        virtual bool HasNonfatalFailure() const IUTEST_CXX_OVERRIDE
        {
            return ptr()->HasNonfatalFailure();
        }
        virtual bool HasFailure() const IUTEST_CXX_OVERRIDE
        {
            return ptr()->HasFailure();
        }
        virtual bool IsSkipped() const IUTEST_CXX_OVERRIDE
        {
            return ptr()->is_skipped();
        }
    public:
        void SetPointer(TestInfo* p) { m_test_info = p; }
    };
private:
    friend class UnitTestImpl;
    friend class UnitTest;
    friend class TestCase;
 
    ::std::string           m_testname;         
    ::std::string           m_value_param;      
    TestResult              m_test_result;      
    Mediator                m_mediator;         
    detail::iuFactoryBase*          m_factory;  
    detail::iuITestCaseMediator*    m_testcase; 
    bool                    m_should_run;       
    bool                    m_ran;              
    bool                    m_disable;          
    bool                    m_skip;             
    bool                    m_matches_filter;   
 
    IUTEST_PP_DISALLOW_COPY_AND_ASSIGN(TestInfo);
};
 
}   // end of namespace iutest
 
#if !IUTEST_HAS_LIB
#  include "impl/iutest_info.ipp"
#endif
 
#endif // INCG_IRIS_IUTEST_INFO_HPP_764A79A8_E822_4C0F_8CB7_82C635BA28BA_