Detailed Description

Definition at line 20 of file TestDefinition.h.

#include <TestDefinition.h>

Classes
struct	CommandLine

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
	Runs all configured test command lines.
OGS_EXPORT_SYMBOL bool	runTests (std::string_view diff_tool_name) const
	Runs only test command lines for the given diff tool.
OGS_EXPORT_SYMBOL bool	runTestsExcluding (std::string_view diff_tool_name) const
	Runs all test command lines except those for the given diff tool.
OGS_EXPORT_SYMBOL bool	hasTests (std::string_view diff_tool_name) const
	Returns true if at least one test command line uses the given diff tool.
std::vector< std::string > const &	getOutputFiles () const
	Returns all output files referenced by the configured test definitions.
std::size_t	numberOfTests () const
	Returns the number of configured test command lines.

Static Private Member Functions
static bool	runCommandLines (std::vector< CommandLine > const &command_lines, bool fail_on_empty)

Private Attributes
std::vector< CommandLine >	_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__xdmfdiff

Input File Parameter: prj__test_definition__vtkdiff__field

Input File Parameter: prj__test_definition__vtkdiff__reference_field

Input File Parameter: prj__test_definition__vtkdiff__regex

Input File Parameter: prj__test_definition__vtkdiff__file

Input File Parameter: prj__test_definition__vtkdiff__reference_file

Input File Parameter: prj__test_definition__vtkdiff__absolute_tolerance

Input File Parameter: prj__test_definition__vtkdiff__relative_tolerance

Input File Parameter: prj__test_definition__xdmfdiff__field

Input File Parameter: prj__test_definition__xdmfdiff__reference_field

Input File Parameter: prj__test_definition__xdmfdiff__regex

Input File Parameter: prj__test_definition__xdmfdiff__file

Input File Parameter: prj__test_definition__xdmfdiff__reference_file

Input File Parameter: prj__test_definition__xdmfdiff__absolute_tolerance

Input File Parameter: prj__test_definition__xdmfdiff__relative_tolerance

Input File Parameter: prj__test_definition__xdmfdiff__timestep

Input File Parameter: prj__test_definition__xdmfdiff__reference_timestep

Definition at line 200 of file TestDefinition.cpp.

{
    if (reference_path.empty())
    {
        OGS_FATAL(
            "Reference path containing expected result files can not be "
            "empty.");
    }
 
    // Construct command lines for each entry.
    auto const& vtkdiff_configs = config_tree.getConfigSubtreeList("vtkdiff");
    auto const& xdmfdiff_configs = config_tree.getConfigSubtreeList("xdmfdiff");
    _command_lines.reserve(vtkdiff_configs.size() + xdmfdiff_configs.size());
 
    // Constructs one command line per file name pair from the entries common
    // to all diff tools and appends it together with the corresponding output
    // file.
    auto const append_tests =
        [&](std::string const& tool, std::string const& tool_path,
            std::size_t const number_of_configs, FilePairs const& filenames,
            std::string const& field_name,
            std::string const& reference_field_name,
            std::string const& absolute_tolerance,
            std::string const& relative_tolerance,
            std::string const& extra_options)
    {
        if (filenames.empty())
        {
            OGS_FATAL(
                "No files from test definitions were added for tests but {} "
                "{:s} specified.",
                number_of_configs,
                (number_of_configs == 1 ? "test was" : "tests were"));
        }
        checkTolerance("absolute", absolute_tolerance);
        checkTolerance("relative", relative_tolerance);
 
        for (auto const& [reference_file, output_file] : filenames)
        {
            auto const output_filename =
                BaseLib::joinPaths(output_directory, output_file);
            _output_files.push_back(output_filename);
 
            std::string command_line = fmt::format(
                "{} -a {} -b {} {} {} --abs {} --rel {}{}", tool_path,
                safeString(reference_field_name), safeString(field_name),
                formatPathForDiffTool(
                    BaseLib::joinPaths(reference_path, reference_file)),
                formatPathForDiffTool(output_filename), absolute_tolerance,
                relative_tolerance, extra_options);
            INFO("Will run '{:s}'", command_line);
            _command_lines.push_back({tool, std::move(command_line)});
        }
    };
 
    std::string const vtkdiff =
        vtkdiff_configs.empty() ? "" : findDiffTool("vtkdiff", "VTKDIFF_EXE");
    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::string const reference_field_name =
            vtkdiff_config
                .getConfigParameterOptional<std::string>("reference_field")
                .value_or(field_name);
 
        FilePairs filenames;
        if (auto const regex_string =
            vtkdiff_config.getConfigParameterOptional<std::string>("regex"))
        {
            // TODO: insert rank into regex for mpi case
            filenames = findFilesMatchingRegex(*regex_string, reference_path);
        }
        else
        {
            std::string filename =
                vtkdiff_config.getConfigParameter<std::string>("file");
            std::string reference_filename =
                vtkdiff_config
                    .getConfigParameterOptional<std::string>("reference_file")
                    .value_or(filename);
#ifdef USE_PETSC
            BaseLib::MPI::Mpi mpi;
            if (mpi.size > 1)
            {
                filename =
                    MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(
                        filename) +
                    "_" + std::to_string(mpi.rank) + ".vtu";
                reference_filename =
                    MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(
                        reference_filename) +
                    "_" + std::to_string(mpi.rank) + ".vtu";
            }
#endif  // OGS_USE_PETSC
            filenames.emplace_back(reference_filename, filename);
        }
 
        auto const absolute_tolerance =
            vtkdiff_config.getConfigParameter<std::string>("absolute_tolerance",
                                                           "");
        auto const relative_tolerance =
            vtkdiff_config.getConfigParameter<std::string>("relative_tolerance",
                                                           "");
 
        append_tests("vtkdiff", vtkdiff, vtkdiff_configs.size(), filenames,
                     field_name, reference_field_name, absolute_tolerance,
                     relative_tolerance, "");
    }
 
    std::string const xdmfdiff = xdmfdiff_configs.empty()
                                     ? ""
                                     : findDiffTool("xdmfdiff", "XDMFDIFF_EXE");
    for (auto const& xdmfdiff_config : xdmfdiff_configs)
    {
        std::string const& field_name =
            xdmfdiff_config.getConfigParameter<std::string>("field");
        DBUG("xdmfdiff will compare field '{:s}'.", field_name);
        std::string const reference_field_name =
            xdmfdiff_config
                .getConfigParameterOptional<std::string>("reference_field")
                .value_or(field_name);
 
        FilePairs filenames;
        if (auto const regex_string =
            xdmfdiff_config.getConfigParameterOptional<std::string>("regex"))
        {
            filenames = findFilesMatchingRegex(*regex_string, reference_path);
        }
        else
        {
            std::string const filename =
                xdmfdiff_config.getConfigParameter<std::string>("file");
            std::string const reference_filename =
                xdmfdiff_config
                    .getConfigParameterOptional<std::string>("reference_file")
                    .value_or(filename);
            filenames.emplace_back(reference_filename, filename);
        }
 
        auto const absolute_tolerance =
            xdmfdiff_config.getConfigParameter<std::string>(
                "absolute_tolerance", "");
        auto const relative_tolerance =
            xdmfdiff_config.getConfigParameter<std::string>(
                "relative_tolerance", "");
 
        std::string const timestep =
            xdmfdiff_config.getConfigParameter<std::string>("timestep");
        std::string const reference_timestep =
            xdmfdiff_config
                .getConfigParameterOptional<std::string>("reference_timestep")
                .value_or(timestep);
 
        append_tests("xdmfdiff", xdmfdiff, xdmfdiff_configs.size(), filenames,
                     field_name, reference_field_name, absolute_tolerance,
                     relative_tolerance,
                     fmt::format(" --timestep-a {} --timestep-b {}",
                                 reference_timestep, timestep));
    }
}

References _command_lines, _output_files, DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), INFO(), BaseLib::joinPaths(), OGS_FATAL, BaseLib::MPI::Mpi::rank, and BaseLib::MPI::Mpi::size.

Member Function Documentation

◆ getOutputFiles()

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

Returns all output files referenced by the configured test definitions.

Definition at line 444 of file TestDefinition.cpp.

{
    return _output_files;
}

References _output_files.

◆ hasTests()

bool ApplicationsLib::TestDefinition::hasTests ( std::string_view diff_tool_name ) const

Returns true if at least one test command line uses the given diff tool.

Definition at line 411 of file TestDefinition.cpp.

{
    return any_of(begin(_command_lines), end(_command_lines),
                  [diff_tool_name](CommandLine const& command_line)
                  { return command_line.diff_tool_name == diff_tool_name; });
}

References _command_lines, and ApplicationsLib::TestDefinition::CommandLine::diff_tool_name.

◆ numberOfTests()

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

Returns the number of configured test command lines.

Definition at line 449 of file TestDefinition.cpp.

{
    return size(_command_lines);
}

References _command_lines.

◆ runCommandLines()

bool ApplicationsLib::TestDefinition::runCommandLines	(	std::vector< CommandLine > const &	command_lines,
		bool	fail_on_empty )

staticprivate

Definition at line 418 of file TestDefinition.cpp.

{
    std::vector<int> return_values;
    transform(begin(command_lines), end(command_lines),
              back_inserter(return_values),
              [](CommandLine const& command_line)
              {
                  INFO("---------- {:s} begin ----------",
                       command_line.diff_tool_name);
                  int const return_value =
                      std::system(command_line.command_line.c_str());
                  if (return_value != 0)
                  {
                      WARN("Value {:d} was returned by '{:s}'.", return_value,
                           command_line.command_line);
                  }
                  INFO("---------- {:s} end ----------\n",
                       command_line.diff_tool_name);
                  return return_value;
              });
    return (!return_values.empty() || !fail_on_empty) &&
           all_of(begin(return_values), end(return_values),
                  [](int const return_value) { return return_value == 0; });
}

References ApplicationsLib::TestDefinition::CommandLine::command_line, ApplicationsLib::TestDefinition::CommandLine::diff_tool_name, INFO(), and WARN().

Referenced by runTests(), runTests(), and runTestsExcluding().

◆ runTests() [1/2]

bool ApplicationsLib::TestDefinition::runTests ( ) const

Runs all configured test command lines.

Definition at line 383 of file TestDefinition.cpp.

{
    return runCommandLines(_command_lines, true);
}

References _command_lines, and runCommandLines().

◆ runTests() [2/2]

bool ApplicationsLib::TestDefinition::runTests ( std::string_view diff_tool_name ) const

Runs only test command lines for the given diff tool.

Definition at line 388 of file TestDefinition.cpp.

{
    std::vector<CommandLine> command_lines;
    copy_if(begin(_command_lines), end(_command_lines),
            back_inserter(command_lines),
            [diff_tool_name](CommandLine const& command_line)
            { return command_line.diff_tool_name == diff_tool_name; });
 
    return runCommandLines(command_lines, true);
}

References _command_lines, ApplicationsLib::TestDefinition::CommandLine::diff_tool_name, and runCommandLines().

◆ runTestsExcluding()

bool ApplicationsLib::TestDefinition::runTestsExcluding ( std::string_view diff_tool_name ) const

Runs all test command lines except those for the given diff tool.

Definition at line 399 of file TestDefinition.cpp.

{
    std::vector<CommandLine> command_lines;
    copy_if(begin(_command_lines), end(_command_lines),
            back_inserter(command_lines),
            [diff_tool_name](CommandLine const& command_line)
            { return command_line.diff_tool_name != diff_tool_name; });
 
    return runCommandLines(command_lines, false);
}

References _command_lines, ApplicationsLib::TestDefinition::CommandLine::diff_tool_name, and runCommandLines().

Member Data Documentation

◆ _command_lines

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

private

Definition at line 59 of file TestDefinition.h.

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

◆ _output_files

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

private

Definition at line 60 of file TestDefinition.h.

Referenced by TestDefinition(), and getOutputFiles().

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