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() );
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() );
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.
Base traits class for getting a properly initialized null pointer.
Smart reference counting pointer class for automatic garbage collection.
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.
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.