unit-test.h

Go to the documentation of this file.

#ifndef UNIT_TEST_UTILS
#define UNIT_TEST_UTILS
 
#ifndef TEST_RESOURCES_DIR
#define TEST_RESOURCES_DIR "../TestResources"
#define TEST_TMP_DIR TEST_RESOURCES_DIR "/tmp"
#endif
 
#include "CscCommon.h"
 
#include <boost/test/execution_monitor.hpp>
#include <boost/test/framework.hpp>
#include <boost/test/results_collector.hpp>
#include <boost/test/tree/observer.hpp>
#include <boost/test/unit_test.hpp>
#include "./fakeit.hpp"
 
#define CSCTEST_HAS_ARGS(...) CSCTEST_HAS_ARGS_IMPL(__VA_ARGS__, 1, 0)
#define CSCTEST_HAS_ARGS_IMPL(_1, _2, N, ...) N
#define CSCTEST_ASSERT(expr, ...)                                            \
    if (CSCTEST_HAS_ARGS(__VA_ARGS__)) {                                     \
        if (!(expr)) {                                                       \
            LOG_ERROR("assert failed - 🧾 stacktrace = " + getStackTrace()); \
        }                                                                    \
    }                                                                        \
    BOOST_TEST(expr __VA_OPT__(, ) __VA_ARGS__);
 
using std::string, std::function, std::vector, std::to_string, boost::unit_test::assertion_result, boost::test_tools::tt_detail::tolerance_manip_delay, boost::test_tools::tolerance;
using namespace conscience_utils;
using namespace fakeit;
using namespace boost::unit_test::framework;
 
namespace fs = std::filesystem;
 
class ConscienceTestObserver : public boost::unit_test::test_observer {
public:
    ConscienceTestObserver();
    void exception_caught(boost::execution_exception const &error) override;
    void assertion_result(enum assertion_result result) override;
    bool wasAnExceptionCaught();
    void resetExceptionTracking();
    void test_finish() override;
 
private:
    int errorCount = 0;
    bool exceptionCaught;
    std::unique_ptr<CscLogger> logger;
};
 
class FixtureBase {
public:
    static ConscienceTestObserver *observer;
    unique_ptr<CscLogger> logger;
    FixtureBase();
    virtual ~FixtureBase();
};
 
class CscEnvironmentSimulator;
class FixtureIntegrationTestBase : public FixtureBase {
public:
    FixtureIntegrationTestBase();
    virtual ~FixtureIntegrationTestBase();
 
    CscEnvironmentSimulator *createEnvironmentSimulator(bool loadDefaultFloor = true);
 
private:
    vector<CscEnvironmentSimulator *> createdEnvironmentSimulators;
};
 
string getCurrentTestName();
fs::path getTestTempPath(const fs::path &relativePath);
 
template <class MockedType>
MockedType *mockToPointer(Mock<MockedType> &mock) {
    Fake(Dtor(mock));
 
    MockedType &instanceReference = mock.get();
    std::shared_ptr<MockedType> sharedPtr(&instanceReference);
    MockedType *pointer = sharedPtr.get();
    return pointer;
}
 
template <class MockedType>
ptr<MockedType> mockToSharedPointer(Mock<MockedType> &mock) {
    Fake(Dtor(mock));
 
    MockedType &instanceReference = mock.get();
    ptr<MockedType> sharedPtr(&instanceReference);
 
    return sharedPtr;
}
 
template <class T>
void assertVectorsEqual(const vector<T> &left, const vector<T> &right) {
    CSCTEST_ASSERT(left.size() == right.size());
    for (int i = 0; i < left.size(); i++) {
        if constexpr (std::is_same<T, double>::value) {
            CSCTEST_ASSERT(left[i] == right[i], boost::test_tools::tolerance(0.00001));
        } else {
            CSCTEST_ASSERT(left[i] == right[i]);
        }
    }
}
template <class T>
void assertTrue(const T &boolValue) {
    CSCTEST_ASSERT(bool(boolValue));
}
template <class T>
void assertFalse(const T &boolValue) {
    CSCTEST_ASSERT(!bool(boolValue));
}
 
template <typename T>
concept IsStringLike = std::is_same_v<T, const string> || std::is_same_v<T, string> || std::is_same_v<T, char *> || std::is_same_v<T, const char *>;
template <IsStringLike T1, IsStringLike T2>
void assertEquals(T1 left, T2 right) {
    CSCTEST_ASSERT(string(left) == string(right));
}
 
template <class T1, class T2>
    requires(!IsStringLike<T1>)
void assertEquals(T1 left, T2 right, optional<double> decimalTolerance = {}) {
    if (decimalTolerance.has_value()) {
        CSCTEST_ASSERT(left == right, tolerance(decimalTolerance.value()));
    } else {
        CSCTEST_ASSERT(left == right);
    }
}
template <class T1, class T2>
void assertNotEquals(T1 left, T2 right) {
    CSCTEST_ASSERT(left != right);
}
template <class T>
void assertNotNull(T *object) {
    CSCTEST_ASSERT(object != nullptr);
}
template <class T>
void assertNotNull(ptr<const T> object) {
    CSCTEST_ASSERT(object != nullptr);
}
template <class T>
void assertNotNull(ptr<T> object) {
    CSCTEST_ASSERT(object != nullptr);
}
 
template <class TException>
void assertThrows(function<void()> action) {
    bool thrown = false;
    try {
        action();
    } catch (const TException &e) {
        thrown = true;
    }
    assertTrue(thrown);
}
 
void assertFileContent(const fs::path &path, const string &expectedContent);
 
#endif