rsvs3D  0.0.0
Codes for the c++ implementation of the 3D RSVS
test.cpp
1 #include <cstdlib>
2 #include <functional>
3 #include <iostream>
4 #include <sstream>
5 #include <string>
6 
7 #include "test.hpp"
8 
9 #include "RSVSalgorithm.hpp"
10 #include "RSVSintegration.hpp"
11 #include "RSVSmath.hpp"
12 #include "arraystructures.hpp"
13 #include "matrixtools.hpp"
14 #include "mesh.hpp"
15 #include "meshrefinement.hpp"
16 #include "parameters.hpp"
17 #include "polyscopersvs.hpp"
18 #include "postprocessing.hpp"
19 #include "snake.hpp"
20 #include "snakeengine.hpp"
21 #include "tetgenrsvs.hpp"
22 #include "triangulate.hpp"
23 #include "voxel.hpp"
24 using namespace rsvstest;
25 using namespace std;
26 
27 int rsvstest::maintest()
28 {
29 
30  customtest gridTest("all tests (expected run time: 15 minutes)");
31  gridTest.Run(rsvstest::shorttest, "Short tests");
32  gridTest.Run(rsvstest::longevolution, "Long tests");
33  gridTest.Run(rsvstest::integrationprocesses, "Various integration and derivative tests");
34  gridTest.Run(rsvstest::newtest, "New tests");
35 
36  return (gridTest.ReturnErrCount());
37 }
38 
39 int rsvstest::shorttest()
40 {
41 
42  customtest gridTest("short tests (expected run time: 7 minutes)");
43 
44  gridTest.RunSilent(rsvstest::arraystructtemplates, "Test Arraystructures templates", 1);
45  gridTest.RunSilent(rsvstest::meshprocesses, "Test meshes", 15);
46  gridTest.RunSilent(rsvstest::snakeprocesses, "Test snake processes", 41);
47  gridTest.Run(rsvstest::RSVSprocesses, "Test RSVS process", 150);
48  gridTest.Run(rsvstest::tetgenprocesses, "Tetgen interface tests", 200);
49  gridTest.RunSilent(rsvstest::JSONprocesses, "Parameter and JSON tests", 1);
50  gridTest.RunSilent(rsvstest::polyscopeprocesses, "Test polyscope processes", 10);
51  return (gridTest.ReturnErrCount());
52 }
53 
54 int rsvstest::failingtest()
55 {
56  customtest gridTest("failing tests (expected run time: 1-mn to 7h)");
57  gridTest.RunSilent(rsvstest::RSVS2Dprocesses, "Test 2D-RSVS process", 6);
58  gridTest.Run(tetgen::test::RSVSVORO, "tetgen API testing - Voro to RSVS");
59  gridTest.Run(tetgen::test::RSVSVORO_Contain, "tetgen API testing - Voro to RSVS");
60 
61  return (gridTest.ReturnErrCount());
62 }
63 
64 int rsvstest::arraystructtemplates()
65 {
66  customtest gridTest("Test Arraystructures templates");
67 
68  // BASE templatess
69  gridTest.RunSilent(Test_ArrayStructures, "arraystructures");
70  gridTest.RunSilent(TestTemplate_ArrayStruct<vert>, "TestTemplate_ArrayStruct<vert>");
71  gridTest.RunSilent(TestTemplate_ArrayStruct<edge>, "TestTemplate_ArrayStruct<edge>");
72  gridTest.RunSilent(TestTemplate_ArrayStruct<surf>, "TestTemplate_ArrayStruct<surf>");
73  gridTest.RunSilent(TestTemplate_ArrayStruct<volu>, "TestTemplate_ArrayStruct<volu>");
74  gridTest.RunSilent(TestTemplate_ArrayStruct<snax>, "TestTemplate_ArrayStruct<snax>");
75  gridTest.RunSilent(TestTemplate_ArrayStruct<snaxedge>, "TestTemplate_ArrayStruct<snaxedge>");
76  gridTest.RunSilent(TestTemplate_ArrayStruct<snaxsurf>, "TestTemplate_ArrayStruct<snaxsurf>");
77  return (gridTest.ReturnErrCount());
78 }
79 
80 int rsvstest::meshprocesses()
81 {
82  customtest gridTest("Test meshes");
83 
84  // Building blocks
85  gridTest.RunSilent(Test_BuildBlockGrid_noout, "Voxel");
86  gridTest.RunSilent(Test_tecplotfile, "post-processing class");
87  gridTest.RunSilent(Test_MeshOut, "Mesh output");
88  gridTest.RunSilent(Test_MeshOut2, "Functionalised Mesh output");
89  gridTest.RunSilent(Test_MeshReOrder, "Mesh Reordering");
90  gridTest.RunSilent(Test_surfcentre, "test SurfCentroid");
91  gridTest.RunSilent(Test_MeshRefinement, "Multi-Level Meshes");
92  gridTest.RunSilent(Test_MeshOrient, "Output mesh orientation");
93  gridTest.RunSilent(Test_Crop, "test cropping of meshes");
94 
95  return (gridTest.ReturnErrCount());
96 }
97 
98 int rsvstest::snakeprocesses()
99 {
100  customtest gridTest("Test snake processes");
101 
102  // Snakstruct 3D tests
103  gridTest.RunSilent(Test_snakeOrderEdges, "Snake Order error");
104  gridTest.RunSilent(Test_SnakeStructures, "Snake containers");
105  gridTest.RunSilent(Test_RSVSalgo_init, "RSVS spawn");
106  gridTest.RunSilent(Test_RSVSvoro_init, "Snake spawning voronoi");
107  gridTest.RunSilent(Test_snakeinit_random_short, "(short) Snake rand velocity");
108  gridTest.RunSilent(Test_snakeinit_unit_short, "(short) Snake unit velocity (reflected)");
109  gridTest.RunSilent(Test_snakeinit_unitnoreflect_short, "(short) Snake unit velocity "
110  "(no reflection)");
111  return (gridTest.ReturnErrCount());
112 }
113 
114 int rsvstest::longevolution()
115 {
116  customtest gridTest("Test process with long processing");
117  gridTest.RunSilent(Test_snakeinit_random, "Snake rand velocity");
118  gridTest.RunSilent(Test_snakeinit_unit, "Snake unit velocity (reflected)");
119  gridTest.RunSilent(Test_snakeinit_unitnoreflect, "Snake unit velocity "
120  "(no reflection)");
121  return (gridTest.ReturnErrCount());
122 }
123 int rsvstest::RSVSprocesses()
124 {
125  customtest gridTest("Test RSVS process");
126 
127  gridTest.RunSilent(Test_RSVSalgo, "Snake RSVS from spawn", 90);
128  gridTest.RunSilent(Test_snakeRSVS, "Snake RSVS", 5);
129  gridTest.RunSilent(Test_snakeRSVS_singlevol, "Snake RSVS single vol", 5);
130  gridTest.RunSilent(Test_RSVSalgo_singlevol_fullmath, "Snake RSVS algorithm (full maths)", 25);
131  gridTest.RunSilent(Test_RSVSalgo_singlevol_sparse, "Snake RSVS algorithm (sparse)", 12);
132  return (gridTest.ReturnErrCount());
133 }
134 
135 int rsvstest::RSVS2Dprocesses()
136 {
137  customtest gridTest("Test 2D-RSVS process");
138 
139  gridTest.RunSilent(Test_snakeinitflat, "Snake spawning 2D");
140  gridTest.Run(Test_RSVSalgoflat, "RSVS 2D"); // Non working test - Maths not finished
141 
142  return (gridTest.ReturnErrCount());
143 }
144 
145 int rsvstest::tetgenprocesses()
146 {
147  customtest gridTest("Tetgen interface tests");
148 
149  // Tetgen interface tests
150  gridTest.RunSilent(tetgen::test::CFD, "tetgen API testing - CFD meshing", 26);
151  gridTest.RunSilent(tetgen::test::call, "tetgen API testing - RSVS meshing", 30);
152  // gridTest.RunSilent(tetgen::test::RSVSVORO,"tetgen API testing - Voro to RSVS", 78);
153  // gridTest.RunSilent(tetgen::test::RSVSVORO_Contain,"tetgen API testing - Voro to RSVS", 42);
154  return (gridTest.ReturnErrCount());
155 }
156 
157 int rsvstest::polyscopeprocesses()
158 {
159  customtest gridTest("Test polyscope processes");
160  gridTest.RunSilent(polyscopersvs::test::init, "Initialise polyscope");
161  gridTest.RunSilent(polyscopersvs::test::init, "Try to initialise polyscope twice");
162  gridTest.RunSilent(polyscopersvs::test::show, "Show the polyscope window");
163  gridTest.RunSilent(polyscopersvs::test::meshShow, "Print a mesh");
164  return (gridTest.ReturnErrCount());
165 }
166 
167 int rsvstest::JSONprocesses()
168 {
169  customtest gridTest("Parameter and JSON tests");
170 
171  gridTest.RunSilent(param::test::base, "parameter implementation");
172  gridTest.RunSilent(param::test::symmetry, "Test json internal symmetry");
173  gridTest.RunSilent(param::test::io, "parameter read write");
174  gridTest.RunSilent(param::test::ioflat, "parameter read write flat format");
175  gridTest.RunSilent(param::test::ipartialread, "parameter partial read"
176  " write flat format");
177  gridTest.RunSilent(param::test::autoflat, "Algorithm for automatic "
178  "determination of flat json");
179  gridTest.RunSilent(tetgen::test::api, "tegen test api parameter class");
180  return (gridTest.ReturnErrCount());
181 }
182 
183 int rsvstest::integrationprocesses()
184 {
185 
186  customtest gridTest("Various integration and derivative tests");
187 
188  // RSVS and integration tests
189  gridTest.RunSilent(integrate::test::Prepare, "Mesh integration function");
190  gridTest.RunSilent(integrate::test::All, "Test full integration");
191  gridTest.Run(Test_SurfCentreDerivatives, "Surf centroid");
192  gridTest.Run(Test_Matrix3D, "'3D' matrix maths");
193  gridTest.Run(integrate::test::CompareSurfCentreDerivatives, "Test Surf centroid");
194 
195  gridTest.Run(integrate::test::CompareDerivativesSpike, "Test spike issues");
196  gridTest.Run(integrate::test::CompareDerivativesSpikeNoDPos, "Test spike issues no dPos");
197  gridTest.Run(integrate::test::StudyDerivatives, "Generate Derivative study");
198 
199  return (gridTest.ReturnErrCount());
200 }
201 
202 int rsvstest::newtest()
203 {
204  customtest gridTest("3-D RSVS tests: New and breaking ");
205 
206 #ifdef TEST_KNOWN_FAILURES
207  gridTest.RunSilent(Test_snakeinitflat, "Snake spawning 2D");
208  gridTest.Run(Test_RSVSalgoflat, "RSVS 2D"); // Non working test - Maths not finished
209  gridTest.Run(integrate::test::CompareDerivativesSpike, "Test spike issues");
210  gridTest.Run(integrate::test::CompareDerivativesSpikeNoDPos, "Test spike issues no dPos");
211  gridTest.Run(integrate::test::StudyDerivatives, "Generate Derivative study");
212 #endif
213 #ifdef IGNORE_THESE_TESTS
214  // Parameter and JSON tests
215  gridTest.Run(tetgen::test::RSVSVORO, "tetgen API testing - Voro to RSVS");
216  gridTest.Run(tetgen::test::RSVSVORO_Contain, "tetgen API testing - Voro to RSVS");
217  gridTest.Run(rsvstest::polyscopeprocesses, "Test polyscope processes");
218 #endif
219  gridTest.Run(tetgen::test::CFD, "tetgen API testing - CFD meshing");
220  gridTest.Run(tetgen::test::call, "tetgen API testing - RSVS meshing");
221  return (gridTest.ReturnErrCount());
222 }
223 
224 int customtest::Run(function<int()> test, const char *funcName, int expectedTime)
225 {
226  cout << "-------------------------------------------------------------"
227  "---------------------------"
228  << endl;
229  cout << "-------------------------------------------------------------"
230  "---------------------------"
231  << endl;
232  cout << " Start testing " << funcName;
233  if (expectedTime >= 0)
234  {
235  std::cout << " (expected execution time: " << expectedTime << " s)";
236  }
237  std::cout << std::endl;
238  cout << "-------------------------------------------------------------"
239  "---------------------------"
240  << endl;
241  this->prevTime = clock();
242  errFlag = test();
243  this->lastRunTime = clock() - this->prevTime;
244 
245  runTotal += this->lastRunTime;
246  ++testCount;
247  cout << "-------------------------------------------------------------"
248  "---------------------------"
249  << endl;
250  if (errFlag != 0)
251  {
252  ++errCount;
253  cout << "Finished testing " << funcName << endl;
254  cout << " - Caught Error: " << errFlag << endl;
255  }
256  else
257  {
258  cout << "Finished testing " << funcName << endl;
259  cout << " - No Error" << endl;
260  }
261  cout << " Execution time : " << double(this->lastRunTime) / double(CLOCKS_PER_SEC) * 1000 << " ms"
262  << endl;
263  cout << "-------------------------------------------------------------"
264  "---------------------------"
265  << endl;
266  cout << "-------------------------------------------------------------"
267  "---------------------------"
268  << endl;
269  cout << endl;
270  return (errFlag);
271 }
272 
281 int customtest::RunSilent(function<int()> test, const char *funcName, int expectedTime)
282 {
283 
284  stringstream streamOut;
285  int errFlag;
286 
287  std::cout << "START test " << this->testCount + 1 << ": " << funcName;
288  if (expectedTime >= 0)
289  {
290  std::cout << " (expected execution time: " << expectedTime << " s)";
291  }
292  std::cout << std::endl;
293 
294  auto coutBuff = std::cout.rdbuf(streamOut.rdbuf());
295  auto cerrBuff = std::cerr.rdbuf(streamOut.rdbuf());
296  try
297  {
298  try
299  {
300  errFlag = this->Run(test, funcName, expectedTime);
301  }
302  catch (exception const &ex)
303  {
304  cerr << "Exception: " << ex.what() << endl;
305  throw ex;
306  }
307  }
308  catch (...)
309  {
310  std::cerr << "-------------------------------------------------------------"
311  "---------------------------"
312  << endl;
313  errFlag = 1;
314  this->unhandledError++;
315  std::cerr << "Unhandled error in " << funcName << endl;
316  std::cerr << "-------------------------------------------------------------"
317  "---------------------------"
318  << endl;
319  std::cerr << "-------------------------------------------------------------"
320  "---------------------------"
321  << endl;
322  }
323  std::cout.rdbuf(coutBuff);
324  std::cerr.rdbuf(cerrBuff);
325  if (errFlag != 0)
326  {
327  std::cerr << streamOut.str();
328  }
329  else
330  {
331  std::cout << " DONE, finished in " << double(this->lastRunTime) / double(CLOCKS_PER_SEC) * 1000 << " ms"
332  << endl;
333  }
334  return errFlag;
335 }
336 
337 void customtest::PrintSummary()
338 {
339  cout << endl;
340 
341  cout << "-------------------------------------------------------------"
342  "---------------------------"
343  << endl;
344  cout << "-------------------------------------------------------------"
345  "---------------------------"
346  << endl;
347  cout << " Summary of Tests: (" << this->testName << ")" << endl;
348  cout << " " << testCount << " tests completed" << endl;
349  cout << " " << errCount << " detected errors " << endl;
350  cout << " " << unhandledError << " errors handled by the test class " << endl;
351  cout << " Total run time:" << endl;
352  cout << " " << double(this->runTotal) / double(CLOCKS_PER_SEC) << " seconds " << endl;
353  cout << "-------------------------------------------------------------"
354  "---------------------------"
355  << endl;
356  cout << "-------------------------------------------------------------"
357  "---------------------------"
358  << endl;
359 #ifdef DBG_MEMLEAK
360  _CrtDumpMemoryLeaks();
361 #endif
362 }
RSVSalgorithm.hpp
Functions which are part of the RSVS algorithm but not core to the snaking process.
RSVSintegration.hpp
Integration into the full 3 dimensional Restricted Snake Volume of Solid method.
RSVSmath.hpp
Performs Volume and Area calculations for the RSVS process.
arraystructures.hpp
Provide std::vector container with hashed index mapping.
rsvstest::customtest
Class for customtest.
Definition: test.hpp:51
rsvstest::customtest::RunSilent
int RunSilent(std::function< int()> test, const char *funcName, int expectedTime=-1)
Runs a test function silently except if it returns an error.
Definition: test.cpp:281
matrixtools.hpp
Tools to support conversion, display and derivatives of Eigen matrices.
mesh.hpp
Provides all the mesh tools used for the generation of 3D grids and geometries.
meshrefinement.hpp
Tools for the refinement and coarsening of meshes.
polyscopersvs::test::show
int show()
Should display the polyscope window.
Definition: polyscopersvs.cpp:826
polyscopersvs::test::init
int init()
Should initialise polyscope.
Definition: polyscopersvs.cpp:814
polyscopersvs::test::meshShow
int meshShow()
Should display a single small cubic mesh.
Definition: polyscopersvs.cpp:838
rsvstest
Namespace for rsvs tests.
Definition: test.hpp:45
parameters.hpp
Parameters for the integrated 3DRSVS.
polyscopersvs.hpp
Provide an interface between the RSVS process and polyscope.
postprocessing.hpp
Provide tecplot file formating for mesh and snake outputs.
snake.hpp
Provides the core restricted surface snake container.
snakeengine.hpp
Functions needed to evolve the r-surface snake.
test.hpp
Provides the custom testing system used by the RSVS3D project.
tetgenrsvs.hpp
Interface between the RSVS project and tetgen.
triangulate.hpp
Provides a triangulation for snake and meshes.
voxel.hpp
Generation of cartesian grids.