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