unit-test.h File Reference

#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"

Go to the source code of this file.

Classes
class	ConscienceTestObserver
class	FixtureBase
class	FixtureIntegrationTestBase

Macros
#define	TEST_RESOURCES_DIR   "../TestResources"
#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, ...)

Functions
template<class MockedType >
MockedType *	mockToPointer (Mock< MockedType > &mock)
template<class MockedType >
ptr< MockedType >	mockToSharedPointer (Mock< MockedType > &mock)
template<class T >
void	assertVectorsEqual (const vector< T > &left, const vector< T > &right)
template<class T >
void	assertTrue (const T &boolValue)
template<class T >
void	assertFalse (const T &boolValue)
template<IsStringLike T1, IsStringLike T2>
void	assertEquals (T1 left, T2 right)
template<class T1 , class T2 >
	requires (!IsStringLike< T1 >) void assertEquals(T1 left
T2 optional< double > class T2 void	assertNotEquals (T1 left, T2 right)
template<class T >
void	assertNotNull (T *object)
template<class T >
void	assertNotNull (ptr< const T > object)
template<class TException >
void	assertThrows (function< void()> action)
void	assertFileContent (const fs::path &path, const string &expectedContent)

Variables
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 *>
T2	right
T2 optional< double >	decimalTolerance

Macro Definition Documentation

CSCTEST_ASSERT

#define CSCTEST_ASSERT	(		expr,
			...
	)

Value:

    if (CSCTEST_HAS_ARGS(__VA_ARGS__)) {                                     \
        if (!(expr)) {                                                       \
            LOG_ERROR("assert failed - 🧾 stacktrace = " + getStackTrace()); \
        }                                                                    \
    }                                                                        \
    BOOST_TEST(expr __VA_OPT__(, ) __VA_ARGS__);

CSCTEST_HAS_ARGS

#define CSCTEST_HAS_ARGS

(

...

)

CSCTEST_HAS_ARGS_IMPL(__VA_ARGS__, 1, 0)

CSCTEST_HAS_ARGS_IMPL

#define CSCTEST_HAS_ARGS_IMPL	(		_1,
			_2,
			N,
			...
	)		N

TEST_RESOURCES_DIR

#define TEST_RESOURCES_DIR   "../TestResources"

Function Documentation

assertEquals()

template<IsStringLike T1, IsStringLike T2>

void assertEquals	(	T1	left,
		T2	right
	)

assertFalse()

template<class T >

void assertFalse

(

const T &

boolValue

)

assertFileContent()

void assertFileContent	(	const fs::path &	path,
		const string &	expectedContent
	)

assertNotEquals()

T2 optional<double> class T2 void assertNotEquals	(	T1	left,
		T2	right
	)

assertNotNull() [1/2]

template<class T >

void assertNotNull

(

ptr< const T >

object

)

assertNotNull() [2/2]

template<class T >

void assertNotNull

(

T *

object

)

assertThrows()

template<class TException >

void assertThrows

(

function< void()>

action

)

assertTrue()

template<class T >

void assertTrue

(

const T &

boolValue

)

assertVectorsEqual()

template<class T >

void assertVectorsEqual	(	const vector< T > &	left,
		const vector< T > &	right
	)

mockToPointer()

template<class MockedType >

MockedType* mockToPointer

(

Mock< MockedType > &

mock

)

mockToSharedPointer()

template<class MockedType >

ptr<MockedType> mockToSharedPointer

(

Mock< MockedType > &

mock

)

requires()

template<class T1 , class T2 >

requires

(

!IsStringLike< T1 >

)

Variable Documentation

decimalTolerance

T2 optional<double> decimalTolerance

Initial value:

= {}) {
    if (decimalTolerance.has_value()) {
        CSCTEST_ASSERT(left == right, tolerance(decimalTolerance.value()));
    } else {
        CSCTEST_ASSERT(left == right);
    }
}
template <class T1

IsStringLike

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 *>

right

T2 right