Detailed Description

Definition at line 25 of file TestDefinition.h.

#include <TestDefinition.h>

Public Member Functions
	TestDefinition (BaseLib::ConfigTree const &config_tree, std::string const &reference_path, std::string const &output_directory)

bool	runTests () const

std::vector< std::string > const &	getOutputFiles () const

std::size_t	numberOfTests () const

Private Attributes
std::vector< std::string >	_command_lines

std::vector< std::string >	_output_files

Constructor & Destructor Documentation

◆ TestDefinition()

ApplicationsLib::TestDefinition::TestDefinition	(	BaseLib::ConfigTree const &	config_tree,
		std::string const &	reference_path,
		std::string const &	output_directory
	)

Constructs test definition from the config and reference path essentially constructing the command lines to be run on run() function call.

Input File Parameter:: prj__test_definition__vtkdiff

Input File Parameter:: prj__test_definition__vtkdiff__field

Input File Parameter:: prj__test_definition__vtkdiff__regex

Input File Parameter:: prj__test_definition__vtkdiff__file

Input File Parameter:: prj__test_definition__vtkdiff__absolute_tolerance

Input File Parameter:: prj__test_definition__vtkdiff__relative_tolerance

Definition at line 147 of file TestDefinition.cpp.

 {
     if (reference_path.empty())
     {
         OGS_FATAL(
             "Reference path containing expected result files can not be "
             "empty.");
     }
  
     std::string const vtkdiff = findVtkdiff();
  
     // Construct command lines for each entry.
     auto const& vtkdiff_configs = config_tree.getConfigSubtreeList("vtkdiff");
     _command_lines.reserve(vtkdiff_configs.size());
     for (auto const& vtkdiff_config : vtkdiff_configs)
     {
         std::string const& field_name =
             vtkdiff_config.getConfigParameter<std::string>("field");
         DBUG("vtkdiff will compare field '{:s}'.", field_name);
  
         std::vector<std::string> filenames;
         if (auto const regex_string =
             vtkdiff_config.getConfigParameterOptional<std::string>("regex"))
         {
             // TODO: insert rank into regex for mpi case
             DBUG("vtkdiff regex is '{}'.", *regex_string);
             auto const regex = std::regex(*regex_string);
             for (auto const& p :
                  fs::directory_iterator(fs::path(reference_path)))
             {
                 auto const filename = p.path().filename().string();
                 if (std::regex_match(filename, regex))
                 {
                     DBUG("        -> matched '{}'", filename);
                     filenames.push_back(filename);
                 }
             }
         }
         else
         {
 #ifdef USE_PETSC
             int rank;
             MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
             int mpi_size;
             MPI_Comm_size(PETSC_COMM_WORLD, &mpi_size);
             std::string const& filename =
                 MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(
                     vtkdiff_config.getConfigParameter<std::string>("file")) +
                 "_" + std::to_string(rank) + ".vtu";
 #else
             std::string const& filename =
                 vtkdiff_config.getConfigParameter<std::string>("file");
 #endif  // OGS_USE_PETSC
             filenames.push_back(filename);
         }
  
         if (empty(filenames))
         {
             OGS_FATAL(
                 "No files from test definitions were added for tests but {} "
                 "{:s} specified.",
                 size(vtkdiff_configs),
                 (size(vtkdiff_configs) == 1 ? "test was" : "tests were"));
         }
  
         auto const absolute_tolerance =
             vtkdiff_config.getConfigParameter<std::string>("absolute_tolerance",
                                                            "");
         if (!absolute_tolerance.empty() &&
             !isConvertibleToDouble(absolute_tolerance))
         {
             OGS_FATAL(
                 "The absolute tolerance value '{:s}' is not convertible to "
                 "double.",
                 absolute_tolerance);
         }
         std::string const absolute_tolerance_parameter =
             "--abs " + absolute_tolerance;
         auto const relative_tolerance =
             vtkdiff_config.getConfigParameter<std::string>("relative_tolerance",
                                                            "");
         if (!relative_tolerance.empty() &&
             !isConvertibleToDouble(relative_tolerance))
         {
             OGS_FATAL(
                 "The relative tolerance value '{:s}' is not convertible to "
                 "double.",
                 relative_tolerance);
         }
         std::string const relative_tolerance_parameter =
             "--rel " + relative_tolerance;
  
         for (auto const& filename : filenames)
         {
             std::string const& output_filename =
                 BaseLib::joinPaths(output_directory, filename);
             _output_files.push_back(output_filename);
             std::string const& reference_filename =
                 BaseLib::joinPaths(reference_path, filename);
  
             //
             // Construct command line.
             //
             std::string command_line =
                 vtkdiff + " -a " + safeString(field_name) + " -b " +
                 safeString(field_name) + " " + safeString(reference_filename) +
                 " " + safeString(output_filename) + " " +
                 absolute_tolerance_parameter + " " +
                 relative_tolerance_parameter;
             INFO("Will run '{:s}'", command_line);
             _command_lines.emplace_back(std::move(command_line));
         }
     }
 }

References _command_lines, _output_files, DBUG(), anonymous_namespace{TestDefinition.cpp}::findVtkdiff(), BaseLib::ConfigTree::getConfigSubtreeList(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), INFO(), anonymous_namespace{TestDefinition.cpp}::isConvertibleToDouble(), BaseLib::joinPaths(), OGS_FATAL, and anonymous_namespace{TestDefinition.cpp}::safeString().

Member Function Documentation

◆ getOutputFiles()

std::vector< std::string > const & ApplicationsLib::TestDefinition::getOutputFiles ( ) const

Definition at line 291 of file TestDefinition.cpp.

 {
     return _output_files;
 }

References _output_files.

◆ numberOfTests()

std::size_t ApplicationsLib::TestDefinition::numberOfTests ( ) const

Definition at line 296 of file TestDefinition.cpp.

 {
     return size(_command_lines);
 }

References _command_lines.

◆ runTests()

bool ApplicationsLib::TestDefinition::runTests ( ) const

Definition at line 271 of file TestDefinition.cpp.

 {
     std::vector<int> return_values;
     transform(begin(_command_lines), end(_command_lines),
               back_inserter(return_values),
               [](std::string const& command_line)
               {
                   int const return_value = std::system(command_line.c_str());
                   if (return_value != 0)
                   {
                       WARN("Return value {:d} was returned by '{:s}'.",
                            return_value, command_line);
                   }
                   return return_value;
               });
     return !return_values.empty() &&
            all_of(begin(return_values), end(return_values),
                   [](int const& return_value) { return return_value == 0; });
 }

References _command_lines, and WARN().

Member Data Documentation

◆ _command_lines

std::vector<std::string> ApplicationsLib::TestDefinition::_command_lines

private

Definition at line 40 of file TestDefinition.h.

Referenced by TestDefinition(), numberOfTests(), and runTests().

◆ _output_files

std::vector<std::string> ApplicationsLib::TestDefinition::_output_files

private

Definition at line 41 of file TestDefinition.h.

Referenced by TestDefinition(), and getOutputFiles().

The documentation for this class was generated from the following files:

Applications/ApplicationsLib/TestDefinition.h
Applications/ApplicationsLib/TestDefinition.cpp