unit_test.h

// -*-c++-*-
#ifndef STORMM_UNIT_TEST_H
#define STORMM_UNIT_TEST_H
 
#include <cmath>
#include <cstdlib>
#include <stdexcept>
#include <string>
#include <vector>
#include "copyright.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Parsing/polynumeric.h"
#include "Parsing/textfile.h"
#include "Reporting/error_format.h"
#include "Math/summation.h"
#include "Math/vector_ops.h"
#include "approx.h"
#include "checklist.h"
#include "file_snapshot.h"
#include "test_environment.h"
#include "vector_report.h"

#define CHECK_THROWS(test_code, error_message) {\
  bool exception_thrown = false;\
  try {\
    test_code;\
  }\
  catch (std::runtime_error) {\
    exception_thrown = true;\
  }\
  check(exception_thrown, error_message);\
}

#define CHECK_THROWS_SOFT(test_code, error_message, priority) {\
  if (priority == stormm::testing::TestPriority::ABORT) {\
    check(true, error_message, priority);\
  }\
  else {\
    bool exception_thrown = false;\
    try {\
      test_code;\
    }\
    catch (std::runtime_error) {\
      exception_thrown = true;\
    }\
    check(exception_thrown, error_message, priority);\
  }\
}
 
namespace stormm {
namespace testing {
 
using errors::rtErr;
using errors::terminalFormat;
using data_types::isScalarType;
using data_types::isSignedIntegralScalarType;
using data_types::isUnsignedIntegralScalarType;
using data_types::isFloatingPointScalarType;
using stmath::sum;
using stmath::maxAbsoluteDifference;
using stmath::maxRelativeDifference;
using stmath::meanUnsignedError;
using stmath::relativeRmsError;
using parse::NumberFormat;
using parse::polyNumericVector;
using parse::TextFile;

void section(const std::string &section_name);
void section(const int section_index);

int unitTestSectionIndex(const std::string &name);

std::string unitTestSectionName(int index);

CheckResult check(const bool statement, const std::string &error_message = "",
                  TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult check(double lhs, RelationalOperator relationship, const Approx &rhs,
                  const std::string &error_message, TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult check(const Approx &lhs, RelationalOperator relationship, const double rhs,
                  const std::string &error_message, TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult check(const double lhs, RelationalOperator relationship, const double rhs,
                  const std::string &error_message, TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult check(const std::string &lhs, RelationalOperator relationship,
                  const std::string &rhs, const std::string &error_message,
                  TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult check(const char4 &lhs, RelationalOperator relationship, const char4 &rhs,
                  const std::string &error_message, TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult check(const std::vector<char4> &lhs, RelationalOperator relationship,
                  const std::vector<char4> &rhs, const std::string &error_message,
                  TestPriority urgency = TestPriority::CRITICAL);

template <typename T>
CheckResult check(const std::vector<T> &lhs, RelationalOperator relationship,
                  const Approx &rhs, const std::string &error_message,
                  TestPriority urgency = TestPriority::CRITICAL);

template <typename T>
CheckResult check(const Approx &lhs, const RelationalOperator relationship,
                  const std::vector<T> &rhs, const std::string &error_message,
                  TestPriority urgency = TestPriority::CRITICAL);

template <typename T1, typename T2>
CheckResult check(const std::vector<T1> &lhs, const RelationalOperator relationship,
                  const std::vector<T2> &rhs, const std::string &error_message,
                  TestPriority urgency = TestPriority::CRITICAL);

CheckResult snapshot(const std::string &filename, const std::vector<PolyNumeric> &content,
                     const std::string &label = std::string(""),
                     double comparison_tolerance = 1.0e-4,
                     const std::string &error_message = std::string(""),
                     SnapshotOperation activity = SnapshotOperation::COMPARE,
                     double output_precision = 1.0e-8,
                     NumberFormat data_format = NumberFormat::STANDARD_REAL,
                     PrintSituation expectation = PrintSituation::OVERWRITE,
                     TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult snapshot(const std::string &filename, const std::vector<PolyNumeric> &content,
                     const std::string &label = std::string(""),
                     NumberFormat data_format = NumberFormat::STANDARD_REAL,
                     const std::string &error_message = std::string(""),
                     SnapshotOperation activity = SnapshotOperation::COMPARE,
                     double comparison_tolerance = 1.0e-4, double output_precision = 1.0e-8,
                     PrintSituation expectation = PrintSituation::OVERWRITE,
                     TestPriority urgency = TestPriority::CRITICAL);
 
CheckResult snapshot(const std::string &filename, const TextFile &content,
                     const std::string &label = std::string(""),
                     const std::string &error_message = std::string(""),
                     const SnapshotOperation activity = SnapshotOperation::COMPARE,
                     const PrintSituation expectation = PrintSituation::OVERWRITE,
                     const TestPriority urgency = TestPriority::CRITICAL,
                     int comparison_tolerance = 0);
 
CheckResult snapshot(const std::string &filename, const std::string &content,
                     const std::string &label = std::string(""),
                     const std::string &error_message = std::string(""),
                     const SnapshotOperation activity = SnapshotOperation::COMPARE,
                     const PrintSituation expectation = PrintSituation::OVERWRITE,
                     const TestPriority urgency = TestPriority::CRITICAL,
                     int comparison_tolerance = 0);

void printTestSummary(TestVerbosity tv);

int countGlobalTestFailures();
  
std::string getRelationalOperatorString(RelationalOperator ro);
 
} // namespace testing
} // namespace stormm

extern stormm::testing::CheckList gbl_test_results;
 
#include "unit_test.tpp"
 
#endif