OGS
ApplicationsLib::TestDefinition Class Referencefinal

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.

154{
155 if (reference_path.empty())
156 {
157 OGS_FATAL(
158 "Reference path containing expected result files can not be "
159 "empty.");
160 }
161
162 std::string const vtkdiff = findVtkdiff();
163
164 // Construct command lines for each entry.
166 auto const& vtkdiff_configs = config_tree.getConfigSubtreeList("vtkdiff");
167 _command_lines.reserve(vtkdiff_configs.size());
168 for (auto const& vtkdiff_config : vtkdiff_configs)
169 {
170 std::string const& field_name =
172 vtkdiff_config.getConfigParameter<std::string>("field");
173 DBUG("vtkdiff will compare field '{:s}'.", field_name);
174
175 std::vector<std::string> filenames;
176 if (auto const regex_string =
178 vtkdiff_config.getConfigParameterOptional<std::string>("regex"))
179 {
180 // TODO: insert rank into regex for mpi case
181 DBUG("vtkdiff regex is '{}'.", *regex_string);
182 auto const regex = std::regex(*regex_string);
183 for (auto const& p : std::filesystem::directory_iterator(
184 std::filesystem::path(reference_path)))
185 {
186 auto const filename = p.path().filename().string();
187 if (std::regex_match(filename, regex))
188 {
189 DBUG(" -> matched '{}'", filename);
190 filenames.push_back(filename);
191 }
192 }
193 }
194 else
195 {
196 std::string filename =
198 vtkdiff_config.getConfigParameter<std::string>("file");
199#ifdef USE_PETSC
200 int mpi_size;
201 MPI_Comm_size(PETSC_COMM_WORLD, &mpi_size);
202 if (mpi_size > 1)
203 {
204 int rank;
205 MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
206 filename =
208 filename) +
209 "_" + std::to_string(rank) + ".vtu";
210 }
211#endif // OGS_USE_PETSC
212 filenames.push_back(filename);
213 }
214
215 if (empty(filenames))
216 {
217 OGS_FATAL(
218 "No files from test definitions were added for tests but {} "
219 "{:s} specified.",
220 std::size(vtkdiff_configs),
221 (std::size(vtkdiff_configs) == 1 ? "test was" : "tests were"));
222 }
223
224 auto const absolute_tolerance =
226 vtkdiff_config.getConfigParameter<std::string>("absolute_tolerance",
227 "");
228 if (!absolute_tolerance.empty() &&
229 !isConvertibleToDouble(absolute_tolerance))
230 {
231 OGS_FATAL(
232 "The absolute tolerance value '{:s}' is not convertible to "
233 "double.",
234 absolute_tolerance);
235 }
236 std::string const absolute_tolerance_parameter =
237 "--abs " + absolute_tolerance;
238 auto const relative_tolerance =
240 vtkdiff_config.getConfigParameter<std::string>("relative_tolerance",
241 "");
242 if (!relative_tolerance.empty() &&
243 !isConvertibleToDouble(relative_tolerance))
244 {
245 OGS_FATAL(
246 "The relative tolerance value '{:s}' is not convertible to "
247 "double.",
248 relative_tolerance);
249 }
250 std::string const relative_tolerance_parameter =
251 "--rel " + relative_tolerance;
252
253 for (auto const& filename : filenames)
254 {
255 std::string output_filename =
256 BaseLib::joinPaths(output_directory, filename);
257 _output_files.push_back(output_filename);
258 std::string reference_filename =
259 BaseLib::joinPaths(reference_path, filename);
260#if _WIN32
261 // vtk does not handle Windows long paths:
262 // https://gitlab.kitware.com/vtk/vtk/-/blob/master/Utilities/KWSys/vtksys/SystemTools.cxx#L1519-1521
263 // workaround is to make path absolute and prefix with a special
264 // marker and put everything in quotes, see
265 // https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell
266 auto const& long_path_indicator = R"(\\?\)";
267
268 reference_filename =
269 std::filesystem::absolute(reference_filename).string();
270 reference_filename = std::format("\"{}{}\"", long_path_indicator,
271 reference_filename);
272 output_filename =
273 std::filesystem::absolute(output_filename).string();
274 output_filename =
275 std::format("\"{}{}\"", long_path_indicator, output_filename);
276
277#else
278 output_filename = safeString(output_filename);
279 reference_filename = safeString(reference_filename);
280#endif
281 //
282 // Construct command line.
283 //
284 std::string command_line =
285 vtkdiff + " -a " + safeString(field_name) + " -b " +
286 safeString(field_name) + " " + reference_filename + " " +
287 output_filename + " " + absolute_tolerance_parameter + " " +
288 relative_tolerance_parameter;
289 INFO("Will run '{:s}'", command_line);
290 _command_lines.emplace_back(std::move(command_line));
291 }
292 }
293}
#define OGS_FATAL(...)
Definition Error.h:26
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:35
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30
std::vector< std::string > _output_files
std::vector< std::string > _command_lines
std::string joinPaths(std::string const &pathA, std::string const &pathB)
std::string getVtuFileNameForPetscOutputWithoutExtension(std::string const &file_name)
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.

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.

318{
319 return _output_files;
320}

References _output_files.

◆ numberOfTests()

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

Definition at line 322 of file TestDefinition.cpp.

323{
324 return size(_command_lines);
325}
constexpr int size(int const displacement_dim)
Vectorized tensor size for given displacement dimension.

References _command_lines.

◆ runTests()

bool ApplicationsLib::TestDefinition::runTests ( ) const

Definition at line 295 of file TestDefinition.cpp.

296{
297 std::vector<int> return_values;
298 transform(begin(_command_lines), end(_command_lines),
299 back_inserter(return_values),
300 [](std::string const& command_line)
301 {
302 INFO("---------- vtkdiff begin ----------");
303 int const return_value = std::system(command_line.c_str());
304 if (return_value != 0)
305 {
306 WARN("Return value {:d} was returned by '{:s}'.",
307 return_value, command_line);
308 }
309 INFO("---------- vtkdiff end ----------\n");
310 return return_value;
311 });
312 return !return_values.empty() &&
313 all_of(begin(return_values), end(return_values),
314 [](int const& return_value) { return return_value == 0; });
315}
void WARN(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:40
constexpr bool all_of(List const &values)
Checks if all of the elements in the given list are true.
Definition Algorithm.h:292

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: