Turn unused aliases in tests into assertions

Several tests declared aliases that were used only in some builds, or
not used at all. Where the alias pointed at something worth checking,
the test now checks it:

- The xassign_traits aliases in test_xcomplex, test_xmath,
  test_xstrided_view and test_xview were only read under
  XTENSOR_USE_XSIMD. Without xsimd, simd_linear_assign() is always
  false, so the tests now assert that in an #else branch. The
  assign_traits2 check in test_xview expects false in both builds and
  no longer needs the #if. Note that test_xtensor_core_lib never
  defines XTENSOR_USE_XSIMD, even in an xsimd build.
- test_xview declared carr, a dynamic-rank column-major array, without
  using it. Add the check the column-major is_contiguous_view comment
  describes: such a view is not contiguous because implicit trailing
  all() slices may follow.
- test_xexpression only declared the strides aliases of a shared
  xfunction, one of them under a garbled name. Check that all four
  come from the shape type, as an xfunction has no strides of its own.

Also fix the remaining clang warnings in tests:

- test_xmath tested math::abs(char(1)). Plain char is unsigned on
  aarch64, so the line did not test a signed type there. Use
  signed char with a negative value.
- test_xexpression_holder moved a temporary into the holder, which
  prevents copy elision. Move a named holder instead, which still
  exercises the move constructor.
- test_xsort passed the axis as {0}. Pass 0.

Author: gouarin

test/test_xcomplex.cpp

@@ -137,6 +137,8 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         EXPECT_TRUE(assign_t_angle::simd_linear_assign());
+#else
+        EXPECT_FALSE(assign_t_angle::simd_linear_assign());
 #endif
 
         auto cmplres_conj = xt::conj(cmplarg_0);
@@ -155,6 +157,8 @@ namespace xt
         static_cast<void>(b1);
         static_cast<void>(b2);
         EXPECT_TRUE(assign_t_conj::simd_linear_assign());
+#else
+        EXPECT_FALSE(assign_t_conj::simd_linear_assign());
 #endif
 
         auto cmplres_norm = xt::norm(cmplarg_0);
@@ -168,6 +172,8 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         EXPECT_TRUE(assign_t_norm::simd_linear_assign());
+#else
+        EXPECT_FALSE(assign_t_norm::simd_linear_assign());
 #endif
 
         EXPECT_TRUE(allclose(fieldnorm, cmplres_norm));
@@ -196,6 +202,8 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         EXPECT_TRUE(assign_t_arg::simd_linear_assign());
+#else
+        EXPECT_FALSE(assign_t_arg::simd_linear_assign());
 #endif
     }
 

test/test_xexpression.cpp

@@ -102,13 +102,15 @@ namespace xt
         buffer << expr1;
         EXPECT_EQ(buffer.str(), "{{  2.,   4.,   6.,   8.},\n { 10.,  12.,  14.,  16.}}");
 
-        // Compilation test
+        // An xfunction has no strides of its own, so the shared expression
+        // derives all its strides types from its shape type.
         auto sexpr1 = make_xshared(std::move(expr1));
         using expr_type = decltype(sexpr1);
-        using strides_type = typename expr_type::strides_type;
-        using inner_strides_type = typename expr_type::inner_strides_type;
-        using backstrides_type = typename expr_type::backstrides_type;
-        using inner_strides_tybackstrides_typepe = typename expr_type::inner_backstrides_type;
+        using expected_strides_type = get_strides_type<expr_type::shape_type>::type;
+        EXPECT_TRUE((std::is_same<expr_type::strides_type, expected_strides_type>::value));
+        EXPECT_TRUE((std::is_same<expr_type::inner_strides_type, expected_strides_type>::value));
+        EXPECT_TRUE((std::is_same<expr_type::backstrides_type, expected_strides_type>::value));
+        EXPECT_TRUE((std::is_same<expr_type::inner_backstrides_type, expected_strides_type>::value));
     }
 
     TEST(xexpression, shared_expr_return)

test/test_xexpression_holder.cpp

@@ -24,7 +24,8 @@ namespace xt
 
         xexpression_holder holder_a = xexpression_holder(a);
         xexpression_holder holder_b(b);
-        xexpression_holder holder_c(std::move(xexpression_holder(c)));
+        xexpression_holder holder_tmp(c);
+        xexpression_holder holder_c(std::move(holder_tmp));
     }
 
     TEST(xexpression_holder, assign)

test/test_xmath.cpp

@@ -47,6 +47,8 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         EXPECT_TRUE(assign_traits::simd_linear_assign());
+#else
+        EXPECT_FALSE(assign_traits::simd_linear_assign());
 #endif
     }
 
@@ -743,7 +745,7 @@ namespace xt
         EXPECT_EQ(math::abs(1ul), 1ul);
         EXPECT_EQ(math::abs(1u), 1u);
         EXPECT_EQ(math::abs(static_cast<unsigned char>(1)), static_cast<unsigned char>(1));
-        EXPECT_EQ(math::abs(char(1)), 1);
+        EXPECT_EQ(math::abs(static_cast<signed char>(-1)), 1);
         EXPECT_EQ(math::abs(int(1)), 1);
         EXPECT_EQ(math::abs(int(-1)), 1);
         EXPECT_EQ(math::abs(long(-1)), long(1));

test/test_xsort.cpp

@@ -173,7 +173,7 @@ namespace xt
             47,  41,  40,  34,  33,  43,  64
         };
 
-        EXPECT_EQ(ex, xt::argsort(a, {0}, xt::sorting_method::stable));
+        EXPECT_EQ(ex, xt::argsort(a, 0, xt::sorting_method::stable));
     }
 
     TEST(xsort, sort_easy)

test/test_xstrided_view.cpp

@@ -691,6 +691,8 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         EXPECT_TRUE(assign_traits::simd_linear_assign());
+#else
+        EXPECT_FALSE(assign_traits::simd_linear_assign());
 #endif
 
         EXPECT_EQ(av, e);

test/test_xview.cpp

@@ -1360,6 +1360,7 @@ namespace xt
 
         EXPECT_TRUE((detail::is_contiguous_view<ctes, xall<int>, xall<int>, int, int>()));
         EXPECT_TRUE((detail::is_contiguous_view<cfix, xall<int>, xall<int>, int, int>()));
+        EXPECT_FALSE((detail::is_contiguous_view<carr, xall<int>, xall<int>, int, int>()));
         EXPECT_FALSE((detail::is_contiguous_view<xarr, xall<int>, xall<int>, int, int>()));
         EXPECT_TRUE((detail::is_contiguous_view<ctes, xall<int>, xall<int>, xrange<int>, int>()));
         EXPECT_FALSE((detail::is_contiguous_view<ctes, xall<int>, xrange<int>, xrange<int>, int>()));
@@ -1477,13 +1478,12 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
             EXPECT_TRUE(assign_traits::simd_linear_assign());
+#else
+            EXPECT_FALSE(assign_traits::simd_linear_assign());
 #endif
 
             using assign_traits2 = xassign_traits<decltype(b), decltype(vxa)>;
-
-#if XTENSOR_USE_XSIMD
             EXPECT_FALSE(assign_traits2::simd_linear_assign());
-#endif
         }
     }