unittest.h

Go to the documentation of this file.

//
// Bareflank Hypervisor
//
// Copyright (C) 2015 Assured Information Security, Inc.
// Author: Rian Quinn        <quinnr@ainfosec.com>
// Author: Brendan Kerrigan  <kerriganb@ainfosec.com>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

#ifndef UNITTEST_H
#define UNITTEST_H

#ifdef OS_LINUX
#define LINUX_TARGET
#endif

#include <gsl/gsl>

#include <memory>
#include <cstdlib>
#include <stdlib.h>
#include <string>
#include <iostream>

#include <exception.h>
#include <view_as_pointer.h>

#define NO_HIPPOMOCKS_NAMESPACE

#pragma GCC system_header
#include <hippomocks.h>

struct exception_state
{
    bool caught;
    bool wrong_exception;
    std::string caught_type;
    std::string expecting_type;
    std::string caught_what;
    std::string expecting_what;
};

inline auto operator"" _ut_ree(const char *str, std::size_t len)
{ (void)len; return std::make_shared<std::runtime_error>(str); }

inline auto operator"" _ut_lee(const char *str, std::size_t len)
{ (void)len; return std::make_shared<std::logic_error>(str); }

inline auto operator"" _ut_iae(const char *str, std::size_t len)
{ (void)len; return std::make_shared<std::invalid_argument>(str); }

inline auto operator"" _ut_ore(const char *str, std::size_t len)
{ (void)len; return std::make_shared<std::out_of_range>(str); }

inline auto operator"" _ut_dme(const char *str, std::size_t len)
{ (void)len; return std::make_shared<std::domain_error>(str); }

inline auto operator"" _ut_ffe(const char *str, std::size_t len)
{ (void)len; return std::make_shared<gsl::fail_fast>(str); }

inline auto operator"" _ut_bae(const char *str, std::size_t len)
{ (void)str; (void)len; return std::make_shared<std::bad_alloc>(); }

template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
auto make_ptr(const T ptr)
{ return reinterpret_cast<void *>(ptr); }

template<class P, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
auto make_ptr(const T ptr)
{ return reinterpret_cast<P *>(ptr); }

template<class T, class = typename std::enable_if<std::is_pointer<T>::value>::type>
auto make_uintptr(const T ptr)
{ return reinterpret_cast<uintptr_t>(ptr); }

#define expect_true(c) expect_true_with_args(c, gsl::cstring_span<>(#c), gsl::cstring_span<>(__PRETTY_FUNCTION__), __LINE__)

#define expect_false(c) expect_false_with_args(c, gsl::cstring_span<>(#c), gsl::cstring_span<>(__PRETTY_FUNCTION__), __LINE__)

#define expect_exception(f, e) expect_exception_with_args(f, e, __PRETTY_FUNCTION__, __LINE__)

#define expect_no_exception(f) expect_no_exception_with_args(f, __PRETTY_FUNCTION__, __LINE__)

#define RUN_UNITTEST_WITH_MOCKS(a,b) \
    this->run_unittest_with_mocks(a,b, static_cast<const char *>(__PRETTY_FUNCTION__), __LINE__);

#define RUN_ALL_TESTS(ut) [&]() -> decltype(auto) { (void) argc; (void) argv; ut _ut; return _ut.run(); }()

template<class T> void
no_delete(T *)
{ }

namespace bfn
{

template<class T> auto
mock_no_delete(MockRepository &mocks)
{
    auto &&ptr = mocks.Mock<T>();
    mocks.OnCallDestructor(ptr);

    return ptr;
}

template<class T> auto
mock_shared(MockRepository &mocks)
{ return std::shared_ptr<T>(mocks.Mock<T>(), no_delete<T>); }

template<class T> auto
mock_unique(MockRepository &mocks)
{ return std::unique_ptr<T>(mock_no_delete<T>(mocks)); }

}

static void
check_exception_type(struct exception_state &state, const std::exception &caught, const std::exception &expected)
{
    state.caught = true;
    state.caught_type = std::string(typeid(caught).name());
    state.caught_what = caught.what();

    if (typeid(caught) != typeid(expected))
    {
        state.wrong_exception = true;
        return;
    }

    if (state.expecting_what.size() > 0 && state.caught_what != state.expecting_what)
        state.wrong_exception = true;
}

class unittest
{

    // -------------------------------------------------------------------------
    // Public Interface
    // -------------------------------------------------------------------------

protected:

    virtual bool
    list() { return true; };

    virtual bool
    init() { return true; };

    virtual bool
    fini() { return true; };

    template<typename T>
    void run_unittest_with_mocks(MockRepository &mocks, T lamda, const char *func, int line)
    {
        // TODO: Would be great if we could get a printout of the functions
        // that are called that we were not expecting. Would also be great
        // to get a list of calls that we were expecting that were not called.
        //
        // This will require some mods to HippoMocks to store a list of both
        // types of problems, and then get that list when an exception
        // occurs.
        //
        // There also seems to be a lot of logic in HippMocks for the
        // NotImplementedException that doesn't ever seem to be filled in
        // correctly. e.what() always returns "std::exception" but there
        // appears to be logic to fill in e.what() with something else. Would
        // be great to clean that up.

        std::cout << std::uppercase;

        try
        {
            lamda();
        }
        catch (std::exception &e)
        {
            this->expect_failed(e.what(), func, line);
        }

        try
        {
            m_pass += mocks.VerifyAll();
        }
        catch (std::exception &e)
        {
            this->expect_failed(e.what(), func, line);
        }

        mocks.reset();

        // There is an issue with clang-tidy were is basically doesn't see the
        // call to this from hippomocks, so we run it here to silence the
        // warnings. Hippomocks currently doesn't support the reuse of the
        // mocking engine after a call to reset, so it's safe to run this as
        // any code that tries to use the mocking engine will fail regardless.
        MockRepoInstanceHolder<0>::instance = 0;
    }

    void
    compare_exceptions(const struct exception_state &state, gsl::cstring_span<> func, int line, int path_id = -1)
    {
        std::string not_caught = "no exception was caught";
        std::string wrong_caught = "wrong exception caught";

        if (path_id >= 0)
        {
            not_caught.append(std::string(" on path number ") + std::to_string(path_id));
            wrong_caught.append(std::string(" on path number ") + std::to_string(path_id));
        }

        if (!state.caught)
        {
            this->expect_failed(not_caught.c_str(), func.data(), line);
            std::cerr << "    - expecting: " << '\n';
            std::cout << "        - type: " << state.expecting_type << '\n';
            std::cout << "        - what: " << state.expecting_what << '\n';
        }
        else
        {
            if (state.wrong_exception)
            {
                this->expect_failed(wrong_caught.c_str(), func.data(), line);
                std::cerr << "    - caught: " << '\n';
                std::cout << "        - type: " << state.caught_type << '\n';
                std::cout << "        - what: " << state.caught_what << '\n';
                std::cerr << "    - expecting: " << '\n';
                std::cout << "        - type: " << state.expecting_type << '\n';
                std::cout << "        - what: " << state.expecting_what << '\n';
            }
            else
            {
                this->inc_pass();
            }
        }
    }

public:

    template <typename F> void
    expect_exception_with_args(F &&f, std::shared_ptr<const std::exception> expected,
                               gsl::cstring_span<> func, int line, int path_id = -1)
    {
        struct exception_state state = {false, false, "",  "", "", ""};

        state.expecting_type = std::string(typeid(*expected).name());
        state.expecting_what = expected->what();

        try { f(); }
        catch (BaseException &be) { throw; }
        catch (bfn::general_exception &ge) { check_exception_type(state, ge, *expected); }
        catch (std::exception &e) { check_exception_type(state, e, *expected); }
        catch (...)
        {
            state.wrong_exception = true;
            state.caught = true;
            state.caught_type = "unknown exception";
            std::cerr << "unknown exception caught" << '\n';
        }

        compare_exceptions(state, func, line, path_id);
    }

    template <typename F> void
    expect_no_exception_with_args(F &&f, gsl::cstring_span<> func, int line, int path_id = -1)
    {
        struct exception_state state = {false, false, "",  "", "", ""};

        try { f(); }
        catch (BaseException &be) { throw; }
        catch (bfn::general_exception &ge)
        {
            state.caught = true;
            state.caught_type = std::string("expected not to catch ") + typeid(ge).name();
        }
        catch (std::exception &e)
        {
            state.caught = true;
            state.caught_type = std::string("expected not to catch ") + typeid(e).name() + ": "_s + e.what();
        }
        catch (...)
        {
            state.caught = true;
            state.caught_type = "caught unkown exception";
        }

        if (path_id >= 0)
            state.caught_type.append(std::string(" on path number ") + std::to_string(path_id));

        this->expect_false_with_args(state.caught, gsl::string_span<>(state.caught_type), func, line);
    }


    void
    expect_true_with_args(bool condition, gsl::cstring_span<> condition_text, gsl::cstring_span<> func, int line)
    {
        if (condition)
        {
            this->inc_pass();
            return;
        }

        std::string reason = std::string(condition_text.data()) + " is false";
        this->expect_failed(reason.c_str(), func.data(), line);
    }

    //  this function.
    void
    expect_false_with_args(bool condition, gsl::cstring_span<> condition_text, gsl::cstring_span<> func, int line)
    {
        if (!condition)
        {
            this->inc_pass();
            return;
        }

        std::string reason = std::string(condition_text.data());
        this->expect_failed(reason.c_str(), func.data(), line);
    }

protected:

    void inc_pass() { m_pass++; }
    void inc_fail() { m_fail++; }

    // -------------------------------------------------------------------------
    // Private Interface
    // -------------------------------------------------------------------------

private:

    decltype(auto)
    internal_init()
    {
        m_pass = 0;
        m_fail = 0;

        return true;
    }

    decltype(auto)
    internal_fini()
    {
        if (m_fail > 0)
        {
            std::cout << '\n';
            std::cout << "totals: ";
            std::cout << std::dec << m_pass << " passed, ";
            std::cout << "\033[1;31m";
            std::cout << std::dec << m_fail << " failed";
            std::cout << "\033[0m";
            std::cout << '\n';

            return false;
        }
        else
        {
            std::cout << "totals: ";
            std::cout << "\033[1;32m";
            std::cout << std::dec << m_pass << " passed, ";
            std::cout << "\033[0m";
            std::cout << std::dec << m_fail << " failed";
            std::cout << '\n';

            return true;
        }
    }

public:

    unittest() :
        m_pass(0),
        m_fail(0)
    { }

    virtual ~unittest() {}

    decltype(auto)
    run()
    {
        if (this->internal_init() == false)
            return EXIT_FAILURE;

        if (this->init() == false)
        {
            std::cout << "\033[1;31mFAILED\033[0m: init" << '\n';
            return EXIT_FAILURE;
        }

        try
        {
            if (this->list() == false)
            {
                std::cout << "\033[1;31mFAILED\033[0m: list" << '\n';
                return EXIT_FAILURE;
            }
        }
        catch (std::exception &e)
        {
            std::cout << "unexpected exception was caught: " << e.what() << '\n';
            std::cout << "\033[1;31mFAILED\033[0m: list" << '\n';
            return EXIT_FAILURE;
        }
        catch (...)
        {
            std::cout << "unexpected exception was caught: unknown" << '\n';
            std::cout << "\033[1;31mFAILED\033[0m: list" << '\n';
            return EXIT_FAILURE;
        }

        if (this->fini() == false)
        {
            std::cout << "\033[1;31mFAILED\033[0m: fini" << '\n';
            return EXIT_FAILURE;
        }

        if (this->internal_fini() == false)
            return EXIT_FAILURE;

        return EXIT_SUCCESS;
    }

    void
    expect_failed(const char *condition, const char *func, int line)
    {
        std::cout << "\033[1;31mFAILED\033[0m: [" << std::dec << line << "]: " << func << '\n';
        std::cout << "    - reason: " << condition << '\n';
        this->inc_fail();
    }

    void
    assert_failed(const char *condition, const char *func, int line)
    {
        this->expect_failed(condition, func, line);
        throw (0);
    }

private:

    int m_pass;
    int m_fail;
};

#endif