quickcpplib::_xxx::unit_test Namespace Reference

Classes
struct	requirement_failed
struct	test_case
struct	test_case_registration
struct	test_suite
struct	test_suite_registration

Functions
jmp_buf &	test_case_failed ()
std::vector< test_suite > &	test_suites ()
test_suite *&	current_test_suite ()
test_case *&	current_test_case ()
int	run (int argc, const char *const argv[])

Function Documentation

test_case_failed()

jmp_buf & quickcpplib::_xxx::unit_test::test_case_failed ( )

externinline

  {
    static jmp_buf b;
    return b;
  }

test_suites()

std::vector< test_suite > & quickcpplib::_xxx::unit_test::test_suites ( )

externinline

  {
    static std::vector<test_suite> v;
    return v;
  }

current_test_suite()

test_suite *& quickcpplib::_xxx::unit_test::current_test_suite ( )

externinline

  {
    static test_suite *v;
    return v;
  }

current_test_case()

test_case *& quickcpplib::_xxx::unit_test::current_test_case ( )

externinline

  {
    static test_case default_test_case("unnamed", "Default test case for unit test which don't declare test cases",
                                       nullptr);
    static test_case *v = &default_test_case;
    return v;
  }

run()

int quickcpplib::_xxx::unit_test::run ( int  argc, const char *const  argv[]  )

externinline

  {
    std::regex enabled(".*"), disabled;
    bool list_tests = false;
    std::string output_xml;
    for(int n = 1; n < argc; n++)
    {
      // Double -- means it's a flag
      if(argv[n][0] == '-' && argv[n][1] == '-')
      {
        if(strstr(argv[n] + 2, "help"))
        {
          std::cout << "\nQuickCppLib minimal unit test framework\n\n"  //
                    << "Usage: " << argv[0]
                    << " [options] [<regex for tests to run, defaults to .*>] [-<regex for tests to not run>]\n\n"  //
                    << "  --help              : Prints this help\n"                                                 //
                    << "  --list-tests        : List matching tests\n"                                              //
                    << "  --reporter <format> : Reporter to use, only format possible is junit\n"                   //
                    << "  --out <filename>    : Write JUnit XML test report to filename\n"                          //
                    << std::endl;
          return 0;
        }
        else if(strstr(argv[n] + 2, "list-tests"))
        {
          list_tests = true;
        }
        else if(strstr(argv[n] + 2, "reporter"))
        {
          if(n + 1 >= argc || strcmp(argv[n + 1], "junit"))
          {
            std::cerr << "--reporter must be followed by 'junit'" << std::endl;
            return 1;
          }
          n++;
        }
        else if(strstr(argv[n] + 2, "out"))
        {
          if(n + 1 >= argc)
          {
            std::cerr << "--out must be followed by the output filename" << std::endl;
            return 1;
          }
          output_xml = argv[n + 1];
          n++;
        }
      }
      else
      {
        // -regex is disabled, otherwise it's an enabled
        if(argv[n][0] == '-')
          disabled.assign(argv[n] + 1);
        else
          enabled.assign(argv[n]);
      }
    }
    if(list_tests)
    {
      size_t maxname = 0;
      for(const auto &j : test_suites())
      {
        for(const auto &i : j.test_cases)
        {
          if(strlen(i.name) > maxname)
            maxname = strlen(i.name);
        }
      }
      for(const auto &j : test_suites())
      {
        std::cout << "\n" << j.name << ":\n";
        for(const auto &i : j.test_cases)
        {
          if(std::regex_match(i.name, enabled) && !std::regex_match(i.name, disabled))
          {
            std::string padding(maxname - strlen(i.name), ' ');
            std::cout << "  " << i.name << padding << " (" << i.desc << ")\n";
          }
        }
      }
      std::cout << std::endl;
      return 0;
    }
    for(auto &j : test_suites())
    {
      for(auto &i : j.test_cases)
      {
        if(std::regex_match(i.name, enabled) && !std::regex_match(i.name, disabled))
        {
          current_test_case() = &i;
          std::cout << std::endl << bold << blue << i.name << white << " : " << i.desc << normal << std::endl;
          std::chrono::steady_clock::time_point begin, end;
#ifdef __cpp_exceptions
          try
          {
#else
          if(setjmp(test_case_failed()))
          {
            end = std::chrono::steady_clock::now();
            i.requirement_failed = true;
          }
          else
#endif
            {
              begin = std::chrono::steady_clock::now();
              i.func();
              end = std::chrono::steady_clock::now();
            }
#ifdef __cpp_exceptions
          }
          catch(const requirement_failed &)
          {
            end = std::chrono::steady_clock::now();
            i.requirement_failed = true;
          }
          catch(const std::exception &e)
          {
            end = std::chrono::steady_clock::now();
            ++i.fails;
            std::cerr << red << "FAILURE: std::exception '" << e.what() << "' thrown out of test case" << normal
                      << std::endl;
          }
          catch(...)
          {
            end = std::chrono::steady_clock::now();
            ++i.fails;
            std::cerr << red << "FAILURE: Exception thrown out of test case" << normal << std::endl;
          }
#endif
          i.duration = end - begin;
          if(i.passes)
            std::cout << green << i.passes << " checks passed  ";
          if(i.fails)
            std::cout << red << i.fails << " checks failed  ";
          std::cout << normal << "duration "
                    << std::chrono::duration_cast<std::chrono::milliseconds>(i.duration).count() << " ms" << std::endl;
        }
        else
          i.skipped = true;
      }
    }
    current_test_case() = nullptr;
    std::ofstream oh;
    if(!output_xml.empty())
    {
      oh.open(output_xml);
      oh << R"(<?xml version="1.0" encoding="UTF-8"?>
<testsuites>
)";
    }
    size_t totalpassed = 0, totalfailed = 0, totalskipped = 0;
    double totaltime = 0;
    for(const auto &j : test_suites())
    {
      size_t passed = 0, failed = 0, skipped = 0;
      double time = 0;
      for(const auto &i : j.test_cases)
      {
        if(i.skipped)
          ++skipped;
        else if(i.fails)
          ++failed;
        else
          ++passed;
        time += std::chrono::duration_cast<std::chrono::duration<double>>(i.duration).count();
      }
      if(!output_xml.empty())
      {
        oh << "  <testsuite name=\"" << j.name << "\" errors=\"" << 0 << "\" failures=\"" << failed << "\" skipped=\""
           << skipped << "\" tests=\"" << j.test_cases.size() << "\" hostname=\"\" time=\"" << time
           << "\" timestamp=\"\">\n";
        for(const auto &i : j.test_cases)
        {
          oh << "    <testcase classname=\"\" name=\"" << i.name << "\" time=\""
             << std::chrono::duration_cast<std::chrono::duration<double>>(i.duration).count() << "\">";
          if(i.skipped)
            oh << "<skipped/>";
          else if(i.fails)
            oh << "<failure/>";
          oh << "</testcase>\n";
        }
        oh << "  </testsuite>\n";
      }
      totalpassed += passed;
      totalfailed += failed;
      totalskipped += skipped;
      totaltime += time;
    }
    if(!output_xml.empty())
    {
      oh << R"(</testsuites>
)";
    }
    std::cout << bold << white << "\n\nTest case summary: " << green << totalpassed << " passed " << red << totalfailed
              << " failed " << yellow << totalskipped << " skipped" << normal << "\nTotal duration: " << totaltime