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
TEUCHOS_UNIT_TEST(OrdinalIndex,defaultConstruct)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
TEUCHOS_UNIT_TEST(OrdinalIndex,construct)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
TEUCHOS_UNIT_TEST(KeyObjectPair,defaultConstruct)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
TEUCHOS_UNIT_TEST(KeyObjectPair,construct_default_isActive)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
TEUCHOS_UNIT_TEST(KeyObjectPair,makeInvalid)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
TEUCHOS_UNIT_TEST(KeyObjectPair,construct_set_isActive)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
TEUCHOS_UNIT_TEST(KeyObjectPair,copyConstruct)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
TEUCHOS_UNIT_TEST(KeyObjectPair,assign)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,defaultConstruct)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,basic_set_get)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,set_two_keep_ref)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,getObjOrdinalIndex)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,set_and_set_again)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,basicNonconstIterators)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,basicConstIterators)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_idx_first)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_key_first)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_idx_middle)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_key_middle)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_idx_last)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_key_last)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,getNonconstObjPtr_idx_invalid)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,getObjPtr_idx_invalid)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_idx_invalid)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,getNonconstObjPtr_key_invalid)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,getObjPtr_key_invalid)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
TEUCHOS_UNIT_TEST(StringIndexedOrderedValueObjectContainer,removeObj_key_invalid)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
530