Teuchos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
SIOVOC_UnitTests.cpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Teuchos: Common Tools Package
5// Copyright (2004) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38//
39// ***********************************************************************
40// @HEADER
41
42#include "Teuchos_StringIndexedOrderedValueObjectContainer.hpp"
43#include "Teuchos_UnitTestHarness.hpp"
44
45namespace Teuchos {
46
47
48TEUCHOS_UNIT_TEST( OrdinalIndex, defaultConstruct )
49{
50 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
51 ECHO(SIOVOCB::OrdinalIndex idx);
52 TEST_EQUALITY_CONST(idx.idx, -1); // Depends on implementation choice!
53}
54
55
56TEUCHOS_UNIT_TEST( OrdinalIndex, construct )
57{
58 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
59 ECHO(SIOVOCB::OrdinalIndex idx(5));
60 TEST_EQUALITY_CONST(idx.idx, 5);
61}
62
63
64TEUCHOS_UNIT_TEST( KeyObjectPair, defaultConstruct )
65{
66 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
67 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop);
68 TEST_EQUALITY_CONST(kop.first, "");
69 TEST_EQUALITY_CONST(kop.second.idx, -1);
70 TEST_EQUALITY_CONST(kop.isActive(), true);
71}
72
73
74TEUCHOS_UNIT_TEST( KeyObjectPair, construct_default_isActive )
75{
76 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
77 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop("key_name1", 7));
78 TEST_EQUALITY_CONST(kop.first, "key_name1");
79 TEST_EQUALITY_CONST(kop.second.idx, 7);
80 TEST_EQUALITY_CONST(kop.isActive(), true);
81}
82
83
84TEUCHOS_UNIT_TEST( KeyObjectPair, makeInvalid )
85{
86 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
87 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop =
88 SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex>::makeInvalid());
89 TEST_EQUALITY_CONST(kop.first, "");
90 TEST_EQUALITY_CONST(kop.second.idx, -1);
91 TEST_EQUALITY_CONST(kop.isActive(), false);
92}
93
94
95TEUCHOS_UNIT_TEST( KeyObjectPair, construct_set_isActive )
96{
97 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
98 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop("key_name2", 8, false));
99 TEST_EQUALITY_CONST(kop.first, "key_name2");
100 TEST_EQUALITY_CONST(kop.second.idx, 8);
101 TEST_EQUALITY_CONST(kop.isActive(), false);
102}
103
104
105TEUCHOS_UNIT_TEST( KeyObjectPair, copyConstruct )
106{
107 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
108 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop1("key_name", 3, false));
109 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop2(kop1));
110 TEST_EQUALITY_CONST(kop2.first, "key_name");
111 TEST_EQUALITY_CONST(kop2.second.idx, 3);
112 TEST_EQUALITY_CONST(kop2.isActive(), false);
113}
114
115
116TEUCHOS_UNIT_TEST( KeyObjectPair, assign )
117{
118 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
119 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop1("key_name", 3, false));
120 ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop2);
121 TEST_EQUALITY_CONST(kop2.isActive(), true);
122 ECHO(kop2 = kop1);
123 TEST_EQUALITY_CONST(kop2.first, "key_name");
124 TEST_EQUALITY_CONST(kop2.second.idx, 3);
125 TEST_EQUALITY_CONST(kop2.isActive(), false);
126}
127
128
135
136
137TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, basic_set_get )
138{
139
140 //typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB; // unused
141 //typedef SIOVOCB::Ordinal Ordinal;
142 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
143
144 ECHO(const Ordinal my_int_1_idx1 = oc.setObj("my_int_1", 3));
145 TEST_EQUALITY_CONST(my_int_1_idx1, 0);
146 TEST_EQUALITY_CONST(oc.numObjects(), 1);
147 TEST_EQUALITY_CONST(oc.numStorage(), 1);
148 ECHO(const Ordinal my_int_1_idx2 = oc.getObjOrdinalIndex(("my_int_1")));
149 TEST_EQUALITY(my_int_1_idx2, my_int_1_idx2);
150 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr(my_int_1_idx1), 3);
151 TEST_EQUALITY_CONST(*oc.getObjPtr(my_int_1_idx1), 3);
152 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_1"), 3);
153 TEST_EQUALITY_CONST(*oc.getObjPtr("my_int_1"), 3);
154
155 ECHO(const Ordinal my_int_2_idx1 = oc.setObj("my_int_2", 4));
156 TEST_EQUALITY_CONST(my_int_2_idx1, 1);
157 TEST_EQUALITY_CONST(oc.numObjects(), 2);
158 TEST_EQUALITY_CONST(oc.numStorage(), 2);
159 ECHO(const Ordinal my_int_2_idx2 = oc.getObjOrdinalIndex(("my_int_2")));
160 TEST_EQUALITY(my_int_2_idx2, my_int_2_idx2);
161 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr(my_int_2_idx1), 4);
162 TEST_EQUALITY_CONST(*oc.getObjPtr(my_int_2_idx1), 4);
163 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_2"), 4);
164 TEST_EQUALITY_CONST(*oc.getObjPtr("my_int_2"), 4);
165
166}
167
168
169TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, set_two_keep_ref )
170{
171 // Test test makes sure that objects keep the same address when adding new
172 // objects.
173 //typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB; // unused
174 //typedef SIOVOCB::Ordinal Ordinal;
175 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
176 ECHO(const Ordinal my_int_1_idx = oc.setObj("my_int_1", 3));
177 ECHO(const int &my_int_1 = *oc.getObjPtr(my_int_1_idx));
178 ECHO(oc.setObj("my_int_2", 4));
179 TEST_EQUALITY_CONST(*oc.getObjPtr(my_int_1_idx), 3);
180 TEST_EQUALITY(&my_int_1, oc.getObjPtr(my_int_1_idx).get());
181 TEST_EQUALITY_CONST(my_int_1, 3);
182}
183
184
185TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, getObjOrdinalIndex )
186{
187
188 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
189 //typedef SIOVOCB::Ordinal Ordinal;
190 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
191 ECHO(oc.setObj("my_int_1", 3));
192 TEST_EQUALITY_CONST(oc.getObjOrdinalIndex("my_int_1"), 0);
193 ECHO(oc.setObj("my_int_2", 3));
194 TEST_EQUALITY_CONST(oc.getObjOrdinalIndex("my_int_2"), 1);
195 TEST_EQUALITY_CONST(oc.getObjOrdinalIndex("does_not_exist"), SIOVOCB::getInvalidOrdinal());
196}
197
198
199TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, set_and_set_again )
200{
201
202 //typedef StringIndexedOrderedValueObjectContainerBase::Ordinal Ordinal;
203 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
204
205 ECHO(const Ordinal my_int_1_idx1 = oc.setObj("my_int_1", 3));
206 TEST_EQUALITY_CONST(my_int_1_idx1, 0);
207 ECHO(const Ordinal my_int_1_idx2 = oc.getObjOrdinalIndex(("my_int_1")));
208 TEST_EQUALITY_CONST(my_int_1_idx2, my_int_1_idx1);
209 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_1"), 3);
210
211 ECHO(const Ordinal my_int_1_idx3 = oc.setObj("my_int_1", 4));
212 TEST_EQUALITY_CONST(my_int_1_idx3, 0);
213 ECHO(const Ordinal my_int_1_idx4 = oc.getObjOrdinalIndex(("my_int_1")));
214 TEST_EQUALITY_CONST(my_int_1_idx3, my_int_1_idx4);
215 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_1"), 4);
216
217}
218
219
220TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, basicNonconstIterators )
221{
222 typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator;
223 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
224 ECHO(oc.setObj("c", 1));
225 ECHO(oc.setObj("a", 2));
226 ECHO(oc.setObj("b", 3));
227 ECHO(Iterator itr = oc.nonconstBegin());
228 TEST_EQUALITY_CONST(itr->first, "c");
229 TEST_EQUALITY_CONST(itr->second, 1);
230 ECHO(itr->second = 5);
231 TEST_EQUALITY_CONST(itr->second, 5);
232 ECHO(++itr);
233 TEST_EQUALITY_CONST(itr->first, "a");
234 TEST_EQUALITY_CONST(itr->second, 2);
235 ECHO(itr->second = 6);
236 TEST_EQUALITY_CONST(itr->second, 6);
237 ECHO(++itr);
238 TEST_EQUALITY_CONST(itr->first, "b");
239 TEST_EQUALITY_CONST(itr->second, 3);
240 ECHO(itr->second = 7);
241 TEST_EQUALITY_CONST(itr->second, 7);
242 ECHO(++itr);
243 TEST_ITER_EQUALITY(itr, oc.nonconstEnd());
244}
245
246
247TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, basicConstIterators )
248{
249 typedef StringIndexedOrderedValueObjectContainer<int>::ConstIterator ConstIterator;
250 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
251 ECHO(oc.setObj("c", 1));
252 ECHO(oc.setObj("a", 2));
253 ECHO(oc.setObj("b", 3));
254 ECHO(ConstIterator itr = oc.begin());
255 TEST_EQUALITY_CONST(itr->first, "c");
256 TEST_EQUALITY_CONST(itr->second, 1);
257 ECHO(++itr);
258 TEST_EQUALITY_CONST(itr->first, "a");
259 TEST_EQUALITY_CONST(itr->second, 2);
260 ECHO(++itr);
261 TEST_EQUALITY_CONST(itr->first, "b");
262 TEST_EQUALITY_CONST(itr->second, 3);
263 ECHO(++itr);
264 TEST_ITER_EQUALITY(itr, oc.end());
265}
266
267
268TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_idx_first )
269{
270 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
271 typedef SIOVOCB::OrdinalIndex OI;
272 typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
273 ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
274 ECHO(oc.setObj("c", 1));
275 ECHO(oc.setObj("a", 2));
276 ECHO(oc.setObj("b", 3));
277 TEST_EQUALITY_CONST(oc.numObjects(), 3);
278 TEST_EQUALITY_CONST(oc.numStorage(), 3);
279 ECHO(const OI &b = *oc.getObjPtr("b"));
280 ECHO(oc.removeObj(0));
281 TEST_EQUALITY_CONST(oc.numObjects(), 2);
282 TEST_EQUALITY_CONST(oc.numStorage(), 3);
283 TEST_EQUALITY(&b, oc.getObjPtr("b").get());
284 ECHO(ConstIterator itr = oc.begin());
285 TEST_EQUALITY_CONST(itr->first, "a");
286 TEST_EQUALITY_CONST(itr->second.idx, 2);
287 TEST_EQUALITY_CONST(itr->isActive(), true);
288 ECHO(++itr);
289 TEST_EQUALITY_CONST(itr->first, "b");
290 TEST_EQUALITY_CONST(itr->second.idx, 3);
291 TEST_EQUALITY_CONST(itr->isActive(), true);
292 ECHO(++itr);
293 TEST_ITER_EQUALITY(itr, oc.end());
294}
295
296
297TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_key_first )
298{
299 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
300 typedef SIOVOCB::OrdinalIndex OI;
301 typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
302 ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
303 ECHO(oc.setObj("c", 1));
304 ECHO(oc.setObj("a", 2));
305 ECHO(oc.setObj("b", 3));
306 TEST_EQUALITY_CONST(oc.numObjects(), 3);
307 TEST_EQUALITY_CONST(oc.numStorage(), 3);
308 ECHO(const OI &b = *oc.getObjPtr("b"));
309 ECHO(oc.removeObj("c"));
310 TEST_EQUALITY_CONST(oc.numObjects(), 2);
311 TEST_EQUALITY_CONST(oc.numStorage(), 3);
312 TEST_EQUALITY(&b, oc.getObjPtr("b").get());
313 ECHO(ConstIterator itr = oc.begin());
314 TEST_EQUALITY_CONST(itr->first, "a");
315 TEST_EQUALITY_CONST(itr->second.idx, 2);
316 TEST_EQUALITY_CONST(itr->isActive(), true);
317 ECHO(++itr);
318 TEST_EQUALITY_CONST(itr->first, "b");
319 TEST_EQUALITY_CONST(itr->second.idx, 3);
320 TEST_EQUALITY_CONST(itr->isActive(), true);
321 ECHO(++itr);
322 TEST_ITER_EQUALITY(itr, oc.end());
323}
324
325
326TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_idx_middle )
327{
328 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
329 typedef SIOVOCB::OrdinalIndex OI;
330 typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
331 ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
332 ECHO(oc.setObj("c", 1));
333 ECHO(oc.setObj("a", 2));
334 ECHO(oc.setObj("b", 3));
335 TEST_EQUALITY_CONST(oc.numObjects(), 3);
336 TEST_EQUALITY_CONST(oc.numStorage(), 3);
337 ECHO(const OI &c = *oc.getObjPtr("c"));
338 ECHO(oc.removeObj(1));
339 TEST_EQUALITY(&c, oc.getObjPtr("c").get());
340 ECHO(ConstIterator itr = oc.begin());
341 TEST_EQUALITY_CONST(oc.numObjects(), 2);
342 TEST_EQUALITY_CONST(oc.numStorage(), 3);
343 TEST_EQUALITY_CONST(itr->first, "c");
344 TEST_EQUALITY_CONST(itr->second.idx, 1);
345 TEST_EQUALITY_CONST(itr->isActive(), true);
346 ECHO(++itr);
347 TEST_EQUALITY_CONST(itr->first, "b");
348 TEST_EQUALITY_CONST(itr->second.idx, 3);
349 TEST_EQUALITY_CONST(itr->isActive(), true);
350 ECHO(++itr);
351 TEST_ITER_EQUALITY(itr, oc.end());
352}
353
354
355TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_key_middle )
356{
357 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
358 typedef SIOVOCB::OrdinalIndex OI;
359 typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
360 ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
361 ECHO(oc.setObj("c", 1));
362 ECHO(oc.setObj("a", 2));
363 ECHO(oc.setObj("b", 3));
364 TEST_EQUALITY_CONST(oc.numObjects(), 3);
365 TEST_EQUALITY_CONST(oc.numStorage(), 3);
366 ECHO(const OI &c = *oc.getObjPtr("c"));
367 ECHO(oc.removeObj("a"));
368 TEST_EQUALITY(&c, oc.getObjPtr("c").get());
369 TEST_EQUALITY_CONST(oc.numObjects(), 2);
370 TEST_EQUALITY_CONST(oc.numStorage(), 3);
371 ECHO(ConstIterator itr = oc.begin());
372 TEST_EQUALITY_CONST(itr->first, "c");
373 TEST_EQUALITY_CONST(itr->second.idx, 1);
374 TEST_EQUALITY_CONST(itr->isActive(), true);
375 ECHO(++itr);
376 TEST_EQUALITY_CONST(itr->first, "b");
377 TEST_EQUALITY_CONST(itr->second.idx, 3);
378 TEST_EQUALITY_CONST(itr->isActive(), true);
379 ECHO(++itr);
380 TEST_ITER_EQUALITY(itr, oc.end());
381}
382
383
384TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_idx_last )
385{
386 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
387 typedef SIOVOCB::OrdinalIndex OI;
388 typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
389 ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
390 ECHO(oc.setObj("c", 1));
391 ECHO(oc.setObj("a", 2));
392 ECHO(oc.setObj("b", 3));
393 TEST_EQUALITY_CONST(oc.numObjects(), 3);
394 TEST_EQUALITY_CONST(oc.numStorage(), 3);
395 ECHO(const OI &a = *oc.getObjPtr("a"));
396 ECHO(oc.removeObj(2));
397 TEST_EQUALITY_CONST(oc.numObjects(), 2);
398 TEST_EQUALITY_CONST(oc.numStorage(), 3);
399 TEST_EQUALITY(&a, oc.getObjPtr("a").get());
400 ECHO(ConstIterator itr = oc.begin());
401 TEST_EQUALITY_CONST(itr->first, "c");
402 TEST_EQUALITY_CONST(itr->second.idx, 1);
403 TEST_EQUALITY_CONST(itr->isActive(), true);
404 ECHO(++itr);
405 TEST_EQUALITY_CONST(itr->first, "a");
406 TEST_EQUALITY_CONST(itr->second.idx, 2);
407 TEST_EQUALITY_CONST(itr->isActive(), true);
408 ECHO(++itr);
409 TEST_ITER_EQUALITY(itr, oc.end());
410}
411
412
413TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_key_last )
414{
415 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
416 typedef SIOVOCB::OrdinalIndex OI;
417 typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
418 ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
419 ECHO(oc.setObj("c", 1));
420 ECHO(oc.setObj("a", 2));
421 ECHO(oc.setObj("b", 3));
422 TEST_EQUALITY_CONST(oc.numObjects(), 3);
423 TEST_EQUALITY_CONST(oc.numStorage(), 3);
424 ECHO(const OI &a = *oc.getObjPtr("a"));
425 ECHO(oc.removeObj("b"));
426 TEST_EQUALITY_CONST(oc.numObjects(), 2);
427 TEST_EQUALITY_CONST(oc.numStorage(), 3);
428 TEST_EQUALITY(&a, oc.getObjPtr("a").get());
429 ECHO(ConstIterator itr = oc.begin());
430 TEST_EQUALITY_CONST(itr->first, "c");
431 TEST_EQUALITY_CONST(itr->second.idx, 1);
432 TEST_EQUALITY_CONST(itr->isActive(), true);
433 ECHO(++itr);
434 TEST_EQUALITY_CONST(itr->first, "a");
435 TEST_EQUALITY_CONST(itr->second.idx, 2);
436 TEST_EQUALITY_CONST(itr->isActive(), true);
437 ECHO(++itr);
438 TEST_ITER_EQUALITY(itr, oc.end());
439}
440
441
442TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, getNonconstObjPtr_idx_invalid )
443{
444 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
445 //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
446 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
447 ECHO(oc.setObj("a", 4));
448 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr(0), 4);
449 TEST_THROW(oc.getNonconstObjPtr(-1), SIOVOCB::InvalidOrdinalIndexError);
450 TEST_THROW(oc.getNonconstObjPtr(1), SIOVOCB::InvalidOrdinalIndexError);
451 ECHO(oc.removeObj(0));
452 TEST_THROW(oc.getNonconstObjPtr(0), SIOVOCB::InvalidOrdinalIndexError);
453}
454
455
456TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, getObjPtr_idx_invalid )
457{
458 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
459 //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
460 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
461 ECHO(oc.setObj("a", 4));
462 TEST_EQUALITY_CONST(*oc.getObjPtr(0), 4);
463 TEST_THROW(oc.getObjPtr(-1), SIOVOCB::InvalidOrdinalIndexError);
464 TEST_THROW(oc.getObjPtr(1), SIOVOCB::InvalidOrdinalIndexError);
465 ECHO(oc.removeObj(0));
466 TEST_THROW(oc.getObjPtr(0), SIOVOCB::InvalidOrdinalIndexError);
467}
468
469
470TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_idx_invalid )
471{
472 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
473 //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
474 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
475 ECHO(oc.setObj("a", 4));
476 TEST_EQUALITY_CONST(*oc.getObjPtr(0), 4);
477 TEST_THROW(oc.removeObj(-1), SIOVOCB::InvalidOrdinalIndexError);
478 TEST_THROW(oc.removeObj(1), SIOVOCB::InvalidOrdinalIndexError);
479 TEST_EQUALITY_CONST(oc.numObjects(), 1);
480 ECHO(oc.removeObj(0));
481 TEST_EQUALITY_CONST(oc.numObjects(), 0);
482 TEST_THROW(oc.removeObj(0), SIOVOCB::InvalidOrdinalIndexError);
483}
484
485
486TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, getNonconstObjPtr_key_invalid )
487{
488 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
489 //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
490 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
491 ECHO(oc.setObj("a", 4));
492 TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("a"), 4);
493 TEST_THROW(oc.getNonconstObjPtr("does_not_exist"), SIOVOCB::InvalidKeyError);
494 ECHO(oc.removeObj("a"));
495 TEST_THROW(oc.getNonconstObjPtr("a"), SIOVOCB::InvalidKeyError);
496}
497
498
499TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, getObjPtr_key_invalid )
500{
501 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
502 //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
503 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
504 ECHO(oc.setObj("a", 4));
505 TEST_EQUALITY_CONST(*oc.getObjPtr("a"), 4);
506 TEST_THROW(oc.getObjPtr("does_not_exist"), SIOVOCB::InvalidKeyError);
507 ECHO(oc.removeObj("a"));
508 TEST_THROW(oc.getObjPtr("a"), SIOVOCB::InvalidKeyError);
509}
510
511
512TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, removeObj_key_invalid )
513{
514 typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
515 //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
516 ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
517 ECHO(oc.setObj("a", 4));
518 TEST_EQUALITY_CONST(*oc.getObjPtr("a"), 4);
519 TEST_THROW(oc.removeObj("does_not_exist"), SIOVOCB::InvalidKeyError);
520 TEST_EQUALITY_CONST(oc.numObjects(), 1);
521 ECHO(oc.removeObj("a"));
522 TEST_EQUALITY_CONST(oc.numObjects(), 0);
523 TEST_THROW(oc.removeObj("a"), SIOVOCB::InvalidKeyError);
524}
525
526// ToDo: Test dangling object references!
527
528
529} // namespace Teuchos
TEST_EQUALITY_CONST
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
Definition Teuchos_LocalTestingHelpers.hpp:79
TEST_EQUALITY
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
Definition Teuchos_LocalTestingHelpers.hpp:87
TEST_THROW
#define TEST_THROW(code, ExceptType)
Assert that the statement 'code' throws the exception 'ExceptType' (otherwise the test fails).
Definition Teuchos_LocalTestingHelpers.hpp:198
ECHO
#define ECHO(statement)
Echo the given statement before it is executed.
Definition Teuchos_LocalTestingHelpers.hpp:63
TEST_ITER_EQUALITY
#define TEST_ITER_EQUALITY(iter1, iter2)
Assert that two iterators are equal.
Definition Teuchos_LocalTestingHelpers.hpp:120
Teuchos_StringIndexedOrderedValueObjectContainer.hpp
Teuchos_UnitTestHarness.hpp
Unit testing support.
TEUCHOS_UNIT_TEST
#define TEUCHOS_UNIT_TEST(TEST_GROUP, TEST_NAME)
Macro for defining a (non-templated) unit test.
Definition Teuchos_UnitTestHelpers.hpp:83
Teuchos::StringIndexedOrderedValueObjectContainer::setObj
Ordinal setObj(const std::string &key, U &&obj)
Set (or reset) object by value and return its ordinal index.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:482
Teuchos::StringIndexedOrderedValueObjectContainer::getObjOrdinalIndex
Ordinal getObjOrdinalIndex(const std::string &key) const
Get the ordinal index given the string key.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:469
Teuchos::StringIndexedOrderedValueObjectContainer::ConstIterator
FilteredIterator< typename key_and_obj_array_t::const_iterator, SelectActive< ObjType > > ConstIterator
The const iterator type.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:210
Teuchos::StringIndexedOrderedValueObjectContainer::Iterator
FilteredIterator< typename key_and_obj_array_t::iterator, SelectActive< ObjType > > Iterator
The non-const iterator type.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:206
Teuchos::StringIndexedOrderedValueObjectContainer::removeObj
void removeObj(const Ordinal &idx)
Remove an object given its ordinal index.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:501
Teuchos::StringIndexedOrderedValueObjectContainer::getNonconstObjPtr
Ptr< ObjType > getNonconstObjPtr(const Ordinal &idx)
Get a nonconst semi-persisting association with the stored object indexed by ordinal.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:358
Teuchos::StringIndexedOrderedValueObjectContainer::getObjPtr
Ptr< const ObjType > getObjPtr(const Ordinal &idx) const
Get a const semi-persisting association with the stored object indexed by ordinal.
Definition Teuchos_StringIndexedOrderedValueObjectContainer.hpp:367
Generated by doxygen 1.17.0