Teuchos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 
45 namespace Teuchos {
46 
47 
48 TEUCHOS_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 
56 TEUCHOS_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 
64 TEUCHOS_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 
74 TEUCHOS_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 
84 TEUCHOS_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 
95 TEUCHOS_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 
105 TEUCHOS_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 
116 TEUCHOS_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 
129 TEUCHOS_UNIT_TEST( StringIndexedOrderedValueObjectContainer, defaultConstruct )
130 {
131  StringIndexedOrderedValueObjectContainer<int> oc;
132  TEST_EQUALITY_CONST(oc.numObjects(), 0);
133  TEST_EQUALITY_CONST(oc.numStorage(), 0);
134 }
135 
136 
137 TEUCHOS_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 
169 TEUCHOS_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 
185 TEUCHOS_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 
199 TEUCHOS_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 
220 TEUCHOS_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 
247 TEUCHOS_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 
268 TEUCHOS_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 
297 TEUCHOS_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 
326 TEUCHOS_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 
355 TEUCHOS_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 
384 TEUCHOS_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 
413 TEUCHOS_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 
442 TEUCHOS_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 
456 TEUCHOS_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 
470 TEUCHOS_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 
486 TEUCHOS_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 
499 TEUCHOS_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 
512 TEUCHOS_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
Teuchos::FilteredIterator
C++ Standard Library compatable filtered iterator.
Definition: Teuchos_FilteredIterator.hpp:60
Teuchos::StringIndexedOrderedValueObjectContainer::getObjOrdinalIndex
Ordinal getObjOrdinalIndex(const std::string &key) const
Get the ordinal index given the string key.
Definition: Teuchos_StringIndexedOrderedValueObjectContainer.hpp:464
Teuchos::StringIndexedOrderedValueObjectContainer
String indexed ordered value-type object container class.
Definition: Teuchos_StringIndexedOrderedValueObjectContainer.hpp:180
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
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 &#39;code&#39; throws the exception &#39;ExceptType&#39; (otherwise the test fails)...
Definition: Teuchos_LocalTestingHelpers.hpp:198
Teuchos::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(ConstNonconstObjectContainer, create)
Definition: ConstNonconstObjectContainer.cpp:48
Teuchos_UnitTestHarness.hpp
Unit testing support.
TEST_EQUALITY_CONST
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
Definition: Teuchos_LocalTestingHelpers.hpp:79
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:362
Teuchos_StringIndexedOrderedValueObjectContainer.hpp
Teuchos::StringIndexedOrderedValueObjectContainer::setObj
Ordinal setObj(const std::string &key, const ObjType &obj)
Set (or reset) object by value and return its ordinal index.
Definition: Teuchos_StringIndexedOrderedValueObjectContainer.hpp:476
Teuchos::StringIndexedOrderedValueObjectContainer::removeObj
void removeObj(const Ordinal &idx)
Remove an object given its ordinal index.
Definition: Teuchos_StringIndexedOrderedValueObjectContainer.hpp:495
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:353
Generated by   doxygen 1.8.5