utpp.h

Go to the documentation of this file.

#pragma once
/*
  UTPP - A New Generation of UnitTest++
  (c) Mircea Neacsu 2017-2025
 
  See LICENSE file for full copyright information.
*/

 
#ifdef _WIN32
#if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS 1
#endif
//Acrobatics to leave out winsock.h (for the benefit of winsock2.h)
#ifndef _WINSOCKAPI_
#define _WINSOCKAPI_
#define MUST_UNDEF_WINSOCK
#endif
 
#include <windows.h>
 
#ifdef MUST_UNDEF_WINSOCK
#undef _WINSOCKAPI_
#undef MUST_UNDEF_WINSOCK
#endif
 
#endif
 
#include <string>
#include <deque>
#include <stdexcept>
#include <sstream>
#include <cassert>
#include <chrono>
#ifndef _WIN32
#include <sys/stat.h>
#include <unistd.h>
#endif
 
// --------------- Global configuration options -------------------------------
#define UTPP_VERSION "2.2.0"
 
// --------------- end of configuration options -------------------------------
 
namespace UnitTest {

const size_t MAX_MESSAGE_SIZE = 1024;
 
}
#define DEFAULT_SUITE "DefaultSuite"
 
//------------------------------ Test macros ----------------------------------
#ifdef TEST
#error Macro TEST is already defined
#endif
 
#ifdef TEST_FIXTURE
#error Macro TEST_FIXTURE is already defined
#endif
 
#ifdef SUITE
#error Macro SUITE is already defined
#endif
 
/* VC doesn't define the proper value for __cplusplus but _MSVC_LANG is correct.
  Fake it here for non-MS compilers
*/
#ifndef _MSVC_LANG
#define _MSVC_LANG __cplusplus
#endif

 
#if _MSVC_LANG < 201703L
#define TEST_MAIN(ARGC, ARGV) \
UnitTest::Test *UnitTest::CurrentTest; \
UnitTest::Reporter *UnitTest::CurrentReporter; \
double UnitTest::default_tolerance; \
std::string UnitTest::CurrentSuite; \
int main (ARGC,ARGV)
#else
#define TEST_MAIN(ARGC, ARGV) int main (ARGC, ARGV)
#endif
 


#define SUITE(Name)                                                           \
  namespace Suite##Name                                                       \
  {                                                                           \
      inline char const* GetSuiteName () { return #Name ; }                   \
  }                                                                           \
  namespace Suite##Name
 
#define TEST(Name)                                                            \
  class Test##Name : public UnitTest::Test                                    \
  {                                                                           \
  public:                                                                     \
    Test##Name() : Test(#Name) {}                                             \
  private:                                                                    \
    void RunImpl() override;                                                  \
  };                                                                          \
  UnitTest::Test* Name##_maker() {return new Test##Name; }                    \
  UnitTest::TestSuite::Inserter Name##_inserter (GetSuiteName(), #Name, __FILE__, __LINE__,\
    Name##_maker);                                                            \
  void Test##Name::RunImpl()
 

#define TEST_FIXTURE(Fixture, Name)                                           \
  class Fixture##Name##Helper : public Fixture, public UnitTest::Test         \
  {                                                                           \
  public:                                                                     \
    Fixture##Name##Helper() : Fixture (), Test(#Name) {}                      \
  private:                                                                    \
    void RunImpl() override;                                                  \
  };                                                                          \
  UnitTest::Test* Name##_maker() {return new Fixture##Name##Helper;}          \
  UnitTest::TestSuite::Inserter Name##_inserter (GetSuiteName(), #Name,       \
    __FILE__, __LINE__, Name##_maker);                                        \
  void Fixture##Name##Helper::RunImpl()
 
#ifdef ABORT
#error Macro ABORT is already defined
#endif

#define ABORT(value) \
  do                                                                          \
  {                                                                           \
    if (UnitTest::Check(value))                                               \
      throw UnitTest::test_abort (__FILE__, __LINE__, #value);                \
  } while (0)
 
#ifdef ABORT_EX
#error Macro ABORT_EX is already defined
#endif

#define ABORT_EX(value, ...) \
  do                                                                          \
  {                                                                           \
    if (UnitTest::Check(value)) {                                             \
      char message[UnitTest::MAX_MESSAGE_SIZE];                               \
      snprintf (message, UnitTest::MAX_MESSAGE_SIZE, __VA_ARGS__);            \
      throw UnitTest::test_abort (__FILE__, __LINE__, message);               \
    }                                                                         \
  } while (0)



#define UTPP_TIME_CONSTRAINT(tmax) \
  UnitTest::TimeConstraint unitTest__timeConstraint__(tmax, __FILE__, __LINE__)

#define UTPP_TIME_CONSTRAINT_EXEMPT() no_time_constraint ()

 
namespace UnitTest {
 
// forward declarations
struct Failure;
class TestSuite;
 
void ReportFailure(const std::string& filename, int line, const std::string& message);

class Test
{
public:
  Test (const std::string& testName);
  virtual ~Test() {};
  void no_time_constraint ();
  bool is_time_constraint () const;
 
  int failure_count () const;
  std::chrono::milliseconds test_time_ms () const;
  const std::string& test_name () const;
 
  void failure ();
  void run ();

  virtual void RunImpl () {};
 
protected:
  std::string name;                   
  int failures;                       
  std::chrono::milliseconds time;     
  bool time_exempt;                   
 
private:
  Test (Test const&) = delete;
  Test& operator =(Test const&) = delete;
  friend class TestSuite;
};

struct Failure
{
  std::string filename;     
  std::string message;      
  int line_number;          
};
 

class Reporter
{
public:
  Reporter ();
  virtual ~Reporter () {};

  void SetTrace (bool on_off) { trace = on_off; }

  virtual void SuiteStart (const TestSuite& suite);

  virtual void TestStart (const Test& test);

  virtual void ReportFailure (const Failure& failure);

  virtual void TestFinish (const Test& test);

  virtual int SuiteFinish (const TestSuite& suite);

  virtual int Summary () { return total_failed_count; }

  virtual void Clear ();
 
protected:
  int suite_test_count,     
    suite_failed_count,     
    suite_failures_count;   
  std::chrono::milliseconds suite_time; 
 
  int total_test_count,     
    total_failed_count,     
    total_failures_count;   
  std::chrono::milliseconds total_time;  
 
  int suites_count;         
  bool trace;               
 
};

class ReporterDeferred : public Reporter
{
public:
  ReporterDeferred () {};
  void SuiteStart (const TestSuite& suite) override;
  void TestStart (const Test& test) override;
  void ReportFailure (const Failure& failure) override;
  void TestFinish (const Test& test) override;
  void Clear () override;
 
protected:
  struct TestResult
  {
    TestResult ();
    TestResult (const std::string& suite, const std::string& test);
 
    std::string suite_name;         
    std::string test_name;          
    std::chrono::milliseconds test_time;  
    std::deque<Failure> failures;   
  };
 
  std::deque<TestResult> results;   
};

typedef UnitTest::Test* (*Testmaker)();

class TestSuite
{
public:
  class Inserter
  {
  public:
    Inserter (const std::string& suite,
      const std::string& test,
      const std::string& file,
      int line,
      Testmaker func);
 
  private:
    const std::string test_name,      
      file_name;                      
    const int line;                   
    const Testmaker maker;            
 
    friend class TestSuite;
  };
 
  explicit TestSuite (const std::string& name);
  void Add (const Inserter* inf);
  bool IsEnabled () const;
  void Enable (bool on_off);
  int RunTests (Reporter& reporter, std::chrono::milliseconds max_runtime);
 
  std::string name;     
 
private:
  std::deque <const Inserter*> test_list;  
  std::chrono::milliseconds max_runtime;
  bool enabled;
 
  bool SetupCurrentTest (const Inserter* inf);
  void RunCurrentTest (const Inserter* inf);
  void TearDownCurrentTest (const Inserter* inf);
};

class Timer
{
public:
  Timer ();
  void Start ();
  std::chrono::milliseconds GetTimeInMs () const;
  std::chrono::microseconds GetTimeInUs () const;
 
private:
  std::chrono::steady_clock::time_point startTime;
};

class TimeConstraint
{
public:
  template<typename R, typename P>
  TimeConstraint (std::chrono::duration<R, P> t, const char* file, int line);
  ~TimeConstraint ();
 
private:
  void operator=(TimeConstraint const&) = delete;
  TimeConstraint (TimeConstraint const&) = delete;
 
  Timer timer;
  std::string filename;
  int line_number;
  std::chrono::milliseconds tmax;
};

class SuitesList {
public:
  void Add (const std::string& suite, const TestSuite::Inserter* inf);
  int Run (const std::string& suite, Reporter& reporter, std::chrono::milliseconds max_time);
  int RunAll (Reporter& reporter, std::chrono::milliseconds max_time);
  static SuitesList& GetSuitesList ();
  void Enable (const std::string& suite, bool enable = true);
 
private:
 
  std::deque <TestSuite> suites;
};

struct test_abort : public std::runtime_error
{
  test_abort (const char* file_, int line_, const char* msg)
    : std::runtime_error (msg)
    , file (file_)
    , line (line_)
  {};
  const char* file;
  int line;
};
 
struct tolerance_not_set : public std::runtime_error
{
  tolerance_not_set ()
    : std::runtime_error ("UnitTest::default_tolerance not set")
  {};
};

extern Test* CurrentTest;

extern std::string CurrentSuite;

extern Reporter* CurrentReporter;

Reporter& GetDefaultReporter ();

int RunAllTests (Reporter& rpt = GetDefaultReporter (), std::chrono::milliseconds max_time = std::chrono::milliseconds{ 0 });

void DisableSuite (const std::string& suite_name);

void EnableSuite (const std::string& suite_name);

int RunSuite (const char *suite_name, Reporter& rpt = GetDefaultReporter (), std::chrono::milliseconds max_time = std::chrono::milliseconds{ 0 });

void ReportFailure (const std::string& filename, int line, const std::string& message);
 
//-------------------------- Test member functions ----------------------------
inline
Test::Test(const std::string& test_name)
    : name(test_name)
    , failures(0)
    , time(0)
    , time_exempt(false)
{
}

inline
void Test::run()
{
    Timer test_timer;
    test_timer.Start();
 
    RunImpl();
    time = test_timer.GetTimeInMs();
}

inline
void Test::failure()
{
    failures++;
}

inline
int Test::failure_count () const
{
  return failures;
}

inline
std::chrono::milliseconds Test::test_time_ms () const
{
  return time;
}

inline
const std::string& Test::test_name () const
{
  return name;
}

inline
void Test::no_time_constraint ()
{
  time_exempt = true;
}

inline
bool Test::is_time_constraint () const
{
  return !time_exempt;
}
 
//--------------------- Reporter member functions -----------------------------
inline
Reporter::Reporter ()
  : suite_test_count (0)
  , suite_failed_count (0)
  , suite_failures_count (0)
  , suite_time (0)
  , total_test_count (0)
  , total_failed_count (0)
  , total_failures_count (0)
  , total_time (0)
  , suites_count (0)
  , trace (false)
{
}

inline
void Reporter::SuiteStart (const TestSuite&)
{
  suites_count++;
  suite_test_count = suite_failed_count = suite_failures_count = 0;
}
 
inline
void Reporter::TestStart (const Test&)
{
  suite_test_count++;
  total_test_count++;
}
 
inline
void Reporter::ReportFailure (const Failure&)
{
}
 
inline
void Reporter::TestFinish (const Test& t)
{
  int f = t.failure_count ();
  if (f)
  {
    suite_failed_count++;
    suite_failures_count += f;
    total_failed_count++;
    total_failures_count += f;
  }
  auto ms = t.test_time_ms ();
  suite_time += ms;
  total_time += ms;
}

inline
int Reporter::SuiteFinish (const TestSuite&)
{
  return suite_failures_count;
}
 
 
inline 
void Reporter::Clear ()
{
  using namespace std::chrono_literals;
  suite_test_count =
    suite_failed_count =
    suite_failures_count = 0;
    suite_time = 0ms;
 
    total_test_count =
      total_failed_count =
      total_failures_count = 0;
    total_time = 0ms;
 
  suites_count = 0;
}
 
//------------------- ReporterDeferred member functions -----------------------
inline
ReporterDeferred::TestResult::TestResult ()
  : test_time{0}
{
}

inline
ReporterDeferred::TestResult::TestResult (const std::string& suite, const std::string& test)
  : suite_name (suite)
  , test_name (test)
  , test_time (0)
{
}

inline
void ReporterDeferred::SuiteStart (const TestSuite& suite)
{
  results.push_back (TestResult (suite.name, std::string()));
}

inline
void ReporterDeferred::TestStart (const Test& test)
{
  Reporter::TestStart (test);
  results.push_back (TestResult (CurrentSuite, test.test_name ()));
}

inline
void ReporterDeferred::ReportFailure (const Failure& failure)
{
  assert (!results.empty ());
 
  Reporter::ReportFailure (failure);
  results.back ().failures.push_back (failure);
}

inline
void ReporterDeferred::TestFinish (const Test& test)
{
  Reporter::TestFinish (test);
  results.back ().test_time = test.test_time_ms();
}
 
inline void ReporterDeferred::Clear ()
{
  Reporter::Clear ();
  results.clear ();
}
 
 
//------------------- TestSuite member functions ------------------------------
 
inline
TestSuite::TestSuite (const std::string& name_)
  : name (name_)
  , max_runtime (0)
  , enabled (true)
{
}

inline
void TestSuite::Add (const Inserter* inf)
{
  test_list.push_back (inf);
}

inline
int TestSuite::RunTests (Reporter& rep, std::chrono::milliseconds maxtime)
{
  CurrentSuite = name;
  CurrentReporter = &rep;

  CurrentReporter->SuiteStart (*this);
  std::deque <const Inserter*>::iterator listp = test_list.begin ();
  max_runtime = maxtime;
  while (listp != test_list.end ())
  {
    if (SetupCurrentTest (*listp))
    {
      RunCurrentTest (*listp); 
      TearDownCurrentTest (*listp);  
    }
    ++listp;
  }
  return CurrentReporter->SuiteFinish (*this);
}

inline
bool TestSuite::SetupCurrentTest (const Inserter* inf)
{
  bool ok = false;
  try {
    CurrentTest = (inf->maker)();
    ok = true;
  }
  catch (UnitTest::test_abort& x)
  {
    std::stringstream stream;
    stream << " Aborted setup of " << inf->test_name << " - " << x.what ();
    CurrentTest = new Test (inf->test_name); //mock-up to keep ReportFailure happy
    ReportFailure (x.file, x.line, stream.str ());
    delete CurrentTest;
    CurrentTest = 0;
  }
  catch (const std::exception& e)
  {
    std::stringstream stream;
    stream << "Unhandled exception: " << e.what ()
      << " while setting up test " << inf->test_name;
    CurrentTest = new Test (inf->test_name); //mock-up to keep ReportFailure happy
    ReportFailure (inf->file_name, inf->line, stream.str ());
    delete CurrentTest;
    CurrentTest = 0;
  }
  catch (...)
  {
    std::stringstream stream;
    stream << "Setup unhandled exception while setting up test " << inf->test_name;
    CurrentTest = new Test (inf->test_name); //mock-up to keep ReportFailure happy
    ReportFailure (inf->file_name, inf->line, stream.str ());
    delete CurrentTest;
    CurrentTest = 0;
  }
  return ok;
}

inline
void TestSuite::RunCurrentTest (const Inserter* inf)
{
  assert (CurrentTest);
  CurrentReporter->TestStart (*CurrentTest);
 
 
  try {
    CurrentTest->run ();
  }
  catch (UnitTest::test_abort& x)
  {
    ReportFailure (x.file, x.line, std::string ("Test aborted: ") + x.what ());
  }
  catch (const std::exception& e)
  {
    std::stringstream stream;
    stream << "Unhandled exception: " << e.what ()
      << " while running test " << inf->test_name;
    ReportFailure (inf->file_name, inf->line, stream.str ());
  }
  catch (...)
  {
    std::stringstream stream;
    stream << "Unhandled exception while running test " << inf->test_name;
    ReportFailure (inf->file_name, inf->line, stream.str ());
  }
 
  auto actual_time = CurrentTest->test_time_ms ();
  if (CurrentTest->is_time_constraint () && max_runtime.count() && actual_time > max_runtime)
  {
    std::stringstream stream;
    stream << "Global time constraint failed while running test " << inf->test_name
      << " Expected time <" << max_runtime << "; actual = " << actual_time;
 
    ReportFailure (inf->file_name, inf->line, stream.str ());
  }
  CurrentReporter->TestFinish (*CurrentTest);
}

inline
void TestSuite::TearDownCurrentTest (const Inserter* inf)
{
  try {
    delete CurrentTest;
    CurrentTest = 0;
  }
  catch (const std::exception& e)
  {
    std::stringstream stream;
    stream << "Unhandled exception: " << e.what ()
      << " while tearing down test " << inf->test_name;
    ReportFailure (inf->file_name, inf->line, stream.str ());
  }
  catch (...)
  {
    std::stringstream stream;
    stream << "Unhandled exception tearing down test " << inf->test_name;
    ReportFailure (inf->file_name, inf->line, stream.str ());
  }
}

inline
bool TestSuite::IsEnabled () const
{
  return enabled;
}

inline
void TestSuite::Enable (bool on_off)
{
  enabled = on_off;
}
 
//------------------ TestSuite::Inserter --------------------------------------
inline
TestSuite::Inserter::Inserter (const std::string& suite, const std::string& test,
    const std::string& file, int ln, Testmaker func)
  : test_name (test)
  , file_name (file)
  , line (ln)
  , maker (func)
{
  SuitesList::GetSuitesList ().Add (suite, this);
}
 
//-----------------Timer member functions -------------------------------------
inline
Timer::Timer ()
{
}

inline
void Timer::Start ()
{
  startTime = std::chrono::steady_clock::now ();
}

inline
std::chrono::milliseconds Timer::GetTimeInMs () const
{
  auto elapsedTime = std::chrono::steady_clock::now () - startTime;
  return std::chrono::duration_cast<std::chrono::milliseconds>(elapsedTime);
}

inline
std::chrono::microseconds Timer::GetTimeInUs () const
{
  auto elapsedTime = std::chrono::steady_clock::now () - startTime;
  return std::chrono::duration_cast<std::chrono::microseconds>(elapsedTime);
}
 
//------------------TimeConstraint member functions ---------------------------

template <typename R, typename P>
TimeConstraint::TimeConstraint (std::chrono::duration<R, P> t, const char* file, int line)
  : filename (file)
  , line_number (line)
  , tmax (t)
{
  timer.Start ();
}

inline
TimeConstraint::~TimeConstraint ()
{
  std::chrono::milliseconds t = timer.GetTimeInMs ();
  if (t > tmax)
  {
    std::stringstream stream;
    stream << "Time constraint failed. Expected time <" << tmax << "; actual = " << t;
 
    ReportFailure (filename, line_number, stream.str ());
  }
}
 
 
//-------------------SuitesList member functions ------------------------------

inline
void SuitesList::Add (const std::string& suite_name, const TestSuite::Inserter* inf)
{
  auto p = suites.begin ();
  while (p != suites.end () && p->name != suite_name)
    p++;
 
  if (p == suites.end ())
  {
    suites.emplace_back (suite_name);
    suites.back ().Add (inf);
  }
  else
    p->Add (inf);
}

inline
int SuitesList::Run (const std::string& suite_name, Reporter& reporter, std::chrono::milliseconds max_time)
{
  for (auto& s : suites)
  {
    if (s.name == suite_name)
    {
      s.RunTests (reporter, max_time);
      return reporter.Summary ();
    }
  }
  return -1;
}

inline
int SuitesList::RunAll (Reporter& reporter, std::chrono::milliseconds max_time)
{
  for (auto& s : suites)
  {
    if (s.IsEnabled ())
      s.RunTests (reporter, max_time);
  }
 
  return reporter.Summary ();
}

inline
SuitesList& SuitesList::GetSuitesList ()
{
  static SuitesList all_suites;
  return all_suites;
}

inline
void SuitesList::Enable (const std::string& suite, bool enable)
{
  for (auto& s : suites)
  {
    if (s.name == suite)
    {
      s.Enable (enable);
      break;
    }
  }
}


inline
int RunAllTests (Reporter& rpt, std::chrono::milliseconds max_time)
{
  rpt.Clear ();
  return SuitesList::GetSuitesList ().RunAll (rpt, max_time);
}

inline
int RunSuite (const char* suite_name, Reporter& rpt, std::chrono::milliseconds max_time)
{
  return SuitesList::GetSuitesList ().Run (suite_name, rpt, max_time);
}

inline
void DisableSuite (const std::string& suite_name)
{
  SuitesList::GetSuitesList ().Enable (suite_name, false);
}

inline
void EnableSuite (const std::string& suite_name)
{
  SuitesList::GetSuitesList ().Enable (suite_name, true);
}

inline
void ReportFailure(const std::string& filename, int line, const std::string& message)
{
    if (CurrentTest)
        CurrentTest->failure();
    Failure f = { filename, message, line };
    CurrentReporter->ReportFailure(f);
}
 
} // end of UnitTest namespace
 

inline
const char* GetSuiteName ()
{
  return DEFAULT_SUITE;
}
 
#include "reporter_stream.h"
#include "reporter_xml.h"
#ifdef _WIN32
#include "reporter_dbgout.h"
#endif
#include "checks.h"

inline
UnitTest::Reporter& UnitTest::GetDefaultReporter ()
{
  static UnitTest::ReporterStream the_default_reporter;
  return the_default_reporter;
}
 
#if (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)  \
  || (!defined(_MSVC_LANG) && (__cplusplus >= 201703L))
// In C++ 17 and later we have inline data. TEST_MAIN is not really needed.
inline UnitTest::Test* UnitTest::CurrentTest;
inline UnitTest::Reporter* UnitTest::CurrentReporter;
inline std::string UnitTest::CurrentSuite;
#endif