doc/html/ArrayConversions__UnitTests_8cpp_source.html

/*

// @HEADER

// ***********************************************************************

//

//                    Teuchos: Common Tools Package

//                 Copyright (2004) Sandia Corporation

//

// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive

// license for use of this work by or on behalf of the U.S. Government.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

// 1. Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//

// 2. Redistributions in binary form must reproduce the above copyright

// notice, this list of conditions and the following disclaimer in the

// documentation and/or other materials provided with the distribution.

//

// 3. Neither the name of the Corporation nor the names of the

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY

// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Questions? Contact Michael A. Heroux (maherou@sandia.gov)

//

// ***********************************************************************

// @HEADER

*/


#include "Teuchos_ArrayConversions.hpp"

#include "Teuchos_implicit_cast.hpp"

#include "Array_UnitTest_helpers.hpp"

#include "ArrayConversions_UnitTest_helpers.hpp"

#include "TestClasses.hpp"


namespace {


using ArrayUnitTestHelpers::n;

using ArrayConversionsUnitTestHelpers::generateArrayRcp;

using ArrayConversionsUnitTestHelpers::generateArrayRcpGen;

using ArrayConversionsUnitTestHelpers::testArrayViewInput;

using ArrayConversionsUnitTestHelpers::testArrayViewOutput;

using Teuchos::arrayPtrConv;

using Teuchos::arrayRcpConv;

using Teuchos::arrayViewPtrConv;

using Teuchos::arrayViewRcpConv;

using Teuchos::Array;

using Teuchos::ArrayView;

using Teuchos::Ptr;

using Teuchos::RCP;

using Teuchos::rcp;

using Teuchos::as;

using Teuchos::implicit_ptr_cast;


// Verify generateArrayRcp works correctly

TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, generateArrayRcp, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  TEST_EQUALITY_CONST( as<Teuchos_Ordinal>(a_in.size()), n );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY_CONST( Teuchos::is_null(a_in[i]), false );

    TEST_EQUALITY_CONST( *a_in[i], as<T>(i) );

  }

}


// Verify testArrayViewInput works correctly

TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, testArrayViewInput, T )

{

  //typedef Teuchos::ScalarTraits<T> ST; // unused

  const Array<RCP<T> > a_data = generateArrayRcp<T>(n);

  Array<Ptr<const T> > a_in(n);

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    a_in[i] = a_data[i].ptr();

  }

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY_CONST( Teuchos::is_null(a_in[i]), false );

  }

  T a_out = testArrayViewInput<T>(a_in);

  TEST_EQUALITY_CONST( a_out, as<T>(n*(n-1)/2) );

}


// Verify testArrayViewOutput works correctly

TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, testArrayViewOutput, T )

{

  typedef Teuchos::ScalarTraits<T> ST;

  const Array<RCP<T> > a_data = generateArrayRcp<T>(n);

  Array<Ptr<T> > a_out;

  a_out.reserve(n);

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    *a_data[i] = ST::zero();

    a_out.push_back( a_data[i].ptr() );

  }

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY_CONST( Teuchos::is_null(a_out[i]), false );

  }

  testArrayViewOutput<T>(a_out);

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY_CONST( *a_out[i], as<T>(i) );

  }


}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrConst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<Ptr<const T> > a_out = arrayPtrConv<const T>(a_in);

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( a_out[i].get(), a_in[i].get() );

    TEST_EQUALITY( *a_out[i], *a_in[i] );

  }

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrNonconst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<Ptr<T> > a_out = arrayPtrConv<T>(a_in);

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( a_out[i].get(), a_in[i].get() );

    TEST_EQUALITY( *a_out[i], *a_in[i] );

  }

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrNonconst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<Ptr<T> > a1_out = arrayPtrConv<T>(a_in);

  const Array<Ptr<T> > a2_out = arrayPtrConv<T>(a1_out());

  TEST_COMPARE_ARRAYS( a2_out, a1_out );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrConst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<Ptr<T> > a1_out = arrayPtrConv<T>(a_in);

  const Array<Ptr<const T> > a2_out = arrayPtrConv<const T>(a1_out());

  TEST_COMPARE_ARRAYS( a2_out, a1_out );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PtrConst_to_PtrConst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<Ptr<const T> > a1_out = arrayPtrConv<const T>(a_in);

  const Array<Ptr<const T> > a2_out = arrayPtrConv<const T>(a1_out());

  TEST_COMPARE_ARRAYS( a2_out, a1_out );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PassConst, T )

{

  Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  T a = testArrayViewInput<T>(arrayPtrConv<const T>(a_in));

  T a_exact = as<T>(n*(n-1)/2);

  TEST_EQUALITY( a, a_exact );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PassNonconst, T )

{

  typedef Teuchos::ScalarTraits<T> ST;

  Array<RCP<T> > a_out = generateArrayRcp<T>(n);

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    *a_out[i] = ST::zero();

  }

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY_CONST( *a_out[i], ST::zero() );

  }

  testArrayViewOutput<T>(arrayPtrConv<T>(a_out));

  TEST_EQUALITY_CONST( as<Teuchos_Ordinal>(a_out.size()), n );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY_CONST( *a_out[i], as<T>(i) );

  }

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpNonconst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<RCP<T> > a1_out = arrayRcpConv<T>(a_in);

  TEST_COMPARE_ARRAYS( a1_out, a_in );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpConst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<RCP<const T> > a1_out = arrayRcpConv<const T>(a_in);

  TEST_COMPARE_ARRAYS( a1_out, a_in );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayRcpConv_RcpConst_to_RcpConst, T )

{

  const Array<RCP<T> > a_in = generateArrayRcp<T>(n);

  const Array<RCP<const T> > a1_out = arrayRcpConv<const T>(a_in);

  const Array<RCP<const T> > a2_out = arrayRcpConv<const T>(a1_out);

  TEST_COMPARE_ARRAYS( a2_out, a1_out );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstPtrConstCast_nonconst_to_const,

  T )

{

  Array<RCP<T> > a_rcp = generateArrayRcp<T>(n);

  Array<Ptr<T> > a_ptr = arrayPtrConv<T>(a_rcp);

  const ArrayView<const Ptr<T> > av_ptr_nonconst = a_ptr();

  const ArrayView<const Ptr<const T> > av_ptr_const =

    Teuchos::arrayConstPtrConstCast(av_ptr_nonconst);

  TEST_COMPARE_ARRAYS( av_ptr_nonconst, av_ptr_const );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstPtrConstCast_const_to_const,

  T )

{

  Array<RCP<T> > a_rcp = generateArrayRcp<T>(n);

  Array<Ptr<const T> > a_ptr = arrayPtrConv<const T>(a_rcp);

  const ArrayView<const Ptr<const T> > av_ptr_const1 = a_ptr();

  const ArrayView<const Ptr<const T> > av_ptr_const2 =

    Teuchos::arrayConstPtrConstCast(av_ptr_const1);

  TEST_COMPARE_ARRAYS( av_ptr_const1, av_ptr_const2 );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstRcpConstCast_nonconst_to_const,

  T )

{

  Array<RCP<T> > a_rcp = generateArrayRcp<T>(n);

  const ArrayView<const RCP<T> > av_rcp_nonconst = a_rcp();

  const ArrayView<const RCP<const T> > av_rcp_const =

    Teuchos::arrayConstRcpConstCast(av_rcp_nonconst);

  TEST_COMPARE_ARRAYS( av_rcp_nonconst, av_rcp_const );

}


TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstRcpConstCast_const_to_const,

  T )

{

  Array<RCP<T> > a_rcp_orig = generateArrayRcp<T>(n);

  Array<RCP<const T> > a_rcp = arrayRcpConv<const T>(a_rcp_orig);

  const ArrayView<const RCP<const T> > av_rcp_const1 = a_rcp();

  const ArrayView<const RCP<const T> > av_rcp_const2 =

    Teuchos::arrayConstRcpConstCast(av_rcp_const1);

  TEST_COMPARE_ARRAYS( av_rcp_const1, av_rcp_const2 );

}


#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK


#  define DEBUG_UNIT_TEST_GROUP( T )


#else // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK


#  define DEBUG_UNIT_TEST_GROUP( T )


#endif // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK


#define UNIT_TEST_GROUP( T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, generateArrayRcp, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, testArrayViewInput, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, testArrayViewOutput, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrConst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrNonconst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrNonconst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrConst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PtrConst_to_PtrConst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayRcpConv_RcpConst_to_RcpConst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PassConst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PassNonconst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpNonconst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpConst, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstPtrConstCast_nonconst_to_const, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstPtrConstCast_const_to_const, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstRcpConstCast_nonconst_to_const, T ) \

  TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstRcpConstCast_const_to_const, T ) \

  DEBUG_UNIT_TEST_GROUP( T )


UNIT_TEST_GROUP(Teuchos_Ordinal)

UNIT_TEST_GROUP(float)

UNIT_TEST_GROUP(double)


TEUCHOS_UNIT_TEST( ArrayConversions, arrayPtrConv_RcpNonconstDerived_to_PtrNonconstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  const Array<Ptr<A> > a_out = arrayPtrConv<A>(a_in);

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayPtrConv_RcpNonconstDerived_to_PtrConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  const Array<Ptr<const A> > a_out = arrayPtrConv<const A>(a_in);

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayPtrConv_RcpConstDerived_to_PtrConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  const Array<RCP<const C> > a1_out = arrayRcpConv<const C>(a_in);

  const Array<Ptr<const A> > a2_out = arrayPtrConv<const A>(a1_out);

  TEST_EQUALITY( a2_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayRcpConv_RcpNonconstDerived_to_RcpNonconstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  const Array<RCP<A> > a_out = arrayRcpConv<A>(a_in);

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayRcpConv_RcpNonconstDerived_to_RcpConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  const Array<RCP<const A> > a_out = arrayRcpConv<const A>(a_in);

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayRcpConv_RcpConstDerived_to_RcpConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  const Array<RCP<const C> > a1_out = arrayRcpConv<const C>(a_in);

  const Array<RCP<const A> > a2_out = arrayRcpConv<const A>(a1_out);

  TEST_EQUALITY( a2_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewPtrConv_RcpNonconstDerived_to_PtrNonconstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  Array<Ptr<A> > a_out(n);

  arrayViewPtrConv(a_in, a_out());

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewPtrConv_RcpNonconstDerived_to_PtrConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  Array<Ptr<const A> > a_out(n);

  arrayViewPtrConv(a_in, a_out());

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewPtrConv_RcpConstDerived_to_PtrConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  Array<RCP<const C> > a1_out(n);

  arrayViewRcpConv(a_in, a1_out());

  Array<Ptr<const A> > a2_out(n);

  arrayViewPtrConv(a1_out, a2_out());

  TEST_EQUALITY( a2_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewRcpConv_RcpNonconstDerived_to_RcpNonconstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  Array<RCP<A> > a_out(n);

  arrayViewRcpConv(a_in, a_out());

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewRcpConv_RcpNonconstDerived_to_RcpConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  Array<RCP<const A> > a_out(n);

  arrayViewRcpConv(a_in, a_out());

  TEST_EQUALITY( a_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewRcpConv_RcpConstDerived_to_RcpConstBase)

{

  const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);

  Array<RCP<const C> > a1_out(n);

  arrayViewRcpConv(a_in, a1_out());

  Array<RCP<const A> > a2_out(n);

  arrayViewRcpConv(a1_out, a2_out());

  TEST_EQUALITY( a2_out.size(), a_in.size() );

  for (Teuchos_Ordinal i=0 ; i<n ; ++i) {

    TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<A>(&*a_in[i]) );

  }

}


} // namespace

ArrayConversions_UnitTest_helpers.hpp

UNIT_TEST_GROUP
#define UNIT_TEST_GROUP(T)
Definition ArrayConversions_UnitTests.cpp:283

Array_UnitTest_helpers.hpp

TestClasses.hpp

Teuchos_ArrayConversions.hpp
Templated conversions between Array<RCP<T> > and ArrayView<Ptr<T> >

Teuchos_Ordinal
TEUCHOS_ORDINAL_TYPE Teuchos_Ordinal
Definition Teuchos_ConfigDefs.hpp:141

TEST_EQUALITY_CONST
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
Definition Teuchos_LocalTestingHelpers.hpp:79

TEST_EQUALITY
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
Definition Teuchos_LocalTestingHelpers.hpp:87

TEST_COMPARE_ARRAYS
#define TEST_COMPARE_ARRAYS(a1, a2)
Assert that a1.size()==a2.size() and a[i]==b[i], i=0....
Definition Teuchos_LocalTestingHelpers.hpp:172

TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL
#define TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(TEST_GROUP, TEST_NAME, TYPE)
Macro for defining a templated unit test with one template parameter.
Definition Teuchos_UnitTestHelpers.hpp:160

TEUCHOS_UNIT_TEST
#define TEUCHOS_UNIT_TEST(TEST_GROUP, TEST_NAME)
Macro for defining a (non-templated) unit test.
Definition Teuchos_UnitTestHelpers.hpp:83

Teuchos_implicit_cast.hpp

Array
Replacement for std::vector that is compatible with the Teuchos Memory Management classes.
Definition Teuchos_Array.hpp:195

Array::reserve
void reserve(size_type n)
Definition Teuchos_Array.hpp:1068

Array::size
size_type size() const
Definition Teuchos_Array.hpp:1027

Array::push_back
void push_back(const value_type &x)
Definition Teuchos_Array.hpp:1166

Teuchos::ArrayView
Nonowning array view.
Definition Teuchos_ArrayViewDecl.hpp:123

Teuchos::Array
Replacement for std::vector that is compatible with the Teuchos Memory Management classes.
Definition Teuchos_Array.hpp:195

Teuchos::ParameterList::get
T & get(ParameterList &l, const std::string &name)
A shorter name for getParameter().
Definition Teuchos_ParameterList.hpp:1319

Teuchos::Ptr
Simple wrapper class for raw pointers to single objects where no persisting relationship exists.
Definition Teuchos_PtrDecl.hpp:104

Teuchos::Ptr::ptr
Ptr< T > ptr(T *p)
Create a pointer to an object from a raw pointer.
Definition Teuchos_PtrDecl.hpp:329

Teuchos::RCP
Smart reference counting pointer class for automatic garbage collection.
Definition Teuchos_RCPDecl.hpp:429

as
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
Definition Teuchos_as.hpp:2840

Teuchos::is_null
bool is_null(const std::shared_ptr< T > &p)
Returns true if p.get()==NULL.
Definition Teuchos_RCPStdSharedPtrConversionsDecl.hpp:148

ArrayConversionsUnitTestHelpers::testArrayViewOutput
void testArrayViewOutput(const ArrayView< const Ptr< T > > &a_out)
Definition ArrayConversions_UnitTest_helpers.hpp:98

ArrayConversionsUnitTestHelpers::generateArrayRcp
Array< RCP< T > > generateArrayRcp(const Teuchos_Ordinal n_in)
Definition ArrayConversions_UnitTest_helpers.hpp:63

ArrayConversionsUnitTestHelpers::testArrayViewInput
T testArrayViewInput(const ArrayView< const Ptr< const T > > &a_in)
Definition ArrayConversions_UnitTest_helpers.hpp:86

ArrayConversionsUnitTestHelpers::generateArrayRcpGen
Array< RCP< T > > generateArrayRcpGen(const Teuchos_Ordinal n_in)
Definition ArrayConversions_UnitTest_helpers.hpp:75

ArrayUnitTestHelpers::n
int n
Definition Array_UnitTest_helpers.cpp:47

Teuchos::arrayViewPtrConv
void arrayViewPtrConv(const ArrayPtrT_in &a_in, const ArrayView< Ptr< T_out > > &a_out)
Utility function to convert from an an input Array[View,RCP]<[const] PTR<T_in> > object to an output ...
Definition Teuchos_ArrayConversions.hpp:63

Teuchos::as
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
Definition Teuchos_as.hpp:2840

Teuchos::implicit_ptr_cast
TypeTo * implicit_ptr_cast(TypeFrom *t)
Perform an implicit cast of pointer types with a pointer being returned.
Definition Teuchos_implicit_cast.hpp:150

Teuchos::arrayConstRcpConstCast
ArrayView< const RCP< const T > > arrayConstRcpConstCast(const ArrayView< const RCP< T > > &a_in)
Utility function that does a reinterpret case to convert an ArrayView<const RCP<T> > object to an Arr...
Definition Teuchos_ArrayConversions.hpp:171

Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Definition Teuchos_RCPDecl.hpp:1266

Teuchos::arrayPtrConv
Array< Ptr< T_out > > arrayPtrConv(const ArrayPtrT_in &a_in)
Utility function to convert an Array[View,RCP]<[const] PTR<T_in> > object to an Array<Ptr<T_out> > ob...
Definition Teuchos_ArrayConversions.hpp:116

Teuchos::arrayConstPtrConstCast
ArrayView< const Ptr< const T > > arrayConstPtrConstCast(const ArrayView< const Ptr< T > > &a_in)
Utility function that does a reinterpret case to convert an ArrayView<const Ptr<T> > object to an Arr...
Definition Teuchos_ArrayConversions.hpp:153

Teuchos::arrayViewRcpConv
void arrayViewRcpConv(const ArrayPtrT_in &a_in, const ArrayView< RCP< T_out > > &a_out)
Utility function to convert from an input Array[View,RCP]<[const] RCP<T_in> > object to an output Arr...
Definition Teuchos_ArrayConversions.hpp:81

Teuchos::arrayRcpConv
Array< RCP< T_out > > arrayRcpConv(const ArrayPtrT_in &a_in)
Utility function to convert any Array[View,RCP]<[const] RCP<T_in> > object to an Array<RCP<T_out> > o...
Definition Teuchos_ArrayConversions.hpp:132

Teuchos::ScalarTraits
This structure defines some basic traits for a scalar field type.
Definition Teuchos_ScalarTraitsDecl.hpp:91