Teuchos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
ArrayRCP_UnitTests.cpp
Go to the documentation of this file.
1/*
2// @HEADER
3// ***********************************************************************
4//
5// Teuchos: Common Tools Package
6// Copyright (2004) Sandia Corporation
7//
8// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
9// license for use of this work by or on behalf of the U.S. Government.
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17//
18// 2. Redistributions in binary form must reproduce the above copyright
19// notice, this list of conditions and the following disclaimer in the
20// documentation and/or other materials provided with the distribution.
21//
22// 3. Neither the name of the Corporation nor the names of the
23// contributors may be used to endorse or promote products derived from
24// this software without specific prior written permission.
25//
26// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37//
38// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
39//
40// ***********************************************************************
41// @HEADER
42*/
43
46#include "TestClasses.hpp"
47#include "Teuchos_ArrayRCP.hpp"
48#include "Teuchos_RCP.hpp"
50#include "Teuchos_as.hpp"
51#include "Teuchos_getRawPtr.hpp"
52
53namespace {
54
57
58typedef Teuchos_Ordinal Ordinal;
60using Teuchos::as;
61using Teuchos::null;
62using Teuchos::rcp;
63using Teuchos::RCP;
65using Teuchos::Array;
66using Teuchos::arcp;
67using Teuchos::arcpCloneNode;
68using Teuchos::arcp_reinterpret_cast;
69using Teuchos::arcp_reinterpret_cast_nonpod;
80
81
82//
83// Non templated unit tests
84//
85
86
87TEUCHOS_UNIT_TEST( ArrayRCP, memberPointer )
88{
89 ArrayRCP<A> a_arcp = arcp<A>(1);
90 TEST_EQUALITY_CONST( a_arcp->A_f(), A_f_return );
91}
92
93
94TEUCHOS_UNIT_TEST( ArrayRCP, getConst_null )
95{
96 const ArrayRCP<A> a1_arcp;
97 const ArrayRCP<const A> a2_arcp = a1_arcp.getConst();
98 TEST_ASSERT(is_null(a2_arcp));
99}
100
101
102TEUCHOS_UNIT_TEST( ArrayRCP, operator_parenth_ArrayView_null )
103{
104 const ArrayRCP<A> a_arcp;
105 const ArrayView<A> av = a_arcp();
106 TEST_ASSERT(is_null(av));
107}
108
109
110TEUCHOS_UNIT_TEST( ArrayRCP, operator_parenth_ArrayView_const_null )
111{
112 const ArrayRCP<const A> a_arcp;
113 const ArrayView<const A> av = a_arcp();
114 TEST_ASSERT(is_null(av));
115}
116
117
118TEUCHOS_UNIT_TEST( ArrayRCP, null_zero_ArrayView_operator )
119{
120 const ArrayRCP<const A> a_arcp;
121 const ArrayView<const A> av = a_arcp(0, 0);
122 TEST_ASSERT(is_null(av));
123}
124
125
126TEUCHOS_UNIT_TEST( ArrayRCP, null_zero_ArrayView_view_func )
127{
128 const ArrayRCP<const A> a_arcp;
129 const ArrayView<const A> av = a_arcp.view(0, 0);
130 TEST_ASSERT(is_null(av));
131}
132
133
134TEUCHOS_UNIT_TEST( ArrayRCP, null_zero_ArrayView_persistingView )
135{
136 const ArrayRCP<const A> a_arcp;
137 const ArrayRCP<const A> a_arcp2 = a_arcp.persistingView(0, 0);
138 TEST_ASSERT(is_null(a_arcp2));
139}
140
141
142TEUCHOS_UNIT_TEST( ArrayRCP, raw_ptr_nonowning_self_view )
143{
144 A *data = new A[10];
145 ArrayRCP<A> arcp_view(data, 0, 10, false);
146 ArrayView<A> view = arcp_view(0, 5);
147 arcp_view = null;
148#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
149 TEST_THROW(view.size(), DanglingReferenceError);
150#endif
151 delete [] data;
152}
153
154
155TEUCHOS_UNIT_TEST( ArrayRCP, implicit_ArrayRCP_const )
156{
157 const ArrayRCP<A> a_arcp;
158 const ArrayRCP<const A> ac_arcp = a_arcp;
159 TEST_ASSERT(is_null(ac_arcp));
160}
161
162
163TEUCHOS_UNIT_TEST( ArrayRCP, ArrayRCP_void_throws )
164{
165 TEST_THROW( const ArrayRCP< void> v_arcp, std::logic_error );
166 TEST_THROW( const ArrayRCP<const void> cv_arcp, std::logic_error );
167}
168
169
170TEUCHOS_UNIT_TEST( ArrayRCP, release )
171{
172 ArrayRCP<A> a_arcp = arcp<A>(1);
173 delete [] a_arcp.release();
174}
175
176
177TEUCHOS_UNIT_TEST( ArrayRCP, arcp_null )
178{
179 ArrayRCP<A> a_arcp = arcp<A>(0, 0, -1, false);
180 TEST_ASSERT(is_null(a_arcp));
181}
182
183
184TEUCHOS_UNIT_TEST( ArrayRCP, arcp_dealloc_null )
185{
186 ArrayRCP<A> a_arcp = arcp<A, Teuchos::DeallocNull<A> >(0, 0, -1,
187 Teuchos::DeallocNull<A>(), false);
188 TEST_ASSERT(is_null(a_arcp));
189}
190
191
192TEUCHOS_UNIT_TEST( ArrayRCP, convert_from_vector_null )
193{
194 const RCP<std::vector<int> > v_rcp;
195 const ArrayRCP<int> a_arcp = arcp(v_rcp);
196 TEST_ASSERT(is_null(a_arcp));
197}
198
199
200TEUCHOS_UNIT_TEST( ArrayRCP, convert_from_const_vector_null )
201{
202 const RCP<const std::vector<int> > v_rcp;
203 const ArrayRCP<const int> a_arcp = arcp(v_rcp);
204 TEST_ASSERT(is_null(a_arcp));
205}
206
207
208TEUCHOS_UNIT_TEST( ArrayRCP, convert_from_vector_unsized )
209{
210 const RCP<std::vector<int> > v_rcp = rcp(new std::vector<int>);
211 const ArrayRCP<int> a_arcp = arcp(v_rcp);
212 TEST_ASSERT(is_null(a_arcp));
213}
214
215
216TEUCHOS_UNIT_TEST( ArrayRCP, convert_from_const_vector_unsized )
217{
218 const RCP<const std::vector<int> > v_rcp = rcp(new std::vector<int>);
219 const ArrayRCP<const int> a_arcp = arcp(v_rcp);
220 TEST_ASSERT(is_null(a_arcp));
221}
222
223
224TEUCHOS_UNIT_TEST( ArrayRCP, arcpWithEmbeddedObj )
225{
226 const ArrayRCP<const int> a_arcp =
227 Teuchos::arcpWithEmbeddedObj<int>(new int[1], 0, 1, as<int>(1), true);
228 const int embeddedObj = Teuchos::getEmbeddedObj<int,int>(a_arcp);
229 TEST_EQUALITY_CONST( embeddedObj, as<int>(1) );
230}
231
232
233TEUCHOS_UNIT_TEST( ArrayRCP, nonnull )
234{
235 ECHO(ArrayRCP<int> a_arcp = arcp<int>(10));
236 TEST_EQUALITY_CONST(is_null(a_arcp), false);
237 TEST_EQUALITY_CONST(nonnull(a_arcp), true);
238 ECHO(a_arcp = null);
239 TEST_EQUALITY_CONST(is_null(a_arcp), true);
240 TEST_EQUALITY_CONST(nonnull(a_arcp), false);
241}
242
243
244TEUCHOS_UNIT_TEST( ArrayRCP, weak_strong )
245{
246
247 ECHO(ArrayRCP<int> arcp1 = arcp<int>(10));
248 TEST_EQUALITY_CONST( arcp1.strength(), RCP_STRONG );
249
250 ECHO(ArrayRCP<int> arcp2 = arcp1.create_weak());
251
252 TEST_EQUALITY_CONST( arcp2.strength(), RCP_WEAK );
253 TEST_EQUALITY_CONST( arcp1.strong_count(), 1 );
254 TEST_EQUALITY_CONST( arcp1.weak_count(), 1 );
255 TEST_EQUALITY_CONST( arcp2.strong_count(), 1 );
256 TEST_EQUALITY_CONST( arcp2.weak_count(), 1 );
257
258 ECHO(ArrayRCP<int> arcp3 = arcp2.create_strong());
259
260 TEST_EQUALITY_CONST( arcp3.strength(), RCP_STRONG );
261 TEST_EQUALITY_CONST( arcp1.strong_count(), 2 );
262 TEST_EQUALITY_CONST( arcp1.weak_count(), 1 );
263 TEST_EQUALITY_CONST( arcp2.strong_count(), 2 );
264 TEST_EQUALITY_CONST( arcp2.weak_count(), 1 );
265
266 // This will make the underlying object A gets deleted!
267 ECHO(arcp1 = null);
268 ECHO(arcp3 = null);
269
270 ECHO(arcp2 = null); // Should make the underlying node go away
271
272}
273
274
275TEUCHOS_UNIT_TEST( ArrayRCP, arcp_reinterpret_cast_null )
276{
277 ECHO(ArrayRCP<char> arcp_char = null);
278 ECHO(ArrayRCP<int> arcp_int = arcp_reinterpret_cast<int>(arcp_char));
279 TEST_EQUALITY_CONST(arcp_int, null);
280}
281
282
283TEUCHOS_UNIT_TEST( ArrayRCP, arcp_reinterpret_cast_char_to_int )
284{
285
286 const int sizeOfInt = sizeof(int);
287 const int sizeOfChar = sizeof(char);
288 const int num_ints = n;
289 const int num_chars = (num_ints*sizeOfInt)/sizeOfChar;
290 out << "num_ints = " << num_ints << "\n";
291 out << "num_chars = " << num_chars << "\n";
292
293 ECHO(ArrayRCP<char> arcp_char = arcp<char>(num_chars));
294 ECHO(ArrayRCP<int> arcp_int = arcp_reinterpret_cast<int>(arcp_char));
295 TEST_EQUALITY(arcp_int.size(), num_ints);
296 TEST_EQUALITY(implicit_ptr_cast<void>(&arcp_int[0]),
297 implicit_ptr_cast<void>(&arcp_char[0]));
298 TEST_EQUALITY(implicit_ptr_cast<void>((&arcp_int[num_ints-1])+1),
299 implicit_ptr_cast<void>((&arcp_char[num_chars-1])+1));
300
301 ECHO(arcp_char+=sizeOfInt);
302 ECHO(arcp_int = arcp_reinterpret_cast<int>(arcp_char));
303 TEST_EQUALITY(arcp_int.size(), num_ints);
304 TEST_EQUALITY_CONST( arcp_int.lowerOffset(), -1);
305 TEST_EQUALITY( arcp_int.upperOffset(), num_ints-2);
306 TEST_EQUALITY( implicit_ptr_cast<void>(&arcp_int[-1]),
307 implicit_ptr_cast<void>(&arcp_char[-sizeOfInt])
308 );
309 TEST_EQUALITY( implicit_ptr_cast<void>((&arcp_int[num_ints-2])+1),
310 implicit_ptr_cast<void>((&arcp_char[num_chars-1-sizeOfInt])+1));
311
312}
313
314
315TEUCHOS_UNIT_TEST( ArrayRCP, arcp_reinterpret_cast_int_to_char )
316{
317
318 const int sizeOfInt = sizeof(int);
319 const int sizeOfChar = sizeof(char);
320 const int num_ints = n;
321 const int num_chars = (num_ints*sizeOfInt)/sizeOfChar;
322 out << "num_ints = " << num_ints << "\n";
323 out << "num_chars = " << num_chars << "\n";
324
325 ECHO(ArrayRCP<int> arcp_int = arcp<int>(num_ints));
326 ECHO(ArrayRCP<char> arcp_char = arcp_reinterpret_cast<char>(arcp_int));
327 TEST_EQUALITY(arcp_char.size(), num_chars);
328 TEST_EQUALITY(implicit_ptr_cast<void>(&arcp_int[0]),
329 implicit_ptr_cast<void>(&arcp_char[0]));
330 TEST_EQUALITY(implicit_ptr_cast<void>((&arcp_int[num_ints-1])+1),
331 implicit_ptr_cast<void>((&arcp_char[num_chars-1])+1));
332 TEST_EQUALITY(implicit_ptr_cast<void>((&arcp_int[num_ints-1])+1),
333 implicit_ptr_cast<void>((&arcp_char[num_chars-1])+1));
334
335 ECHO(++arcp_int);
336 ECHO(arcp_char = arcp_reinterpret_cast<char>(arcp_int));
337 TEST_EQUALITY(as<int>(arcp_char.lowerOffset()), as<int>(-sizeOfInt));
338 TEST_EQUALITY(as<int>(arcp_char.upperOffset()), as<int>(num_chars-1-sizeOfInt));
339 TEST_EQUALITY(implicit_ptr_cast<void>(&arcp_int[-1]),
340 implicit_ptr_cast<void>(&arcp_char[-sizeOfInt]));
341 TEST_EQUALITY(implicit_ptr_cast<void>((&arcp_int[num_ints-2])+1),
342 implicit_ptr_cast<void>((&arcp_char[num_chars-1-sizeOfInt])+1));
343
344}
345
346
347TEUCHOS_UNIT_TEST( ArrayRCP, evil_reinterpret_cast )
348{
349 ECHO(ArrayRCP<ArrayRCP<int> > arcp1 = arcp<ArrayRCP<int> >(n));
350 ECHO(ArrayRCP<ArrayRCP<const int> > arcp2 =
351 arcp_reinterpret_cast<ArrayRCP<const int> >(arcp1));
352 TEST_EQUALITY(arcp2.size(), arcp1.size());
353 TEST_EQUALITY(implicit_ptr_cast<const void>(&arcp1[0]),
354 implicit_ptr_cast<const void>(&arcp2[0]));
355 ECHO(ArrayRCP<const ArrayRCP<const int> > arcp3 = arcp2);
356 TEST_EQUALITY(arcp3.size(), arcp1.size());
357 TEST_EQUALITY(implicit_ptr_cast<const void>(&arcp1[0]),
358 implicit_ptr_cast<const void>(&arcp3[0]));
359 out << "arcp3 = " << arcp3 << "\n";
360}
361
362
363//
364// Test arcpCloneNode(...)
365//
366
367
368TEUCHOS_UNIT_TEST( ArrayRCP, arcpCloneNode_null )
369{
370 ECHO(ArrayRCP<ArrayRCP<int> > arcp1 = null);
371 ECHO(ArrayRCP<ArrayRCP<int> > arcp2 = arcpCloneNode(arcp1));
372 TEST_EQUALITY(arcp2, null);
373}
374
375
376TEUCHOS_UNIT_TEST( ArrayRCP, arcpCloneNode_basic )
377{
378
379 ECHO(ArrayRCP<int> arcp1 = arcp<int>(n));
380
381 ECHO(ArrayRCP<int> arcp2 = arcpCloneNode(arcp1));
382 TEST_ASSERT(nonnull(arcp2));
383 TEST_EQUALITY(arcp1.strong_count(), 2);
384 TEST_EQUALITY(arcp2.strong_count(), 1);
385
386 ECHO(ArrayRCP<int> arcp3 = arcp2);
387 TEST_EQUALITY(arcp1.strong_count(), 2);
388 TEST_EQUALITY(arcp2.strong_count(), 2);
389 TEST_EQUALITY(arcp3.strong_count(), 2);
390
391 ECHO(ArrayRCP<int> arcp4 = arcp1);
392 TEST_EQUALITY(arcp1.strong_count(), 3);
393 TEST_EQUALITY(arcp2.strong_count(), 2);
394 TEST_EQUALITY(arcp3.strong_count(), 2);
395
396 ECHO(arcp4 = null);
397 TEST_EQUALITY(arcp1.strong_count(), 2);
398 TEST_EQUALITY(arcp2.strong_count(), 2);
399 TEST_EQUALITY(arcp3.strong_count(), 2);
400 TEST_EQUALITY(arcp4.strong_count(), 0);
401
402 ECHO(arcp1 = null);
403 TEST_EQUALITY(arcp1.strong_count(), 0);
404 TEST_EQUALITY(arcp2.strong_count(), 2);
405 TEST_EQUALITY(arcp3.strong_count(), 2);
406 TEST_EQUALITY(arcp4.strong_count(), 0);
407
408 ECHO(arcp2 = null);
409 TEST_EQUALITY(arcp2.strong_count(), 0);
410 TEST_EQUALITY(arcp3.strong_count(), 1);
411
412 ECHO(arcp3 = null);
413 TEST_EQUALITY(arcp3.strong_count(), 0);
414
415}
416
417
418//
419// Test arcp_reinterpret_cast_nonpod(...)
420//
421
422
423class MockObject {
424 int member_;
425public:
426
427 MockObject(int member_in = -1) : member_(member_in) { ++(numConstructorsCalled()); }
428 MockObject(const MockObject &mo) : member_(mo.member_) { ++(numCopyConstructorsCalled()); }
429 ~MockObject() { ++(numDestructorsCalled()); }
430 int member() const { return member_; }
431
432 static int & numConstructorsCalled()
433 { static int s_numConstructorsCalled = 0; return s_numConstructorsCalled; }
434 static int & numCopyConstructorsCalled()
435 { static int s_numCopyConstructorsCalled = 0; return s_numCopyConstructorsCalled; }
436 static int & numDestructorsCalled()
437 { static int s_numDestructorsCalled = 0; return s_numDestructorsCalled; }
438 static void reset() { numConstructorsCalled() = numCopyConstructorsCalled() = numDestructorsCalled() = 0; }
439
440};
441
442
443TEUCHOS_UNIT_TEST( ArrayRCP, arcp_reinterpret_cast_nonpod_default_construct )
444{
445
446 const int sizeOfMockObject = sizeof(MockObject);
447 const int sizeOfChar = sizeof(char);
448 const int num_objs = n;
449 const int num_chars = (num_objs*sizeOfMockObject)/sizeOfChar;
450 out << "num_objs = " << num_objs << "\n";
451 out << "num_chars = " << num_chars << "\n";
452
453 ECHO(ArrayRCP<char> arcp_chars = arcp<char>(num_chars));
454
455 ECHO(MockObject::reset());
456 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
457 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), 0);
458 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
459 ECHO(ArrayRCP<MockObject> arcp_objs =
460 arcp_reinterpret_cast_nonpod<MockObject>(arcp_chars));
461 TEST_EQUALITY(arcp_objs.size(), num_objs);
462 TEST_EQUALITY(MockObject::numConstructorsCalled(), 1);
463 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
464 TEST_EQUALITY(MockObject::numDestructorsCalled(), 1);
465 {
466 int sum = 0; for (int i=0; i < num_objs; ++i) sum += arcp_objs[i].member();
467 TEST_EQUALITY(sum, -num_objs);
468 }
469
470 ECHO(ArrayRCP<MockObject> arcp_objs2 = arcp_objs);
471 TEST_EQUALITY(arcp_objs.size(), num_objs);
472 TEST_EQUALITY(MockObject::numConstructorsCalled(), 1);
473 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
474 TEST_EQUALITY(MockObject::numDestructorsCalled(), 1);
475 {
476 int sum = 0; for (int i=0; i < num_objs; ++i) sum += arcp_objs[i].member();
477 TEST_EQUALITY(sum, -num_objs);
478 }
479
480 ECHO(arcp_objs = null);
481 TEST_EQUALITY(MockObject::numConstructorsCalled(), 1);
482 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
483 TEST_EQUALITY(MockObject::numDestructorsCalled(), 1);
484
485 ECHO(arcp_objs2 = null);
486 TEST_EQUALITY(MockObject::numConstructorsCalled(), 1);
487 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
488 TEST_EQUALITY(MockObject::numDestructorsCalled(), num_objs + 1);
489
490}
491
492
493TEUCHOS_UNIT_TEST( ArrayRCP, arcp_reinterpret_cast_nonpod_copy_construct )
494{
495
496 const int sizeOfMockObject = sizeof(MockObject);
497 const int sizeOfChar = sizeof(char);
498 const int num_objs = n;
499 const int num_chars = (num_objs*sizeOfMockObject)/sizeOfChar;
500 out << "num_objs = " << num_objs << "\n";
501 out << "num_chars = " << num_chars << "\n";
502
503 ECHO(ArrayRCP<char> arcp_chars = arcp<char>(num_chars));
504
505 ECHO(MockObject::reset());
506 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
507 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), 0);
508 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
509 ECHO(const MockObject mockObj(1));
510 TEST_EQUALITY(MockObject::numConstructorsCalled(), 1);
511 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), 0);
512 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
513
514 ECHO(MockObject::reset());
515 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
516 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), 0);
517 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
518 ECHO(ArrayRCP<MockObject> arcp_objs =
519 arcp_reinterpret_cast_nonpod(arcp_chars, mockObj));
520 TEST_EQUALITY(arcp_objs.size(), num_objs);
521 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
522 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
523 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
524 {
525 int sum = 0; for (int i=0; i < num_objs; ++i) sum += arcp_objs[i].member();
526 TEST_EQUALITY(sum, num_objs);
527 }
528
529 ECHO(ArrayRCP<MockObject> arcp_objs2 = arcp_objs);
530 TEST_EQUALITY(arcp_objs.size(), num_objs);
531 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
532 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
533 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
534 {
535 int sum = 0; for (int i=0; i < num_objs; ++i) sum += arcp_objs[i].member();
536 TEST_EQUALITY(sum, num_objs);
537 }
538
539 ECHO(arcp_objs = null);
540 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
541 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
542 TEST_EQUALITY(MockObject::numDestructorsCalled(), 0);
543
544 ECHO(arcp_objs2 = null);
545 TEST_EQUALITY(MockObject::numConstructorsCalled(), 0);
546 TEST_EQUALITY(MockObject::numCopyConstructorsCalled(), num_objs);
547 TEST_EQUALITY(MockObject::numDestructorsCalled(), num_objs);
548
549}
550
551
552//
553// Test catching of duplicate owning ArrayRCP objects
554//
555
556
557TEUCHOS_UNIT_TEST( ArrayRCP, duplicate_arcp_owning )
558{
560 ECHO(A *a_ptr = new A[n]);
561 ECHO(ArrayRCP<A> a_arcp1 = arcp(a_ptr, 0, n)); // Okay
562#if defined(TEUCHOS_DEBUG)
563 // With node tracing turned on, the implementation knows that an RCPNode
564 // already exists pointing to this same underlying array and will therefore
565 // throw.
566 TEST_THROW(ArrayRCP<A> a_arcp2 = arcp(a_ptr, 0, n), DuplicateOwningRCPError);
567#else
568 // Will not determine they are point to the same object!
569 ECHO(ArrayRCP<A> a_arcp2 = arcp(a_ptr, 0, n));
570 TEST_EQUALITY(a_arcp2.getRawPtr(), a_ptr);
571 ECHO(a_arcp2.release()); // Better or we will get a segfault!
572#endif
573}
574
575
576TEUCHOS_UNIT_TEST( ArrayRCP, dangling_nonowning )
577{
579 ECHO(A *a_ptr = new A[n]);
580 ECHO(ArrayRCP<A> a_arcp1 = arcp(a_ptr, 0, n)); // Okay
581 ECHO(ArrayRCP<A> a_arcp2 = arcp(a_ptr, 0, n, false)); // Okay
582 a_arcp1 = null;
583#if defined(TEUCHOS_DEBUG)
584 // With node tracing turned on, the implementation knows that the original
585 // array is deleted and this is a dangling reference!
586 TEST_THROW(a_arcp2.getRawPtr(), DanglingReferenceError);
587#else
588 // With node tracing turned off, the implemetation does not know the
589 // original array is deleted and therefore it will return a now invalid
590 // pointer.
591 TEST_NOTHROW(a_arcp2.getRawPtr());
592#endif
593}
594
595
596class WeirdDealloc {
597 int size_;
598 RCP<std::ostream > out_;
599public:
600 WeirdDealloc(int size, const RCP<std::ostream> &out) : size_(size), out_(out) {}
601 void free(void *ptr) const
602 {
603 int * const int_ptr = reinterpret_cast<int*>(ptr);
604 {
605 // Create an ArrayView that points to the same memory that is being
606 // deallocated by the owning ArrayRCP. Here, if RCPNode tracing is
607 // enabled, this will thrown and there is really no way around it.
608 ArrayView<const int> tmpav(int_ptr, size_, Teuchos::RCP_DISABLE_NODE_LOOKUP);
609 assert(tmpav[0] == int_ptr[0]);
610 *out_ << tmpav << std::endl;
611 // Create a copy of the ArrayView and make sure that it does not do
612 // node tracing either.
613 ArrayView<const int> tmpav2(tmpav);
614 assert(tmpav2[0] == int_ptr[0]);
615 *out_ << tmpav2 << std::endl;
616 // Assign the ArrayView and make sure that it does not do node tracing
617 // either.
618 ArrayView<const int> tmpav3;
619 tmpav3 = tmpav;
620 assert(tmpav3[0] == int_ptr[0]);
621 *out_ << tmpav2 << std::endl;
622 }
623 delete [] int_ptr;
624 }
625};
626
627
628TEUCHOS_UNIT_TEST( ArrayRCP, weirdDealloc )
629{
630 using Teuchos::rcpFromRef;
631 const int size = 4;
632 const bool ownsMem = true;
633 int *int_ptr = new int[size];
634 std::fill_n(int_ptr, size, 0);
635 ArrayRCP<int> a = arcp<int>( int_ptr , 0, size,
636 WeirdDealloc(size, rcpFromRef(out)), ownsMem );
637 a = Teuchos::null;
638}
639
640
641//
642// Templated unit tests
643//
644
645
646TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, construct_n, T )
647{
648 std::vector<T> a(n, as<T>(1));
649 ArrayRCP<T> a_arcp(n, as<T>(1));
650 TEST_COMPARE_ARRAYS(a, a_arcp);
651}
652
653
654TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, assignSelf, T )
655{
656 ArrayRCP<T> a_arcp;
657 a_arcp = a_arcp;
658}
659
660
661TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, assign_n_val, T )
662{
663 const T val = as<T>(1);
664 std::vector<T> a;
665 a.assign(n, val);
666 ArrayRCP<T> a_arcp;
667 a_arcp.assign(as<Ordinal>(n), val);
668 TEST_COMPARE_ARRAYS(a, a_arcp);
669}
670
671
672TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, assign_begin_end, T )
673{
674 const T val = as<T>(1);
675 std::vector<T> a;
676 a.assign(n, val);
677 ArrayRCP<T> a_arcp;
678 a_arcp.assign(a.begin(), a.end());
679 TEST_COMPARE_ARRAYS(a, a_arcp);
680}
681
682
683TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, print_iterators, T )
684{
685 typedef typename ArrayRCP<T>::const_iterator const_iterator;
686 ECHO(ArrayRCP<T> a_arcp = arcp<T>(n));
687 ECHO(const_iterator itr = a_arcp.begin());
688 out << "itr = " << itr << "\n";
689 TEST_EQUALITY(itr, a_arcp.begin());
690 ECHO(itr += n);
691 out << "itr = " << itr << "\n";
692 TEST_EQUALITY(itr, a_arcp.end());
693}
694
695
696TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, deepCopy, T )
697{
698 const T val = as<T>(1);
699 std::vector<T> a;
700 a.assign(n, val);
701 ArrayRCP<T> a_arcp = arcp<T>(n);
702 ArrayRCP<T> a_arcp_cpy = a_arcp;
703 a_arcp.deepCopy(Teuchos::arrayViewFromVector(a));
704 TEST_COMPARE_ARRAYS(a, a_arcp);
705 TEST_EQUALITY(a_arcp.getRawPtr(), a_arcp_cpy.getRawPtr());
706}
707
708
709TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, resize, T )
710{
711 const T val1 = as<T>(1);
712 const T val2 = as<T>(2);
713
714 std::vector<T> a;
715 ArrayRCP<T> a_arcp;
716
717 out << "\nChecking resize(n, val1) ...\n";
718 a.resize(n, val1);
719 a_arcp.resize(n, val1);
720 TEST_COMPARE_ARRAYS(a, a_arcp);
721
722 out << "\nChecking resize(2*n, val2) ...\n";
723 a.resize(2*n, val2);
724 a_arcp.resize(2*n, val2);
725 TEST_COMPARE_ARRAYS(a, a_arcp);
726
727 out << "\nChecking resize(n/2) ...\n";
728 a.resize(n/2);
729 a_arcp.resize(n/2);
730 TEST_COMPARE_ARRAYS(a, a_arcp);
731
732 out << "\nChecking resize(0) ...\n";
733 a.resize(0);
734 a_arcp.resize(0);
735 TEST_COMPARE_ARRAYS(a, a_arcp);
736
737#ifdef TEUCHOS_DEBUG
738 a_arcp = arcp<T>(n);
739 ++a_arcp;
740 TEST_THROW(a_arcp.resize(1), std::out_of_range);
741#endif
742}
743
744
745TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, clear, T )
746{
747 ArrayRCP<T> a_arcp = arcp<T>(n);
748 TEST_EQUALITY( a_arcp.size(), n );
749 a_arcp.clear();
750 TEST_EQUALITY( a_arcp.size(), 0 );
751}
752
753
754TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, nullIterator, T )
755{
756 typedef ArrayRCP<T> iter_t;
759}
760
761
762TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, implicitConversions, T )
763{
764
765 ECHO(ArrayRCP<T> arcp1 = arcp<T>(n));
766 ECHO(ArrayRCP<const T> arcp2 = arcp1);
767 TEST_ASSERT(arcp1.shares_resource(arcp2));
768
769}
770
771
772TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, weakDelete, T )
773{
774
775 ECHO(ArrayRCP<T> arcp_strong = arcp<T>(n));
776
777 TEST_EQUALITY_CONST( arcp_strong.strength(), RCP_STRONG );
778 TEST_EQUALITY_CONST( arcp_strong.is_null(), false );
779 TEST_EQUALITY_CONST( arcp_strong.strong_count(), 1 );
780 TEST_EQUALITY_CONST( arcp_strong.weak_count(), 0 );
781 TEST_EQUALITY_CONST( arcp_strong.total_count(), 1 );
782
783 ECHO(ArrayRCP<T> arcp_weak1 = arcp_strong.create_weak());
784
785 TEST_EQUALITY_CONST( arcp_weak1.strength(), RCP_WEAK );
786 TEST_EQUALITY_CONST( arcp_weak1.is_null(), false );
787 TEST_EQUALITY_CONST( arcp_weak1.strong_count(), 1 );
788 TEST_EQUALITY_CONST( arcp_weak1.weak_count(), 1 );
789 TEST_EQUALITY_CONST( arcp_weak1.total_count(), 2 );
790
791 TEST_EQUALITY_CONST( arcp_strong.strong_count(), 1 );
792 TEST_EQUALITY_CONST( arcp_strong.is_null(), false );
793 TEST_EQUALITY_CONST( arcp_strong.weak_count(), 1 );
794 TEST_EQUALITY_CONST( arcp_strong.total_count(), 2 );
795
796 TEST_EQUALITY_CONST( arcp_weak1.shares_resource(arcp_strong), true );
797
798 TEST_EQUALITY( arcp_weak1.get(), arcp_weak1.getRawPtr() );
799 TEST_EQUALITY( arcp_weak1.get(), arcp_strong.get() );
800 TEST_EQUALITY( arcp_weak1.getRawPtr(), arcp_strong.getRawPtr() );
801
802 ECHO(ArrayRCP<T> arcp_weak2 = arcp_weak1);
803
804 TEST_EQUALITY_CONST( arcp_weak2.strength(), RCP_WEAK );
805 TEST_EQUALITY_CONST( arcp_weak2.is_null(), false );
806 TEST_EQUALITY_CONST( arcp_weak2.strong_count(), 1 );
807 TEST_EQUALITY_CONST( arcp_weak2.weak_count(), 2 );
808 TEST_EQUALITY_CONST( arcp_weak2.total_count(), 3 );
809
810 TEST_EQUALITY_CONST( arcp_strong.strong_count(), 1 );
811 TEST_EQUALITY_CONST( arcp_strong.is_null(), false );
812 TEST_EQUALITY_CONST( arcp_strong.weak_count(), 2 );
813 TEST_EQUALITY_CONST( arcp_strong.total_count(), 3 );
814
815 TEST_EQUALITY_CONST( arcp_weak1.shares_resource(arcp_strong), true );
816 TEST_EQUALITY_CONST( arcp_weak1.shares_resource(arcp_weak2), true );
817 TEST_EQUALITY_CONST( arcp_weak2.shares_resource(arcp_strong), true );
818
819 TEST_EQUALITY( arcp_weak2.get(), arcp_strong.get() );
820 TEST_EQUALITY( arcp_weak2.getRawPtr(), arcp_strong.getRawPtr() );
821
822 ECHO(arcp_strong = null); // This deletes the underlying object of type T!
823
824 TEST_EQUALITY_CONST( arcp_strong.strength(), RCP_STRONG );
825 TEST_EQUALITY_CONST( arcp_strong.is_null(), true );
826 TEST_EQUALITY_CONST( arcp_strong.strong_count(), 0 );
827 TEST_EQUALITY_CONST( arcp_strong.strong_count(), 0 );
828 TEST_EQUALITY_CONST( arcp_strong.weak_count(), 0 );
829 TEST_EQUALITY_CONST( arcp_strong.total_count(), 0 );
830 TEST_EQUALITY_CONST( arcp_strong.is_valid_ptr(), true );
831
832 TEST_EQUALITY_CONST( arcp_strong.shares_resource(arcp_weak1), false );
833 TEST_EQUALITY_CONST( arcp_strong.shares_resource(arcp_weak2), false );
834
835 TEST_EQUALITY_CONST( arcp_weak1.has_ownership(), true );
836 TEST_EQUALITY_CONST( arcp_weak1.strong_count(), 0 );
837 TEST_EQUALITY_CONST( arcp_weak1.strong_count(), 0 );
838 TEST_EQUALITY_CONST( arcp_weak1.weak_count(), 2 );
839 TEST_EQUALITY_CONST( arcp_weak1.total_count(), 2 );
840 TEST_EQUALITY_CONST( arcp_weak1.is_valid_ptr(), false );
841
842 TEST_EQUALITY_CONST( arcp_weak2.has_ownership(), true );
843 TEST_EQUALITY_CONST( arcp_weak2.strong_count(), 0 );
844 TEST_EQUALITY_CONST( arcp_weak2.strong_count(), 0 );
845 TEST_EQUALITY_CONST( arcp_weak2.weak_count(), 2 );
846 TEST_EQUALITY_CONST( arcp_weak2.total_count(), 2 );
847 TEST_EQUALITY_CONST( arcp_weak2.is_valid_ptr(), false );
848
849 TEST_EQUALITY_CONST( arcp_weak1.shares_resource(arcp_weak2), true );
850
851 ECHO(arcp_weak1.assert_not_null()); // Does not throw!
852 ECHO(arcp_weak2.assert_not_null()); // Does not throw!
853
854 TEST_THROW( arcp_weak1.assert_valid_ptr(), DanglingReferenceError );
855#ifdef TEUCHOS_DEBUG
856 TEST_THROW( arcp_weak1.operator->(), DanglingReferenceError );
857 TEST_THROW( *arcp_weak1, DanglingReferenceError );
858 TEST_THROW( arcp_weak1.create_weak(), DanglingReferenceError );
859 TEST_THROW( arcp_weak1.get(), DanglingReferenceError );
860 TEST_THROW( arcp_weak1.getRawPtr(), DanglingReferenceError );
861 TEST_THROW( arcp_weak1[0], DanglingReferenceError );
862 TEST_THROW( ++arcp_weak1, DanglingReferenceError );
863 TEST_THROW( arcp_weak1++, DanglingReferenceError );
864 TEST_THROW( --arcp_weak1, DanglingReferenceError );
865 TEST_THROW( arcp_weak1--, DanglingReferenceError );
866 TEST_THROW( arcp_weak1+=1, DanglingReferenceError );
867 TEST_THROW( arcp_weak1-=1, DanglingReferenceError );
868 TEST_THROW( arcp_weak1+1, DanglingReferenceError );
869 TEST_THROW( arcp_weak1-1, DanglingReferenceError );
870 TEST_THROW( arcp_weak1.getConst(), DanglingReferenceError );
871 TEST_THROW( arcp_weak1.persistingView(0,n), DanglingReferenceError );
872 TEST_THROW( arcp_weak1.lowerOffset(), DanglingReferenceError );
873 TEST_THROW( arcp_weak1.upperOffset(), DanglingReferenceError );
874 TEST_THROW( arcp_weak1.size(), DanglingReferenceError );
875 TEST_THROW( arcp_weak1.begin(), DanglingReferenceError );
876 TEST_THROW( arcp_weak1.end(), DanglingReferenceError );
877 TEST_THROW( arcp_weak1.view(0,n), DanglingReferenceError );
878 TEST_THROW( arcp_weak1(0,n), DanglingReferenceError );
879 TEST_THROW( arcp_weak1(), DanglingReferenceError );
880 TEST_THROW( {ArrayView<T> av = arcp_weak1();}, DanglingReferenceError );
881 TEST_THROW( {ArrayRCP<const T> ap = getConst(arcp_weak1);},
882 DanglingReferenceError );
883 TEST_THROW( arcp_weak1.release(), DanglingReferenceError );
884#endif // TEUCHOS_DEBUG
885
886 ECHO(arcp_weak1 = null); // Just deicrements weak count!
887
888 TEST_EQUALITY_CONST( arcp_weak1.strength(), RCP_STRONG );
889 TEST_EQUALITY_CONST( arcp_weak1.is_null(), true );
890 TEST_EQUALITY_CONST( arcp_weak1.strong_count(), 0 );
891 TEST_EQUALITY_CONST( arcp_weak1.strong_count(), 0 );
892 TEST_EQUALITY_CONST( arcp_weak1.weak_count(), 0 );
893 TEST_EQUALITY_CONST( arcp_weak1.total_count(), 0 );
894 TEST_EQUALITY_CONST( arcp_weak1.is_valid_ptr(), true );
895
896 TEST_EQUALITY_CONST( arcp_weak2.has_ownership(), true );
897 TEST_EQUALITY_CONST( arcp_weak2.strong_count(), 0 );
898 TEST_EQUALITY_CONST( arcp_weak2.strong_count(), 0 );
899 TEST_EQUALITY_CONST( arcp_weak2.weak_count(), 1 );
900 TEST_EQUALITY_CONST( arcp_weak2.total_count(), 1 );
901 TEST_EQUALITY_CONST( arcp_weak2.is_valid_ptr(), false );
902
903 TEST_EQUALITY_CONST( arcp_weak1.shares_resource(arcp_weak2), false );
904
905 TEST_THROW( arcp_weak2.assert_valid_ptr(), DanglingReferenceError );
906#ifdef TEUCHOS_DEBUG
907 // ToDo: Fill in
908#endif // TEUCHOS_DEBUG
909
910}
911
912
913TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, danglingArrayView, T )
914{
915 ArrayView<T> av;
916 {
917 ArrayRCP<T> arcp1 = arcp<T>(n);
918 av = arcp1();
919 }
920#ifdef TEUCHOS_DEBUG
921 TEST_THROW( av.size(), DanglingReferenceError );
922 TEST_THROW( av.toString(), DanglingReferenceError );
923 TEST_THROW( av.getRawPtr(), DanglingReferenceError );
924 TEST_THROW( av[0], DanglingReferenceError );
925 TEST_THROW( av.front(), DanglingReferenceError );
926 TEST_THROW( av.back(), DanglingReferenceError );
927 TEST_THROW( av.view(0, n), DanglingReferenceError );
928 TEST_THROW( av(0, n), DanglingReferenceError );
929 TEST_THROW( av(), DanglingReferenceError );
930 TEST_THROW( av.getConst(), DanglingReferenceError );
931 TEST_THROW( av.begin(), DanglingReferenceError );
932 TEST_THROW( av.end(), DanglingReferenceError );
933#endif
934}
935
936
937TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, getRawPtr, T )
938{
939 ArrayRCP<const T> cptr;
940 ArrayRCP<T> ptr;
941 TEST_EQUALITY_CONST( getRawPtr(cptr), (const T*)NULL );
942 TEST_EQUALITY_CONST( getRawPtr(ptr), (T*)NULL );
943 cptr = arcp<T>(n);
944 ptr = arcp<T>(n);
945 TEST_EQUALITY( getRawPtr(cptr), &cptr[0]);
946 TEST_EQUALITY( getRawPtr(ptr), &ptr[0] );
947}
948
949
950TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( CPtr, getRawPtr, T )
951{
952 const T *cptr = NULL;
953 T *ptr = NULL;
954 TEST_EQUALITY_CONST( getRawPtr(cptr), (const T*)NULL );
955 TEST_EQUALITY_CONST( getRawPtr(ptr), (T*)NULL );
956 cptr = new T[n];
957 ptr = new T[n];
958 TEST_EQUALITY( getRawPtr(cptr), &cptr[0]);
959 TEST_EQUALITY( getRawPtr(ptr), &ptr[0] );
960 delete [] cptr;
961 delete [] ptr;
962}
963
964
965TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, arcp_zero, T )
966{
967 ArrayRCP<T> arcp_strong = arcp<T>(0);
968 TEST_EQUALITY(arcp_strong.size(), as<Ordinal>(0));
969}
970
971
972TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, arcpFromArrayView, T )
973{
974 Array<T> a = generateArray<T>(n);
975 ArrayView<T> av = a;
976 ArrayRCP<T> arcp1 = Teuchos::arcpFromArrayView(av);
977 TEST_COMPARE_ARRAYS(arcp1, av);
978}
979
980
981#ifdef TEUCHOS_DEBUG
982
983
984TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, arcp_neg, T )
985{
986 TEST_THROW(ArrayRCP<T> arcp_strong = arcp<T>(-1),
987 std::out_of_range);
988}
989
990
991TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayRCP, outOfBounds, T )
992{
993 ECHO(ArrayRCP<T> arcp1 = arcp<T>(n));
994 TEST_THROW(arcp1(-1,n), RangeError);
995 TEST_THROW(arcp1(0,n+1), RangeError);
996 TEST_THROW(arcp1(0,-1), RangeError);
997 TEST_THROW(arcp1.view(-1,n), RangeError);
998 TEST_THROW(arcp1.view(0,n+1), RangeError);
999 TEST_THROW(arcp1.view(0,-1), RangeError);
1000 TEST_THROW(arcp1.persistingView(-1,n), RangeError);
1001 TEST_THROW(arcp1.persistingView(0,n+1), RangeError);
1002 TEST_THROW(arcp1.persistingView(0,-1), RangeError);
1003}
1004
1005
1006#endif // TEUCHOS_DEBUG
1007
1008
1009//
1010// Template Instantiations
1011//
1012
1013
1014#ifdef TEUCHOS_DEBUG
1015
1016# define DEBUG_UNIT_TEST_GROUP( T ) \
1017 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, arcp_neg, T ) \
1018 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, outOfBounds, T ) \
1019
1020#else
1021
1022# define DEBUG_UNIT_TEST_GROUP( T )
1023
1024#endif
1025
1026
1027#define UNIT_TEST_GROUP( T ) \
1028 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, construct_n, T ) \
1029 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, assignSelf, T ) \
1030 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, assign_n_val, T ) \
1031 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, assign_begin_end, T ) \
1032 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, print_iterators, T ) \
1033 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, deepCopy, T ) \
1034 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, resize, T ) \
1035 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, clear, T ) \
1036 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, nullIterator, T ) \
1037 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, implicitConversions, T ) \
1038 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, weakDelete, T ) \
1039 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, danglingArrayView, T ) \
1040 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, getRawPtr, T) \
1041 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( CPtr, getRawPtr, T) \
1042 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, arcp_zero, T ) \
1043 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayRCP, arcpFromArrayView, T ) \
1044 DEBUG_UNIT_TEST_GROUP(T)
1045
1046
1047UNIT_TEST_GROUP(int)
1048UNIT_TEST_GROUP(double)
1049UNIT_TEST_GROUP(float)
1050
1051
1052} // namespace
#define UNIT_TEST_GROUP(T)
const int A_f_return
Definition: TestClasses.hpp:51
TEUCHOS_ORDINAL_TYPE Teuchos_Ordinal
#define TEST_ASSERT(v1)
Assert the given statement is true.
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
#define TEST_NOTHROW(code)
Asserr that the statement 'code' does not thrown any excpetions.
#define TEST_THROW(code, ExceptType)
Assert that the statement 'code' throws the exception 'ExceptType' (otherwise the test fails).
#define TEST_COMPARE_ARRAYS(a1, a2)
Assert that a1.size()==a2.size() and a[i]==b[i], i=0....
#define ECHO(statement)
Echo the given statement before it is executed.
#define SET_RCPNODE_TRACING()
Reference-counted pointer class and non-member templated function implementations.
Unit testing support.
#define TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(TEST_GROUP, TEST_NAME, TYPE)
Macro for defining a templated unit test with one template parameter.
#define TEUCHOS_UNIT_TEST(TEST_GROUP, TEST_NAME)
Macro for defining a (non-templated) unit test.
Definition of Teuchos::as, for conversions between types.
Reference-counted smart pointer for managing arrays.
Nonowning array view.
Replacement for std::vector that is compatible with the Teuchos Memory Management classes.
Dangling reference error exception class.
Policy class for deallocator for non-owned RCPs.
Thrown if a duplicate owning RCP is creatd the the same object.
Null reference error exception class.
Smart reference counting pointer class for automatic garbage collection.
Range error exception class.
bool is_null(const boost::shared_ptr< T > &p)
Returns true if p.get()==NULL.
bool nonnull(const boost::shared_ptr< T > &p)
Returns true if p.get()!=NULL.
Definition: PackageA.cpp:3
Teuchos::Array< T > generateArray(const int n_in)
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
TypeTo * implicit_ptr_cast(TypeFrom *t)
Perform an implicit cast of pointer types with a pointer being returned.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
@ RCP_DISABLE_NODE_LOOKUP
RawPointerConversionTraits< Container >::Ptr_t getRawPtr(const Container &c)
const T & getConst(T &t)
Return a constant reference to an object given a non-const reference.