Teuchos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Array_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
45#include "Teuchos_Tuple.hpp"
46#include "Teuchos_ArrayRCP.hpp"
47
48
49namespace {
50
51
54using Teuchos::null;
55using Teuchos::tuple;
56using Teuchos::RCP;
57using Teuchos::Array;
60using Teuchos::arcp;
61using Teuchos::arcpFromArray;
62using Teuchos::as;
65using Teuchos::fromStringToArray;
67
68
69TEUCHOS_UNIT_TEST( Utils, trimWhiteSpace_empty )
70{
72}
73
74
75
76TEUCHOS_UNIT_TEST( Array, TypeNameTraits )
77{
78 TEST_EQUALITY(Teuchos::TypeNameTraits<Array<double> >::name(),
79 std::string("Array(double)"));
80}
81
82
83TEUCHOS_UNIT_TEST( Array, stringToArray )
84{
85
86 {
87 std::string arrayString="{}";
88 std::istringstream arrayStream(arrayString);
89 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
90 Array<std::string> arrayStreamVal;
91 arrayStream >> arrayStreamVal;
92 Array<std::string> arrayVal_exp;
93 TEST_EQUALITY(arrayVal, arrayVal_exp);
94 TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
95 }
96
97 {
98 std::string arrayString = "{ a, b, c, d }";
99 std::istringstream arrayStream(arrayString);
100 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
101 Array<std::string> arrayStreamVal;
102 arrayStream >> arrayStreamVal;
103 Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("a", "b", "c", "d" );
104 TEST_EQUALITY(arrayVal, arrayVal_exp);
105 TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
106 }
107
108 {
109 std::string arrayString = "{ (a), b, c, (d) }";
110 std::istringstream arrayStream(arrayString);
111 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
112 Array<std::string> arrayStreamVal;
113 arrayStream >> arrayStreamVal;
114 Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("(a)", "b", "c", "(d)" );
115 TEST_EQUALITY(arrayVal, arrayVal_exp);
116 TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
117 }
118
119 {
120 std::string arrayString = "{ (a ), b, c, (d ) }";
121 std::istringstream arrayStream(arrayString);
122 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
123 Array<std::string> arrayStreamVal;
124 arrayStream >> arrayStreamVal;
125 Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("(a )", "b", "c", "(d )" );
126 TEST_EQUALITY(arrayVal, arrayVal_exp);
127 TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
128 }
129
130 // This should work but does not. I should fix this!
131// {
132// Array<std::string> arrayVal = fromStringToArray<std::string>("{ {a}, 'b', {c }, d }");
133// Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("{a}", "'b'", "{c }", "d" );
134// TEST_EQUALITY(arrayVal, arrayVal_exp);
135// }
136
137}
138
139
140TEUCHOS_UNIT_TEST( Array, stringToArray_invalid )
141{
142 TEST_THROW(fromStringToArray<std::string>("{ a, b, c"),
143 InvalidArrayStringRepresentation);
144 TEST_THROW(fromStringToArray<std::string>("a, b, c}"),
145 InvalidArrayStringRepresentation);
146 TEST_THROW(fromStringToArray<std::string>("a, b, c"),
147 InvalidArrayStringRepresentation);
148}
149
150
151TEUCHOS_UNIT_TEST( Array, stringToArray_string_hyphens )
152{
153
154 {
155 std::string arrayString="{-}";
156 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
157 Array<std::string> arrayVal_exp = tuple<std::string>("-");
158 TEST_EQUALITY(arrayVal, arrayVal_exp);
159 }
160
161 {
162 std::string arrayString="{-,-}";
163 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
164 Array<std::string> arrayVal_exp = tuple<std::string>("-","-");
165 TEST_EQUALITY(arrayVal, arrayVal_exp);
166 }
167
168 {
169 std::string arrayString="{-,1,-}";
170 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
171 Array<std::string> arrayVal_exp = tuple<std::string>("-","1","-");
172 TEST_EQUALITY(arrayVal, arrayVal_exp);
173 }
174
175 {
176 std::string arrayString="{}";
177 Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
178 Array<std::string> arrayVal_exp;
179 TEST_EQUALITY(arrayVal, arrayVal_exp);
180 }
181
182 {
183 std::string arrayString="{,}";
184 TEST_THROW(Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString),
186 }
187
188}
189
190
191TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, defaultConstruct, T )
192{
193 Array<T> a2;
194 TEST_EQUALITY_CONST( as<int>(a2.size()), 0 );
195 TEST_EQUALITY_CONST( as<int>(a2.empty()), true );
196 TEST_EQUALITY_CONST( a2.getRawPtr(), 0 );
197 TEST_EQUALITY_CONST( a2.getRawPtr(), a2.data() );
198 TEST_EQUALITY_CONST( getConst(a2).getRawPtr(), 0 );
199 TEST_EQUALITY_CONST( getConst(a2).getRawPtr(), getConst(a2).data() );
200}
201
202
203TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, sizedConstruct, T )
204{
205 typedef typename Array<T>::size_type size_type;
206 Array<T> a(n);
207 TEST_EQUALITY_CONST( a.empty(), false );
208 TEST_EQUALITY( a.length(), n );
209 TEST_EQUALITY( as<int>(a.size()), n );
210 TEST_EQUALITY( a.getRawPtr(), &a[0] );
211 TEST_EQUALITY( a.getRawPtr(), a.data() );
212 TEST_EQUALITY( getConst(a).getRawPtr(), &getConst(a)[0] );
213 TEST_EQUALITY( getConst(a).getRawPtr(), getConst(a).data() );
214 TEST_COMPARE( a.max_size(), >=, as<size_type>(n) );
215 TEST_COMPARE( as<int>(a.capacity()), >=, n );
216}
217
218
219TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, operatorBracket, T )
220{
221 out << "\nTest that a[i] == i ... ";
222 Array<T> a = generateArray<T>(n);
223 bool local_success = true;
224 for( int i = 0; i < n; ++i ) {
225 TEST_ARRAY_ELE_EQUALITY( a, i, as<T>(i) );
226 }
227 if (local_success) out << "passed\n";
228 else success = false;
229}
230
231
232TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constAt, T )
233{
234 out << "\nTest that a.at(i) == i ...\n";
235 Array<T> a = generateArray<T>(n);
236 bool local_success = true;
237 for( int i = 0; i < n; ++i ) {
238 TEUCHOS_TEST_EQUALITY( a.at(i), as<T>(i), out, local_success );
239 }
240 if (local_success) out << "passed\n";
241 else success = false;
242}
243
244
245TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayViewIter_before_block_end, T )
246{
247 typedef typename ArrayView<T>::iterator iter_t;
249 iter_t iter = NIT::getNull();
250 {
251 ECHO(Array<T> a(n, as<T>(0)));
252 ECHO(ArrayView<T> av = a);
253 ECHO(iter = av.begin());
254 ECHO(av = null);
255 TEST_EQUALITY( *iter, a[0] );
256 // Above, the iterator to the ArrayView object is still valid even through
257 // the ArrayView object is was created from is gone now. This is just
258 // fine since the underlying data is still there in the original Array object.
259 iter = NIT::getNull();
260 }
261}
262
263
264TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPArray_to_ArrayRCP_null, T )
265{
266 const RCP<Array<T> > a_rcp = null;
267 const ArrayRCP<T> a_arcp = arcp(a_rcp);
268 TEST_ASSERT( a_arcp == null );
269}
270
271
272TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPconstArray_to_ArrayRCP_null, T )
273{
274 const RCP<const Array<T> > a_rcp = null;
275 const ArrayRCP<const T> a_arcp = arcp(a_rcp);
276 TEST_ASSERT( a_arcp == null );
277}
278
279
280TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPArray_to_ArrayRCP, T )
281{
282 const Array<T> a_const = generateArray<T>(n);
283 const RCP<Array<T> > a_rcp = Teuchos::rcp( new Array<T>(a_const));
284 const ArrayRCP<T> a_arcp = arcp(a_rcp);
285 TEST_COMPARE_ARRAYS( a_const(), a_arcp() );
286}
287
288
289TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPconstArray_to_ArrayRCP, T )
290{
291 const Array<T> a_const = generateArray<T>(n);
292 const RCP<const Array<T> > a_rcp = Teuchos::rcp( new Array<T>(a_const));
293 const ArrayRCP<const T> a_arcp = arcp(a_rcp);
294 TEST_COMPARE_ARRAYS( a_const(), a_arcp() );
295}
296
297
298TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, Array_to_ArrayRCP_null, T )
299{
300 Array<T> a;
301 const ArrayRCP<T> a_arcp = arcpFromArray(a);
302 TEST_ASSERT(a_arcp == null);
303}
304
305
306TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constArray_to_ArrayRCP_null, T )
307{
308 const Array<T> a;
309 const ArrayRCP<const T> a_arcp = arcpFromArray(a);
310 TEST_ASSERT(a_arcp == null);
311}
312
313
314TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, Array_to_ArrayRCP, T )
315{
316 Array<T> a = generateArray<T>(n);
317 const ArrayRCP<T> a_arcp = arcpFromArray(a);
318 TEST_COMPARE_ARRAYS( a(), a_arcp() );
319}
320
321
322TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constArray_to_ArrayRCP, T )
323{
324 const Array<T> a = generateArray<T>(n);
325 const ArrayRCP<const T> a_arcp = arcpFromArray(a);
326 TEST_COMPARE_ARRAYS( a(), a_arcp() );
327}
328
329
330TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, Array_to_ArrayRCP_dangling, T )
331{
332 ArrayRCP<T> a_arcp;
333 {
334 Array<T> a = generateArray<T>(n);
335 a_arcp = arcpFromArray(a);
336 }
337#ifdef TEUCHOS_DEBUG
338 TEST_THROW(a_arcp[0], DanglingReferenceError);
339#endif
340}
341
342
343TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constArray_to_ArrayRCP_dangling, T )
344{
345 ArrayRCP<const T> a_arcp;
346 {
347 const Array<T> a = generateArray<T>(n);
348 a_arcp = arcpFromArray(a);
349 }
350#ifdef TEUCHOS_DEBUG
351 TEST_THROW(a_arcp[0], DanglingReferenceError);
352#endif
353}
354
355
356TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, toVector, T )
357{
358 const Array<T> a = generateArray<T>(n);
359 const std::vector<T> v = a.toVector();
360 TEST_COMPARE_ARRAYS( a, v );
361}
362
363
364TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, toVector_empty, T )
365{
366 const Array<T> a;
367 const std::vector<T> v = a.toVector();
368 TEST_EQUALITY_CONST( as<int>(v.size()), 0 );
369}
370
371
372TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, view_empty_func, T )
373{
374 Array<T> a;
375 const ArrayView<T> av = a.view(0, 0);
376 TEST_ASSERT(is_null(av));
377}
378
379
380TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, view_empty_operator, T )
381{
382 Array<T> a;
383 const ArrayView<T> av = a(0, 0);
384 TEST_ASSERT(is_null(av));
385}
386
387
388TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, view_const_empty, T )
389{
390 const Array<T> a;
391 const ArrayView<const T> av = a.view(0, 0);
392 TEST_ASSERT(is_null(av));
393}
394
395
396TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, implicit_to_ArrayView_empty, T )
397{
398 Array<T> a;
399 const ArrayView<T> av = a();
400 TEST_ASSERT(is_null(av));
401}
402
403
404TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, implicit_to_ArrayView_const_empty, T )
405{
406 const Array<T> a;
407 const ArrayView<const T> av = a();
408 TEST_ASSERT(is_null(av));
409}
410
411
412TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_implicit, T )
413{
414 ArrayView<T> av;
415 { Array<T> a(n); av = a; }
416#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
417 TEST_THROW( av[0] = 0, DanglingReferenceError );
418#endif
419}
420
421
422TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_implicit_const, T )
423{
424 ArrayView<const T> av;
425 { Array<T> a(n); av = getConst(a); }
426#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
427 TEST_THROW( av[0], DanglingReferenceError );
428#endif
429}
430
431
432TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_explicit, T )
433{
434 ArrayView<T> av;
435 { Array<T> a(n); av = a(); }
436#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
437 TEST_THROW( av[0] = 0, DanglingReferenceError );
438#endif
439}
440
441
442TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_explicit_const, T )
443{
444 ArrayView<const T> av;
445 { Array<T> a(n); av = getConst(a)(); }
446#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
447 TEST_THROW( av[0], DanglingReferenceError );
448#endif
449}
450
451
452TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_subview, T )
453{
454 ArrayView<T> av;
455 { Array<T> a(n); av = a(0,1); }
456#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
457 TEST_THROW( av[0] = 0, DanglingReferenceError );
458#endif
459}
460
461
462TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_subview_const, T )
463{
464 ArrayView<const T> av;
465 { Array<T> a(n); av = getConst(a)(0,1); }
466#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
467 TEST_THROW( av[0], DanglingReferenceError );
468#endif
469}
470
471TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayViewIter, T )
472{
473 typedef typename ArrayView<T>::iterator iter_t;
474 ECHO(Array<T> a(n));
475 ECHO(ArrayView<T> av = a);
476 ECHO(iter_t iter = av.begin());
477 ECHO(av = null);
478 ECHO(a.resize(0));
479#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
480 TEST_THROW( *iter = 0, DanglingReferenceError );
481#else
482 (void)iter;
483#endif
484}
485
486
487TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayViewIter_const, T )
488{
489 typedef typename ArrayView<const T>::iterator iter_t;
490 ECHO(Array<T> a(n));
491 ECHO(ArrayView<T> av = a);
492 ECHO(iter_t iter = av.begin());
493 ECHO(av = null);
494 ECHO(a.resize(0));
495#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
496 TEST_THROW( *iter, DanglingReferenceError );
497#else
498 (void)iter;
499#endif
500}
501
502
503TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, erase_empty, T )
504{
505 ECHO(std::vector<T> v);
506 TEST_NOTHROW(v.erase(v.begin(), v.end()));
507 ECHO(Array<T> a);
508 TEST_NOTHROW(a.erase(a.begin(), a.end()));
509}
510
511
512TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, structuralChangeArrayView, T )
513{
514 Array<T> a = generateArray<T>(n);
515 ArrayView<T> av = a;
516 a.push_back(a[0]);
517#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
518 TEST_THROW( av[0] = 0, DanglingReferenceError );
519#endif
520}
521
522
523TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, structuralChangeArrayView_const, T )
524{
525 Array<T> a = generateArray<T>(n);
526 ArrayView<const T> av = getConst(a);
527 a.push_back(a[0]);
528#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
529 TEST_THROW( av[0], DanglingReferenceError );
530#endif
531}
532
533
534//
535// Instantiations
536//
537
538#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
539
540# define DEBUG_UNIT_TEST_GROUP( T )
541
542#else // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
543
544# define DEBUG_UNIT_TEST_GROUP( T )
545
546#endif // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
547
548
549#define UNIT_TEST_GROUP( T ) \
550 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, defaultConstruct, T ) \
551 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, sizedConstruct, T ) \
552 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, operatorBracket, T ) \
553 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constAt, T ) \
554 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayViewIter_before_block_end, T ) \
555 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPArray_to_ArrayRCP_null, T ) \
556 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPconstArray_to_ArrayRCP_null, T ) \
557 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPArray_to_ArrayRCP, T ) \
558 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPconstArray_to_ArrayRCP, T ) \
559 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, Array_to_ArrayRCP_null, T ) \
560 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constArray_to_ArrayRCP_null, T ) \
561 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, Array_to_ArrayRCP, T ) \
562 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constArray_to_ArrayRCP, T ) \
563 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, Array_to_ArrayRCP_dangling, T ) \
564 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constArray_to_ArrayRCP_dangling, T ) \
565 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, toVector, T ) \
566 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, toVector_empty, T ) \
567 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, view_empty_func, T ) \
568 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, view_empty_operator, T ) \
569 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, implicit_to_ArrayView_empty, T ) \
570 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_implicit, T ) \
571 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_implicit_const, T ) \
572 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_explicit, T ) \
573 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_explicit_const, T ) \
574 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_subview, T ) \
575 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_subview_const, T ) \
576 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayViewIter, T ) \
577 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayViewIter_const, T ) \
578 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, erase_empty, T ) \
579 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, structuralChangeArrayView, T ) \
580 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, structuralChangeArrayView_const, T ) \
581 DEBUG_UNIT_TEST_GROUP( T )
582
584UNIT_TEST_GROUP(float)
585UNIT_TEST_GROUP(double)
586
587
588} // namespace
#define UNIT_TEST_GROUP(T)
#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_ARRAY_ELE_EQUALITY(a, i, val)
Assert that a[i] == val.
#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 TEST_COMPARE(v1, comp, v2)
Assert that v1 comp v2 (where comp = '==', '>=", "!=", etc).
#define ECHO(statement)
Echo the given statement before it is executed.
#define TEUCHOS_TEST_EQUALITY(v1, v2, out, success)
Test that two values are equal.
#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.
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.
Smart reference counting pointer class for automatic garbage collection.
Concrete serial communicator subclass.
Default traits class that just returns typeid(T).name().
static std::string trimWhiteSpace(const std::string &str)
Trim whitespace from beginning and end of std::string.
bool is_null(const boost::shared_ptr< T > &p)
Returns true if p.get()==NULL.
Teuchos::Array< T > generateArray(const int n_in)
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
const T & getConst(T &t)
Return a constant reference to an object given a non-const reference.