iutest_result.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_RESULT_HPP_D27B1599_F42F_4E2D_B3EB_FACE24C2B921_
#define INCG_IRIS_IUTEST_RESULT_HPP_D27B1599_F42F_4E2D_B3EB_FACE24C2B921_
 
//======================================================================
// include
#include "internal/iutest_message.hpp"
 
namespace iutest
{
 
//======================================================================
// declare
namespace detail
{
 
class DefaultGlobalTestPartResultReporter;
 
}   // end of namespace detail
 
//======================================================================
// class
class TestPartResultReporterInterface
{
public:
    virtual ~TestPartResultReporterInterface() {}
    virtual void ReportTestPartResult(const TestPartResult& result) = 0;
};
 
class TestPartResult : public detail::iuCodeMessage
{
public:
    enum Type
    {
        kAssumeFailure = -3,    
        kSkip = -2,             
        kWarning = -1,          
        kSuccess,               
        kNonFatalFailure,       
        kFatalFailure           
    };
public:
    TestPartResult(const char* file, int line, const char* message, Type type)
        : detail::iuCodeMessage(file, line, message), m_type(type) {}
 
public:
    static bool type_is_failed(Type type) IUTEST_CXX_NOEXCEPT_SPEC
    {
        if( iutest::IUTEST_FLAG(warning_into_error) )
        {
            if( type == kWarning )
            {
                return true;
            }
        }
        return type > kSuccess;
    }
 
public:
    bool        failed() const IUTEST_CXX_NOEXCEPT_SPEC { return type_is_failed(m_type);; }
    bool        passed() const IUTEST_CXX_NOEXCEPT_SPEC { return !failed(); }
    bool        warning() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type == kWarning; }
    bool        skipped() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type == kSkip; }
    bool        assume_failed() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type == kAssumeFailure; }
    bool        succeeded() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type == kSuccess; }
 
    bool        nonfatally_failed() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type == kNonFatalFailure; }
 
    bool        fatally_failed() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type == kFatalFailure; }
 
    const char* summary() const { return message(); }
 
    Type        type() const IUTEST_CXX_NOEXCEPT_SPEC { return m_type; }
 
private:
    Type m_type;
};
 
inline iu_ostream& operator << (iu_ostream& os, const TestPartResult& result)
{
    return os << result.make_message();
}
 
class TestProperty
{
public:
    TestProperty(const ::std::string& key, const ::std::string& value)
        : m_key(key), m_value(value) {}
 
public:
    void SetValue(const ::std::string& value) { m_value = value; }
    const char* key()   const { return m_key.c_str(); }     
    const char* value() const { return m_value.c_str(); }   
 
public:
    bool Validate(const char** ban_list, size_t size) const
    {
        return ValidateName(m_key, ban_list, ban_list+size);
    }
    template<typename Ite>
    static bool ValidateName(const ::std::string& name, Ite begin, Ite end)
    {
        return ::std::find(begin, end, name) == end;
    }
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
 
    template<typename T, size_t N>
    static bool ValidateName(const ::std::string& name, T (&ar)[N])
    {
        return ValidateName(name, ar, ar + N);
    }
#endif
 
private:
    friend class TestResult;
    ::std::string m_key;
    ::std::string m_value;
};
 
class TestResult
{
    typedef ::std::vector<TestPartResult>   TestPartResults;
    typedef ::std::vector<TestProperty>     TestPropertys;
public:
    TestResult() : m_elapsedmsec(0) {}
 
public:
    bool        Passed() const { return !Failed(); }
    bool        Failed() const
    {
        for( TestPartResults::const_iterator it=m_test_part_results.begin()
            , end=m_test_part_results.end(); it != end; ++it )
        {
            if( it->failed() )
            {
                return true;
            }
        }
        return false;
    }
    bool        Skipped() const
    {
        for( TestPartResults::const_iterator it=m_test_part_results.begin()
            , end=m_test_part_results.end(); it != end; ++it )
        {
            if( it->skipped() || it->assume_failed() )
            {
                return Passed();
            }
        }
        return false;
    }
 
    bool        HasFatalFailure() const { return HasResult(TestPartResult::kFatalFailure); }
 
    bool        HasNonfatalFailure() const { return HasResult(TestPartResult::kNonFatalFailure); }
 
    bool        HasAssumeFailure() const { return HasResult(TestPartResult::kAssumeFailure); }
 
    bool        HasWarning() const { return HasResult(TestPartResult::kWarning); }
 
    TimeInMillisec  elapsed_time() const IUTEST_CXX_NOEXCEPT_SPEC { return m_elapsedmsec; }
 
    int         total_part_count() const { return static_cast<int>(m_test_part_results.size()); }
 
    int         test_property_count() const { return static_cast<int>(m_test_propertys.size()); }
 
    const TestPartResult&   GetTestPartResult(int index) const { return m_test_part_results[index]; }
 
    const TestProperty&     GetTestProperty(int index) const { return m_test_propertys[index]; }
 
public:
    int total_error_count() const
    {
        int count = 0;
        for( TestPartResults::const_iterator it=m_test_part_results.begin()
            , end=m_test_part_results.end(); it != end; ++it )
        {
            if( it->failed() )
            {
                ++count;
            }
        }
        return count;
    }
 
private:
    void AddTestPartResult(const TestPartResult& result) { m_test_part_results.push_back(result); }
    void set_elapsed_time(TimeInMillisec time) IUTEST_CXX_NOEXCEPT_SPEC { m_elapsedmsec = time; }
 
private:
    void RecordProperty(const TestProperty& prop)
    {
        for( TestPropertys::iterator it=m_test_propertys.begin()
            , end=m_test_propertys.end(); it != end; ++it )
        {
            if( detail::IsStringEqual(it->key(), prop.key()) )
            {
                it->m_value = prop.m_value;
                return;
            }
        }
        m_test_propertys.push_back(prop);
    }
 
    void ClearResult()
    {
        m_test_part_results.clear();
    }
    void Clear()
    {
        m_test_part_results.clear();
        m_test_propertys.clear();
        m_elapsedmsec = 0;
    }
    bool HasResult(TestPartResult::Type eType) const
    {
        for( TestPartResults::const_iterator it=m_test_part_results.begin()
            , end=m_test_part_results.end(); it != end; ++it )
        {
            if( it->type() == eType )
            {
                return true;
            }
        }
        return false;
    }
private:
    friend class UnitTestImpl;
    friend class TestInfo;
    friend class TestCase;
    friend class detail::DefaultGlobalTestPartResultReporter;
 
    TestPartResults m_test_part_results;
    TestPropertys   m_test_propertys;
    TimeInMillisec  m_elapsedmsec;
 
    IUTEST_PP_DISALLOW_COPY_AND_ASSIGN(TestResult);
};
 
}   // end of namespace iutest
 
#endif // INCG_IRIS_IUTEST_RESULT_HPP_D27B1599_F42F_4E2D_B3EB_FACE24C2B921_