/*
//@HEADER
// ************************************************************************
// 
//                        Kokkos v. 2.0
//              Copyright (2014) Sandia Corporation
// 
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
// 
// 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  H. Carter Edwards (hcedwar@sandia.gov)
// 
// ************************************************************************
//@HEADER
*/

#include <gtest/gtest.h>

#include <Kokkos_Core.hpp>
#include <stdexcept>
#include <sstream>
#include <iostream>

/*--------------------------------------------------------------------------*/


/*--------------------------------------------------------------------------*/

namespace Test {

#if KOKKOS_USING_EXP_VIEW

template< class T , class ... P >
size_t allocation_count( const Kokkos::View<T,P...> & view )
{
  const size_t card  = view.size();
  const size_t alloc = view.span();

  const int memory_span = Kokkos::View<int*>::required_allocation_size(100);

  return (card <= alloc && memory_span == 400) ? alloc : 0 ;
}

#else

template< class T , class L , class D , class M , class S >
size_t allocation_count( const Kokkos::View<T,L,D,M,S> & view )
{
  const size_t card  = Kokkos::Impl::cardinality_count( view.shape() );
  const size_t alloc = view.capacity();

  return card <= alloc ? alloc : 0 ;
}

#endif

/*--------------------------------------------------------------------------*/

template< typename T, class DeviceType>
struct TestViewOperator
{
  typedef typename DeviceType::execution_space  execution_space ;

  static const unsigned N = 100 ;
  static const unsigned D = 3 ;

  typedef Kokkos::View< T*[D] , execution_space > view_type ;

  const view_type v1 ;
  const view_type v2 ;

  TestViewOperator()
    : v1( "v1" , N )
    , v2( "v2" , N )
    {}

  static void testit()
  {
    Kokkos::parallel_for( N , TestViewOperator() );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const unsigned i ) const
  {
    const unsigned X = 0 ;
    const unsigned Y = 1 ;
    const unsigned Z = 2 ;

    v2(i,X) = v1(i,X);
    v2(i,Y) = v1(i,Y);
    v2(i,Z) = v1(i,Z);
  }
};

/*--------------------------------------------------------------------------*/

template< class DataType ,
          class DeviceType ,
          unsigned Rank = Kokkos::ViewTraits< DataType >::rank >
struct TestViewOperator_LeftAndRight ;

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 8 >
{
  typedef typename DeviceType::execution_space    execution_space ;
  typedef typename DeviceType::memory_space       memory_space ;
  typedef typename execution_space::size_type     size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;

  left_view    left ;
  right_view   right ;
  stride_view  left_stride ;
  stride_view  right_stride ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_stride( left )
    , right_stride( right )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i7 = 0 ; i7 < unsigned(left.dimension_7()) ; ++i7 )
    for ( unsigned i6 = 0 ; i6 < unsigned(left.dimension_6()) ; ++i6 )
    for ( unsigned i5 = 0 ; i5 < unsigned(left.dimension_5()) ; ++i5 )
    for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
    for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1, i2, i3, i4, i5, i6, i7 ) -
                     & left(  0,  0,  0,  0,  0,  0,  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;

      if ( & left(i0,i1,i2,i3,i4,i5,i6,i7) !=
           & left_stride(i0,i1,i2,i3,i4,i5,i6,i7) ) {
        update |= 4 ;
      }
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
    for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
    for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
    for ( unsigned i5 = 0 ; i5 < unsigned(right.dimension_5()) ; ++i5 )
    for ( unsigned i6 = 0 ; i6 < unsigned(right.dimension_6()) ; ++i6 )
    for ( unsigned i7 = 0 ; i7 < unsigned(right.dimension_7()) ; ++i7 )
    {
      const long j = & right( i0, i1, i2, i3, i4, i5, i6, i7 ) -
                     & right(  0,  0,  0,  0,  0,  0,  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;

      if ( & right(i0,i1,i2,i3,i4,i5,i6,i7) !=
           & right_stride(i0,i1,i2,i3,i4,i5,i6,i7) ) {
        update |= 8 ;
      }
    }
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 7 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  left_view    left ;
  right_view   right ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i6 = 0 ; i6 < unsigned(left.dimension_6()) ; ++i6 )
    for ( unsigned i5 = 0 ; i5 < unsigned(left.dimension_5()) ; ++i5 )
    for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
    for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1, i2, i3, i4, i5, i6 ) -
                     & left(  0,  0,  0,  0,  0,  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
    for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
    for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
    for ( unsigned i5 = 0 ; i5 < unsigned(right.dimension_5()) ; ++i5 )
    for ( unsigned i6 = 0 ; i6 < unsigned(right.dimension_6()) ; ++i6 )
    {
      const long j = & right( i0, i1, i2, i3, i4, i5, i6 ) -
                     & right(  0,  0,  0,  0,  0,  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;
    }
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 6 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  left_view    left ;
  right_view   right ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i5 = 0 ; i5 < unsigned(left.dimension_5()) ; ++i5 )
    for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
    for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1, i2, i3, i4, i5 ) -
                     & left(  0,  0,  0,  0,  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
    for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
    for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
    for ( unsigned i5 = 0 ; i5 < unsigned(right.dimension_5()) ; ++i5 )
    {
      const long j = & right( i0, i1, i2, i3, i4, i5 ) -
                     & right(  0,  0,  0,  0,  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;
    }
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 5 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;

  left_view    left ;
  right_view   right ;
  stride_view  left_stride ;
  stride_view  right_stride ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_stride( left )
    , right_stride( right )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
    for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1, i2, i3, i4 ) -
                     & left(  0,  0,  0,  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;

      if ( & left( i0, i1, i2, i3, i4 ) !=
           & left_stride( i0, i1, i2, i3, i4 ) ) { update |= 4 ; }
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
    for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
    for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
    {
      const long j = & right( i0, i1, i2, i3, i4 ) -
                     & right(  0,  0,  0,  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;

      if ( & right( i0, i1, i2, i3, i4 ) !=
           & right_stride( i0, i1, i2, i3, i4 ) ) { update |= 8 ; }
    }
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 4 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  left_view    left ;
  right_view   right ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1, i2, i3 ) -
                     & left(  0,  0,  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
    for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
    {
      const long j = & right( i0, i1, i2, i3 ) -
                     & right(  0,  0,  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;
    }
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 3 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;

  left_view    left ;
  right_view   right ;
  stride_view  left_stride ;
  stride_view  right_stride ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  std::string("left") )
    , right( std::string("right") )
    , left_stride( left )
    , right_stride( right )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1, i2 ) -
                     & left(  0,  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;

      if ( & left(i0,i1,i2) != & left_stride(i0,i1,i2) ) { update |= 4 ; }
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
    {
      const long j = & right( i0, i1, i2 ) -
                     & right(  0,  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;

      if ( & right(i0,i1,i2) != & right_stride(i0,i1,i2) ) { update |= 8 ; }
    }

#if KOKKOS_USING_EXP_VIEW
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
    {
      if ( & left(i0,i1,i2)  != & left(i0,i1,i2,0,0,0,0,0) )  { update |= 3 ; }
      if ( & right(i0,i1,i2) != & right(i0,i1,i2,0,0,0,0,0) ) { update |= 3 ; }
    }
#endif
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 2 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  left_view    left ;
  right_view   right ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    long offset ;

    offset = -1 ;
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
      const long j = & left( i0, i1 ) -
                     & left(  0,  0 );
      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
      offset = j ;
    }

    offset = -1 ;
    for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
    {
      const long j = & right( i0, i1 ) -
                     & right(  0,  0 );
      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
      offset = j ;
    }

#if KOKKOS_USING_EXP_VIEW
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
    {
      if ( & left(i0,i1)  != & left(i0,i1,0,0,0,0,0,0) )  { update |= 3 ; }
      if ( & right(i0,i1) != & right(i0,i1,0,0,0,0,0,0) ) { update |= 3 ; }
    }
#endif
  }
};

template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 1 >
{
  typedef typename DeviceType::execution_space  execution_space ;
  typedef typename DeviceType::memory_space     memory_space ;
  typedef typename execution_space::size_type   size_type ;

  typedef int value_type ;

  KOKKOS_INLINE_FUNCTION
  static void join( volatile value_type & update ,
                    const volatile value_type & input )
    { update |= input ; }

  KOKKOS_INLINE_FUNCTION
  static void init( value_type & update )
    { update = 0 ; }


  typedef Kokkos::
    View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutRight, execution_space > right_view ;

  typedef Kokkos::
    View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;

  left_view    left ;
  right_view   right ;
  stride_view  left_stride ;
  stride_view  right_stride ;
  long         left_alloc ;
  long         right_alloc ;

  TestViewOperator_LeftAndRight()
    : left(  "left" )
    , right( "right" )
    , left_stride( left )
    , right_stride( right )
    , left_alloc( allocation_count( left ) )
    , right_alloc( allocation_count( right ) )
    {}

  static void testit()
  {
    TestViewOperator_LeftAndRight driver ;

    int error_flag = 0 ;

    Kokkos::parallel_reduce( 1 , driver , error_flag );

    ASSERT_EQ( error_flag , 0 );
  }

  KOKKOS_INLINE_FUNCTION
  void operator()( const size_type , value_type & update ) const
  {
    for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
    {
#if KOKKOS_USING_EXP_VIEW
      if ( & left(i0)  != & left(i0,0,0,0,0,0,0,0) )  { update |= 3 ; }
      if ( & right(i0) != & right(i0,0,0,0,0,0,0,0) ) { update |= 3 ; }
#endif
      if ( & left(i0)  != & left_stride(i0) ) { update |= 4 ; }
      if ( & right(i0) != & right_stride(i0) ) { update |= 8 ; }
    }
  }
};

template<class Layout, class DeviceType>
struct TestViewMirror {

  template<class MemoryTraits>
  void static test_mirror() {
    Kokkos::View<double*, Layout, Kokkos::HostSpace> a_org("A",1000);
    Kokkos::View<double*, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
    auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(),a_h);
    auto a_d = Kokkos::create_mirror(DeviceType(),a_h);

    int equal_ptr_h_h2  = (a_h.data() ==a_h2.data())?1:0;
    int equal_ptr_h_d   = (a_h.data() ==a_d. data())?1:0;
    int equal_ptr_h2_d  = (a_h2.data()==a_d. data())?1:0;

    ASSERT_EQ(equal_ptr_h_h2,0);
    ASSERT_EQ(equal_ptr_h_d ,0);
    ASSERT_EQ(equal_ptr_h2_d,0);
    

    ASSERT_EQ(a_h.dimension_0(),a_h2.dimension_0());
    ASSERT_EQ(a_h.dimension_0(),a_d .dimension_0());
  }


  template<class MemoryTraits>
  void static test_mirror_view() {
    Kokkos::View<double*, Layout, Kokkos::HostSpace> a_org("A",1000);
    Kokkos::View<double*, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
    auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(),a_h);
    auto a_d = Kokkos::create_mirror_view(DeviceType(),a_h);

    int equal_ptr_h_h2  = a_h.data() ==a_h2.data()?1:0;
    int equal_ptr_h_d   = a_h.data() ==a_d. data()?1:0;
    int equal_ptr_h2_d  = a_h2.data()==a_d. data()?1:0;

    int is_same_memspace = std::is_same<Kokkos::HostSpace,typename DeviceType::memory_space>::value?1:0; 
    ASSERT_EQ(equal_ptr_h_h2,1);
    ASSERT_EQ(equal_ptr_h_d ,is_same_memspace);
    ASSERT_EQ(equal_ptr_h2_d ,is_same_memspace);


    ASSERT_EQ(a_h.dimension_0(),a_h2.dimension_0());
    ASSERT_EQ(a_h.dimension_0(),a_d .dimension_0());
  } 

  void static testit() {
    test_mirror<Kokkos::MemoryTraits<0>>();
    test_mirror<Kokkos::MemoryTraits<Kokkos::Unmanaged>>();
    test_mirror_view<Kokkos::MemoryTraits<0>>();
    test_mirror_view<Kokkos::MemoryTraits<Kokkos::Unmanaged>>();
  }
};

/*--------------------------------------------------------------------------*/

template< typename T, class DeviceType >
class TestViewAPI
{
public:
  typedef DeviceType        device ;

  enum { N0 = 1000 ,
         N1 = 3 ,
         N2 = 5 ,
         N3 = 7 };

  typedef Kokkos::View< T , device > dView0 ;
  typedef Kokkos::View< T* , device > dView1 ;
  typedef Kokkos::View< T*[N1] , device > dView2 ;
  typedef Kokkos::View< T*[N1][N2] , device > dView3 ;
  typedef Kokkos::View< T*[N1][N2][N3] , device > dView4 ;
  typedef Kokkos::View< const T*[N1][N2][N3] , device > const_dView4 ;

  typedef Kokkos::View< T****, device, Kokkos::MemoryUnmanaged > dView4_unmanaged ;

  typedef typename dView0::host_mirror_space host ;

  TestViewAPI()
  {
    run_test_mirror();
    run_test();
    run_test_scalar();
    run_test_const();
    run_test_subview();
    run_test_subview_strided();
    run_test_vector();

    TestViewOperator< T , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3][4][2][3][4][2][3] , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3][4][2][3][4][2] , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3][4][2][3][4] , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3][4][2][3] , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3][4][2] , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3][4] , device >::testit();
    TestViewOperator_LeftAndRight< int[2][3] , device >::testit();
    TestViewOperator_LeftAndRight< int[2] , device >::testit();
    TestViewMirror<Kokkos::LayoutLeft, device >::testit(); 
    TestViewMirror<Kokkos::LayoutRight, device >::testit(); 

  }

  static void run_test_mirror()
  {
    typedef Kokkos::View< int , host > view_type ;
    typedef typename view_type::HostMirror mirror_type ;

    static_assert( std::is_same< typename view_type::memory_space
                               , typename mirror_type::memory_space
                               >::value , "" );

    view_type a("a");
    mirror_type am = Kokkos::create_mirror_view(a);
    mirror_type ax = Kokkos::create_mirror(a);
    ASSERT_EQ( & a() , & am() );
  }

  static void run_test_scalar()
  {
    typedef typename dView0::HostMirror  hView0 ;

    dView0 dx , dy ;
    hView0 hx , hy ;

    dx = dView0( "dx" );
    dy = dView0( "dy" );

    hx = Kokkos::create_mirror( dx );
    hy = Kokkos::create_mirror( dy );

    hx() = 1 ;

    Kokkos::deep_copy( dx , hx );
    Kokkos::deep_copy( dy , dx );
    Kokkos::deep_copy( hy , dy );

    ASSERT_EQ( hx(), hy() );
  }

  static void run_test()
  {
    // mfh 14 Feb 2014: This test doesn't actually create instances of
    // these types.  In order to avoid "declared but unused typedef"
    // warnings, we declare empty instances of these types, with the
    // usual "(void)" marker to avoid compiler warnings for unused
    // variables.

    typedef typename dView0::HostMirror  hView0 ;
    typedef typename dView1::HostMirror  hView1 ;
    typedef typename dView2::HostMirror  hView2 ;
    typedef typename dView3::HostMirror  hView3 ;
    typedef typename dView4::HostMirror  hView4 ;

    {
      hView0 thing;
      (void) thing;
    }
    {
      hView1 thing;
      (void) thing;
    }
    {
      hView2 thing;
      (void) thing;
    }
    {
      hView3 thing;
      (void) thing;
    }
    {
      hView4 thing;
      (void) thing;
    }

    dView4 dx , dy , dz ;
    hView4 hx , hy , hz ;

    ASSERT_TRUE( dx.ptr_on_device() == 0 );
    ASSERT_TRUE( dy.ptr_on_device() == 0 );
    ASSERT_TRUE( dz.ptr_on_device() == 0 );
    ASSERT_TRUE( hx.ptr_on_device() == 0 );
    ASSERT_TRUE( hy.ptr_on_device() == 0 );
    ASSERT_TRUE( hz.ptr_on_device() == 0 );
    ASSERT_EQ( dx.dimension_0() , 0u );
    ASSERT_EQ( dy.dimension_0() , 0u );
    ASSERT_EQ( dz.dimension_0() , 0u );
    ASSERT_EQ( hx.dimension_0() , 0u );
    ASSERT_EQ( hy.dimension_0() , 0u );
    ASSERT_EQ( hz.dimension_0() , 0u );
    ASSERT_EQ( dx.dimension_1() , unsigned(N1) );
    ASSERT_EQ( dy.dimension_1() , unsigned(N1) );
    ASSERT_EQ( dz.dimension_1() , unsigned(N1) );
    ASSERT_EQ( hx.dimension_1() , unsigned(N1) );
    ASSERT_EQ( hy.dimension_1() , unsigned(N1) );
    ASSERT_EQ( hz.dimension_1() , unsigned(N1) );

    dx = dView4( "dx" , N0 );
    dy = dView4( "dy" , N0 );

    #if KOKKOS_USING_EXP_VIEW
    ASSERT_EQ( dx.use_count() , size_t(1) );
    #else
    ASSERT_EQ( dx.tracker().ref_count() , size_t(1) );
    #endif

    dView4_unmanaged unmanaged_dx = dx;
    #if KOKKOS_USING_EXP_VIEW
    ASSERT_EQ( dx.use_count() , size_t(1) );
    #else
    ASSERT_EQ( dx.tracker().ref_count() , size_t(1) );
    #endif

    dView4_unmanaged unmanaged_from_ptr_dx = dView4_unmanaged(dx.ptr_on_device(),
                                                              dx.dimension_0(),
                                                              dx.dimension_1(),
                                                              dx.dimension_2(),
                                                              dx.dimension_3());

    {
      // Destruction of this view should be harmless
      const_dView4 unmanaged_from_ptr_const_dx( dx.ptr_on_device() ,
                                                dx.dimension_0() ,
                                                dx.dimension_1() ,
                                                dx.dimension_2() ,
                                                dx.dimension_3() );
    }

    const_dView4 const_dx = dx ;
    #if KOKKOS_USING_EXP_VIEW
    ASSERT_EQ( dx.use_count() , size_t(2) );
    #else
    ASSERT_EQ( dx.tracker().ref_count() , size_t(2) );
    #endif

    {
      const_dView4 const_dx2;
      const_dx2 = const_dx;
      #if KOKKOS_USING_EXP_VIEW
      ASSERT_EQ( dx.use_count() , size_t(3) );
      #else
      ASSERT_EQ( dx.tracker().ref_count() , size_t(3) );
      #endif

      const_dx2 = dy;
      #if KOKKOS_USING_EXP_VIEW
      ASSERT_EQ( dx.use_count() , size_t(2) );
      #else
      ASSERT_EQ( dx.tracker().ref_count() , size_t(2) );
      #endif

      const_dView4 const_dx3(dx);
      #if KOKKOS_USING_EXP_VIEW
      ASSERT_EQ( dx.use_count() , size_t(3) );
      #else
      ASSERT_EQ( dx.tracker().ref_count() , size_t(3) );
      #endif
      
      dView4_unmanaged dx4_unmanaged(dx);
      #if KOKKOS_USING_EXP_VIEW
      ASSERT_EQ( dx.use_count() , size_t(3) );
      #else
      ASSERT_EQ( dx.tracker().ref_count() , size_t(3) );
      #endif
    }

    #if KOKKOS_USING_EXP_VIEW
    ASSERT_EQ( dx.use_count() , size_t(2) );
    #else
    ASSERT_EQ( dx.tracker().ref_count() , size_t(2) );
    #endif


    ASSERT_FALSE( dx.ptr_on_device() == 0 );
    ASSERT_FALSE( const_dx.ptr_on_device() == 0 );
    ASSERT_FALSE( unmanaged_dx.ptr_on_device() == 0 );
    ASSERT_FALSE( unmanaged_from_ptr_dx.ptr_on_device() == 0 );
    ASSERT_FALSE( dy.ptr_on_device() == 0 );
    ASSERT_NE( dx , dy );

    ASSERT_EQ( dx.dimension_0() , unsigned(N0) );
    ASSERT_EQ( dx.dimension_1() , unsigned(N1) );
    ASSERT_EQ( dx.dimension_2() , unsigned(N2) );
    ASSERT_EQ( dx.dimension_3() , unsigned(N3) );

    ASSERT_EQ( dy.dimension_0() , unsigned(N0) );
    ASSERT_EQ( dy.dimension_1() , unsigned(N1) );
    ASSERT_EQ( dy.dimension_2() , unsigned(N2) );
    ASSERT_EQ( dy.dimension_3() , unsigned(N3) );

    ASSERT_EQ( unmanaged_from_ptr_dx.capacity(),unsigned(N0)*unsigned(N1)*unsigned(N2)*unsigned(N3) );

    hx = Kokkos::create_mirror( dx );
    hy = Kokkos::create_mirror( dy );

    // T v1 = hx() ;    // Generates compile error as intended
    // T v2 = hx(0,0) ; // Generates compile error as intended
    // hx(0,0) = v2 ;   // Generates compile error as intended

#if ! KOKKOS_USING_EXP_VIEW
    // Testing with asynchronous deep copy with respect to device
    {
      size_t count = 0 ;
      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < hx.dimension_1() ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < hx.dimension_2() ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < hx.dimension_3() ; ++i3 ) {
        hx(ip,i1,i2,i3) = ++count ;
      }}}}


      Kokkos::deep_copy(typename hView4::execution_space(), dx , hx );
      Kokkos::deep_copy(typename hView4::execution_space(), dy , dx );
      Kokkos::deep_copy(typename hView4::execution_space(), hy , dy );

      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
        { ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
      }}}}

      Kokkos::deep_copy(typename hView4::execution_space(), dx , T(0) );
      Kokkos::deep_copy(typename hView4::execution_space(), hx , dx );

      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
        { ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
      }}}}
    }

    // Testing with asynchronous deep copy with respect to host
    {
      size_t count = 0 ;
      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < hx.dimension_1() ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < hx.dimension_2() ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < hx.dimension_3() ; ++i3 ) {
        hx(ip,i1,i2,i3) = ++count ;
      }}}}

      Kokkos::deep_copy(typename dView4::execution_space(), dx , hx );
      Kokkos::deep_copy(typename dView4::execution_space(), dy , dx );
      Kokkos::deep_copy(typename dView4::execution_space(), hy , dy );

      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
        { ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
      }}}}

      Kokkos::deep_copy(typename dView4::execution_space(), dx , T(0) );
      Kokkos::deep_copy(typename dView4::execution_space(), hx , dx );

      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
        { ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
      }}}}
    }
#endif /* #if ! KOKKOS_USING_EXP_VIEW */

    // Testing with synchronous deep copy
    {
      size_t count = 0 ;
      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < hx.dimension_1() ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < hx.dimension_2() ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < hx.dimension_3() ; ++i3 ) {
        hx(ip,i1,i2,i3) = ++count ;
      }}}}

      Kokkos::deep_copy( dx , hx );
      Kokkos::deep_copy( dy , dx );
      Kokkos::deep_copy( hy , dy );

      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
        { ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
      }}}}

      Kokkos::deep_copy( dx , T(0) );
      Kokkos::deep_copy( hx , dx );

      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
        { ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
      }}}}
    }
    dz = dx ; ASSERT_EQ( dx, dz); ASSERT_NE( dy, dz);
    dz = dy ; ASSERT_EQ( dy, dz); ASSERT_NE( dx, dz);

    dx = dView4();
    ASSERT_TRUE( dx.ptr_on_device() == 0 );
    ASSERT_FALSE( dy.ptr_on_device() == 0 );
    ASSERT_FALSE( dz.ptr_on_device() == 0 );
    dy = dView4();
    ASSERT_TRUE( dx.ptr_on_device() == 0 );
    ASSERT_TRUE( dy.ptr_on_device() == 0 );
    ASSERT_FALSE( dz.ptr_on_device() == 0 );
    dz = dView4();
    ASSERT_TRUE( dx.ptr_on_device() == 0 );
    ASSERT_TRUE( dy.ptr_on_device() == 0 );
    ASSERT_TRUE( dz.ptr_on_device() == 0 );
  }

  typedef T DataType[2] ;

  static void
  check_auto_conversion_to_const(
     const Kokkos::View< const DataType , device > & arg_const ,
     const Kokkos::View< DataType , device > & arg )
  {
    ASSERT_TRUE( arg_const == arg );
  }

  static void run_test_const()
  {
    typedef Kokkos::View< DataType , device > typeX ;
    typedef Kokkos::View< const DataType , device > const_typeX ;
    typedef Kokkos::View< const DataType , device , Kokkos::MemoryRandomAccess > const_typeR ;
    typeX x( "X" );
    const_typeX xc = x ;
    const_typeR xr = x ;

    ASSERT_TRUE( xc == x );
    ASSERT_TRUE( x == xc );

    // For CUDA the constant random access View does not return
    // an lvalue reference due to retrieving through texture cache
    // therefore not allowed to query the underlying pointer.
#if defined( KOKKOS_HAVE_CUDA )
    if ( ! std::is_same< typename device::execution_space , Kokkos::Cuda >::value )
#endif
    {
      ASSERT_TRUE( x.ptr_on_device() == xr.ptr_on_device() );
    }

    // typeX xf = xc ; // setting non-const from const must not compile

    check_auto_conversion_to_const( x , x );
  }

  static void run_test_subview()
  {
    typedef Kokkos::View< const T , device > sView ;

    dView0 d0( "d0" );
    dView1 d1( "d1" , N0 );
    dView2 d2( "d2" , N0 );
    dView3 d3( "d3" , N0 );
    dView4 d4( "d4" , N0 );

    sView s0 = d0 ;
    sView s1 = Kokkos::subview( d1 , 1 );
    sView s2 = Kokkos::subview( d2 , 1 , 1 );
    sView s3 = Kokkos::subview( d3 , 1 , 1 , 1 );
    sView s4 = Kokkos::subview( d4 , 1 , 1 , 1 , 1 );
  }

  static void run_test_subview_strided()
  {
    typedef Kokkos::View< int **** , Kokkos::LayoutLeft  , host >  view_left_4 ;
    typedef Kokkos::View< int **** , Kokkos::LayoutRight , host >  view_right_4 ;
    typedef Kokkos::View< int **   , Kokkos::LayoutLeft  , host >  view_left_2 ;
    typedef Kokkos::View< int **   , Kokkos::LayoutRight , host >  view_right_2 ;

    typedef Kokkos::View< int * ,  Kokkos::LayoutStride , host >  view_stride_1 ;
    typedef Kokkos::View< int ** ,  Kokkos::LayoutStride , host >  view_stride_2 ;

    view_left_2  xl2("xl2", 100 , 200 );
    view_right_2 xr2("xr2", 100 , 200 );
    view_stride_1  yl1 = Kokkos::subview( xl2 , 0 , Kokkos::ALL() );
    view_stride_1  yl2 = Kokkos::subview( xl2 , 1 , Kokkos::ALL() );
    view_stride_1  yr1 = Kokkos::subview( xr2 , 0 , Kokkos::ALL() );
    view_stride_1  yr2 = Kokkos::subview( xr2 , 1 , Kokkos::ALL() );

    ASSERT_EQ( yl1.dimension_0() , xl2.dimension_1() );
    ASSERT_EQ( yl2.dimension_0() , xl2.dimension_1() );
    ASSERT_EQ( yr1.dimension_0() , xr2.dimension_1() );
    ASSERT_EQ( yr2.dimension_0() , xr2.dimension_1() );

    ASSERT_EQ( & yl1(0) - & xl2(0,0) , 0 );
    ASSERT_EQ( & yl2(0) - & xl2(1,0) , 0 );
    ASSERT_EQ( & yr1(0) - & xr2(0,0) , 0 );
    ASSERT_EQ( & yr2(0) - & xr2(1,0) , 0 );

    view_left_4 xl4( "xl4" , 10 , 20 , 30 , 40 );
    view_right_4 xr4( "xr4" , 10 , 20 , 30 , 40 );

    view_stride_2 yl4 = Kokkos::subview( xl4 , 1 , Kokkos::ALL() , 2 , Kokkos::ALL() );
    view_stride_2 yr4 = Kokkos::subview( xr4 , 1 , Kokkos::ALL() , 2 , Kokkos::ALL() );

    ASSERT_EQ( yl4.dimension_0() , xl4.dimension_1() );
    ASSERT_EQ( yl4.dimension_1() , xl4.dimension_3() );
    ASSERT_EQ( yr4.dimension_0() , xr4.dimension_1() );
    ASSERT_EQ( yr4.dimension_1() , xr4.dimension_3() );

    ASSERT_EQ( & yl4(4,4) - & xl4(1,4,2,4) , 0 );
    ASSERT_EQ( & yr4(4,4) - & xr4(1,4,2,4) , 0 );
  }

  static void run_test_vector()
  {
    static const unsigned Length = 1000 , Count = 8 ;

    typedef Kokkos::View< T* ,  Kokkos::LayoutLeft , host > vector_type ;
    typedef Kokkos::View< T** , Kokkos::LayoutLeft , host > multivector_type ;

    typedef Kokkos::View< T* ,  Kokkos::LayoutRight , host > vector_right_type ;
    typedef Kokkos::View< T** , Kokkos::LayoutRight , host > multivector_right_type ;

    typedef Kokkos::View< const T* , Kokkos::LayoutRight, host > const_vector_right_type ;
    typedef Kokkos::View< const T* , Kokkos::LayoutLeft , host > const_vector_type ;
    typedef Kokkos::View< const T** , Kokkos::LayoutLeft , host > const_multivector_type ;

    multivector_type mv = multivector_type( "mv" , Length , Count );
    multivector_right_type mv_right = multivector_right_type( "mv" , Length , Count );

    vector_type v1 = Kokkos::subview( mv , Kokkos::ALL() , 0 );
    vector_type v2 = Kokkos::subview( mv , Kokkos::ALL() , 1 );
    vector_type v3 = Kokkos::subview( mv , Kokkos::ALL() , 2 );

    vector_type rv1 = Kokkos::subview( mv_right , 0 , Kokkos::ALL() );
    vector_type rv2 = Kokkos::subview( mv_right , 1 , Kokkos::ALL() );
    vector_type rv3 = Kokkos::subview( mv_right , 2 , Kokkos::ALL() );

    multivector_type mv1 = Kokkos::subview( mv , std::make_pair( 1 , 998 ) ,
                                                 std::make_pair( 2 , 5 ) );

    multivector_right_type mvr1 =
      Kokkos::subview( mv_right ,
                       std::make_pair( 1 , 998 ) ,
                       std::make_pair( 2 , 5 ) );

    const_vector_type cv1 = Kokkos::subview( mv , Kokkos::ALL(), 0 );
    const_vector_type cv2 = Kokkos::subview( mv , Kokkos::ALL(), 1 );
    const_vector_type cv3 = Kokkos::subview( mv , Kokkos::ALL(), 2 );

    vector_right_type vr1 = Kokkos::subview( mv , Kokkos::ALL() , 0 );
    vector_right_type vr2 = Kokkos::subview( mv , Kokkos::ALL() , 1 );
    vector_right_type vr3 = Kokkos::subview( mv , Kokkos::ALL() , 2 );

    const_vector_right_type cvr1 = Kokkos::subview( mv , Kokkos::ALL() , 0 );
    const_vector_right_type cvr2 = Kokkos::subview( mv , Kokkos::ALL() , 1 );
    const_vector_right_type cvr3 = Kokkos::subview( mv , Kokkos::ALL() , 2 );

    ASSERT_TRUE( & v1[0] == & v1(0) );
    ASSERT_TRUE( & v1[0] == & mv(0,0) );
    ASSERT_TRUE( & v2[0] == & mv(0,1) );
    ASSERT_TRUE( & v3[0] == & mv(0,2) );

    ASSERT_TRUE( & cv1[0] == & mv(0,0) );
    ASSERT_TRUE( & cv2[0] == & mv(0,1) );
    ASSERT_TRUE( & cv3[0] == & mv(0,2) );

    ASSERT_TRUE( & vr1[0] == & mv(0,0) );
    ASSERT_TRUE( & vr2[0] == & mv(0,1) );
    ASSERT_TRUE( & vr3[0] == & mv(0,2) );

    ASSERT_TRUE( & cvr1[0] == & mv(0,0) );
    ASSERT_TRUE( & cvr2[0] == & mv(0,1) );
    ASSERT_TRUE( & cvr3[0] == & mv(0,2) );

    ASSERT_TRUE( & mv1(0,0) == & mv( 1 , 2 ) );
    ASSERT_TRUE( & mv1(1,1) == & mv( 2 , 3 ) );
    ASSERT_TRUE( & mv1(3,2) == & mv( 4 , 4 ) );
    ASSERT_TRUE( & mvr1(0,0) == & mv_right( 1 , 2 ) );
    ASSERT_TRUE( & mvr1(1,1) == & mv_right( 2 , 3 ) );
    ASSERT_TRUE( & mvr1(3,2) == & mv_right( 4 , 4 ) );

    const_vector_type c_cv1( v1 );
    typename vector_type::const_type c_cv2( v2 );
    typename const_vector_type::const_type c_ccv2( v2 );

    const_multivector_type cmv( mv );
    typename multivector_type::const_type cmvX( cmv );
    typename const_multivector_type::const_type ccmvX( cmv );
  }
};

} // namespace Test

/*--------------------------------------------------------------------------*/

