iutest_env.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_ENV_HPP_F4017EAB_6CA3_4E6E_8983_059393DADD04_
#define INCG_IRIS_IUTEST_ENV_HPP_F4017EAB_6CA3_4E6E_8983_059393DADD04_
 
//======================================================================
// include
// IWYU pragma: begin_exports
#include "internal/iutest_charcode.hpp"
#include "internal/iutest_random.hpp"
#include "internal/iutest_regex.hpp"
#include "iutest_listener.hpp"
// IWYU pragma: end_exports
 
//======================================================================
// define
#define IUTEST_FLAG(name)   IIUT_FLAG(name)
 
#define IIUT_FLAG(name)     TestEnv::name()
 
#if IUTEST_HAS_LIB && IUTEST_HAS_EXTERN_TEMPLATE
 
namespace iutest { class Environment; }
 
IUTEST_PRAGMA_EXTERN_TEMPLATE_WARN_DISABLE_BEGIN()
 
extern template class ::std::vector< ::iutest::Environment* >;
 
IUTEST_PRAGMA_EXTERN_TEMPLATE_WARN_DISABLE_END()
 
#endif
 
namespace iutest
{
 
//======================================================================
// function
inline ::std::string EnvironmentString(const char* name)
{
    ::std::string var;
    detail::GetEnvironmentVariable(name, var);
    return var;
}
 
//======================================================================
// class
class Environment
{
public:
    virtual ~Environment() { Release(); }
    virtual void SetUp() {}     
    virtual void TearDown() {}  
private:
    void Release();
private:
    struct should_be_SetUp {};
    virtual should_be_SetUp* Setup() IUTEST_CXX_FINAL { return NULL; }
};
 
class TestFlag
{
public:
    class ScopedGuard
    {
        IUTEST_PP_DISALLOW_COPY_AND_ASSIGN(ScopedGuard);
 
        int m_test_flags;
    public:
        ScopedGuard()
        {
            m_test_flags = TestFlag::GetInstance().m_test_flags;
        }
        ~ScopedGuard()
        {
            TestFlag::GetInstance().m_test_flags = m_test_flags;
        }
    };
public:
    enum Kind
    {
        SHUFFLE_TESTS           = 0x00000001,   
        RUN_DISABLED_TESTS      = 0x00000002,   
        FILTERING_TESTS         = 0x00000004,   
 
        BREAK_ON_FAILURE        = 0x00000010,   
        THROW_ON_FAILURE        = 0x00000040,   
        WARNING_INTO_ERROR      = 0x00000080,   
 
        CONSOLE_COLOR_ON        = 0x00000100,   
        CONSOLE_COLOR_OFF       = 0x00000200,   
        CONSOLE_COLOR_ANSI      = 0x00000400,   
 
        PRINT_TIME              = 0x00001000,   
        FILELOCATION_STYLE_MSVC = 0x00002000,   
        VERBOSE                 = 0x00004000,   
 
        CATCH_EXCEPTION_EACH    = 0x00010000,   
        CATCH_EXCEPTION_GLOBAL  = 0x00020000,   
        CATCH_EXCEPTION         = 0x00030000,   
 
        SHOW_HELP               = 0x01000000,   
        SHOW_VERSION            = 0x02000000,   
        SHOW_FEATURE            = 0x04000000,   
        SHOW_SPEC               = 0x08000000,   
 
        SHOW_TESTS_LIST         = 0x20000000,   
        SHOW_TESTS_LIST_WITH_WHERE
                                = 0x40000000,   
 
        SHOW_INFO_MASK          = 0x0F000000,   
        SHOW_MASK               = 0x7F000000,   
        MASK                    = 0x7FFFFFFF,   
 
#if defined(_MSC_VER)
        DEFAULT = CATCH_EXCEPTION|PRINT_TIME|FILELOCATION_STYLE_MSVC
#else
        DEFAULT = CATCH_EXCEPTION|PRINT_TIME
#endif
    };
 
private:
    TestFlag() IUTEST_CXX_NOEXCEPT_SPEC
        : m_test_flags(DEFAULT) {}
 
public:
    static TestFlag& GetInstance() { static TestFlag flag; return flag; }
public:
    static void SetFlag(int enable, int mask=-1)
    {
        GetInstance().m_test_flags |= enable;
        GetInstance().m_test_flags &= mask;
    }
    static bool IsEnableFlag(int flag) { return (GetInstance().m_test_flags & flag) ? true : false; }
 
private:
    template<int KIND>
    class Fragment
    {
        typedef Fragment<KIND> _Myt;
    public:
        Fragment() IUTEST_CXX_NOEXCEPT_SPEC {}
        Fragment(bool enabled) { SetFlag(KIND, enabled ? -1 : ~KIND); } // NOLINT
        _Myt& operator = (bool enabled) { SetFlag(KIND, enabled ? -1 : ~KIND); return *this; }
        operator bool() const { return IsEnableFlag(KIND); }
    };
 
private:
    friend class TestEnv;
#if defined(IUTEST_NO_PRIVATE_IN_AGGREGATE)
    friend class ScopedGuard;
#endif
 
    int m_test_flags;
};
 
// declare
class TestPartResultReporterInterface;
 
class TestEnv
{
    typedef ::std::vector<Environment*> iuEnvironmentList;
 
public:
    typedef TestFlag::Fragment<TestFlag::SHUFFLE_TESTS>         shuffle;
    typedef TestFlag::Fragment<TestFlag::RUN_DISABLED_TESTS>    also_run_disabled_tests;
    typedef TestFlag::Fragment<TestFlag::BREAK_ON_FAILURE>      break_on_failure;
    typedef TestFlag::Fragment<TestFlag::CATCH_EXCEPTION>       catch_exceptions;
    typedef TestFlag::Fragment<TestFlag::THROW_ON_FAILURE>      throw_on_failure;
    typedef TestFlag::Fragment<TestFlag::WARNING_INTO_ERROR>    warning_into_error;
    typedef TestFlag::Fragment<TestFlag::PRINT_TIME>            print_time;
    typedef TestFlag::Fragment<TestFlag::SHOW_TESTS_LIST>       list_tests;
    typedef TestFlag::Fragment<TestFlag::SHOW_TESTS_LIST_WITH_WHERE> list_tests_with_where;
 
    typedef TestFlag::Fragment<TestFlag::CATCH_EXCEPTION_EACH>      catch_exceptions_each;
    typedef TestFlag::Fragment<TestFlag::CATCH_EXCEPTION_GLOBAL>    catch_exceptions_global;
 
    typedef TestFlag::Fragment<TestFlag::FILELOCATION_STYLE_MSVC>   file_location_style_msvc;
    typedef TestFlag::Fragment<TestFlag::VERBOSE>   verbose;
 
    typedef class RandomSeedSet
    {
    public:
        RandomSeedSet() IUTEST_CXX_NOEXCEPT_SPEC {}
        RandomSeedSet(unsigned int seed) { init_random(seed); }
        RandomSeedSet& operator = (unsigned int seed) { init_random(seed); return *this; }
        operator unsigned int() const { return get_random_seed(); }
    } random_seed;
 
    typedef class RepeatCountSet
    {
    public:
        RepeatCountSet() IUTEST_CXX_NOEXCEPT_SPEC {}
        RepeatCountSet(int count) { set_repeat_count(count); }
        RepeatCountSet& operator = (int count) { set_repeat_count(count); return *this; }
        operator int() const { return get_repeat_count(); }
    } repeat;
 
#if defined(IUTEST_NO_PRIVATE_IN_AGGREGATE)
    friend class RandomSeedSet;
    friend class RepeatCountSet;
#endif
 
    template<typename T>
    class StateVariable
    {
        bool m_dirty;
        T   m_value;
    public:
        StateVariable& operator = (const T& rhs) { m_value = rhs; m_dirty = true; return *this; }
        operator const T& () const { return m_value; }
        const T& operator ()() const { return m_value; }
        bool is_dirty() const { return m_dirty; }
        void flush() { m_dirty = false; }
        T& get() { return m_value; }
        const T& get() const { return m_value; }
    };
 
private:
    struct Variable
    {
        Variable()
            : m_random_seed(0)
            , m_current_random_seed(0)
            , m_before_origin_random_seed(0)
            , m_repeat_count(1)
            , m_testpartresult_reporter(NULL)
        {}
        unsigned int        m_random_seed;
        unsigned int        m_current_random_seed;
        unsigned int        m_before_origin_random_seed;
        int                 m_repeat_count;
        StateVariable< ::std::string >  m_output_option;
        ::std::string       m_test_filter;
        ::std::string       m_flagfile;
#if IUTEST_HAS_STREAM_RESULT
        StateVariable< ::std::string >  m_stream_result_to;
#endif
        ::std::string       m_default_package_name;
        detail::iuRandom    m_genrand;
        iuEnvironmentList   m_environment_list;
        TestEventListeners  m_event_listeners;
        TestPartResultReporterInterface*    m_testpartresult_reporter;
#if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
        iu_stringstream     m_ostream_formatter;
#endif
        ::std::string       m_locale_ctype;
    };
 
    static Variable& get_vars() { static Variable sVars; return sVars; }
 
private:
    static const char*          get_output_option_c_str() { return get_vars().m_output_option.get().c_str(); }
#if IUTEST_HAS_STREAM_RESULT
    static const char*          get_stream_result_to_c_str() { return get_vars().m_stream_result_to.get().c_str(); }
#endif
 
public:
    static detail::iuRandom&    genrand() { return get_vars().m_genrand; }              
    static unsigned int         get_random_seed() { return get_vars().m_random_seed; }              
    static unsigned int         current_random_seed() { return get_vars().m_current_random_seed; }  
    static int                  get_repeat_count() { return get_vars().m_repeat_count; }            
    static const StateVariable< ::std::string >& get_output_option() { return get_vars().m_output_option; }  
    static const char*          get_default_package_name() { return get_vars().m_default_package_name.c_str(); }    
    static const char*          test_filter() { return get_vars().m_test_filter.c_str(); }      
    static const char*          get_flagfile() { return get_vars().m_flagfile.c_str(); }        
#if IUTEST_HAS_STREAM_RESULT
    static const StateVariable< ::std::string >& get_stream_result_to() { return get_vars().m_stream_result_to; }
#endif
#if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
    static void                 global_ostream_copyfmt(iu_ostream& os) { os.copyfmt(get_vars().m_ostream_formatter); }  // NOLINT
#endif
    static const char*          get_locale_ctype() { return get_vars().m_locale_ctype.c_str(); }    
    static bool                 is_specific_locale_ctype() { return !get_vars().m_locale_ctype.empty(); }
 
    static ::std::string get_report_xml_filepath();
    static ::std::string get_report_junit_xml_filepath();
 
    static TestEventListeners& event_listeners() { return get_vars().m_event_listeners; }
    static TestPartResultReporterInterface* GetGlobalTestPartResultReporter()
    {
        return get_vars().m_testpartresult_reporter;
    }
    static void SetGlobalTestPartResultReporter(TestPartResultReporterInterface* ptr)
    {
        get_vars().m_testpartresult_reporter = ptr;
    }
    static bool has_output_option()
    {
        return !get_vars().m_output_option.get().empty();
    }
    static bool is_output_option_dirty()
    {
        return get_vars().m_output_option.is_dirty();
    }
    static void flush_output_option()
    {
        get_vars().m_output_option.flush();
    }
 
private:
    static void init_random(unsigned int seed)
    {
        get_vars().m_random_seed = seed;
    }
 
    static void set_repeat_count(int count)
    {
        get_vars().m_repeat_count = count;
    }
 
    static void set_test_filter(const char* str)
    {
        get_vars().m_test_filter = str == NULL ? "*" : str;
        TestFlag::SetFlag(TestFlag::FILTERING_TESTS);
    }
 
    static void set_flagfile_path(const char* str)
    {
        get_vars().m_flagfile = str;
    }
 
    static void set_flagfile(const char* str)
    {
        ParseFlagFileOption(str);
        LoadFlagFile();
    }
 
#if IUTEST_HAS_STREAM_RESULT
    static void set_stream_result_to(const char* str)
    {
        get_vars().m_stream_result_to = detail::NullableString(str);
    }
#endif
 
    static const char* get_color_option()
    {
        if( TestFlag::IsEnableFlag(TestFlag::CONSOLE_COLOR_ANSI) )
        {
            return "ansi";
        }
        else if( TestFlag::IsEnableFlag(TestFlag::CONSOLE_COLOR_ON) )
        {
            return "yes";
        }
        else if( TestFlag::IsEnableFlag(TestFlag::CONSOLE_COLOR_OFF) )
        {
            return "no";
        }
        return "auto";
    }
    static void set_color_option(const char* str)
    {
        ParseColorOption(str);
    }
 
    static void set_output_option(const char* str)
    {
        get_vars().m_output_option = detail::NullableString(str);
    }
 
    static void set_default_package_name(const char* str)
    {
        get_vars().m_default_package_name = detail::NullableString(str);
    }
 
    static void set_locale_ctype(const char* str)
    {
        get_vars().m_locale_ctype = detail::NullableString(str);
    }
 
private:
    typedef const char* (*pfnOptionStringGet)();
    typedef void(*pfnOptionStringSet)(const char*);
    template<pfnOptionStringGet G, pfnOptionStringSet S>
    class OptionString
    {
        typedef OptionString<G, S> _Myt;
        typedef const _Myt& _Argt;
    protected:
        ::std::string m_option;
    public:
        friend bool operator == (const char* c_str_, _Argt rhs)         { return rhs.m_option == c_str_; }
        friend bool operator == (const ::std::string& str, _Argt rhs)   { return rhs.m_option == str; }
        friend bool operator == (_Argt lhs, const char* c_str_)         { return lhs.m_option == c_str_; }
        friend bool operator == (_Argt lhs, const ::std::string& str)   { return lhs.m_option == str; }
        friend bool operator != (const char* c_str_, _Argt rhs)         { return rhs.m_option != c_str_; }
        friend bool operator != (const ::std::string& str, _Argt rhs)   { return rhs.m_option != str; }
        friend bool operator != (_Argt lhs, const char* c_str_)         { return lhs.m_option != c_str_; }
        friend bool operator != (_Argt lhs, const ::std::string& str)   { return lhs.m_option != str; }
 
        operator ::std::string() const { return m_option; }
    public:
        bool empty() const          { return m_option.empty(); }
        const char* c_str() const   { return m_option.c_str(); }
        size_t length() const       { return m_option.length(); }
    public:
        OptionString()
            : m_option(G())
        {
        }
        const _Myt& operator = (const char* c_str_)
        {
            m_option = detail::NullableString(c_str_);
            S(c_str_);
            return *this;
        }
        const _Myt& operator = (const ::std::string& str)
        {
            m_option = str;
            S(str.c_str());
            return *this;
        }
    };
 
public:
    typedef OptionString<get_color_option, set_color_option> color;
 
    typedef OptionString<test_filter, set_test_filter> filter;
 
    typedef OptionString<get_flagfile, set_flagfile> flagfile;
 
    typedef OptionString<get_output_option_c_str, set_output_option> output;
 
#if IUTEST_HAS_STREAM_RESULT
    typedef OptionString<get_stream_result_to_c_str, set_stream_result_to> stream_result_to;
#endif
 
    typedef OptionString<get_default_package_name, set_default_package_name> default_package_name;
 
    typedef OptionString<get_locale_ctype, set_locale_ctype> locale_ctype;
 
#if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
    typedef class OStreamFormatter : public iu_stringstream
    {
        IUTEST_WORKAROUND_MSC_STLSTREAM_C4250()
    public:
        OStreamFormatter()
        {
            copyfmt(get_vars().m_ostream_formatter);
        }
        virtual ~OStreamFormatter()
        {
            get_vars().m_ostream_formatter.copyfmt(*this);
        }
    } ostream_formatter;
 
#if defined(IUTEST_NO_PRIVATE_IN_AGGREGATE)
    friend class OStreamFormatter;
#endif
 
#endif
 
private:
    static iuEnvironmentList& environments() { return get_vars().m_environment_list; }
 
public:
    static Environment* AddGlobalTestEnvironment(Environment* env)
    {
        if( env == NULL )
        {
            return NULL;
        }
        environments().push_back(env);
        return env;
    }
 
    static Environment* ReleaseGlobalTestEnvironment(Environment* env)
    {
        if( env == NULL )
        {
            return NULL;
        }
        iuEnvironmentList& list = environments();
        iuEnvironmentList::iterator it = ::std::find(list.begin(), list.end(), env);
        if( it == list.end() )
        {
            return NULL;
        }
        list.erase(it);
        return env;
    }
 
    static ::std::string AddDefaultPackageName(const char* testsuite_name);
 
private:
    static void ReleaseGlobalTestEnvironment()
    {
        // すべて解放する
        for( iuEnvironmentList::iterator it=environments().begin(); it != environments().end(); )
        {
            Environment* p = *it;
            it = environments().erase(it);
            delete p;
        }
    }
 
public:
    template<typename CharType>
    static void ParseCommandLine(int* pargc, CharType** argv)
    {
        if( argv == NULL )
        {
            return;
        }
        int argc = *pargc;
 
        for( int i=0; i < argc; )
        {
            if( ParseCommandLineElem(argv[i]) )
            {
                --argc;
                // 見つかった場合、オプションを末尾に移動
                for( int k=i; k < argc; ++k )
                {
                    CharType* tmp = argv[k];
                    argv[k] = argv[k+1];
                    argv[k+1] = tmp;
                }
            }
            else
            {
                ++i;
            }
        }
        *pargc = argc;
    }
 
    template<typename CharType>
    static void ParseCommandLine(::std::vector< ::std::basic_string<CharType> >& argv)
    {
        typedef ::std::vector< ::std::basic_string<CharType> > argv_t;
        for( typename argv_t::iterator it = argv.begin(); it != argv.end(); )
        {
            if( ParseCommandLineElem(it->c_str()) )
            {
                it = argv.erase(it);
            }
            else
            {
                ++it;
            }
        }
    }
 
    static bool LoadFlagFile();
 
private:
    template<typename CharType>
    static bool ParseCommandLineElem(CharType* argv)
    {
        typedef typename detail::mbs_ptr<CharType> formatter;
 
        formatter argv_format;
        const char* str = argv_format.ptr(argv);
        return ParseCommandLineElemA(str);
    }
    static bool ParseCommandLineElemA(const char* str);
    static bool ParseIutestOptionCommandLineElemA(const char* str);
    static bool SetFlag(int enable, int mask = -1);
 
private:
    static void LoadEnvironmentVariable();
 
    static void SetUp();
 
private:
    static inline const char* ParseOptionSettingStr(const char* opt)
    {
        const char* eq = strchr(opt, '=');
        if( eq == NULL )
        {
            return NULL;
        }
        return eq+1;
    }
    static bool ParseColorOption(const char* option);
 
    static bool ParseOutputOption(const char* option);
 
    static bool ParseFileLocationOption(const char* option);
 
    static bool ParseFilterOption(const char* option);
 
    static bool ParseFlagFileOption(const char* option);
 
    static bool ParseYesNoFlagCommandLine(const char* str, TestFlag::Kind flag, int def);
 
    static int ParseYesNoOption(const char* option);
 
    static bool IsYes(const char* option);
    static bool IsNo(const char* option);
 
private:
    friend class UnitTest;
};
 
class iu_global_format_stringstream : public iu_stringstream
{
    IUTEST_WORKAROUND_MSC_STLSTREAM_C4250()
public:
    iu_global_format_stringstream()
    {
#if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
        TestEnv::global_ostream_copyfmt(*this);
#endif
    }
    explicit iu_global_format_stringstream(const char* str)
        : iu_stringstream(str)
    {
#if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
        TestEnv::global_ostream_copyfmt(*this);
#endif
    }
    explicit iu_global_format_stringstream(const ::std::string& str)
        : iu_stringstream(str)
    {
#if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
        TestEnv::global_ostream_copyfmt(*this);
#endif
    }
};
 
template<typename T>
inline iu_ostream& operator << (iu_ostream& os, const TestEnv::StateVariable<T>& value)
{
    return os << value.get();
}
 
 
}   // end of namespace iutest
 
#if !IUTEST_HAS_LIB
#  include "impl/iutest_env.ipp" // IWYU pragma: export
#endif
 
#endif // INCG_IRIS_IUTEST_ENV_HPP_F4017EAB_6CA3_4E6E_8983_059393DADD04_