UnitTestLog.h

// UnitTestLog.h:
// --------------
//

#ifndef __IPSDKUNITTESTTOOLS_UNITTESTLOG_H__
#define __IPSDKUNITTESTTOOLS_UNITTESTLOG_H__

// suppression warnings
// warning C4275: non dll-interface class 'boost::noncopyable_::noncopyable' used as base for dll-interface class 'ipsdk::UnitTestLog'
// warning C4251: 'ipsdk::unittest::UnitTestLog::_outputHtmlFileName' : class 'std::basic_string<_Elem,_Traits,_Ax>' needs to have dll-interface to be used by clients of class 'ipsdk::unittest::UnitTestLog'
#pragma warning (push)
#pragma warning (disable : 4275 4251)

#include <UnitTest/IPSDKUnitTestTools/IPSDKUnitTestToolsExports.h>
#include <UnitTest/IPSDKUnitTestTools/UnitTestTypes.h>
#include <IPSDKUtil/BaseTypes.h>
#include <IPSDKUtil/Tools/Chrono.h>
#include <boost/test/unit_test_log_formatter.hpp>
#include <boost/noncopyable.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/shared_ptr.hpp>

namespace ipsdk {
namespace unittest {

class UnitTestResult;
class PythonUnitTestManager;


class IPSDKUNITTESTTOOLS_API UnitTestLog : public boost::unit_test::unit_test_log_formatter,
                                           public boost::noncopyable
{
    // friend class for protected members access
    friend class PythonUnitTestManager;

public:
    UnitTestLog();
    ~UnitTestLog();
    
// methods
public:
    bool                            isInit() const;

    void                            initCpp(const boost::filesystem::path& outputHtmlFilePath,
                                            const boost::filesystem::path& outputResultFilePath,
                                            const boost::filesystem::path& logResourceDir,
                                            const bool bDisplayReport);

    void                            initPython(const boost::filesystem::path& outputHtmlFilePath,
                                               const boost::filesystem::path& outputResultFilePath,
                                               const boost::filesystem::path& logResourceDir,
                                               const ipUInt32 pythonMajorVersion,
                                               const ipUInt32 pythonMinorVersion,
                                               const bool bDisplayReport);

    const boost::filesystem::path&  getOutputHtmlFilePath() const;

    const boost::filesystem::path&  getOutputResultFilePath() const;

    void    notifyTestStart();

    void    notifyTestSuiteStart(const std::string& testSuiteName);

    void    notifyTestCaseStart(const std::string& testCaseName);

    void    notifyTestSuccess(const std::string& testFilePath,
                              const ipUInt32 testLineIdx,
                              const std::string& testMsg);

    void    notifyTestWarning(const std::string& testFilePath,
                              const ipUInt32 testLineIdx,
                              const std::string& testMsg);

    void    notifyTestFailure(const std::string& testFilePath,
                              const ipUInt32 testLineIdx,
                              const std::string& testMsg);

    void    notifyTestCrash(const std::string& testMsg);

    void    notifyTestException(const std::string& lastCheckPointFilePath,
                                const ipUInt32 lastCheckPointLineIdx,
                                const std::string& exceptionFunctionName,
                                const std::string& exceptionFilePath,
                                const ipUInt32 exceptionLineIdx,
                                const std::string& exceptionMsg);

    void    notifyTestCaseEnd();

    void    notifyTestSuiteEnd();

    void    notifyTestEnd();

private:
    void    notifyTestEntry(const std::string& testInfoStr,
                            const std::string& testFilePath,
                            const ipUInt32 testLineIdx,
                            const std::string& testMsg);

    void    log_start(std::ostream& os,
                      boost::unit_test::counter_t);

    void    log_finish(std::ostream& os);

    void    log_build_info(std::ostream& os, bool b);

    void    test_unit_start(std::ostream& os,
                            const boost::unit_test::test_unit& unitTest);

    void    test_unit_finish(std::ostream& os,
                             const boost::unit_test::test_unit& unitTest,
                             unsigned long elapsed);

    void    test_unit_skipped(std::ostream& os,
                              const boost::unit_test::test_unit& unitTest);

    void    log_entry_start(std::ostream& os,
                            const boost::unit_test::log_entry_data& data,
                            log_entry_types let);

    void    log_entry_value(std::ostream& os,
                            boost::unit_test::const_string value);

    void    log_entry_finish(std::ostream& os);

    void    log_exception_start(std::ostream& os,
                                const boost::unit_test::log_checkpoint_data& data,
                                const boost::execution_exception& e);

    void    log_exception_finish(std::ostream& os) {}

    void    entry_context_start(std::ostream& os, boost::unit_test::log_level l) {}

    void    log_entry_context(std::ostream& os, boost::unit_test::log_level l, boost::unit_test::const_string value) {}

    void    entry_context_finish(std::ostream& os, boost::unit_test::log_level l) {}

// attributes
protected:
    boost::filesystem::path     _outputHtmlFilePath;

    boost::filesystem::path     _outputResultFilePath;

    boost::filesystem::path     _logResourceDir;

    std::string                 _testLanguage;

    boost::filesystem::ofstream _ofs;

    ipUInt32                    _nbTestSuites;

    ipUInt32                    _nbTestCases;

    ipUInt32                    _nbTests;

    ipUInt32                    _nbTestsInCurCase;

    ipUInt32                    _nbErrors;

    ipUInt32                    _nbWarnings;

    std::string                 _curTestValueStr;

    std::string                 _curTestInfoStr;

    std::string                 _curTestFileName;

    // current test suite name
    std::string                 _curTestSuiteName;

    // current test case name
    std::string                 _curTestCaseName;

    ipUInt32                    _curTestLineIdx;

    Chrono                      _testsChrono;

    Chrono                      _testSuiteChrono;

    Chrono                      _testCaseChrono;

    bool                        _bDisplayReport;

    typedef boost::shared_ptr<UnitTestResult> UnitTestResultPtr;

    UnitTestResultPtr           _pUnitTestResult;

    bool                        _bTestCaseClosed;

    bool                        _bInit;

};


inline bool
UnitTestLog::isInit() const
{
    return _bInit;
}


} // end of namespace unittest
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKUNITTESTTOOLS_UNITTESTLOG_H__