Teuchos Package Browser (Single Doxygen Collection) Version of the Day
Array_UnitTests.cpp
Go to the documentation of this file.
00001 /*
00002 // @HEADER
00003 // ***********************************************************************
00004 //
00005 //                    Teuchos: Common Tools Package
00006 //                 Copyright (2004) Sandia Corporation
00007 //
00008 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
00009 // license for use of this work by or on behalf of the U.S. Government.
00010 //
00011 // Redistribution and use in source and binary forms, with or without
00012 // modification, are permitted provided that the following conditions are
00013 // met:
00014 //
00015 // 1. Redistributions of source code must retain the above copyright
00016 // notice, this list of conditions and the following disclaimer.
00017 //
00018 // 2. Redistributions in binary form must reproduce the above copyright
00019 // notice, this list of conditions and the following disclaimer in the
00020 // documentation and/or other materials provided with the distribution.
00021 //
00022 // 3. Neither the name of the Corporation nor the names of the
00023 // contributors may be used to endorse or promote products derived from
00024 // this software without specific prior written permission.
00025 //
00026 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
00027 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00028 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00029 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
00030 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00031 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00032 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00033 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00034 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00035 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00036 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00037 //
00038 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
00039 //
00040 // ***********************************************************************
00041 // @HEADER
00042 */
00043 
00044 #include "Array_UnitTest_helpers.hpp"
00045 #include "Teuchos_Tuple.hpp"
00046 #include "Teuchos_ArrayRCP.hpp"
00047 
00048 
00049 namespace {
00050 
00051 
00052 using ArrayUnitTestHelpers::n;
00053 using ArrayUnitTestHelpers::generateArray;
00054 using Teuchos::null;
00055 using Teuchos::tuple;
00056 using Teuchos::RCP;
00057 using Teuchos::Array;
00058 using Teuchos::ArrayView;
00059 using Teuchos::ArrayRCP;
00060 using Teuchos::arcp;
00061 using Teuchos::arcpFromArray;
00062 using Teuchos::as;
00063 using Teuchos::getConst;
00064 using Teuchos::DanglingReferenceError;
00065 using Teuchos::fromStringToArray;
00066 using Teuchos::InvalidArrayStringRepresentation;
00067 
00068 
00069 TEUCHOS_UNIT_TEST( Utils, trimWhiteSpace_empty )
00070 {
00071   TEST_EQUALITY(Teuchos::Utils::trimWhiteSpace(""), "");
00072 }
00073 
00074 
00075 
00076 TEUCHOS_UNIT_TEST( Array, TypeNameTraits )
00077 {
00078   TEST_EQUALITY(Teuchos::TypeNameTraits<Array<double> >::name(),
00079     std::string("Array(double)"));
00080 }
00081 
00082 
00083 TEUCHOS_UNIT_TEST( Array, stringToArray )
00084 {
00085 
00086   {
00087     std::string arrayString="{}";
00088     std::istringstream arrayStream(arrayString);
00089     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00090     Array<std::string> arrayStreamVal;
00091     arrayStream >> arrayStreamVal;
00092     Array<std::string> arrayVal_exp;
00093     TEST_EQUALITY(arrayVal, arrayVal_exp);
00094     TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
00095   }
00096 
00097   {
00098     std::string arrayString = "{ a, b, c, d }";
00099     std::istringstream arrayStream(arrayString);
00100     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00101     Array<std::string> arrayStreamVal;
00102     arrayStream >> arrayStreamVal;
00103     Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("a", "b", "c", "d" );
00104     TEST_EQUALITY(arrayVal, arrayVal_exp);
00105     TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
00106   }
00107 
00108   {
00109     std::string arrayString = "{ (a), b, c, (d) }";
00110     std::istringstream arrayStream(arrayString);
00111     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00112     Array<std::string> arrayStreamVal;
00113     arrayStream >> arrayStreamVal;
00114     Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("(a)", "b", "c", "(d)" );
00115     TEST_EQUALITY(arrayVal, arrayVal_exp);
00116     TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
00117   }
00118 
00119   {
00120     std::string arrayString = "{ (a ), b, c, (d ) }";
00121     std::istringstream arrayStream(arrayString);
00122     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00123     Array<std::string> arrayStreamVal;
00124     arrayStream >> arrayStreamVal;
00125     Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("(a )", "b", "c", "(d )" );
00126     TEST_EQUALITY(arrayVal, arrayVal_exp);
00127     TEST_EQUALITY(arrayStreamVal, arrayVal_exp);
00128   }
00129 
00130   // This should work but does not.  I should fix this!
00131 //  {
00132 //    Array<std::string> arrayVal = fromStringToArray<std::string>("{ {a}, 'b', {c }, d }");
00133 //    Array<std::string> arrayVal_exp = Teuchos::tuple<std::string>("{a}", "'b'", "{c }", "d" );
00134 //    TEST_EQUALITY(arrayVal, arrayVal_exp);
00135 //  }
00136 
00137 }
00138 
00139 
00140 TEUCHOS_UNIT_TEST( Array, stringToArray_invalid )
00141 {
00142   TEST_THROW(fromStringToArray<std::string>("{ a, b, c"),
00143     InvalidArrayStringRepresentation);
00144   TEST_THROW(fromStringToArray<std::string>("a, b, c}"),
00145     InvalidArrayStringRepresentation);
00146   TEST_THROW(fromStringToArray<std::string>("a, b, c"),
00147     InvalidArrayStringRepresentation);
00148 }
00149 
00150 
00151 TEUCHOS_UNIT_TEST( Array, stringToArray_string_hyphens )
00152 {
00153 
00154   {
00155     std::string arrayString="{-}";
00156     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00157     Array<std::string> arrayVal_exp = tuple<std::string>("-");
00158     TEST_EQUALITY(arrayVal, arrayVal_exp);
00159   }
00160 
00161   {
00162     std::string arrayString="{-,-}";
00163     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00164     Array<std::string> arrayVal_exp = tuple<std::string>("-","-");
00165     TEST_EQUALITY(arrayVal, arrayVal_exp);
00166   }
00167 
00168   {
00169     std::string arrayString="{-,1,-}";
00170     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00171     Array<std::string> arrayVal_exp = tuple<std::string>("-","1","-");
00172     TEST_EQUALITY(arrayVal, arrayVal_exp);
00173   }
00174 
00175   {
00176     std::string arrayString="{}";
00177     Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString);
00178     Array<std::string> arrayVal_exp;
00179     TEST_EQUALITY(arrayVal, arrayVal_exp);
00180   }
00181 
00182   {
00183     std::string arrayString="{,}";
00184     TEST_THROW(Array<std::string> arrayVal = fromStringToArray<std::string>(arrayString),
00185       Teuchos::InvalidArrayStringRepresentation);
00186   }
00187 
00188 }
00189 
00190 
00191 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, defaultConstruct, T )
00192 {
00193   Array<T> a2;
00194   TEST_EQUALITY_CONST( as<int>(a2.size()), 0 );
00195   TEST_EQUALITY_CONST( as<int>(a2.empty()), true );
00196   TEST_EQUALITY_CONST( a2.getRawPtr(), 0 );
00197   TEST_EQUALITY_CONST( getConst(a2).getRawPtr(), 0 );
00198 }
00199 
00200 
00201 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, sizedConstruct, T )
00202 {
00203   typedef typename Array<T>::size_type size_type;
00204   Array<T> a(n);
00205   TEST_EQUALITY_CONST( a.empty(), false );
00206   TEST_EQUALITY( a.length(), n );
00207   TEST_EQUALITY( as<int>(a.size()), n );
00208   TEST_EQUALITY( a.getRawPtr(), &a[0] );
00209   TEST_EQUALITY( getConst(a).getRawPtr(), &getConst(a)[0] );
00210   TEST_COMPARE( a.max_size(), >=, as<size_type>(n) );
00211   TEST_COMPARE( as<int>(a.capacity()), >=, n );
00212 }
00213 
00214 
00215 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, operatorBracket, T )
00216 {
00217   out << "\nTest that a[i] == i ... ";
00218   Array<T> a = generateArray<T>(n);
00219   bool local_success = true;
00220   for( int i = 0; i < n; ++i ) {
00221     TEST_ARRAY_ELE_EQUALITY( a, i, as<T>(i) );
00222   }
00223   if (local_success) out << "passed\n";
00224   else success = false;
00225 }
00226 
00227 
00228 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constAt, T )
00229 {
00230   out << "\nTest that a.at(i) == i ...\n";
00231   Array<T> a = generateArray<T>(n);
00232   bool local_success = true;
00233   for( int i = 0; i < n; ++i ) {
00234     TEUCHOS_TEST_EQUALITY( a.at(i), as<T>(i), out, local_success );
00235   }
00236   if (local_success) out << "passed\n";
00237   else success = false;
00238 }
00239 
00240 
00241 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayViewIter_before_block_end, T )
00242 {
00243   typedef typename ArrayView<T>::iterator iter_t;
00244   typedef Teuchos::NullIteratorTraits<iter_t> NIT;
00245   iter_t iter = NIT::getNull();
00246   {
00247     ECHO(Array<T> a(n, as<T>(0)));
00248     ECHO(ArrayView<T> av = a);
00249     ECHO(iter = av.begin());
00250     ECHO(av = null);
00251     TEST_EQUALITY( *iter, a[0] );
00252     // Above, the iterator to the ArrayView object is still valid even through
00253     // the ArrayView object is was created from is gone now.  This is just
00254     // fine since the underlying data is still there in the original Array object.
00255     iter = NIT::getNull();
00256   }
00257 }
00258 
00259 
00260 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPArray_to_ArrayRCP_null, T )
00261 {
00262   const RCP<Array<T> > a_rcp = null;
00263   const ArrayRCP<T> a_arcp = arcp(a_rcp);
00264   TEST_ASSERT( a_arcp == null );
00265 }
00266 
00267 
00268 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPconstArray_to_ArrayRCP_null, T )
00269 {
00270   const RCP<const Array<T> > a_rcp = null;
00271   const ArrayRCP<const T> a_arcp = arcp(a_rcp);
00272   TEST_ASSERT( a_arcp == null );
00273 }
00274 
00275 
00276 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPArray_to_ArrayRCP, T )
00277 {
00278   const Array<T> a_const = generateArray<T>(n);
00279   const RCP<Array<T> > a_rcp = Teuchos::rcp( new  Array<T>(a_const));
00280   const ArrayRCP<T> a_arcp = arcp(a_rcp);
00281   TEST_COMPARE_ARRAYS( a_const(), a_arcp() );
00282 }
00283 
00284 
00285 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, RCPconstArray_to_ArrayRCP, T )
00286 {
00287   const Array<T> a_const = generateArray<T>(n);
00288   const RCP<const Array<T> > a_rcp = Teuchos::rcp( new  Array<T>(a_const));
00289   const ArrayRCP<const T> a_arcp = arcp(a_rcp);
00290   TEST_COMPARE_ARRAYS( a_const(), a_arcp() );
00291 }
00292 
00293 
00294 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, Array_to_ArrayRCP_null, T )
00295 {
00296   Array<T> a;
00297   const ArrayRCP<T> a_arcp = arcpFromArray(a);
00298   TEST_ASSERT(a_arcp == null);
00299 }
00300 
00301 
00302 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constArray_to_ArrayRCP_null, T )
00303 {
00304   const Array<T> a;
00305   const ArrayRCP<const T> a_arcp = arcpFromArray(a);
00306   TEST_ASSERT(a_arcp == null);
00307 }
00308 
00309 
00310 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, Array_to_ArrayRCP, T )
00311 {
00312   Array<T> a = generateArray<T>(n);
00313   const ArrayRCP<T> a_arcp = arcpFromArray(a);
00314   TEST_COMPARE_ARRAYS( a(), a_arcp() );
00315 }
00316 
00317 
00318 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constArray_to_ArrayRCP, T )
00319 {
00320   const Array<T> a = generateArray<T>(n);
00321   const ArrayRCP<const T> a_arcp = arcpFromArray(a);
00322   TEST_COMPARE_ARRAYS( a(), a_arcp() );
00323 }
00324 
00325 
00326 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, Array_to_ArrayRCP_dangling, T )
00327 {
00328   ArrayRCP<T> a_arcp;
00329   {
00330     Array<T> a = generateArray<T>(n);
00331     a_arcp = arcpFromArray(a);
00332   }
00333 #ifdef TEUCHOS_DEBUG
00334   TEST_THROW(a_arcp[0], DanglingReferenceError);
00335 #endif
00336 }
00337 
00338 
00339 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, constArray_to_ArrayRCP_dangling, T )
00340 {
00341   ArrayRCP<const T> a_arcp;
00342   {
00343     const Array<T> a = generateArray<T>(n);
00344     a_arcp = arcpFromArray(a);
00345   }
00346 #ifdef TEUCHOS_DEBUG
00347   TEST_THROW(a_arcp[0], DanglingReferenceError);
00348 #endif
00349 }
00350 
00351 
00352 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, toVector, T )
00353 {
00354   const Array<T> a = generateArray<T>(n);
00355   const std::vector<T> v = a.toVector();
00356   TEST_COMPARE_ARRAYS( a, v );
00357 }
00358 
00359 
00360 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, toVector_empty, T )
00361 {
00362   const Array<T> a;
00363   const std::vector<T> v = a.toVector();
00364   TEST_EQUALITY_CONST( as<int>(v.size()), 0 );
00365 }
00366 
00367 
00368 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, view_empty_func, T )
00369 {
00370   Array<T> a;
00371   const ArrayView<T> av = a.view(0, 0);
00372   TEST_ASSERT(is_null(av));
00373 }
00374 
00375 
00376 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, view_empty_operator, T )
00377 {
00378   Array<T> a;
00379   const ArrayView<T> av = a(0, 0);
00380   TEST_ASSERT(is_null(av));
00381 }
00382 
00383 
00384 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, view_const_empty, T )
00385 {
00386   const Array<T> a;
00387   const ArrayView<const T> av = a.view(0, 0);
00388   TEST_ASSERT(is_null(av));
00389 }
00390 
00391 
00392 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, implicit_to_ArrayView_empty, T )
00393 {
00394   Array<T> a;
00395   const ArrayView<T> av = a();
00396   TEST_ASSERT(is_null(av));
00397 }
00398 
00399 
00400 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, implicit_to_ArrayView_const_empty, T )
00401 {
00402   const Array<T> a;
00403   const ArrayView<const T> av = a();
00404   TEST_ASSERT(is_null(av));
00405 }
00406 
00407 
00408 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_implicit, T )
00409 {
00410   ArrayView<T> av;
00411   { Array<T> a(n); av = a; }
00412 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00413   TEST_THROW( av[0] = 0, DanglingReferenceError );
00414 #endif
00415 }
00416 
00417 
00418 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_implicit_const, T )
00419 {
00420   ArrayView<const T> av;
00421   { Array<T> a(n); av = getConst(a); }
00422 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00423   TEST_THROW( av[0], DanglingReferenceError );
00424 #endif
00425 }
00426 
00427 
00428 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_explicit, T )
00429 {
00430   ArrayView<T> av;
00431   { Array<T> a(n); av = a(); }
00432 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00433   TEST_THROW( av[0] = 0, DanglingReferenceError );
00434 #endif
00435 }
00436 
00437 
00438 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_explicit_const, T )
00439 {
00440   ArrayView<const T> av;
00441   { Array<T> a(n); av = getConst(a)(); }
00442 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00443   TEST_THROW( av[0], DanglingReferenceError );
00444 #endif
00445 }
00446 
00447 
00448 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_subview, T )
00449 {
00450   ArrayView<T> av;
00451   { Array<T> a(n); av = a(0,1); }
00452 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00453   TEST_THROW( av[0] = 0, DanglingReferenceError );
00454 #endif
00455 }
00456 
00457 
00458 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayView_subview_const, T )
00459 {
00460   ArrayView<const T> av;
00461   { Array<T> a(n); av = getConst(a)(0,1); }
00462 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00463   TEST_THROW( av[0], DanglingReferenceError );
00464 #endif
00465 }
00466 
00467 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayViewIter, T )
00468 {
00469   typedef typename ArrayView<T>::iterator iter_t;
00470   ECHO(Array<T> a(n));
00471   ECHO(ArrayView<T> av = a);
00472   ECHO(iter_t iter = av.begin());
00473   ECHO(av = null);
00474   ECHO(a.resize(0));
00475 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00476   TEST_THROW( *iter = 0, DanglingReferenceError );
00477 #else
00478   (void)iter;
00479 #endif
00480 }
00481 
00482 
00483 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, danglingArrayViewIter_const, T )
00484 {
00485   typedef typename ArrayView<const T>::iterator iter_t;
00486   ECHO(Array<T> a(n));
00487   ECHO(ArrayView<T> av = a);
00488   ECHO(iter_t iter = av.begin());
00489   ECHO(av = null);
00490   ECHO(a.resize(0));
00491 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00492   TEST_THROW( *iter, DanglingReferenceError );
00493 #else
00494   (void)iter;
00495 #endif
00496 }
00497 
00498 
00499 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, erase_empty, T )
00500 {
00501   ECHO(std::vector<T> v);
00502   TEST_NOTHROW(v.erase(v.begin(), v.end()));
00503   ECHO(Array<T> a);
00504   TEST_NOTHROW(a.erase(a.begin(), a.end()));
00505 }
00506 
00507 
00508 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, structuralChangeArrayView, T )
00509 {
00510   Array<T> a = generateArray<T>(n);
00511   ArrayView<T> av = a;
00512   a.push_back(a[0]);
00513 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00514   TEST_THROW( av[0] = 0, DanglingReferenceError );
00515 #endif
00516 }
00517 
00518 
00519 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( Array, structuralChangeArrayView_const, T )
00520 {
00521   Array<T> a = generateArray<T>(n);
00522   ArrayView<const T> av = getConst(a);
00523   a.push_back(a[0]);
00524 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00525   TEST_THROW( av[0], DanglingReferenceError );
00526 #endif
00527 }
00528 
00529 
00530 //
00531 // Instantiations
00532 //
00533 
00534 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00535 
00536 #  define DEBUG_UNIT_TEST_GROUP( T )
00537 
00538 #else // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00539 
00540 #  define DEBUG_UNIT_TEST_GROUP( T )
00541 
00542 #endif // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00543 
00544 
00545 #define UNIT_TEST_GROUP( T ) \
00546   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, defaultConstruct, T ) \
00547   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, sizedConstruct, T ) \
00548   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, operatorBracket, T ) \
00549   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constAt, T ) \
00550   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayViewIter_before_block_end, T ) \
00551   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPArray_to_ArrayRCP_null, T ) \
00552   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPconstArray_to_ArrayRCP_null, T ) \
00553   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPArray_to_ArrayRCP, T ) \
00554   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, RCPconstArray_to_ArrayRCP, T ) \
00555   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, Array_to_ArrayRCP_null, T ) \
00556   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constArray_to_ArrayRCP_null, T ) \
00557   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, Array_to_ArrayRCP, T ) \
00558   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constArray_to_ArrayRCP, T ) \
00559   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, Array_to_ArrayRCP_dangling, T ) \
00560   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, constArray_to_ArrayRCP_dangling, T ) \
00561   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, toVector, T ) \
00562   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, toVector_empty, T ) \
00563   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, view_empty_func, T ) \
00564   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, view_empty_operator, T ) \
00565   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, implicit_to_ArrayView_empty, T ) \
00566   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_implicit, T ) \
00567   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_implicit_const, T ) \
00568   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_explicit, T ) \
00569   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_explicit_const, T ) \
00570   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_subview, T ) \
00571   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayView_subview_const, T ) \
00572   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayViewIter, T ) \
00573   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, danglingArrayViewIter_const, T ) \
00574   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, erase_empty, T ) \
00575   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, structuralChangeArrayView, T ) \
00576   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( Array, structuralChangeArrayView_const, T ) \
00577   DEBUG_UNIT_TEST_GROUP( T )
00578 
00579 UNIT_TEST_GROUP(int)
00580 UNIT_TEST_GROUP(float)
00581 UNIT_TEST_GROUP(double)
00582 
00583 
00584 } // namespace
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines