From 26f3c871bb4c0c058d3697f63def61f832a2ace0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thomas=20Gr=C3=BCtzmacher?= <thomas.gruetzmacher@kit.edu>
Date: Mon, 8 Apr 2024 18:34:10 +0200
Subject: [PATCH] Simplify the testing types

Add template type functions to combine and merge type lists.
As a result, the GINKGO_DPCPP_SINGLE_MODE only needs to be present once.

Additionally, change the typen name ValueAndIndexType to ComplexAndPODTypes
(because gko::size_type is not an IndexType).
---
 core/test/base/array.cpp                      |   2 +-
 core/test/base/iterator_factory.cpp           |   2 +-
 core/test/utils.hpp                           | 256 ++++++++++--------
 core/test/utils/CMakeLists.txt                |   1 +
 core/test/utils/utils_test.cpp                | 202 ++++++++++++++
 cuda/test/base/array.cpp                      |   2 +-
 reference/test/base/array.cpp                 |   2 +-
 .../test/components/fill_array_kernels.cpp    |   2 +-
 .../test/components/reduce_array_kernels.cpp  |   2 +-
 test/components/fill_array_kernels.cpp        |   2 +-
 test/components/reduce_array_kernels.cpp      |   2 +-
 11 files changed, 347 insertions(+), 128 deletions(-)
 create mode 100644 core/test/utils/utils_test.cpp

diff --git a/core/test/base/array.cpp b/core/test/base/array.cpp
index 59b1ef177f3..2f694364472 100644
--- a/core/test/base/array.cpp
+++ b/core/test/base/array.cpp
@@ -45,7 +45,7 @@ class Array : public ::testing::Test {
     gko::array<T> x;
 };
 
-TYPED_TEST_SUITE(Array, gko::test::ValueAndIndexTypes, TypenameNameGenerator);
+TYPED_TEST_SUITE(Array, gko::test::ComplexAndPODTypes, TypenameNameGenerator);
 
 
 TYPED_TEST(Array, CanBeCreatedWithoutAnExecutor)
diff --git a/core/test/base/iterator_factory.cpp b/core/test/base/iterator_factory.cpp
index d113f3198f4..0b50cd35558 100644
--- a/core/test/base/iterator_factory.cpp
+++ b/core/test/base/iterator_factory.cpp
@@ -366,7 +366,7 @@ class PermuteIterator : public ::testing::Test {
     using value_type = ValueType;
 };
 
-TYPED_TEST_SUITE(PermuteIterator, gko::test::ValueAndIndexTypes,
+TYPED_TEST_SUITE(PermuteIterator, gko::test::ComplexAndPODTypes,
                  TypenameNameGenerator);
 
 
diff --git a/core/test/utils.hpp b/core/test/utils.hpp
index c6ce7c273d1..da7394b996d 100644
--- a/core/test/utils.hpp
+++ b/core/test/utils.hpp
@@ -32,154 +32,170 @@
 
 namespace gko {
 namespace test {
+namespace detail {
 
 
-using ValueTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<float, std::complex<float>>;
-#else
-    ::testing::Types<float, double, std::complex<float>, std::complex<double>>;
-#endif
+template <typename LeftList, typename RightList, typename... Result>
+struct combine_types {};
 
-using ComplexValueTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<std::complex<float>>;
-#else
-    ::testing::Types<std::complex<float>, std::complex<double>>;
-#endif
+template <template <typename...> class OuterWrapper, typename FirstLeft,
+          typename... RemainingLeftArgs, typename... RightArgs,
+          typename... Result>
+struct combine_types<OuterWrapper<FirstLeft, RemainingLeftArgs...>,
+                     OuterWrapper<RightArgs...>, Result...>
+    : combine_types<OuterWrapper<RemainingLeftArgs...>,
+                    OuterWrapper<RightArgs...>, Result...,
+                    std::tuple<FirstLeft, RightArgs>...> {};
 
-using RealValueTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<float>;
-#else
-    ::testing::Types<float, double>;
-#endif
+template <template <typename...> class OuterWrapper, typename... RightArgs,
+          typename... Result>
+struct combine_types<OuterWrapper<>, OuterWrapper<RightArgs...>, Result...> {
+    using type = OuterWrapper<Result...>;
+};
 
+template <typename ExistingCombinationList, typename NewElementList,
+          typename... Result>
+struct add_combination {};
+
+template <template <typename...> class OuterWrapper,
+          typename... CurrentCombinationArgs,
+          typename... RemainingOldCombinations, typename... NewElementArgs,
+          typename... Result>
+struct add_combination<OuterWrapper<std::tuple<CurrentCombinationArgs...>,
+                                    RemainingOldCombinations...>,
+                       OuterWrapper<NewElementArgs...>, Result...>
+    : add_combination<
+          OuterWrapper<RemainingOldCombinations...>,
+          OuterWrapper<NewElementArgs...>, Result...,
+          std::tuple<CurrentCombinationArgs..., NewElementArgs>...> {};
+
+template <template <typename...> class OuterWrapper, typename... NewElementArgs,
+          typename... Result>
+struct add_combination<OuterWrapper<>, OuterWrapper<NewElementArgs...>,
+                       Result...> {
+    using type = OuterWrapper<Result...>;
+};
 
-using IndexTypes = ::testing::Types<gko::int32, gko::int64>;
+template <typename NewElementList, typename ExistingCombinationList,
+          typename... Result>
+struct add_combination_left {};
+
+template <template <typename...> class OuterWrapper, typename... NewElementArgs,
+          typename... CurrentCombinationArgs,
+          typename... RemainingOldCombinations, typename... Result>
+struct add_combination_left<OuterWrapper<NewElementArgs...>,
+                            OuterWrapper<std::tuple<CurrentCombinationArgs...>,
+                                         RemainingOldCombinations...>,
+                            Result...>
+    : add_combination_left<
+          OuterWrapper<NewElementArgs...>,
+          OuterWrapper<RemainingOldCombinations...>, Result...,
+          std::tuple<NewElementArgs, CurrentCombinationArgs...>...> {};
+
+template <template <typename...> class OuterWrapper, typename... NewElementArgs,
+          typename... Result>
+struct add_combination_left<OuterWrapper<NewElementArgs...>, OuterWrapper<>,
+                            Result...> {
+    using type = OuterWrapper<Result...>;
+};
 
+template <typename FirstList, typename SecondList>
+struct merge_type_list {};
 
-using LocalGlobalIndexTypes =
-    ::testing::Types<std::tuple<int32, int32>, std::tuple<int32, int64>,
-                     std::tuple<int64, int64>>;
+template <template <typename...> class OuterWrapper, typename... Args1,
+          typename... Args2>
+struct merge_type_list<OuterWrapper<Args1...>, OuterWrapper<Args2...>> {
+    using type = OuterWrapper<Args1..., Args2...>;
+};
 
 
-using PODTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<float, gko::int32, gko::int64>;
-#else
-    ::testing::Types<float, double, gko::int32, gko::int64>;
-#endif
+template <template <typename...> class NewOuterWrapper,
+          typename OldOuterWrapper>
+struct change_outer_wrapper {};
 
+template <template <typename...> class NewOuterWrapper,
+          template <typename...> class OldOuterWrapper, typename... Args>
+struct change_outer_wrapper<NewOuterWrapper, OldOuterWrapper<Args...>> {
+    using type = NewOuterWrapper<Args...>;
+};
 
-using ValueAndIndexTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<float, std::complex<float>, gko::int32, gko::int64,
-                     gko::size_type>;
-#else
-    ::testing::Types<float, double, std::complex<float>, std::complex<double>,
-                     gko::int32, gko::int64, gko::size_type>;
-#endif
 
+template <template <typename...> class NewInnerWrapper, typename ListType>
+struct add_internal_wrapper {};
 
-using RealValueAndIndexTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<float, gko::int32, gko::int64, gko::size_type>;
-#else
-    ::testing::Types<float, double, gko::int32, gko::int64, gko::size_type>;
-#endif
+template <template <typename...> class NewInnerWrapper,
+          template <typename...> class OuterWrapper, typename... Args>
+struct add_internal_wrapper<NewInnerWrapper, OuterWrapper<Args...>> {
+    using type = OuterWrapper<NewInnerWrapper<Args>...>;
+};
 
 
-using ValueIndexTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<std::tuple<float, gko::int32>,
-                     std::tuple<std::complex<float>, gko::int32>,
-                     std::tuple<float, gko::int64>,
-                     std::tuple<std::complex<float>, gko::int64>>;
-#else
-    ::testing::Types<
-        std::tuple<float, gko::int32>, std::tuple<double, gko::int32>,
-        std::tuple<std::complex<float>, gko::int32>,
-        std::tuple<std::complex<double>, gko::int32>,
-        std::tuple<float, gko::int64>, std::tuple<double, gko::int64>,
-        std::tuple<std::complex<float>, gko::int64>,
-        std::tuple<std::complex<double>, gko::int64>>;
-#endif
+}  // namespace detail
 
 
-using RealValueIndexTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<std::tuple<float, gko::int32>,
-                     std::tuple<float, gko::int64>>;
-#else
-    ::testing::Types<
-        std::tuple<float, gko::int32>, std::tuple<double, gko::int32>,
-        std::tuple<float, gko::int64>, std::tuple<double, gko::int64>>;
-#endif
+template <typename LeftList, typename RightList>
+using combine_types_t =
+    typename detail::combine_types<LeftList, RightList>::type;
 
+template <typename ExistingCombinationList, typename NewElementList>
+using add_combination_t =
+    typename detail::add_combination<ExistingCombinationList,
+                                     NewElementList>::type;
 
-using ComplexValueIndexTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<std::tuple<std::complex<float>, gko::int32>,
-                     std::tuple<std::complex<float>, gko::int64>>;
-#else
-    ::testing::Types<std::tuple<std::complex<float>, gko::int32>,
-                     std::tuple<std::complex<double>, gko::int32>,
-                     std::tuple<std::complex<float>, gko::int64>,
-                     std::tuple<std::complex<double>, gko::int64>>;
-#endif
+template <typename NewElementList, typename ExistingCombinationList>
+using add_combination_left_t =
+    typename detail::add_combination_left<NewElementList,
+                                          ExistingCombinationList>::type;
+
+template <typename FirstList, typename SecondList>
+using merge_type_list_t =
+    typename detail::merge_type_list<FirstList, SecondList>::type;
+
+template <template <typename...> class NewInnerWrapper, typename ListType>
+using add_internal_wrapper_t =
+    typename detail::add_internal_wrapper<NewInnerWrapper, ListType>::type;
+
+template <template <typename...> class NewOuterWrapper, typename ListType>
+using change_outer_wrapper_t =
+    typename detail::change_outer_wrapper<NewOuterWrapper, ListType>::type;
 
 
-using TwoValueIndexType =
+using RealValueTypes =
 #if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<
-        std::tuple<float, float, gko::int32>,
-        std::tuple<std::complex<float>, std::complex<float>, gko::int32>,
-        std::tuple<float, float, gko::int64>,
-        std::tuple<std::complex<float>, std::complex<float>, gko::int64>>;
+    ::testing::Types<float>;
 #else
-    ::testing::Types<
-        std::tuple<float, float, gko::int32>,
-        std::tuple<float, double, gko::int32>,
-        std::tuple<double, double, gko::int32>,
-        std::tuple<double, float, gko::int32>,
-        std::tuple<std::complex<float>, std::complex<float>, gko::int32>,
-        std::tuple<std::complex<float>, std::complex<double>, gko::int32>,
-        std::tuple<std::complex<double>, std::complex<double>, gko::int32>,
-        std::tuple<std::complex<double>, std::complex<float>, gko::int32>,
-        std::tuple<float, float, gko::int64>,
-        std::tuple<float, double, gko::int64>,
-        std::tuple<double, double, gko::int64>,
-        std::tuple<double, float, gko::int64>,
-        std::tuple<std::complex<float>, std::complex<float>, gko::int64>,
-        std::tuple<std::complex<float>, std::complex<double>, gko::int64>,
-        std::tuple<std::complex<double>, std::complex<double>, gko::int64>,
-        std::tuple<std::complex<double>, std::complex<float>, gko::int64>>;
+    ::testing::Types<float, double>;
 #endif
 
+using ComplexValueTypes = add_internal_wrapper_t<std::complex, RealValueTypes>;
+
+using ValueTypes = merge_type_list_t<RealValueTypes, ComplexValueTypes>;
+
+using IndexTypes = ::testing::Types<int32, int64>;
+
+using LocalGlobalIndexTypes =
+    ::testing::Types<std::tuple<int32, int32>, std::tuple<int32, int64>,
+                     std::tuple<int64, int64>>;
+
+using PODTypes =
+    merge_type_list_t<merge_type_list_t<RealValueTypes, IndexTypes>,
+                      ::testing::Types<size_type>>;
+
+using ComplexAndPODTypes = merge_type_list_t<ComplexValueTypes, PODTypes>;
+
+using ValueIndexTypes = combine_types_t<ValueTypes, IndexTypes>;
+
+using RealValueIndexTypes = combine_types_t<RealValueTypes, IndexTypes>;
+
+using ComplexValueIndexTypes = combine_types_t<ComplexValueTypes, IndexTypes>;
+
+using TwoValueIndexType = add_combination_t<
+    merge_type_list_t<combine_types_t<RealValueTypes, RealValueTypes>,
+                      combine_types_t<ComplexValueTypes, ComplexValueTypes>>,
+    IndexTypes>;
 
 using ValueLocalGlobalIndexTypes =
-#if GINKGO_DPCPP_SINGLE_MODE
-    ::testing::Types<std::tuple<float, gko::int32, int32>,
-                     std::tuple<float, gko::int32, int64>,
-                     std::tuple<float, gko::int64, int64>,
-                     std::tuple<std::complex<float>, gko::int32, int32>,
-                     std::tuple<std::complex<float>, gko::int32, int64>,
-                     std::tuple<std::complex<float>, gko::int64, int64>>;
-#else
-    ::testing::Types<std::tuple<float, gko::int32, int32>,
-                     std::tuple<float, gko::int32, int64>,
-                     std::tuple<float, gko::int64, int64>,
-                     std::tuple<double, gko::int32, int32>,
-                     std::tuple<double, gko::int32, int64>,
-                     std::tuple<double, gko::int64, int64>,
-                     std::tuple<std::complex<float>, gko::int32, int32>,
-                     std::tuple<std::complex<float>, gko::int32, int64>,
-                     std::tuple<std::complex<float>, gko::int64, int64>,
-                     std::tuple<std::complex<double>, gko::int32, int32>,
-                     std::tuple<std::complex<double>, gko::int32, int64>,
-                     std::tuple<std::complex<double>, gko::int64, int64>>;
-#endif
+    add_combination_left_t<ValueTypes, LocalGlobalIndexTypes>;
 
 
 template <typename Precision, typename OutputType>
diff --git a/core/test/utils/CMakeLists.txt b/core/test/utils/CMakeLists.txt
index 88c61456280..af6de8ad1a3 100644
--- a/core/test/utils/CMakeLists.txt
+++ b/core/test/utils/CMakeLists.txt
@@ -1,3 +1,4 @@
+ginkgo_create_test(utils_test)
 ginkgo_create_test(array_generator_test)
 ginkgo_create_test(assertions_test)
 ginkgo_create_test(matrix_generator_test)
diff --git a/core/test/utils/utils_test.cpp b/core/test/utils/utils_test.cpp
new file mode 100644
index 00000000000..47f3601a396
--- /dev/null
+++ b/core/test/utils/utils_test.cpp
@@ -0,0 +1,202 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <complex>
+#include <tuple>
+#include <type_traits>
+
+
+#include <gtest/gtest.h>
+
+
+#include "core/test/utils.hpp"
+
+
+namespace {
+
+
+using i_type = std::integral_constant<int, 42>;
+using t_type = std::tuple<int>;
+
+using testing_types1 = testing::Types<double>;
+using testing_types2 = testing::Types<t_type, int>;
+using testing_types3 = testing::Types<i_type, short, float>;
+
+using tuple_types1 = std::tuple<double>;
+using tuple_types2 = std::tuple<t_type, int>;
+using tuple_types3 = std::tuple<i_type, short, float>;
+
+template <typename... Args>
+struct type_list {};
+
+
+TEST(TypeListHelper, ChangeOuterWrapper)
+{
+    static_assert(std::is_same<i_type, std::integral_constant<int, 42>>::value,
+                  "Must match!");
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<std::tuple, testing_types1>,
+        tuple_types1>();
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<std::tuple, testing_types2>,
+        tuple_types2>();
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<std::tuple, testing_types3>,
+        tuple_types3>();
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<testing::Types, tuple_types1>,
+        testing_types1>();
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<testing::Types, tuple_types2>,
+        testing_types2>();
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<testing::Types, tuple_types3>,
+        testing_types3>();
+
+    using alternative_list1 = type_list<i_type, t_type, double>;
+    using expected_ow2 = testing::Types<i_type, t_type, double>;
+    testing::StaticAssertTypeEq<
+        gko::test::change_outer_wrapper_t<testing::Types, alternative_list1>,
+        expected_ow2>();
+}
+
+TEST(TypeListHelper, AddInternalWrapper)
+{
+    using expected_iw1 = testing::Types<std::tuple<i_type>, std::tuple<short>,
+                                        std::tuple<float>>;
+    testing::StaticAssertTypeEq<
+        gko::test::add_internal_wrapper_t<std::tuple, testing_types3>,
+        expected_iw1>();
+    testing::StaticAssertTypeEq<
+        gko::test::add_internal_wrapper_t<std::tuple, tuple_types3>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_iw1>>();
+
+    using expected_iw2 = testing::Types<std::complex<double>>;
+    testing::StaticAssertTypeEq<
+        gko::test::add_internal_wrapper_t<std::complex, testing_types1>,
+        expected_iw2>();
+    testing::StaticAssertTypeEq<
+        gko::test::add_internal_wrapper_t<std::complex, tuple_types1>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_iw2>>();
+}
+
+TEST(TypeListHelper, MergeTypeList)
+{
+    using expected_m1 = testing::Types<i_type, short, float, t_type, int>;
+
+    testing::StaticAssertTypeEq<
+        gko::test::merge_type_list_t<testing_types3, testing_types2>,
+        expected_m1>();
+    testing::StaticAssertTypeEq<
+        gko::test::merge_type_list_t<tuple_types3, tuple_types2>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_m1>>();
+
+    using expected_m2 = testing::Types<double>;
+
+    testing::StaticAssertTypeEq<
+        gko::test::merge_type_list_t<testing_types1, testing::Types<>>,
+        expected_m2>();
+    testing::StaticAssertTypeEq<
+        gko::test::merge_type_list_t<tuple_types1, std::tuple<>>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_m2>>();
+
+    testing::StaticAssertTypeEq<
+        gko::test::merge_type_list_t<testing::Types<>, testing_types1>,
+        expected_m2>();
+    testing::StaticAssertTypeEq<
+        gko::test::merge_type_list_t<std::tuple<>, tuple_types1>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_m2>>();
+}
+
+TEST(TypeListHelper, CombineTypes)
+{
+    using expected_c1 =
+        testing::Types<std::tuple<t_type, i_type>, std::tuple<t_type, short>,
+                       std::tuple<t_type, float>, std::tuple<int, i_type>,
+                       std::tuple<int, short>, std::tuple<int, float>>;
+    testing::StaticAssertTypeEq<
+        gko::test::combine_types_t<testing_types2, testing_types3>,
+        expected_c1>();
+    testing::StaticAssertTypeEq<
+        gko::test::combine_types_t<tuple_types2, tuple_types3>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_c1>>();
+
+    using expected_c2 =
+        testing::Types<std::tuple<double, t_type>, std::tuple<double, int>>;
+    testing::StaticAssertTypeEq<
+        gko::test::combine_types_t<testing_types1, testing_types2>,
+        expected_c2>();
+    testing::StaticAssertTypeEq<
+        gko::test::combine_types_t<tuple_types1, tuple_types2>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_c2>>();
+}
+
+TEST(TypeListHelper, AddCombination)
+{
+    using list1 =
+        testing::Types<std::tuple<double, int>, std::tuple<double, short>,
+                       std::tuple<float, int>, std::tuple<float, short>>;
+    using list2 = testing::Types<long, char>;
+    using tlist1 = gko::test::change_outer_wrapper_t<std::tuple, list1>;
+    using tlist2 = std::tuple<long, char>;
+
+    using expected_a1 = testing::Types<
+        std::tuple<double, int, long>, std::tuple<double, int, char>,
+        std::tuple<double, short, long>, std::tuple<double, short, char>,
+        std::tuple<float, int, long>, std::tuple<float, int, char>,
+        std::tuple<float, short, long>, std::tuple<float, short, char>>;
+
+    testing::StaticAssertTypeEq<gko::test::add_combination_t<list1, list2>,
+                                expected_a1>();
+    testing::StaticAssertTypeEq<
+        gko::test::add_combination_t<tlist1, tlist2>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_a1>>();
+
+    using list3 = testing::Types<std::tuple<long>>;
+    using list4 = testing::Types<double>;
+    using tlist3 = std::tuple<std::tuple<long>>;
+    using tlist4 = std::tuple<double>;
+    using expected_a2 = testing::Types<std::tuple<long, double>>;
+    testing::StaticAssertTypeEq<gko::test::add_combination_t<list3, list4>,
+                                expected_a2>();
+    testing::StaticAssertTypeEq<
+        gko::test::add_combination_t<tlist3, tlist4>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_a2>>();
+}
+
+TEST(TypeListHelper, AddCombinationLeft)
+{
+    using list1 = testing::Types<long, char>;
+    using list2 =
+        testing::Types<std::tuple<double, int>, std::tuple<double, short>,
+                       std::tuple<float, int>, std::tuple<float, short>>;
+    using tlist1 = std::tuple<long, char>;
+    using tlist2 = gko::test::change_outer_wrapper_t<std::tuple, list2>;
+
+    using expected_a1 = testing::Types<
+        std::tuple<long, double, int>, std::tuple<char, double, int>,
+        std::tuple<long, double, short>, std::tuple<char, double, short>,
+        std::tuple<long, float, int>, std::tuple<char, float, int>,
+        std::tuple<long, float, short>, std::tuple<char, float, short>>;
+
+    testing::StaticAssertTypeEq<gko::test::add_combination_left_t<list1, list2>,
+                                expected_a1>();
+    testing::StaticAssertTypeEq<
+        gko::test::add_combination_left_t<tlist1, tlist2>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_a1>>();
+
+    using list3 = testing::Types<double>;
+    using list4 = testing::Types<std::tuple<long>>;
+    using tlist3 = std::tuple<double>;
+    using tlist4 = std::tuple<std::tuple<long>>;
+    using expected_a2 = testing::Types<std::tuple<double, long>>;
+    testing::StaticAssertTypeEq<gko::test::add_combination_left_t<list3, list4>,
+                                expected_a2>();
+    testing::StaticAssertTypeEq<
+        gko::test::add_combination_left_t<tlist3, tlist4>,
+        gko::test::change_outer_wrapper_t<std::tuple, expected_a2>>();
+}
+
+
+}  // namespace
diff --git a/cuda/test/base/array.cpp b/cuda/test/base/array.cpp
index 6e63b13ff7c..d8cc203583c 100644
--- a/cuda/test/base/array.cpp
+++ b/cuda/test/base/array.cpp
@@ -36,7 +36,7 @@ class Array : public CudaTestFixture {
     gko::array<T> x;
 };
 
-TYPED_TEST_SUITE(Array, gko::test::ValueAndIndexTypes, TypenameNameGenerator);
+TYPED_TEST_SUITE(Array, gko::test::ComplexAndPODTypes, TypenameNameGenerator);
 
 
 TYPED_TEST(Array, CanCreateTemporaryCloneOnDifferentExecutor)
diff --git a/reference/test/base/array.cpp b/reference/test/base/array.cpp
index 4d2c3ea909b..27b04bee0c4 100644
--- a/reference/test/base/array.cpp
+++ b/reference/test/base/array.cpp
@@ -33,7 +33,7 @@ class Array : public ::testing::Test {
     gko::array<T> x;
 };
 
-TYPED_TEST_SUITE(Array, gko::test::ValueAndIndexTypes, TypenameNameGenerator);
+TYPED_TEST_SUITE(Array, gko::test::ComplexAndPODTypes, TypenameNameGenerator);
 
 
 TYPED_TEST(Array, CanBeFilledWithValue)
diff --git a/reference/test/components/fill_array_kernels.cpp b/reference/test/components/fill_array_kernels.cpp
index 2f534be94b8..6cb1ac6d763 100644
--- a/reference/test/components/fill_array_kernels.cpp
+++ b/reference/test/components/fill_array_kernels.cpp
@@ -44,7 +44,7 @@ class FillArray : public ::testing::Test {
     gko::array<value_type> seqs;
 };
 
-TYPED_TEST_SUITE(FillArray, gko::test::ValueAndIndexTypes,
+TYPED_TEST_SUITE(FillArray, gko::test::ComplexAndPODTypes,
                  TypenameNameGenerator);
 
 
diff --git a/reference/test/components/reduce_array_kernels.cpp b/reference/test/components/reduce_array_kernels.cpp
index 2599f83178f..30d5a0bd46e 100644
--- a/reference/test/components/reduce_array_kernels.cpp
+++ b/reference/test/components/reduce_array_kernels.cpp
@@ -35,7 +35,7 @@ class ReduceArray : public ::testing::Test {
     gko::array<value_type> vals;
 };
 
-TYPED_TEST_SUITE(ReduceArray, gko::test::ValueAndIndexTypes,
+TYPED_TEST_SUITE(ReduceArray, gko::test::ComplexAndPODTypes,
                  TypenameNameGenerator);
 
 
diff --git a/test/components/fill_array_kernels.cpp b/test/components/fill_array_kernels.cpp
index 9ccf63e5c88..be629e2fc5d 100644
--- a/test/components/fill_array_kernels.cpp
+++ b/test/components/fill_array_kernels.cpp
@@ -40,7 +40,7 @@ class FillArray : public CommonTestFixture {
     gko::array<value_type> seqs;
 };
 
-TYPED_TEST_SUITE(FillArray, gko::test::ValueAndIndexTypes,
+TYPED_TEST_SUITE(FillArray, gko::test::ComplexAndPODTypes,
                  TypenameNameGenerator);
 
 
diff --git a/test/components/reduce_array_kernels.cpp b/test/components/reduce_array_kernels.cpp
index cd6c2a8d7bf..b6a6bc5e9de 100644
--- a/test/components/reduce_array_kernels.cpp
+++ b/test/components/reduce_array_kernels.cpp
@@ -42,7 +42,7 @@ class ReduceArray : public CommonTestFixture {
     gko::array<value_type> dvals;
 };
 
-TYPED_TEST_SUITE(ReduceArray, gko::test::ValueAndIndexTypes,
+TYPED_TEST_SUITE(ReduceArray, gko::test::ComplexAndPODTypes,
                  TypenameNameGenerator);