anonymous_namespace{TestDefinition.cpp} Namespace Reference

Typedefs
using	FilePairs = std::vector<std::pair<std::string, std::string>>
	Pairs of reference and output file names to be compared.

Functions
bool	isConvertibleToDouble (std::string const &s)
	Test if the given string is convertible to a valid double value, not a NaN.
std::string	safeString (std::string const &s)
	Wraps a string into double ticks.
std::string	findDiffTool (std::string const &executable_name, std::string const &environment_variable_name)
std::string	formatPathForDiffTool (std::string const &filename)
void	checkTolerance (std::string const &tolerance_name, std::string const &tolerance)
FilePairs	findFilesMatchingRegex (std::string const &regex_string, std::string const &reference_path)
	Collects all file names in reference_path matching the regex.

Typedef Documentation

FilePairs

using anonymous_namespace{TestDefinition.cpp}::FilePairs = std::vector<std::pair<std::string, std::string>>

Pairs of reference and output file names to be compared.

Definition at line 174 of file TestDefinition.cpp.

Function Documentation

checkTolerance()

void anonymous_namespace{TestDefinition.cpp}::checkTolerance	(	std::string const &	tolerance_name,
		std::string const &	tolerance )

Definition at line 162 of file TestDefinition.cpp.

{
    if (!tolerance.empty() && !isConvertibleToDouble(tolerance))
    {
        OGS_FATAL(
            "The {:s} tolerance value '{:s}' is not convertible to double.",
            tolerance_name, tolerance);
    }
}

References isConvertibleToDouble(), and OGS_FATAL.

findDiffTool()

std::string anonymous_namespace{TestDefinition.cpp}::findDiffTool	(	std::string const &	executable_name,
		std::string const &	environment_variable_name )

Tries to find a diff tool executable by testing 'path/tool –version' calls for various paths.

Definition at line 69 of file TestDefinition.cpp.

{
    // Try to read the environment variable.
    if (const char* diff_tool_exe_environment_variable =
            std::getenv(environment_variable_name.c_str()))
    {
        std::string const diff_tool_exe{diff_tool_exe_environment_variable};
        DBUG("{:s} set to {:s}.", environment_variable_name, diff_tool_exe);
 
        //
        // Sanity checks.
        //
        {  // Check the base name.
            auto const& base_name =
                BaseLib::extractBaseNameWithoutExtension(diff_tool_exe);
            if (base_name != executable_name)
            {
                OGS_FATAL(
                    "The {:s} environment variable does not point to '{:s}'. "
                    "{:s}='{:s}'",
                    environment_variable_name, executable_name,
                    environment_variable_name, diff_tool_exe);
            }
        }
        {  // Diff tool must exist.
            if (!BaseLib::IsFileExisting(diff_tool_exe))
            {
                OGS_FATAL("The {:s} points to a non-existing file. {:s}='{:s}'",
                          environment_variable_name, environment_variable_name,
                          diff_tool_exe);
            }
        }
 
        //
        // Test the actual call.
        //
        int const return_value =
            // TODO (naumov) replace system call with output consuming call
            // (fork + execl seems to be more safe), and extract the vtkdiff
            // call to common function. Also properly escape all strings in
            // command lines.
            // Reference for POSIX and Windows:
            // https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=87152177
            // Take care when using fork, which might copy resources.
            std::system((diff_tool_exe + " --version").c_str());
        if (return_value == 0)
        {
            return diff_tool_exe;
        }
        WARN(
            "Calling {:s} from the {:s} environment variable didn't work as "
            "expected. Return value was {:d}.",
            diff_tool_exe, environment_variable_name, return_value);
    }
 
    std::vector<std::string> const paths = {"", "bin"};
    auto const path =
        find_if(begin(paths), end(paths),
                [&executable_name](std::string const& path)
                {
                    int const return_value =
                        // TODO (naumov) replace system call with output
                        // consuming call as in an above todo comment.
                        std::system((BaseLib::joinPaths(path, executable_name) +
                                     " --version")
                                        .c_str());
                    return return_value == 0;
                });
    if (path == end(paths))
    {
        OGS_FATAL("{:s} not found.", executable_name);
    }
    return BaseLib::joinPaths(*path, executable_name);
}

References DBUG(), BaseLib::extractBaseNameWithoutExtension(), BaseLib::IsFileExisting(), BaseLib::joinPaths(), OGS_FATAL, and WARN().

findFilesMatchingRegex()

FilePairs anonymous_namespace{TestDefinition.cpp}::findFilesMatchingRegex	(	std::string const &	regex_string,
		std::string const &	reference_path )

Collects all file names in reference_path matching the regex.

Definition at line 177 of file TestDefinition.cpp.

{
    DBUG("regex is '{}'.", regex_string);
    FilePairs filenames;
    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.emplace_back(filename, filename);
        }
    }
    return filenames;
}

References DBUG().

formatPathForDiffTool()

std::string anonymous_namespace{TestDefinition.cpp}::formatPathForDiffTool

(

std::string const &

filename

)

Definition at line 145 of file TestDefinition.cpp.

{
#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 the 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"(\\?\)";
 
    auto const absolute_filename = std::filesystem::absolute(filename).string();
    return fmt::format("\"{}{}\"", long_path_indicator, absolute_filename);
#else
    return safeString(filename);
#endif
}

References safeString().

isConvertibleToDouble()

bool anonymous_namespace{TestDefinition.cpp}::isConvertibleToDouble

(

std::string const &

s

)

Test if the given string is convertible to a valid double value, not a NaN.

Definition at line 30 of file TestDefinition.cpp.

{
    std::size_t pos = 0;
    double value;
    try
    {
        value = std::stod(s, &pos);
    }
    catch (...)
    {
        ERR("The given string '{:s}' is not convertible to double.", s);
        return false;
    }
    if (pos != s.size())
    {
        ERR("Only {:d} characters were used for double conversion of string "
            "'{:s}'",
            pos, s);
        return false;
    }
 
    if (std::isnan(value))
    {
        ERR("The given string '{:s}' results in a NaN value.", s);
        return false;
    }
    return true;
}

References ERR().

Referenced by checkTolerance().

safeString()

std::string anonymous_namespace{TestDefinition.cpp}::safeString

(

std::string const &

s

)

Wraps a string into double ticks.

Definition at line 60 of file TestDefinition.cpp.

{
    std::stringstream ss;
    ss << std::quoted(s);
    return ss.str();
}

Referenced by formatPathForDiffTool().