Lumiera 0.pre.04
»edit your freedom«
Loading...
Searching...
No Matches
path-array-test.cpp
Go to the documentation of this file.
1/*
2 PathArray(Test) - verify container abstraction for a sequence of path elements
3
4 Copyright (C)
5 2017, Hermann Vosseler <Ichthyostega@web.de>
6
7  **Lumiera** is free software; you can redistribute it and/or modify it
8  under the terms of the GNU General Public License as published by the
9  Free Software Foundation; either version 2 of the License, or (at your
10  option) any later version. See the file COPYING for further details.
11
12* *****************************************************************/
13
19#include "lib/test/run.hpp"
20#include "lib/test/test-helper.hpp"
21#include "lib/path-array.hpp"
22#include "lib/format-util.hpp"
23#include "lib/util.hpp"
24
25#include <string>
26
27
28using std::string;
29using lib::Symbol;
30using util::isnil;
31using util::join;
32
33
34
35namespace lib {
36namespace test {
37
38 using LERR_(INDEX_BOUNDS);
39 using LERR_(INVALID);
40
41 using ParrT = lib::PathArray<5>;
42
43
44 /******************************************************************************/
52 class PathArray_test : public Test
53 {
54
55 virtual void
63
64
65 void
66 verify_basics()
67 {
68 ParrT undef;
69 CHECK (isnil (undef));
70
71 ParrT parr{"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω"};
72 CHECK (not isnil (parr));
73 CHECK (8 == parr.size());
74
75 // indexed access
76 CHECK ("Γ" == parr[0]);
77 CHECK ("Δ" == parr[1]);
78 CHECK ("Θ" == parr[2]);
79 CHECK ("Ξ" == parr[3]);
80 CHECK ("Σ" == parr[4]);
81 CHECK ("Ψ" == parr[5]);
82 CHECK ("Φ" == parr[6]);
83 CHECK ("Ω" == parr[7]);
84
85 VERIFY_ERROR (INDEX_BOUNDS, parr[8]);
86
87 // string representation
88 CHECK ("Γ/Δ/Θ/Ξ/Σ/Ψ/Φ/Ω" == string(parr));
89
90 // new value can be assigned, but not altered in place
91 parr = ParrT{nullptr,nullptr,"Θ",nullptr,nullptr,nullptr,"Φ"};
92 CHECK (7 == parr.size());
93
94 // representation is trimmed and filled
95 CHECK ("Θ/*/*/*/Φ" == string(parr));
96 CHECK (Symbol::EMPTY == parr[0]);
97 CHECK (Symbol::EMPTY == parr[1]);
98 CHECK ("Θ" == parr[2]);
99 CHECK ("*" == parr[3]);
100 CHECK ("*" == parr[4]);
101 CHECK ("*" == parr[5]);
102 CHECK ("Φ" == parr[6]);
103 VERIFY_ERROR (INDEX_BOUNDS, parr[7]);
104 VERIFY_ERROR (INDEX_BOUNDS, parr[8]);
105 }
106
107
108 void
109 verify_iteration()
110 {
111 ParrT parr;
112 CHECK (isnil (parr));
113 // path is iterable
114 CHECK ("" == join(parr));
115
116 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω"};
117 CHECK (8 == parr.size());
118 // path is iterable
119 CHECK ("ΓΔΘΞΣΨΦΩ" == join(parr,""));
120
121 // iteration matches index order
122 uint i=0;
123 for (ParrT::iterator ii = parr.begin(); ii; ++ii, ++i)
124 CHECK (parr[i] == *ii);
125 CHECK (8 == i);
126
127
128 // path information is automatically trimmed and filled
129 parr = ParrT{nullptr,nullptr,"Θ",nullptr,nullptr,nullptr,"Φ"};
130 CHECK (7 == parr.size());
131 CHECK ("Θ***Φ" == join(parr,""));
132
133 parr = ParrT{nullptr,"Δ",nullptr,"Ξ",nullptr,nullptr,nullptr};
134 CHECK (4 == parr.size());
135 CHECK ("Δ*Ξ" == join(parr,""));
136
137 parr = ParrT{nullptr,"Δ",nullptr,"Ξ",nullptr,nullptr,"Φ"};
138 CHECK (7 == parr.size());
139 CHECK ("Δ*Ξ**Φ" == join(parr,""));
140
141 parr = ParrT{nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,"Ω",nullptr};
142 CHECK (16 == parr.size());
143 CHECK ("Ω" == join(parr,""));
144
145 // index numbering starts at absolute root
146 CHECK ("Ω" == *parr.begin());
147 CHECK (Symbol::EMPTY == parr[0]);
148 CHECK (Symbol::EMPTY == parr[1]);
149 CHECK (Symbol::EMPTY == parr[2]);
150 CHECK ("Ω" == parr[15]);
151 VERIFY_ERROR (INDEX_BOUNDS, parr[16]);
152
153 // but iteration starts with actual content
154 parr = ParrT{nullptr,nullptr,"Θ","Ξ","Σ","Ψ","Φ","Ω"};
155 CHECK ("Θ" == *parr.begin());
156 CHECK ( 2 == parr.indexOf (*parr.begin()));
157 CHECK ("Θ" == parr[2]);
158
159 parr = ParrT{nullptr,nullptr,nullptr,nullptr,"Σ","Ψ","Φ","Ω"};
160 CHECK ("Σ" == *parr.begin());
161 CHECK ( 4 == parr.indexOf (*parr.begin()));
162 CHECK ( 5 == parr.indexOf (*++parr.begin()));
163 CHECK ( 6 == parr.indexOf (*++++parr.begin()));
164
165 Literal some{"muck"};
166 VERIFY_ERROR (INVALID, parr.indexOf (some));
167 }
168
169
177 void
178 verify_boundaries()
179 {
180 ParrT parr;
181 CHECK ("" == join(parr));
182 CHECK (0 == parr.size());
183
184 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω"};
185 CHECK ("ΓΔΘΞΣΨΦΩ" == join(parr,""));
186 CHECK (8 == parr.size());
187
188 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ",""};
189 CHECK ("ΓΔΘΞΣΨΦ" == join(parr,""));
190 CHECK (7 == parr.size());
191
192 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ",nullptr};
193 CHECK ("ΓΔΘΞΣΨΦ" == join(parr,""));
194 CHECK (7 == parr.size());
195
196 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","Ψ",nullptr,""};
197 CHECK ("ΓΔΘΞΣΨ" == join(parr,""));
198 CHECK (6 == parr.size());
199
200 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","",nullptr,""};
201 CHECK ("ΓΔΘΞΣ" == join(parr,""));
202 CHECK (5 == parr.size());
203
204 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ",nullptr,"",nullptr};
205 CHECK ("ΓΔΘΞΣ" == join(parr,""));
206 CHECK (5 == parr.size());
207
208 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ",nullptr,nullptr,nullptr};
209 CHECK ("ΓΔΘΞΣ" == join(parr,""));
210 CHECK (5 == parr.size());
211
212 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ",nullptr,nullptr,nullptr,""};
213 CHECK ("ΓΔΘΞΣ" == join(parr,""));
214 CHECK (5 == parr.size());
215
216 parr = ParrT{"Γ","Δ","Θ","Ξ","Σ","","",""};
217 CHECK ("ΓΔΘΞΣ" == join(parr,""));
218 CHECK (5 == parr.size());
219
220 parr = ParrT{"Γ","Δ","Θ","Ξ","","","Φ",""};
221 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
222 CHECK (7 == parr.size());
223
224 parr = ParrT{"Γ","Δ","Θ","Ξ",nullptr,"","Φ",""};
225 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
226 CHECK (7 == parr.size());
227
228 parr = ParrT{"Γ","Δ","Θ","Ξ","",nullptr,"Φ",""};
229 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
230 CHECK (7 == parr.size());
231
232 parr = ParrT{"Γ","Δ","Θ","Ξ",nullptr,nullptr,"Φ",""};
233 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
234 CHECK (7 == parr.size());
235
236 parr = ParrT{"Γ","Δ","Θ","Ξ","","","Φ",nullptr};
237 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
238 CHECK (7 == parr.size());
239
240 parr = ParrT{"Γ","Δ","Θ","Ξ","","","Φ",nullptr,""};
241 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
242 CHECK (7 == parr.size());
243
244 parr = ParrT{"Γ","Δ","Θ","Ξ","","","Φ",nullptr,"",nullptr};
245 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
246 CHECK (7 == parr.size());
247
248 parr = ParrT{"Γ","Δ","Θ","Ξ","","","Φ",nullptr,"",nullptr,""};
249 CHECK ("ΓΔΘΞ**Φ" == join(parr,""));
250 CHECK (7 == parr.size());
251
252 parr = ParrT{"Γ","Δ","Θ","Ξ","",nullptr,"",nullptr,"",nullptr,""};
253 CHECK ("ΓΔΘΞ" == join(parr,""));
254 CHECK (4 == parr.size());
255
256 parr = ParrT{"Γ","Δ","Θ","Ξ",nullptr,"",nullptr,"",nullptr,"",nullptr};
257 CHECK ("ΓΔΘΞ" == join(parr,""));
258 CHECK (4 == parr.size());
259
260 parr = ParrT{"","Δ","Θ","Ξ","","",""};
261 CHECK ("ΔΘΞ" == join(parr,""));
262 CHECK (4 == parr.size());
263 CHECK ("" == parr[0]);
264
265 parr = ParrT{nullptr,"Δ","Θ","Ξ","","",""};
266 CHECK ("ΔΘΞ" == join(parr,""));
267 CHECK (4 == parr.size());
268 CHECK ("" == parr[0]);
269
270 parr = ParrT{nullptr,"Δ",nullptr,"Ξ","","",""};
271 CHECK ("Δ*Ξ" == join(parr,""));
272 CHECK (4 == parr.size());
273 CHECK ("" == parr[0]);
274 CHECK ("Δ" == parr[1]);
275 CHECK ("*" == parr[2]);
276 CHECK ("Ξ" == parr[3]);
277
278 parr = ParrT{nullptr,"",nullptr,"Ξ","","",""};
279 CHECK ("Ξ" == join(parr,""));
280 CHECK (4 == parr.size());
281 CHECK ("" == parr[0]);
282 CHECK ("" == parr[1]);
283 CHECK ("" == parr[2]);
284 CHECK ("Ξ" == parr[3]);
285
286 parr = ParrT{nullptr,"",nullptr,"Ξ","","Ψ",""};
287 CHECK ("Ξ*Ψ" == join(parr,""));
288 CHECK (6 == parr.size());
289 CHECK ("" == parr[0]);
290 CHECK ("" == parr[1]);
291 CHECK ("" == parr[2]);
292 CHECK ("Ξ" == parr[3]);
293 CHECK ("*" == parr[4]);
294 CHECK ("Ψ" == parr[5]);
295
296 parr = ParrT{nullptr,"",nullptr,"Ξ",nullptr,"Ψ",""};
297 CHECK ("Ξ*Ψ" == join(parr,""));
298 CHECK (6 == parr.size());
299 CHECK ("" == parr[0]);
300 CHECK ("" == parr[1]);
301 CHECK ("" == parr[2]);
302 CHECK ("Ξ" == parr[3]);
303 CHECK ("*" == parr[4]);
304 CHECK ("Ψ" == parr[5]);
305
306 parr = ParrT{nullptr,"",nullptr,"Ξ",nullptr,nullptr,"Φ",""};
307 CHECK ("Ξ**Φ" == join(parr,""));
308 CHECK (7 == parr.size());
309 CHECK ("" == parr[0]);
310 CHECK ("" == parr[1]);
311 CHECK ("" == parr[2]);
312 CHECK ("Ξ" == parr[3]);
313 CHECK ("*" == parr[4]);
314 CHECK ("*" == parr[5]);
315 CHECK ("Φ" == parr[6]);
316
317 parr = ParrT{nullptr,"",nullptr,"Ξ","",nullptr,"Φ",""};
318 CHECK ("Ξ**Φ" == join(parr,""));
319 CHECK (7 == parr.size());
320 CHECK ("" == parr[0]);
321 CHECK ("" == parr[1]);
322 CHECK ("" == parr[2]);
323 CHECK ("Ξ" == parr[3]);
324 CHECK ("*" == parr[4]);
325 CHECK ("*" == parr[5]);
326 CHECK ("Φ" == parr[6]);
327
328 parr = ParrT{nullptr,"",nullptr,"Ξ",nullptr,"","Φ",""};
329 CHECK ("Ξ**Φ" == join(parr,""));
330 CHECK (7 == parr.size());
331 CHECK ("" == parr[0]);
332 CHECK ("" == parr[1]);
333 CHECK ("" == parr[2]);
334 CHECK ("Ξ" == parr[3]);
335 CHECK ("*" == parr[4]);
336 CHECK ("*" == parr[5]);
337 CHECK ("Φ" == parr[6]);
338
339 parr = ParrT{nullptr,"",nullptr,"Ξ","","","Φ",""};
340 CHECK ("Ξ**Φ" == join(parr,""));
341 CHECK (7 == parr.size());
342 CHECK ("" == parr[0]);
343 CHECK ("" == parr[1]);
344 CHECK ("" == parr[2]);
345 CHECK ("Ξ" == parr[3]);
346 CHECK ("*" == parr[4]);
347 CHECK ("*" == parr[5]);
348 CHECK ("Φ" == parr[6]);
349
350 parr = ParrT{"",nullptr,"",nullptr,"Σ","","Φ",""};
351 CHECK ("Σ*Φ" == join(parr,""));
352 CHECK (7 == parr.size());
353 CHECK ("" == parr[0]);
354 CHECK ("" == parr[1]);
355 CHECK ("" == parr[2]);
356 CHECK ("" == parr[3]);
357 CHECK ("Σ" == parr[4]);
358 CHECK ("*" == parr[5]);
359 CHECK ("Φ" == parr[6]);
360
361 parr = ParrT{"",nullptr,"",nullptr,"Σ",nullptr,"Φ",""};
362 CHECK ("Σ*Φ" == join(parr,""));
363 CHECK (7 == parr.size());
364 CHECK ("" == parr[0]);
365 CHECK ("" == parr[1]);
366 CHECK ("" == parr[2]);
367 CHECK ("" == parr[3]);
368 CHECK ("Σ" == parr[4]);
369 CHECK ("*" == parr[5]);
370 CHECK ("Φ" == parr[6]);
371
372 parr = ParrT{"",nullptr,"",nullptr,"","Ψ",nullptr,"Ω",""};
373 CHECK ("Ψ*Ω" == join(parr,""));
374 CHECK (8 == parr.size());
375 CHECK ("" == parr[0]);
376 CHECK ("" == parr[1]);
377 CHECK ("" == parr[2]);
378 CHECK ("" == parr[3]);
379 CHECK ("" == parr[4]);
380 CHECK ("Ψ" == parr[5]);
381 CHECK ("*" == parr[6]);
382 CHECK ("Ω" == parr[7]);
383
384 parr = ParrT{nullptr,"",nullptr,"",nullptr,"Ψ",nullptr,"Ω",""};
385 CHECK ("Ψ*Ω" == join(parr,""));
386 CHECK (8 == parr.size());
387 CHECK ("" == parr[0]);
388 CHECK ("" == parr[1]);
389 CHECK ("" == parr[2]);
390 CHECK ("" == parr[3]);
391 CHECK ("" == parr[4]);
392 CHECK ("Ψ" == parr[5]);
393 CHECK ("*" == parr[6]);
394 CHECK ("Ω" == parr[7]);
395
396 parr = ParrT{nullptr,"",nullptr,"",nullptr,"","Φ",nullptr,"ω",""};
397 CHECK ("Φ*ω" == join(parr,""));
398 CHECK (9 == parr.size());
399 CHECK ("" == parr[0]);
400 CHECK ("" == parr[1]);
401 CHECK ("" == parr[2]);
402 CHECK ("" == parr[3]);
403 CHECK ("" == parr[4]);
404 CHECK ("" == parr[5]);
405 CHECK ("Φ" == parr[6]);
406 CHECK ("*" == parr[7]);
407 CHECK ("ω" == parr[8]);
408
409 parr = ParrT{"",nullptr,"",nullptr,"",nullptr,"Φ",nullptr,"ω",""};
410 CHECK ("Φ*ω" == join(parr,""));
411 CHECK (9 == parr.size());
412 CHECK ("" == parr[0]);
413 CHECK ("" == parr[1]);
414 CHECK ("" == parr[2]);
415 CHECK ("" == parr[3]);
416 CHECK ("" == parr[4]);
417 CHECK ("" == parr[5]);
418 CHECK ("Φ" == parr[6]);
419 CHECK ("*" == parr[7]);
420 CHECK ("ω" == parr[8]);
421
422 parr = ParrT{"",nullptr,"",nullptr,"",nullptr,"Φ",nullptr,"ω","*"};
423 CHECK ("Φ*ω" == join(parr,""));
424 CHECK (9 == parr.size());
425 CHECK ("" == parr[0]);
426 CHECK ("" == parr[1]);
427 CHECK ("" == parr[2]);
428 CHECK ("" == parr[3]);
429 CHECK ("" == parr[4]);
430 CHECK ("" == parr[5]);
431 CHECK ("Φ" == parr[6]);
432 CHECK ("*" == parr[7]);
433 CHECK ("ω" == parr[8]);
434
435 parr = ParrT{"",nullptr,"",nullptr,"",nullptr,"Φ",nullptr,"*",""};
436 CHECK ("Φ" == join(parr,""));
437 CHECK (7 == parr.size());
438 CHECK ("" == parr[0]);
439 CHECK ("" == parr[1]);
440 CHECK ("" == parr[2]);
441 CHECK ("" == parr[3]);
442 CHECK ("" == parr[4]);
443 CHECK ("" == parr[5]);
444 CHECK ("Φ" == parr[6]);
445
446 parr = ParrT{"",nullptr,"",nullptr,"",nullptr,""};
447 CHECK ("" == join(parr,""));
448 CHECK (0 == parr.size());
449 }
450
451
456 void
457 verify_comparisons()
458 {
459 CHECK (ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω") == ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω"));
460 CHECK (ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω") != ParrT("Γ","Δ","Θ","Σ","Ξ","Ψ","Φ","Ω"));
461 CHECK (ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω") != ParrT("Γ","Δ","Θ","Ξ","Ξ","Ψ","Φ","Ω"));
462 CHECK (ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω") != ParrT("" ,"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ"));
463 CHECK (ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","" ) != ParrT("" ,"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ"));
464 CHECK (ParrT("Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","" ) != ParrT("" ,"Γ","Δ","Θ","Ξ","Σ","Ψ","" ));
465 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) != ParrT("*","Δ","Θ","Ξ","Σ","Ψ","Φ","" ));
466 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) != ParrT("" ,"Δ","Θ","Ξ","" ,"Σ","Ψ","Φ"));
467 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) != ParrT("" ,"Δ","Θ","Ξ","Σ***Ψ","Φ","" ));
468 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","" ,"Φ","" ) != ParrT("" ,"Δ","Θ","Ξ","*","Ψ","Φ","" ));
469 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","" ,"Φ","" ) != ParrT("" ,"Δ","Θ","Ξ","Σ","* ","Φ",""));
470 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","" ,"Φ","" ) != ParrT("" ,"Δ","Θ","Ξ","Σ","**","Φ",""));
471 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) == ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","*"));
472 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","", "Φ","" ) == ParrT("" ,"Δ","Θ","Ξ","Σ","*","Φ","" ));
473 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) == ParrT(nullptr,"Δ","Θ","Ξ","Σ","Ψ","Φ"));
474 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) == ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ",nullptr));
475 CHECK (ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ","" ) == ParrT("" ,"Δ","Θ","Ξ","Σ","Ψ","Φ"));
476 CHECK (ParrT("" ,"Δ","Θ","Ξ","" ,"Ψ","Φ","" ) == ParrT("" ,"Δ","Θ","Ξ",nullptr,"Ψ","Φ"));
477 CHECK (ParrT("" ,"Δ","Θ","Ξ","*","Ψ","Φ","" ) == ParrT("" ,"Δ","Θ","Ξ",nullptr,"Ψ","Φ"));
478 CHECK (ParrT("" ,"Δ","Θ","Ξ","*","Ψ","Φ","" ) == ParrT("" ,"Δ","Θ","Ξ","", "Ψ","Φ"));
479
480 ParrT src{"Γ","Δ","Θ","Ξ","Σ","Ψ","Φ","Ω"};
481 ParrT copy{src};
482 CHECK (not isnil(copy));
483 CHECK (src == copy);
484
485 ParrT target {std::move (copy)};
486 CHECK (src == target);
487 CHECK (copy != target);
488 CHECK (copy != src);
489 }
490 };
491
492
494 LAUNCHER (PathArray_test, "unit stage");
495
496
497}} // namespace lib::test
lib::IterAdapter
Adapter for building an implementation of the »Lumiera Forward Iterator« concept.
Definition iter-adapter.hpp:208
lib::Literal
Inline string literal.
Definition symbol.hpp:78
lib::PathArray
Abstraction for path-like topological coordinates.
Definition path-array.hpp:226
lib::PathArray::begin
iterator begin() const
Definition path-array.hpp:379
lib::PathArray::indexOf
size_t indexOf(Literal const &content) const
reverse lookup of actual path content
Definition path-array.hpp:330
lib::PathArray::size
size_t size() const
Definition path-array.hpp:284
lib::Symbol
Token or Atom with distinct identity.
Definition symbol.hpp:120
lib::Symbol::EMPTY
static Symbol EMPTY
Definition symbol.hpp:123
lib::test::PathArray_test
Definition path-array-test.cpp:53
lib::test::PathArray_test::verify_boundaries
void verify_boundaries()
Definition path-array-test.cpp:178
lib::test::PathArray_test::run
virtual void run(Arg)
Definition path-array-test.cpp:56
lib::test::PathArray_test::verify_basics
void verify_basics()
Definition path-array-test.cpp:66
lib::test::PathArray_test::verify_iteration
void verify_iteration()
Definition path-array-test.cpp:109
lib::test::PathArray_test::verify_comparisons
void verify_comparisons()
Definition path-array-test.cpp:457
LERR_
#define LERR_(_NAME_)
Definition error.hpp:45
format-util.hpp
Collection of small helpers and convenience shortcuts for diagnostics & formatting.
uint
unsigned int uint
Definition integral.hpp:29
lib::test::ParrT
lib::PathArray< 5 > ParrT
Definition path-array-test.cpp:41
lib
Implementation namespace for support and library code.
Definition common-services.cpp:55
test
Test runner and basic definitions for tests.
util::join
string join(COLL &&coll, string const &delim=", ")
enumerate a collection's contents, separated by delimiter.
Definition format-util.hpp:194
util::isnil
bool isnil(lib::time::Duration const &dur)
Definition timevalue.hpp:860
path-array.hpp
Foundation abstraction to implement path-like component sequences.
run.hpp
Simplistic test class runner.
LAUNCHER
#define LAUNCHER(_TEST_CLASS_, _GROUPS_)
Definition run.hpp:116
test-helper.hpp
A collection of frequently used helper functions to support unit testing.
VERIFY_ERROR
#define VERIFY_ERROR(ERROR_ID, ERRONEOUS_STATEMENT)
Macro to verify that a statement indeed raises an exception.
Definition test-helper.hpp:393
util.hpp
Tiny helper functions and shortcuts to be used everywhere Consider this header to be effectively incl...