From 8a2b72e5b6251025d05be37f226335ca6df6a909 Mon Sep 17 00:00:00 2001
From: Alberto Cabrera <alberto.cabrera@codeplay.com>
Date: Fri, 1 Nov 2024 14:30:53 +0000
Subject: [PATCH] Draft: Disabled checks, added verbosity, to trigger full log
 in the CI at the end of specific tests

Signed-off-by: Alberto Cabrera <alberto.cabrera@codeplay.com>
---
 .../test-e2e/syclcompat/math/math_compare.cpp | 109 ++++++++++--------
 sycl/test-e2e/syclcompat/math/math_fixt.hpp   |   9 +-
 sycl/test-e2e/syclcompat/math/math_ops.cpp    |  80 +++++++++----
 3 files changed, 123 insertions(+), 75 deletions(-)

diff --git a/sycl/test-e2e/syclcompat/math/math_compare.cpp b/sycl/test-e2e/syclcompat/math/math_compare.cpp
index 0f77160a564e7..cbc0a9177781b 100644
--- a/sycl/test-e2e/syclcompat/math/math_compare.cpp
+++ b/sycl/test-e2e/syclcompat/math/math_compare.cpp
@@ -96,15 +96,14 @@ void compare_not_equal_vec_kernel(Container *a, Container *b, Container *r) {
   *r = syclcompat::compare(*a, *b, std::not_equal_to<>());
 }
 
-template <template <typename T, int Dim> typename ContainerT,
-typename ValueT> void test_compare_vec() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_compare_vec() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   using Container = ContainerT<ValueT, 2>;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
-  const Container op1 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(2.0)};
+  const Container op1 = {static_cast<ValueT>(1.0), static_cast<ValueT>(2.0)};
   Container op2 = {static_cast<ValueT>(1.0),
                    sycl::nan(static_cast<unsigned int>(0))};
 
@@ -178,15 +177,15 @@ void unordered_compare_not_equal_vec_kernel(Container *a, Container *b,
   *r = syclcompat::unordered_compare(*a, *b, std::not_equal_to<>());
 }
 
-template <template <typename T, int Dim> typename ContainerT,
-typename ValueT> void test_unordered_compare_vec() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_unordered_compare_vec() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
+  std::cerr << __PRETTY_FUNCTION__ << std::endl;
   using Container = ContainerT<ValueT, 2>;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
-  const Container op1 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(2.0)};
+  const Container op1 = {static_cast<ValueT>(1.0), static_cast<ValueT>(2.0)};
   Container op2 = {static_cast<ValueT>(1.0),
                    sycl::nan(static_cast<unsigned int>(0))};
 
@@ -194,11 +193,31 @@ typename ValueT> void test_unordered_compare_vec() {
   // and false instead.
   //  1.0 == 1.0, 2.0 == NaN -> {true, true}
   const Container res1 = {1.0, 1.0};
+  std::cerr << "- 1.0 == 1.0, 2.0 == NaN -> {true, true}: " << std::endl;
+  std::cerr << "Op1: " << op1[0] << " " << op1[1] << std::endl;
+  std::cerr << "op2: " << op2[0] << " " << op2[1] << std::endl;
+  std::cerr << "Res: " << res1[0] << " " << res1[1] << std::endl;
+  std::cerr << "BitSet:    " << std::bitset<8 * sizeof(ValueT)>(op1[0]) << " "
+            << std::bitset<8 * sizeof(ValueT)>(op1[1]) << std::endl;
+  std::cerr << "BitSet2:   " << std::bitset<8 * sizeof(ValueT)>(op2[0]) << " "
+            << std::bitset<8 * sizeof(ValueT)>(op2[1]) << std::endl;
+  std::cerr << "ResBitset: " << std::bitset<8 * sizeof(ValueT)>(res1[0]) << " "
+            << std::bitset<8 * sizeof(ValueT)>(res1[1]) << std::endl;
   BinaryOpTestLauncher<Container, Container>(grid, threads)
       .template launch_test<unordered_compare_equal_vec_kernel<Container>>(
           op1, op2, res1);
   //  1.0 != 1.0, 2.0 != NaN -> {false, true}
   const Container res2 = {0.0, 1.0};
+  std::cerr << "- 1.0 != 1.0, 2.0 != NaN -> {false, true}: " << std::endl;
+  std::cerr << "Op1: " << op1[0] << " " << op1[1] << std::endl;
+  std::cerr << "op2: " << op2[0] << " " << op2[1] << std::endl;
+  std::cerr << "Res: " << res2[0] << " " << res2[1] << std::endl;
+  std::cerr << "BitSet:    " << std::bitset<8 * sizeof(ValueT)>(op1[0]) << " "
+            << std::bitset<8 * sizeof(ValueT)>(op1[1]) << std::endl;
+  std::cerr << "BitSet2:   " << std::bitset<8 * sizeof(ValueT)>(op2[0]) << " "
+            << std::bitset<8 * sizeof(ValueT)>(op2[1]) << std::endl;
+  std::cerr << "ResBitset: " << std::bitset<8 * sizeof(ValueT)>(res2[0]) << " "
+            << std::bitset<8 * sizeof(ValueT)>(res2[1]) << std::endl;
   BinaryOpTestLauncher<Container, Container>(grid, threads)
       .template launch_test<unordered_compare_not_equal_vec_kernel<Container>>(
           op1, op2, res2);
@@ -209,15 +228,14 @@ void compare_both_kernel(Container *a, Container *b, bool *r) {
   *r = syclcompat::compare_both(*a, *b, std::equal_to<>());
 }
 
-template <template <typename T, int Dim> typename ContainerT,
-typename ValueT> void test_compare_both() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_compare_both() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   using Container = ContainerT<ValueT, 2>;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
-  const Container op1 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(2.0)};
+  const Container op1 = {static_cast<ValueT>(1.0), static_cast<ValueT>(2.0)};
   Container op2 = {static_cast<ValueT>(1.0),
                    sycl::nan(static_cast<unsigned int>(0))};
 
@@ -239,15 +257,14 @@ void unordered_compare_both_kernel(Container *a, Container *b, bool *r) {
   *r = syclcompat::unordered_compare_both(*a, *b, std::equal_to<>());
 }
 
-template <template <typename T, int Dim> typename ContainerT,
-typename ValueT> void test_unordered_compare_both() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_unordered_compare_both() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   using Container = ContainerT<ValueT, 2>;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
-  const Container op1 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(2.0)};
+  const Container op1 = {static_cast<ValueT>(1.0), static_cast<ValueT>(2.0)};
   Container op2 = {static_cast<ValueT>(1.0),
                    sycl::nan(static_cast<unsigned int>(0))};
 
@@ -270,21 +287,17 @@ void compare_mask_kernel(Container *a, Container *b, unsigned *r) {
   *r = syclcompat::compare_mask(*a, *b, std::equal_to<>());
 }
 
-template <template <typename T, int Dim> typename ContainerT,
-typename ValueT> void test_compare_mask() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_compare_mask() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   using Container = ContainerT<ValueT, 2>;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
-  const Container op1 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(2.0)};
-  const Container op2 = {static_cast<ValueT>(2.0),
-                             static_cast<ValueT>(1.0)};
-  const Container op3 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(3.0)};
-  const Container op4 = {static_cast<ValueT>(3.0),
-                             static_cast<ValueT>(2.0)};
+  const Container op1 = {static_cast<ValueT>(1.0), static_cast<ValueT>(2.0)};
+  const Container op2 = {static_cast<ValueT>(2.0), static_cast<ValueT>(1.0)};
+  const Container op3 = {static_cast<ValueT>(1.0), static_cast<ValueT>(3.0)};
+  const Container op4 = {static_cast<ValueT>(3.0), static_cast<ValueT>(2.0)};
   Container op5 = {sycl::nan(static_cast<unsigned int>(0)),
                    sycl::nan(static_cast<unsigned int>(0))};
 
@@ -319,21 +332,17 @@ void unordered_compare_mask_kernel(Container *a, Container *b, unsigned *r) {
   *r = syclcompat::unordered_compare_mask(*a, *b, std::equal_to<>());
 }
 
-template <template <typename T, int Dim> typename ContainerT,
-typename ValueT> void test_unordered_compare_mask() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_unordered_compare_mask() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   using Container = ContainerT<ValueT, 2>;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
-  const Container op1 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(2.0)};
-  const Container op2 = {static_cast<ValueT>(2.0),
-                             static_cast<ValueT>(1.0)};
-  const Container op3 = {static_cast<ValueT>(1.0),
-                             static_cast<ValueT>(3.0)};
-  const Container op4 = {static_cast<ValueT>(3.0),
-                             static_cast<ValueT>(2.0)};
+  const Container op1 = {static_cast<ValueT>(1.0), static_cast<ValueT>(2.0)};
+  const Container op2 = {static_cast<ValueT>(2.0), static_cast<ValueT>(1.0)};
+  const Container op3 = {static_cast<ValueT>(1.0), static_cast<ValueT>(3.0)};
+  const Container op4 = {static_cast<ValueT>(3.0), static_cast<ValueT>(2.0)};
   Container op5 = {sycl::nan(static_cast<unsigned int>(0)),
                    sycl::nan(static_cast<unsigned int>(0))};
 
@@ -368,16 +377,24 @@ int main() {
   INSTANTIATE_ALL_TYPES(fp_type_list, test_unordered_compare);
   INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_compare_vec);
   INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_compare_vec);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_unordered_compare_vec);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_unordered_compare_vec);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec,
+                                  test_unordered_compare_vec);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_unordered_compare_vec);
   INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_compare_both);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_compare_both);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_unordered_compare_both);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_unordered_compare_both);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_compare_both);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec,
+                                  test_unordered_compare_both);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_unordered_compare_both);
   INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_compare_mask);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_compare_mask);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_unordered_compare_mask);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_unordered_compare_mask);
-
-  return 0;
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_compare_mask);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec,
+                                  test_unordered_compare_mask);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_unordered_compare_mask);
+
+  return 1;
 }
diff --git a/sycl/test-e2e/syclcompat/math/math_fixt.hpp b/sycl/test-e2e/syclcompat/math/math_fixt.hpp
index 4647142da6c61..d83fea2b83949 100644
--- a/sycl/test-e2e/syclcompat/math/math_fixt.hpp
+++ b/sycl/test-e2e/syclcompat/math/math_fixt.hpp
@@ -68,7 +68,7 @@ template <typename T, typename U> struct container_common_type<T, U> {
 template <typename T, typename U>
 using container_common_type_t = typename container_common_type<T, U>::type;
 
-template <typename ...ValueT> struct should_skip {
+template <typename... ValueT> struct should_skip {
   bool operator()(const sycl::device &dev) const {
     if constexpr ((std::is_same_v<ValueT, double> || ...) ||
                   (contained_is_same_v<ValueT, double> || ...)) {
@@ -173,8 +173,9 @@ class BinaryOpTestLauncher : OpTestLauncher {
     syclcompat::wait();
     syclcompat::memcpy<ResultT>(&res_h_, res_, data_size_);
 
-    CHECK(ResultT, res_h_, expected);
+    // CHECK(ResultT, res_h_, expected);
   };
+
   template <auto Kernel>
   void launch_test(ValueT op1, ValueU op2, ResultT expected, bool need_relu) {
     if (skip_)
@@ -185,7 +186,7 @@ class BinaryOpTestLauncher : OpTestLauncher {
     syclcompat::wait();
     syclcompat::memcpy<ResultT>(&res_h_, res_, data_size_);
 
-    CHECK(ResultT, res_h_, expected);
+    // CHECK(ResultT, res_h_, expected);
   };
   template <auto Kernel>
   void launch_test(ValueT op1, ValueU op2, ResultT expected, bool expected_hi,
@@ -202,7 +203,7 @@ class BinaryOpTestLauncher : OpTestLauncher {
     syclcompat::memcpy<bool>(&res_hi_h_, res_hi_, 1);
     syclcompat::memcpy<bool>(&res_lo_h_, res_lo_, 1);
 
-    CHECK(ResultT, res_h_, expected);
+    // CHECK(ResultT, res_h_, expected);
     assert(res_hi_h_ == expected_hi);
     assert(res_lo_h_ == expected_lo);
   };
diff --git a/sycl/test-e2e/syclcompat/math/math_ops.cpp b/sycl/test-e2e/syclcompat/math/math_ops.cpp
index baaa0f7f15210..23b30d029c795 100644
--- a/sycl/test-e2e/syclcompat/math/math_ops.cpp
+++ b/sycl/test-e2e/syclcompat/math/math_ops.cpp
@@ -54,7 +54,7 @@ void test_syclcompat_max() {
 template <typename ValueT, typename ValueU>
 inline void min_kernel(ValueT *a, ValueU *b,
                        std::common_type_t<ValueT, ValueU> *r) {
-  *r = syclcompat::min<ValueT,ValueU>(*a, *b);
+  *r = syclcompat::min<ValueT, ValueU>(*a, *b);
 }
 
 template <typename ValueT, typename ValueU = ValueT>
@@ -90,8 +90,7 @@ void test_syclcompat_fmin_nan() {
   const ValueU op2 = static_cast<ValueU>(10);
   ValueU op3 = sycl::nan(static_cast<unsigned int>(0));
 
-  const ValueTU res =
-      static_cast<ValueTU>(5);
+  const ValueTU res = static_cast<ValueTU>(5);
 
   BinaryOpTestLauncher<ValueT, ValueU>(grid, threads)
       .template launch_test<fmin_nan_kernel<ValueT, ValueU>>(op1, op2, res);
@@ -100,8 +99,9 @@ void test_syclcompat_fmin_nan() {
       .template launch_test<fmin_nan_kernel<ValueT, ValueU>>(op1, op3, op3);
 }
 
-template <template <typename T, int Dim> typename ContainerT, typename ValueT, typename ValueU = ValueT>
-void test_container_syclcompat_fmin_nan(){
+template <template <typename T, int Dim> typename ContainerT, typename ValueT,
+          typename ValueU = ValueT>
+void test_container_syclcompat_fmin_nan() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
 
   constexpr syclcompat::dim3 grid{1};
@@ -114,8 +114,10 @@ void test_container_syclcompat_fmin_nan(){
 
   const ContT op4 = {static_cast<ValueT>(5), static_cast<ValueT>(10)};
   const ContU op5 = {static_cast<ValueU>(10), static_cast<ValueU>(5)};
-  const ContU op6 = {sycl::nan(static_cast<unsigned int>(0)), sycl::nan(static_cast<unsigned int>(0))};
-  const ContTU op6_res = {sycl::nan(static_cast<unsigned int>(0)), sycl::nan(static_cast<unsigned int>(0))};
+  const ContU op6 = {sycl::nan(static_cast<unsigned int>(0)),
+                     sycl::nan(static_cast<unsigned int>(0))};
+  const ContTU op6_res = {sycl::nan(static_cast<unsigned int>(0)),
+                          sycl::nan(static_cast<unsigned int>(0))};
 
   const ContTU res2{static_cast<ValueTU>(5), static_cast<ValueTU>(5)};
 
@@ -144,8 +146,7 @@ void test_syclcompat_fmax_nan() {
   const ValueU op2 = static_cast<ValueU>(10);
   ValueU op3 = sycl::nan(static_cast<unsigned int>(0));
 
-  const ValueTU res =
-      static_cast<ValueTU>(10);
+  const ValueTU res = static_cast<ValueTU>(10);
 
   BinaryOpTestLauncher<ValueT, ValueU>(grid, threads)
       .template launch_test<fmax_nan_kernel<ValueT, ValueU>>(op1, op2, res);
@@ -154,9 +155,11 @@ void test_syclcompat_fmax_nan() {
       .template launch_test<fmax_nan_kernel<ValueT, ValueU>>(op1, op3, op3);
 }
 
-template <template <typename T, int Dim> typename ContainerT, typename ValueT, typename ValueU = ValueT>
-void test_container_syclcompat_fmax_nan(){
+template <template <typename T, int Dim> typename ContainerT, typename ValueT,
+          typename ValueU = ValueT>
+void test_container_syclcompat_fmax_nan() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
+  std::cerr << __PRETTY_FUNCTION__ << std::endl;
 
   constexpr syclcompat::dim3 grid{1};
   constexpr syclcompat::dim3 threads{1};
@@ -168,14 +171,33 @@ void test_container_syclcompat_fmax_nan(){
 
   const ContT op4 = {static_cast<ValueT>(5), static_cast<ValueT>(10)};
   const ContU op5 = {static_cast<ValueU>(10), static_cast<ValueU>(5)};
-  const ContU op6 = {sycl::nan(static_cast<unsigned int>(0)), sycl::nan(static_cast<unsigned int>(0))};
-  const ContTU op6_res = {sycl::nan(static_cast<unsigned int>(0)), sycl::nan(static_cast<unsigned int>(0))};
+  const ContU op6 = {sycl::nan(static_cast<unsigned int>(0)),
+                     sycl::nan(static_cast<unsigned int>(0))};
+  const ContTU op6_res = {sycl::nan(static_cast<unsigned int>(0)),
+                          sycl::nan(static_cast<unsigned int>(0))};
 
   const ContTU res2{static_cast<ValueTU>(10), static_cast<ValueTU>(10)};
 
+  std::cerr << "- First container test: " << std::endl;
+  std::cerr << "Op4: " << op4[0] << " " << op4[1] << std::endl;
+  std::cerr << "Op5: " << op5[0] << " " << op5[1] << std::endl;
+  std::cerr << "Res: " << res2[0] << " " << res2[1] << std::endl;
+  std::cerr << "BitSet:    " << std::bitset<8 * sizeof(ValueTU)>(op4[0]) << " "
+            << std::bitset<8 * sizeof(ValueTU)>(op4[1]) << std::endl;
+  std::cerr << "BitSet2:   " << std::bitset<8 * sizeof(ValueTU)>(op5[0]) << " "
+            << std::bitset<8 * sizeof(ValueTU)>(op5[1]) << std::endl;
+  std::cerr << "ResBitset: " << std::bitset<8 * sizeof(ValueTU)>(res2[0]) << " "
+            << std::bitset<8 * sizeof(ValueTU)>(res2[1]) << std::endl;
   BinaryOpTestLauncher<ContT, ContU>(grid, threads)
       .template launch_test<fmax_nan_kernel<ContT, ContU>>(op4, op5, res2);
 
+  std::cerr << "Second container test: " << std::endl;
+  std::cerr << "Op4: " << std::bitset<8 * sizeof(ValueTU)>(op4[0]) << " "
+            << std::bitset<8 * sizeof(ValueTU)>(op4[1]) << std::endl;
+  std::cerr << "Op6: " << std::bitset<8 * sizeof(ValueTU)>(op6[0]) << " "
+            << std::bitset<8 * sizeof(ValueTU)>(op6[1]) << std::endl;
+  std::cerr << "Res: " << std::bitset<8 * sizeof(ValueTU)>(op6_res[0]) << " "
+            << std::bitset<8 * sizeof(ValueTU)>(op6_res[1]) << std::endl;
   BinaryOpTestLauncher<ContT, ContU>(grid, threads)
       .template launch_test<fmax_nan_kernel<ContT, ContU>>(op4, op6, op6_res);
 }
@@ -267,8 +289,7 @@ template <typename ValueT> void test_syclcompat_cbrt() {
       .template launch_test<cbrt_kernel<ValueT>>(op2, res2);
 }
 
-template <typename T>
-void isnan_kernel(T *a, T *r) {
+template <typename T> void isnan_kernel(T *a, T *r) {
   *r = syclcompat::isnan(*a);
 }
 
@@ -319,7 +340,8 @@ template <typename ValueT> void test_clamp() {
       .template launch_test<clamp_kernel<ValueT>>(op3, expect3);
 }
 
-template <template <typename T, int Dim> typename ContainerT, typename ValueT> void test_container_clamp() {
+template <template <typename T, int Dim> typename ContainerT, typename ValueT>
+void test_container_clamp() {
   std::cout << __PRETTY_FUNCTION__ << std::endl;
 
   constexpr syclcompat::dim3 grid{1};
@@ -355,21 +377,27 @@ int main() {
 #endif
 
   INSTANTIATE_ALL_TYPES(fp_type_list, test_syclcompat_fmin_nan);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_container_syclcompat_fmin_nan);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_container_syclcompat_fmin_nan);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec,
+                                  test_container_syclcompat_fmin_nan);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_container_syclcompat_fmin_nan);
   test_syclcompat_fmin_nan<double, float>();
   test_container_syclcompat_fmin_nan<sycl::vec, float, double>();
 #ifdef SYCL_EXT_ONEAPI_BFLOAT16_MATH_FUNCTIONS
-  test_container_syclcompat_fmin_nan<sycl::vec, sycl::ext::oneapi::bfloat16, double>();
+  test_container_syclcompat_fmin_nan<sycl::vec, sycl::ext::oneapi::bfloat16,
+                                     double>();
 #endif
 
   INSTANTIATE_ALL_TYPES(fp_type_list, test_syclcompat_fmax_nan);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec, test_container_syclcompat_fmax_nan);
-  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_container_syclcompat_fmax_nan);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::vec,
+                                  test_container_syclcompat_fmax_nan);
+  INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray,
+                                  test_container_syclcompat_fmax_nan);
   test_syclcompat_fmax_nan<double, float>();
   test_container_syclcompat_fmax_nan<sycl::vec, float, double>();
 #ifdef SYCL_EXT_ONEAPI_BFLOAT16_MATH_FUNCTIONS
-  test_container_syclcompat_fmax_nan<sycl::vec, sycl::ext::oneapi::bfloat16, double>();
+  test_container_syclcompat_fmax_nan<sycl::vec, sycl::ext::oneapi::bfloat16,
+                                     double>();
 #endif
 
   INSTANTIATE_ALL_TYPES(value_type_list, test_syclcompat_pow);
@@ -383,8 +411,10 @@ int main() {
   INSTANTIATE_ALL_CONTAINER_TYPES(fp_type_list, sycl::marray, test_isnan);
 
   INSTANTIATE_ALL_TYPES(value_type_list, test_clamp);
-  INSTANTIATE_ALL_CONTAINER_TYPES(vec_type_list, sycl::vec, test_container_clamp);
-  INSTANTIATE_ALL_CONTAINER_TYPES(marray_type_list, sycl::marray, test_container_clamp);
+  INSTANTIATE_ALL_CONTAINER_TYPES(vec_type_list, sycl::vec,
+                                  test_container_clamp);
+  INSTANTIATE_ALL_CONTAINER_TYPES(marray_type_list, sycl::marray,
+                                  test_container_clamp);
 
-  return 0;
+  return 1; // INFO: Making it fail temporarily to trigger the CI log
 }