Detailed Description

Definition at line 27 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)

OGS_EXPORT_SYMBOL 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 151 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 : std::filesystem::directory_iterator(
                     std::filesystem::path(reference_path)))
            {
                auto const filename = p.path().filename().string();
                if (std::regex_match(filename, regex))
                {
                    DBUG("        -> matched '{}'", filename);
                    filenames.push_back(filename);
                }
            }
        }
        else
        {
            std::string filename =
                vtkdiff_config.getConfigParameter<std::string>("file");
#ifdef USE_PETSC
            int mpi_size;
            MPI_Comm_size(PETSC_COMM_WORLD, &mpi_size);
            if (mpi_size > 1)
            {
                int rank;
                MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
                filename =
                    MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(
                        filename) +
                    "_" + std::to_string(rank) + ".vtu";
            }
#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.",
                std::size(vtkdiff_configs),
                (std::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 output_filename =
                BaseLib::joinPaths(output_directory, filename);
            _output_files.push_back(output_filename);
            std::string reference_filename =
                BaseLib::joinPaths(reference_path, filename);
#if _WIN32
            // vtk does not handle Windows long paths:
            // https://gitlab.kitware.com/vtk/vtk/-/blob/master/Utilities/KWSys/vtksys/SystemTools.cxx#L1519-1521
            // workaround is to make path absolute and prefix with a special
            // marker and put everything in quotes, see
            // https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell
            auto const& long_path_indicator = R"(\\?\)";
 
            reference_filename =
                std::filesystem::absolute(reference_filename).string();
            reference_filename = std::format("\"{}{}\"", long_path_indicator,
                                             reference_filename);
            output_filename =
                std::filesystem::absolute(output_filename).string();
            output_filename =
                std::format("\"{}{}\"", long_path_indicator, output_filename);
 
#else
            output_filename = safeString(output_filename);
            reference_filename = safeString(reference_filename);
#endif
            //
            // Construct command line.
            //
            std::string command_line =
                vtkdiff + " -a " + safeString(field_name) + " -b " +
                safeString(field_name) + " " + reference_filename + " " +
                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(), BaseLib::ConfigTree::getConfigSubtreeList(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), INFO(), BaseLib::joinPaths(), and OGS_FATAL.

Member Function Documentation

◆ getOutputFiles()

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

Definition at line 317 of file TestDefinition.cpp.

{
    return _output_files;
}

References _output_files.

◆ numberOfTests()

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

Definition at line 322 of file TestDefinition.cpp.

{
    return size(_command_lines);
}

References _command_lines.

◆ runTests()

bool ApplicationsLib::TestDefinition::runTests ( ) const

Definition at line 295 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)
              {
                  INFO("---------- vtkdiff begin ----------");
                  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);
                  }
                  INFO("---------- vtkdiff end ----------\n");
                  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, INFO(), and WARN().

Member Data Documentation

◆ _command_lines

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

private

Definition at line 42 of file TestDefinition.h.

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

◆ _output_files

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

private

Definition at line 43 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