anonymous_namespace{TestDefinition.cpp} Namespace Reference

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	findVtkdiff ()

Function Documentation

findVtkdiff()

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

(

)

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

Definition at line 71 of file TestDefinition.cpp.

{
    // Try to read the VTKDIFF_EXE environment variable.
    if (const char* vtkdiff_exe_environment_variable =
            std::getenv("VTKDIFF_EXE"))
    {
        std::string const vtkdiff_exe{vtkdiff_exe_environment_variable};
        DBUG("VTKDIFF_EXE set to {:s}.", vtkdiff_exe);
 
        //
        // Sanity checks.
        //
        {  // The base name is 'vtkdiff'
            auto const& base_name =
                BaseLib::extractBaseNameWithoutExtension(vtkdiff_exe);
            if (base_name != "vtkdiff")
            {
                OGS_FATAL(
                    "The VTKDIFF_EXE environment variable does not point to "
                    "'vtkdiff'. VTKDIFF_EXE='{:s}'",
                    vtkdiff_exe);
            }
        }
        {  // vtkdiff must exist.
            if (!BaseLib::IsFileExisting(vtkdiff_exe))
            {
                OGS_FATAL(
                    "The VTKDIFF_EXE points to a non-existing file. "
                    "VTKDIFF_EXE='{:s}'",
                    vtkdiff_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((vtkdiff_exe + " --version").c_str());
        if (return_value == 0)
        {
            return vtkdiff_exe;
        }
        WARN(
            "Calling {:s} from the VTKDIFF_EXE environment variable didn't "
            "work as expected. Return value was {:d}.",
            vtkdiff_exe, return_value);
    }
 
    std::string const vtkdiff_exe{"vtkdiff"};
    std::vector<std::string> const paths = {"", "bin"};
    auto const path =
        find_if(begin(paths), end(paths),
                [&vtkdiff_exe](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, vtkdiff_exe) +
                                     " --version")
                                        .c_str());
                    return return_value == 0;
                });
    if (path == end(paths))
    {
        OGS_FATAL("vtkdiff not found.");
    }
    return BaseLib::joinPaths(*path, vtkdiff_exe);
}

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

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 32 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().

safeString()

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

(

std::string const &

s

)

Wraps a string into double ticks.

Definition at line 62 of file TestDefinition.cpp.

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