console_test_runner.cpp

Go to the documentation of this file.

//  (C) Copyright Gennadiy Rozental 2005-2007.
//  Distributed under the Boost Software License, Version 1.0.
//  (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/test for the library home page.

// Boost.Test
#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
#endif

//suppression of warnings related to 3rd party files
#pragma warning ( disable: 6031 )
#pragma warning ( disable: 6011 )
#pragma warning ( disable: 6001 )

#include <boost/test/unit_test.hpp>

// Boost.Runtime.Param
#include <boost/test/utils/runtime/cla/named_parameter.hpp>
#include <boost/test/utils/runtime/cla/parser.hpp>

//end suppression of warnings related to 3rd party files
#pragma warning ( default: 6031 )
#pragma warning ( default: 6011 )
#pragma warning ( default: 6001 )

namespace rt  = boost::runtime;
namespace cla = boost::runtime::cla;

// STL
#include <iostream>

#include <boost/cstdlib.hpp>    // for exit codes

#include <fstream>
#include "CBoostTestTreeLister.h"
#include "CBoostTestTreeDebugLister.h"

//_________________________________________________________________//

// System API

namespace dyn_lib
{
#if defined(BOOST_WINDOWS) && !defined(BOOST_DISABLE_WIN32) // WIN32 API

#include <windows.h>

typedef HINSTANCE handle;

inline handle
open(std::string const& file_name)
{
    return LoadLibrary(file_name.c_str());
}

//_________________________________________________________________//

template<typename TargType>
inline TargType
locate_symbol(handle h, std::string const& symbol)
{
    return reinterpret_cast<TargType>(GetProcAddress(h, symbol.c_str()));
}

//_________________________________________________________________//

inline void
close(handle h)
{
    if (h)
    {
        FreeLibrary(h);
    }
}

//_________________________________________________________________//

inline std::string
error()
{
    LPTSTR msg = NULL;

    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                  NULL,
                  GetLastError(),
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR)&msg,
                  0, NULL);

    std::string res;

    if (msg)
    {
        res = msg;
        LocalFree(msg);
    }

    return res;
}

//_________________________________________________________________//

#elif defined(BOOST_HAS_UNISTD_H) // POSIX API

#include <dlfcn.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

typedef void* handle;

inline handle
open(std::string const& file_name)
{
    return dlopen(file_name.c_str(), RTLD_LOCAL | RTLD_LAZY);
}

//_________________________________________________________________//
template<typename TargType>
inline TargType
locate_symbol(handle h, std::string const& symbol)
{
    return reinterpret_cast<TargType>(dlsym(h, symbol.c_str()));
}

//_________________________________________________________________//
/*
*   @brief Unloads a dll library on a POSIX run-time environment
*/
inline void
close(handle h)
{
    if (h)
    {
        dlclose(h);
    }
}

//_________________________________________________________________//

inline std::string
error()
{
    return dlerror();
}

//_________________________________________________________________//

#else

#error "Dynamic library API is unknown"

#endif
} // namespace dyn_lib

//____________________________________________________________________________//

static std::string test_lib_name;
static std::string init_func_name("init_unit_test");

dyn_lib::handle test_lib_handle;

typedef bool (*init_func_ptr)();

//____________________________________________________________________________//
bool load_test_lib()
{
    init_func_ptr init_func;

    test_lib_handle = dyn_lib::open(test_lib_name);    //load the library via the relevant OS API

    if (!test_lib_handle)
        throw std::logic_error(std::string("Fail to load test library: ")
                               .append(dyn_lib::error()));

    init_func = dyn_lib::locate_symbol<init_func_ptr>(test_lib_handle, init_func_name);    //locate the initialization method inside the library

    /*
    if( !init_func )
    throw std::logic_error( std::string("Can't locate test initialization function ")
    .append( init_func_name )
    .append( ": " )
    .append( dyn_lib::error() ) );
    */

    return (init_func == nullptr) || ((*init_func)());
}

//____________________________________________________________________________//
std::unique_ptr<std::ofstream> GetListOutputStream(const cla::parser& P, const std::string& arg)
{
    std::string listOut;
    assign_op(listOut, P.get(arg), 0);

    if (!listOut.empty())
    {
        return std::unique_ptr<std::ofstream>(new std::ofstream(listOut, (std::ios_base::out | std::ios_base::trunc)));
    }

    return std::unique_ptr<std::ofstream>();
}

//____________________________________________________________________________//

typedef std::unique_ptr<::etas::boost::unit_test::CBoostTestTreeLister> TBoostTestTreeListerPtr;

/*
*   @brief Factory method return the correct type of test enumerator(lister) depending on the verbosity required
*
*   @param [in]  arg      string containing either either "list" or "list-debug" on which the factory method will use to determine the type of lister to return
*   @param [in]  dll      library path containing the Boost UTF tests
*   @param [in]  out      pointer to an output stream class which the test enumerator will use to output the report
*   @return      object   of either type CBoostTestTreeLister or CBoostTestTreeDebugLister depending on the verbosity required as supplied by argument arg
*/
TBoostTestTreeListerPtr GetTestTreeLister(const std::string& arg, const std::string dll, std::ostream* out = nullptr)
{
    out = (out == nullptr) ? &std::cout : out;

    if (arg == "list")
    {
        return TBoostTestTreeListerPtr(new ::etas::boost::unit_test::CBoostTestTreeLister(dll, out)); //less detail
    }
    else
    {
        return TBoostTestTreeListerPtr(new ::etas::boost::unit_test::CBoostTestTreeDebugLister(dll, out)); //more detail
    }

}

//____________________________________________________________________________//
std::ostream& WriteError(std::ostream& out, const std::string& dll, const std::string& error = std::string())
{
    out << "<![CDATA[Error: Could not load " << dll << '.';

    if (!error.empty())
    {
        out << " Detail: " << error;
    }

    out << "]]>";

    return out;
}

//____________________________________________________________________________//
int ListTests(const cla::parser& P)
{
    int res = ::boost::exit_success;

    std::string arg = (P["list"]) ? "list" : "list-debug";

    std::unique_ptr<std::ofstream> out = GetListOutputStream(P, arg);
    TBoostTestTreeListerPtr lister = GetTestTreeLister(arg, test_lib_name, out.get());

    if (lister != nullptr)
    {
        std::ostream& listing = lister->WriteHeader();

        try
        {
            if (load_test_lib())
            {
                //if the loading the library was successfull, then we proceed in enumerating the tests.
                ::boost::unit_test::traverse_test_tree(::boost::unit_test::framework::master_test_suite(), *lister);
            }
        }
        catch (std::exception& ex)
        {
            WriteError(listing, test_lib_name, ((ex.what() == nullptr) ? std::string() : ex.what()));
            res = ::boost::exit_failure;
        }
        catch (...)
        {
            WriteError(listing, test_lib_name);
            res = ::boost::exit_failure;
        }

        lister->WriteTrailer();
    }

    return res;
}

//____________________________________________________________________________//

int main(int argc, char* argv[])
{
    try
    {
        cla::parser P;

        P - cla::ignore_mismatch
                << cla::named_parameter<rt::cstring>("test") - (cla::prefix = "--")
                << cla::named_parameter<rt::cstring>("list") - (cla::prefix = "--", cla::optional)
                << cla::named_parameter<rt::cstring>("list-debug") - (cla::prefix = "--", cla::optional)
                << cla::named_parameter<rt::cstring>("init") - (cla::prefix = "--", cla::optional);

        P.parse(argc, argv);

        assign_op(test_lib_name, P.get("test"), 0);

        if (P["init"])
        {
            assign_op(init_func_name, P.get("init"), 0);
        }

        int res = ::boost::exit_success;

        //if the list or the list-debug command line directives are present then just enumerate tests,
        //otherwise execute the tests according to the additional Boost UTF specific  command line options supplied
        if (P["list"] || P["list-debug"])
        {
            res = ListTests(P);
        }
        else
        {
            //run tests
            res = ::boost::unit_test::unit_test_main(&load_test_lib, argc, argv);
        }

        ::boost::unit_test::framework::clear();
        dyn_lib::close(test_lib_handle);    //unload the library

        return res;
    }
    catch (rt::logic_error const& ex)
    {
        std::cout << "Fail to parse command line arguments: " << ex.msg() << std::endl;
        return -1;
    }
}

//____________________________________________________________________________//

// EOF