iutest_case.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_CASE_HPP_F57C9B7E_7CAA_4429_BE75_FCAAEED1B220_
#define INCG_IRIS_IUTEST_CASE_HPP_F57C9B7E_7CAA_4429_BE75_FCAAEED1B220_
 
//======================================================================
// include
#include "iutest_info.hpp"
 
namespace iutest
{
 
//======================================================================
// class
class TestCase
#if IUTEST_USE_OWN_LIST
    : public detail::iu_list_node<TestCase>
#endif
{
protected:
#if IUTEST_USE_OWN_LIST
    typedef detail::iu_list<TestInfo>   iuTestInfos;
#else
    typedef ::std::vector<TestInfo*>    iuTestInfos;
#endif
 
protected:
    TestCase(const ::std::string& testcase_name, TestTypeId id, SetUpMethod setup, TearDownMethod teardown)
    : m_testcase_name(testcase_name)
    , m_setup(setup)
    , m_teardown(teardown)
    , m_id(id)
    , m_disable_num(0)
    , m_should_run_num(0)
    , m_elapsedmsec(0)
    , m_start_timestamp(0)
    , m_disable(detail::IsDisableTestName(testcase_name))
    {
    }
 
public:
    virtual ~TestCase() {}
 
public:
    const char*     name()                  const { return m_testcase_name.c_str(); }
 
    int             total_test_count()      const IUTEST_CXX_NOEXCEPT_SPEC { return static_cast<int>(m_testinfos.size()); }
    int             reportable_test_count() const;
    int             test_to_run_count()     const IUTEST_CXX_NOEXCEPT_SPEC { return m_should_run_num; }
    int             failed_test_count()     const;
    int             disabled_test_count()   const IUTEST_CXX_NOEXCEPT_SPEC { return m_disable_num; }
    int             reportable_disabled_test_count() const;
    int             successful_test_count() const;
    int             skip_test_count()       const;
    int             reportable_skip_test_count() const;
    int             test_run_skipped_count() const;
    int             reportable_test_run_skipped_count() const;
    TimeInMillisec  elapsed_time()          const IUTEST_CXX_NOEXCEPT_SPEC { return m_elapsedmsec; }
    TimeInMillisec  start_timestamp()       const IUTEST_CXX_NOEXCEPT_SPEC{ return m_start_timestamp; }
 
    const TestInfo* GetTestInfo(int index)  const { return m_testinfos[index]; }
    bool            should_run()            const IUTEST_CXX_NOEXCEPT_SPEC { return m_should_run_num != 0; }
 
    bool            Passed()                const { return failed_test_count() == 0 && m_ad_hoc_testresult.Passed(); }
    bool            Failed()                const { return !Passed(); }
 
    virtual const char* type_param()        const { return NULL; }
 
    ::std::string testcase_name_with_where() const
    {
        ::std::string str = m_testcase_name;
        if( type_param() != NULL )
        {
            str += ", where TypeParam = ";
            str += type_param();
        }
        return str;
    }
 
    ::std::string testcase_name_with_default_package_name() const
    {
        return TestEnv::AddDefaultPackageName(name());
    }
 
    const TestResult* ad_hoc_testresult() const IUTEST_CXX_NOEXCEPT_SPEC
    {
        return ad_hoc_test_result();
    }
 
    const TestResult* ad_hoc_test_result() const IUTEST_CXX_NOEXCEPT_SPEC
    {
        return &m_ad_hoc_testresult;
    }
 
public:
    static bool ValidateTestPropertyName(const ::std::string& name)
    {
        const char* ban[] = { "name", "tests", "failures", "disabled", "skip", "errors", "time" };
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
        return TestProperty::ValidateName(name, ban);
#else
        return TestProperty::ValidateName(name, ban, ban+IUTEST_PP_COUNTOF(ban));
#endif
    }
 
private:
    bool Run();
 
    bool RunImpl();
 
private:
    bool CheckSetUpSkipped();
 
public:
    struct FindOp
    {
        TestTypeId  m_id;
        const char* m_name;
 
        bool operator () (const TestCase* p) const
        {
            if( p->get_typeid() == m_id && detail::IsStringEqual(p->m_testcase_name, m_name) )
            {
                return true;
            }
            return false;
        }
    };
private:
    void clear();
    /*
     * @brief   テストのフィルタリング
     * @return  実行する場合は真
    */
    bool filter();
 
private:
    friend bool operator == (const TestCase& lhs, const TestCase& rhs)
    {
        return (lhs.m_id == rhs.m_id) && (strcmp(lhs.name(), rhs.name()) == 0);
    }
 
    void push_back(TestInfo* p) { m_testinfos.push_back(p); }
 
private:
    iuTestInfos::const_iterator begin() const       { return m_testinfos.begin(); }
    iuTestInfos::const_iterator end()   const       { return m_testinfos.end(); }
    TestTypeId                  get_typeid() const IUTEST_CXX_NOEXCEPT_SPEC { return m_id; }
 
private:
    bool HasWarning() const { return m_ad_hoc_testresult.HasWarning() || detail::AnyOverList(m_testinfos, &TestInfo::HasWarning); }
 
private:
    static bool IsSuccessfulTest(const TestInfo* p) { return p->is_ran() && p->Passed(); }
    static bool IsFailedTest(const TestInfo* p) { return p->should_run() && p->HasFailure(); }
    static bool IsSkipTest(const TestInfo* p) { return !p->is_ran() || p->is_skipped(); }
    static bool IsReportableSkipTest(const TestInfo* p) { return p->is_reportable() && IsSkipTest(p); }
    static bool IsRunSkippedTest(const TestInfo* p) { return p->should_run() && p->is_skipped(); }
    static bool IsReportableRunSkippedTest(const TestInfo* p) { return p->is_reportable() && IsRunSkippedTest(p); }
    static bool IsReportableDisabledTest(const TestInfo* p) { return p->is_reportable() && p->is_disabled_test(); }
 
private:
    friend class UnitTestImpl;
    friend class UnitTest;
 
#if defined(IUTEST_NO_PRIVATE_IN_AGGREGATE)
    friend struct FindOp;
#endif
 
    ::std::string   m_testcase_name;    
    iuTestInfos     m_testinfos;        
    SetUpMethod     m_setup;            
    TearDownMethod  m_teardown;         
    TestTypeId      m_id;               
    int             m_disable_num;      
    int             m_should_run_num;   
    TimeInMillisec  m_elapsedmsec;      
    TimeInMillisec  m_start_timestamp;  
    bool            m_disable;          
    TestResult      m_ad_hoc_testresult;    
 
    IUTEST_PP_DISALLOW_COPY_AND_ASSIGN(TestCase);
};
 
template<typename T>
class TypedTestCase : public TestCase
{
public:
    typedef T   TypeParam;  
 
protected:
    TypedTestCase(const ::std::string& testcase_name, TestTypeId id, SetUpMethod setup, TearDownMethod teardown)
        : TestCase(testcase_name, id, setup, teardown)
        , m_type_param(detail::GetTypeNameProxy<TypeParam>::GetTypeName())
    {
    }
 
public:
    virtual const char* type_param() const IUTEST_CXX_OVERRIDE
    {
        return m_type_param.empty() ? NULL : m_type_param.c_str();
    }
 
private:
    friend class UnitTestImpl;
 
    ::std::string m_type_param;     
};
 
namespace detail
{
 
class TestCaseMediator IUTEST_CXX_FINAL : public detail::iuITestCaseMediator
{
public:
    explicit TestCaseMediator(TestCase* p) IUTEST_CXX_NOEXCEPT_SPEC : iuITestCaseMediator(p) {}
public:
    virtual const char* test_case_name() const IUTEST_CXX_OVERRIDE { return m_test_case->name(); }
    virtual const char* type_param()     const IUTEST_CXX_OVERRIDE { return m_test_case->type_param(); }
};
 
}   // end of namespace detail
}   // end of namespace iutest
 
#if !IUTEST_HAS_LIB
#  include "impl/iutest_case.ipp"
#endif
 
#endif // INCG_IRIS_IUTEST_CASE_HPP_F57C9B7E_7CAA_4429_BE75_FCAAEED1B220_