test.hpp File Reference

#include <atomic>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <tuple>
#include <valfuzz/common.hpp>

Go to the source code of this file.

Namespaces
namespace	valfuzz

Macros
#define	ASSERT(cond)
#define	ASSERT_EQ(a, b)
#define	ASSERT_NE(a, b)
#define	ASSERT_LT(a, b)
#define	ASSERT_LE(a, b)
#define	ASSERT_GT(a, b)
#define	ASSERT_GE(a, b)
#define	ASSERT_THROW(expr, exception)
#define	ASSERT_NO_THROW(expr)
#define	TEST(name, pretty_name)
#define	BEFORE()
#define	AFTER()

Functions
std::deque< valfuzz::test_pair > &	valfuzz::get_tests ()
std::mutex &	valfuzz::get_test_mutex ()
long unsigned int	valfuzz::get_num_tests ()
std::atomic< bool > &	valfuzz::get_has_failed_once ()
std::function< void()> &	valfuzz::get_function_execute_before ()
std::function< void()> &	valfuzz::get_function_execute_after ()
void	valfuzz::set_function_execute_before (std::function< void()> f)
void	valfuzz::set_function_execute_after (std::function< void()> f)
void	valfuzz::set_has_failed_once (bool has_failed_once)
void	valfuzz::add_test (const std::string &name, test_function test)
std::optional< valfuzz::test_pair >	valfuzz::pop_test_or_null ()
void	valfuzz::run_one_test (const std::string &name)
void	valfuzz::_run_tests ()
void	valfuzz::run_tests ()

Macro Definition Documentation

AFTER

#define AFTER

(

)

Value:

  void after();                                                                \
  static struct after##_register                                               \
  {                                                                            \
    after##_register()                                                         \
    {                                                                          \
      valfuzz::set_function_execute_after(after);                              \
    }                                                                          \
  } after##_register_instance;                                                 \
  void after()

Definition at line 166 of file test.hpp.

ASSERT

#define ASSERT

(

cond

)

Value:

  if (!(cond))                                                                 \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #cond << std::endl;                   \
  }

Definition at line 22 of file test.hpp.

ASSERT_EQ

#define ASSERT_EQ	(		a,
			b )

Value:

  if ((a) != (b))                                                              \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #a << " != " << #b << std::endl;      \
  }

Definition at line 31 of file test.hpp.

ASSERT_GE

#define ASSERT_GE	(		a,
			b )

Value:

  if ((a) < (b))                                                               \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #a << " >= " << #b << std::endl;      \
  }

Definition at line 76 of file test.hpp.

ASSERT_GT

#define ASSERT_GT	(		a,
			b )

Value:

  if ((a) <= (b))                                                              \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #a << " > " << #b << std::endl;       \
  }

Definition at line 67 of file test.hpp.

ASSERT_LE

#define ASSERT_LE	(		a,
			b )

Value:

  if ((a) > (b))                                                               \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #a << " <= " << #b << std::endl;      \
  }

Definition at line 58 of file test.hpp.

ASSERT_LT

#define ASSERT_LT	(		a,
			b )

Value:

  if ((a) >= (b))                                                              \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #a << " < " << #b << std::endl;       \
  }

Definition at line 49 of file test.hpp.

ASSERT_NE

#define ASSERT_NE	(		a,
			b )

Value:

  if ((a) == (b))                                                              \
  {                                                                            \
    valfuzz::set_has_failed_once(true);                                        \
    std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());             \
    std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";      \
    std::cerr << "Assertion failed: " << #a << " == " << #b << std::endl;      \
  }

Definition at line 40 of file test.hpp.

ASSERT_NO_THROW

#define ASSERT_NO_THROW

(

expr

)

Value:

  {                                                                            \
    try                                                                        \
    {                                                                          \
      expr;                                                                    \
    }                                                                          \
    catch (...)                                                                \
    {                                                                          \
      valfuzz::set_has_failed_once(true);                                      \
      std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());           \
      std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";    \
      std::cerr << "Exception thrown" << std::endl;                            \
    }                                                                          \
  }

Definition at line 105 of file test.hpp.

ASSERT_THROW

#define ASSERT_THROW	(		expr,
			exception )

Value:

  {                                                                            \
    bool exception_thrown = false;                                             \
    try                                                                        \
    {                                                                          \
      expr;                                                                    \
    }                                                                          \
    catch (const exception &e)                                                 \
    {                                                                          \
      exception_thrown = true;                                                 \
    }                                                                          \
    if (!exception_thrown)                                                     \
    {                                                                          \
      valfuzz::set_has_failed_once(true);                                      \
      std::lock_guard<std::mutex> lock(valfuzz::get_stream_mutex());           \
      std::cerr << "test: " << test_name << ", line: " << __LINE__ << ", ";    \
      std::cerr << "Exception not thrown: " << #exception << std::endl;        \
    }                                                                          \
  }

Definition at line 85 of file test.hpp.

BEFORE

#define BEFORE

(

)

Value:

  void before();                                                               \
  static struct before##_register                                              \
  {                                                                            \
    before##_register()                                                        \
    {                                                                          \
      valfuzz::set_function_execute_before(before);                            \
    }                                                                          \
  } before##_register_instance;                                                \
  void before()

Definition at line 155 of file test.hpp.

TEST

#define TEST	(		name,
			pretty_name )

Value:

  void name([[maybe_unused]] const std::string &test_name);                    \
  static struct name##_register                                                \
  {                                                                            \
    name##_register()                                                          \
    {                                                                          \
      valfuzz::add_test(pretty_name, name);                                    \
    }                                                                          \
  } name##_register_instance;                                                  \
  void name([[maybe_unused]] const std::string &test_name)

Definition at line 144 of file test.hpp.