mttest::TestSuites Struct Reference

Test suite metadata and runner. More...

#include <mttest.hpp>

Public Member Functions
bool	operator+= (const TestCase &tc)
SuiteStatus	run_suite (bool verbose, const std::string &suite)
SuiteStatus	run (int argc, char **argv)

Public Attributes
std::map< std::string, std::vector< TestCase > >	cases = {}

Detailed Description

Test suite metadata and runner.

Definition at line 171 of file mttest.hpp.

Member Function Documentation

operator+=()

bool mttest::TestSuites::operator+= ( const TestCase & tc )

inline

Definition at line 174 of file mttest.hpp.

                                      {
    cases[tc.suite].push_back(tc);
    return true;
  }

run()

SuiteStatus mttest::TestSuites::run ( int argc, char ** argv )

inline

Definition at line 268 of file mttest.hpp.

                                         {
    std::vector<std::string> suites;
    bool verbose = false;
    for (int i = 1; i < argc; ++i) {
      if (strcmp("-v", argv[i]) == 0) {
        verbose = true;
      } else {
        suites.emplace_back(argv[i]);
      }
    }
 
    SuiteStatus status = OK;
    if (suites.empty()) {
      for (const auto &[suite, cases] : cases) {
        status = std::max(status, run_suite(verbose, suite));
      }
      return status;
    }
    for (const auto &s : suites) {
      status = std::max(status, run_suite(verbose, s));
    }
    return status;
  }

Here is the call graph for this function:

run_suite()

SuiteStatus mttest::TestSuites::run_suite ( bool verbose, const std::string & suite )

inline

Definition at line 179 of file mttest.hpp.

                                                              {
    auto startTime = std::chrono::system_clock::now();
    auto test_cases = cases[suite];
    std::cout << suite << std::flush;
    bool suite_nl = false;
    auto print_suite_nl = [&] {
      if (suite_nl)
        return;
      suite_nl = true;
      std::cout << "\n";
    };
    mttest::SuiteStatus status = mttest::OK;
    for (const auto &tc : test_cases) {
      auto tcStart = std::chrono::system_clock::now();
      bool printed = false;
      auto print_case = [&] {
        print_suite_nl();
        if (printed) return;
        printed = true;
        std::cout << "\tCASE " << tc.name << std::flush;
      };
      if (verbose) print_case();
 
      auto context = mttest::TestContext{};
 
#if __cpp_exceptions
      try {
        tc.case_impl(context);
      } catch (const std::runtime_error &err) {
        context.add_error("Uncaught Exception", err, tc.name, 0);
      } catch (int err) {
        context.add_error("Uncaught Exception", err, tc.name, 0);
      } catch (...) {
        context.add_error("Uncaught Exception", tc.name, 0);
      }
#else
      tc.case_impl(context);
#endif
      if (context.errors.empty() && context.failures.empty() && verbose) {
        std::cout << " [PASS]";
      } else if (!context.errors.empty()) {
        print_case();
        std::cout << " [ERROR]";
        status = std::max(status, mttest::ERROR);
      } else if (!context.failures.empty()) {
        print_case();
        std::cout << " [FAILED]";
        status = std::max(status, mttest::FAIL);
      }
 
      if (printed) {
         std::cout << " (" <<
          std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - tcStart).count()
           << "ms)" << std::endl;
      }
 
      for (const auto &err : context.errors) {
        std::cout << "\t\t" << err.cond << " ERRED WITH " << err.err << "\n"
                  << "\t\t\tWHERE: " << err.file << ":" << err.line << "\n";
      }
 
      for (const auto &fail : context.failures) {
        std::cout << "\t\t" << fail.cond << " FAILED! " << fail.message << "\n"
                  << "\t\t\tWHERE: " << fail.file << ":" << fail.line << "\n";
      }
    }
 
    if (!suite_nl) {
      std::cout << " ";
    } else {
      std::cout << suite << " ";
    }
 
    switch (status) {
      case OK:
      std::cout << "[PASSED]";
      break;
      case FAIL:
      std::cout << "[FAILED]";
      break;
      case ERROR:
      std::cout << "[ERRED]";
      break;
    }
    std::cout << " (" << std::chrono::duration_cast<std::chrono::milliseconds>(
      std::chrono::system_clock::now() - startTime).count()  << "ms)" << std::endl;
    return status;
  }

Here is the caller graph for this function:

Member Data Documentation

cases

std::map<std::string, std::vector<TestCase> > mttest::TestSuites::cases = {}

Definition at line 172 of file mttest.hpp.

{};

---

The documentation for this struct was generated from the following file:

• mttest.hpp