/*
//@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 Christian R. Trott (crtrott@sandia.gov)
//
// ************************************************************************
//@HEADER
*/

#include <gtest/gtest.h>

#include <stdexcept>
#include <sstream>
#include <iostream>
#include <time.h>

#include <Kokkos_Core.hpp>

namespace Test {

TEST_F( TEST_CATEGORY , view_layoutstride_left_to_layoutleft_assignment )
{
  typedef TEST_EXECSPACE exec_space ;

  auto t = time(0);
  srand(t);// Use current time as seed for random generator
  printf("view_layoutstride_left_to_layoutleft_assignment: srand(%lu)\n",size_t(t));

  { // Assignment of rank-1 LayoutLeft = LayoutStride
    int ndims = 1;
    int dims [] = {10};
    int order [] = {0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-2 LayoutLeft = LayoutStride
    int ndims = 2;
    int dims [] = {10,9};
    int order [] = {0,1};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);  
  
    Kokkos::View< double**, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double**, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double**, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-3 LayoutLeft = LayoutStride
    int ndims = 3;
    int dims [] = {10,9,8};
    int order [] = {0,1,2};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double***, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double***, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double***, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-4 LayoutLeft = LayoutStride
    int ndims = 4;
    int dims [] = {10,9,8,7};
    int order [] = {0,1,2,3};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double****, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double****, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-5 LayoutLeft = LayoutStride
    int ndims = 5;
    int dims [] = {10,9,8,7,6};
    int order [] = {0,1,2,3,4};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*****, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double*****, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-6 LayoutLeft = LayoutStride
    int ndims = 6;
    int dims [] = {10,9,8,7,6,5};
    int order [] = {0,1,2,3,4,5};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double******, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double******, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-7 LayoutLeft = LayoutStride
    int ndims = 7;
    int dims [] = {10,9,8,7,6,5,4};
    int order [] = {0,1,2,3,4,5,6};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*******, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double*******, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-8 LayoutLeft = LayoutStride
    int ndims = 8;
    int dims [] = {10,9,8,7,6,5,4,3};
    int order [] = {0,1,2,3,4,5,6,7};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double********, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double********, Kokkos::LayoutLeft, exec_space > dst = src;

    Kokkos::View< double********, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }

}

TEST_F( TEST_CATEGORY , view_layoutstride_right_to_layoutright_assignment )
{
  typedef TEST_EXECSPACE exec_space ;

  auto t = time(0);
  srand(t);// Use current time as seed for random generator
  printf("view_layoutstride_right_to_layoutright_assignment: srand(%lu)\n",size_t(t));

  { // Assignment of rank-1 LayoutRight = LayoutStride
    int ndims = 1;
    int dims [] = {10};
    int order [] = {0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double*, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-2 LayoutRight = LayoutStride
    int ndims = 2;
    int dims [] = {10,9};
    int order [] = {1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double**, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double**, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double**, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-3 LayoutRight = LayoutStride
    int ndims = 3;
    int dims [] = {10,9,8};
    int order [] = {2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double***, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double***, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double***, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-4 LayoutRight = LayoutStride
    int ndims = 4;
    int dims [] = {10,9,8,7};
    int order [] = {3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double****, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double****, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-5 LayoutRight = LayoutStride
    int ndims = 5;
    int dims [] = {10,9,8,7,6};
    int order [] = {4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*****, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double*****, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-6 LayoutRight = LayoutStride
    int ndims = 6;
    int dims [] = {10,9,8,7,6,5};
    int order [] = {5,4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double******, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double******, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-7 LayoutRight = LayoutStride
    int ndims = 7;
    int dims [] = {10,9,8,7,6,5,4};
    int order [] = {6,5,4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*******, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double*******, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-8 LayoutRight = LayoutStride
    int ndims = 8;
    int dims [] = {10,9,8,7,6,5,4,3};
    int order [] = {7,6,5,4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double********, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double********, Kokkos::LayoutRight, exec_space > dst = src;

    Kokkos::View< double********, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }

}

TEST_F( TEST_CATEGORY , view_layoutstride_right_to_layoutleft_assignment )
{
  typedef TEST_EXECSPACE exec_space ;

  auto t = time(0);
  srand(t);// Use current time as seed for random generator
  printf("view_layoutstride_right_to_layoutleft_assignment: srand(%lu)\n",size_t(t));

  { // Assignment of rank-1 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 1;
    int dims [] = {10};
    int order [] = {0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space > dst;
    
    dst = src;

    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-2 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 2;
    int dims [] = {10,9};
    int order [] = {1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double**, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-3 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 3;
    int dims [] = {10,9,8};
    int order [] = {2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double***, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-4 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 4;
    int dims [] = {10,9,8,7};
    int order [] = {3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double****, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-5 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 5;
    int dims [] = {10,9,8,7,6};
    int order [] = {4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*****, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-6 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 6;
    int dims [] = {10,9,8,7,6,5};
    int order [] = {5,4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double******, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-7 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 7;
    int dims [] = {10,9,8,7,6,5,4};
    int order [] = {6,5,4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double*******, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-8 LayoutLeft = LayoutStride (LayoutRight compatible)
    int ndims = 8;
    int dims [] = {10,9,8,7,6,5,4,3};
    int order [] = {7,6,5,4,3,2,1,0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double********, Kokkos::LayoutLeft, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }

}

TEST_F( TEST_CATEGORY , view_layoutstride_left_to_layoutright_assignment )
{
  typedef TEST_EXECSPACE exec_space ;

  auto t = time(0);
  srand(t);// Use current time as seed for random generator
  printf("view_layoutstride_left_to_layoutright_assignment: srand(%lu)\n",size_t(t));

  { // Assignment of rank-1 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 1;
    int dims [] = {10};
    int order [] = {0};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );

    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);

    Kokkos::deep_copy( src, h_src );

    Kokkos::View< double*, Kokkos::LayoutRight, exec_space > dst;
    
    dst = src;

    Kokkos::View< double*, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );

    Kokkos::deep_copy( h_dst, dst );

    bool test = true;
    for(size_t i=0; i<src.span();i++){
      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
    }
    ASSERT_EQ( dst.span(), src.span() );
    ASSERT_EQ( test, true );
  }
  { // Assignment of rank-2 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 2;
    int dims [] = {10,9};
    int order [] = {0,1};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double**, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-3 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 3;
    int dims [] = {10,9,8};
    int order [] = {0,1,2};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double***, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-4 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 4;
    int dims [] = {10,9,8,7};
    int order [] = {0,1,2,3};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double****, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-5 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 5;
    int dims [] = {10,9,8,7,6};
    int order [] = {0,1,2,3,4};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double*****, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-6 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 6;
    int dims [] = {10,9,8,7,6,5};
    int order [] = {0,1,2,3,4,5};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
	
    Kokkos::View< double******, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-7 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 7;
    int dims [] = {10,9,8,7,6,5,4};
    int order [] = {0,1,2,3,4,5,6};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double*******, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }
  { // Assignment of rank-8 LayoutRight = LayoutStride (LayoutLeft compatible)
    int ndims = 8;
    int dims [] = {10,9,8,7,6,5,4,3};
    int order [] = {0,1,2,3,4,5,6,7};
    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);

    Kokkos::View< double********, Kokkos::LayoutRight, exec_space > dst;

    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
  }

}

}