Lumiera  0.pre.03
»edit your freedom«
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 
28 using std::string;
29 using lib::Symbol;
30 using util::isnil;
31 using util::join;
32 
33 
34 
35 namespace lib {
36 namespace 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
56  run (Arg)
57  {
58  verify_basics();
59  verify_iteration();
60  verify_boundaries();
61  verify_comparisons();
62  }
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
test
Definition: run.hpp:40
lib::Literal
inline string literal This is a marker type to indicate that
Definition: symbol.hpp:76
VERIFY_ERROR
#define VERIFY_ERROR(ERROR_ID, ERRONEOUS_STATEMENT)
Macro to verify that a statement indeed raises an exception.
Definition: test-helper.hpp:387
lib::test::PathArray_test
Definition: path-array-test.cpp:52
lib
Implementation namespace for support and library code.
Definition: common-services.cpp:54
lib::PathArray
Abstraction for path-like topological coordinates.
Definition: path-array.hpp:225
lib::Symbol
Token or Atom with distinct identity.
Definition: symbol.hpp:117
run.hpp
Simplistic test class runner.
lib::PathArray::begin
iterator begin() const
Definition: path-array.hpp:380
util.hpp
Tiny helper functions and shortcuts to be used everywhere Consider this header to be effectively incl...
test-helper.hpp
A collection of frequently used helper functions to support unit testing.
format-util.hpp
Collection of small helpers and convenience shortcuts for diagnostics & formatting.
path-array.hpp
Foundation abstraction to implement path-like component sequences.
lib::test::PathArray_test::verify_boundaries
void verify_boundaries()
Definition: path-array-test.cpp:178
lib::PathArray::indexOf
size_t indexOf(Literal const &content) const
reverse lookup of actual path content
Definition: path-array.hpp:331
lib::test::PathArray_test::verify_comparisons
void verify_comparisons()
Definition: path-array-test.cpp:457
lib::IterAdapter
Adapter for building an implementation of the »Lumiera Forward Iterator« concept. ...
Definition: iter-adapter.hpp:206