Add unit tests for template optimization helpers

tenpercent · tenpercent · commit 0b356511ca69 · 2026-01-19T18:31:21.000-06:00
Add Google Tests for optimized template utilities:
- sequence_gen: Tests with custom functors (4 tests)
- generate_identity_sequences: Tuple of identity sequences (4 tests)
- find_in_tuple_of_sequences: O(1) sequence search (6 tests)
- sequence_find_value: Value lookup in sequences (5 tests)
- container_concat: Tuple/array concatenation (5 tests)
- make_uniform_tuple: Repeated value tuples (4 tests)
- compute_element_space_size: Fold expression (8 tests)
- unpack_and_merge_sequences: Sequence merging (2 tests)

Total: 43 new tests across 4 test files.
diff --git a/test/util/CMakeLists.txt b/test/util/CMakeLists.txt
@@ -5,3 +5,18 @@ add_gtest_executable(unit_sequence unit_sequence.cpp)
 if(result EQUAL 0)
   target_link_libraries(unit_sequence PRIVATE utility)
 endif()
+
+add_gtest_executable(unit_sequence_helper unit_sequence_helper.cpp)
+if(result EQUAL 0)
+  target_link_libraries(unit_sequence_helper PRIVATE utility)
+endif()
+
+add_gtest_executable(unit_container_helper unit_container_helper.cpp)
+if(result EQUAL 0)
+  target_link_libraries(unit_container_helper PRIVATE utility)
+endif()
+
+add_gtest_executable(unit_tensor_descriptor_helper unit_tensor_descriptor_helper.cpp)
+if(result EQUAL 0)
+  target_link_libraries(unit_tensor_descriptor_helper PRIVATE utility)
+endif()
diff --git a/test/util/unit_container_helper.cpp b/test/util/unit_container_helper.cpp
@@ -0,0 +1,141 @@
+// Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
+// SPDX-License-Identifier: MIT
+
+#include <gtest/gtest.h>
+#include "ck/utility/container_helper.hpp"
+#include "ck/utility/tuple_helper.hpp"
+
+using namespace ck;
+
+// Test container_concat with tuples
+TEST(ContainerConcat, ConcatTwoTuples)
+{
+    constexpr auto t1     = make_tuple(Number<1>{}, Number<2>{});
+    constexpr auto t2     = make_tuple(Number<3>{}, Number<4>{});
+    constexpr auto result = container_concat(t1, t2);
+
+    EXPECT_EQ(result.Size(), 4);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+    EXPECT_EQ(result[Number<2>{}], 3);
+    EXPECT_EQ(result[Number<3>{}], 4);
+}
+
+TEST(ContainerConcat, ConcatThreeTuples)
+{
+    constexpr auto t1     = make_tuple(Number<1>{});
+    constexpr auto t2     = make_tuple(Number<2>{});
+    constexpr auto t3     = make_tuple(Number<3>{});
+    constexpr auto result = container_concat(t1, t2, t3);
+
+    EXPECT_EQ(result.Size(), 3);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+    EXPECT_EQ(result[Number<2>{}], 3);
+}
+
+TEST(ContainerConcat, ConcatWithEmptyTuple)
+{
+    constexpr auto t1     = make_tuple(Number<1>{}, Number<2>{});
+    constexpr auto empty  = make_tuple();
+    constexpr auto result = container_concat(t1, empty);
+
+    EXPECT_EQ(result.Size(), 2);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+}
+
+TEST(ContainerConcat, ConcatSingleTuple)
+{
+    constexpr auto t1     = make_tuple(Number<1>{}, Number<2>{}, Number<3>{});
+    constexpr auto result = container_concat(t1);
+
+    EXPECT_EQ(result.Size(), 3);
+}
+
+// Test container_concat with arrays
+TEST(ContainerConcat, ConcatTwoArrays)
+{
+    constexpr auto a1     = make_array(1, 2);
+    constexpr auto a2     = make_array(3, 4);
+    constexpr auto result = container_concat(a1, a2);
+
+    EXPECT_EQ(result.Size(), 4);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+    EXPECT_EQ(result[Number<2>{}], 3);
+    EXPECT_EQ(result[Number<3>{}], 4);
+}
+
+// Test make_uniform_tuple
+TEST(MakeUniformTuple, Size3)
+{
+    constexpr auto result = make_uniform_tuple<3>(Number<42>{});
+
+    EXPECT_EQ(result.Size(), 3);
+    EXPECT_EQ(result[Number<0>{}], 42);
+    EXPECT_EQ(result[Number<1>{}], 42);
+    EXPECT_EQ(result[Number<2>{}], 42);
+}
+
+TEST(MakeUniformTuple, Size1)
+{
+    constexpr auto result = make_uniform_tuple<1>(Number<99>{});
+
+    EXPECT_EQ(result.Size(), 1);
+    EXPECT_EQ(result[Number<0>{}], 99);
+}
+
+TEST(MakeUniformTuple, Size0)
+{
+    constexpr auto result = make_uniform_tuple<0>(Number<42>{});
+
+    EXPECT_EQ(result.Size(), 0);
+}
+
+TEST(MakeUniformTuple, Size5)
+{
+    constexpr auto result = make_uniform_tuple<5>(Number<7>{});
+
+    EXPECT_EQ(result.Size(), 5);
+    EXPECT_EQ(result[Number<0>{}], 7);
+    EXPECT_EQ(result[Number<1>{}], 7);
+    EXPECT_EQ(result[Number<2>{}], 7);
+    EXPECT_EQ(result[Number<3>{}], 7);
+    EXPECT_EQ(result[Number<4>{}], 7);
+}
+
+// Test make_tuple_functor (used internally by container_concat)
+TEST(MakeTupleFunctor, CreatesTuple)
+{
+    make_tuple_functor functor;
+    auto result = functor(Number<1>{}, Number<2>{}, Number<3>{});
+
+    EXPECT_EQ(result.Size(), 3);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+    EXPECT_EQ(result[Number<2>{}], 3);
+}
+
+// Test container_push_front and container_push_back
+TEST(ContainerPush, PushFront)
+{
+    constexpr auto t      = make_tuple(Number<2>{}, Number<3>{});
+    constexpr auto result = container_push_front(t, Number<1>{});
+
+    EXPECT_EQ(result.Size(), 3);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+    EXPECT_EQ(result[Number<2>{}], 3);
+}
+
+TEST(ContainerPush, PushBack)
+{
+    constexpr auto t      = make_tuple(Number<1>{}, Number<2>{});
+    constexpr auto result = container_push_back(t, Number<3>{});
+
+    EXPECT_EQ(result.Size(), 3);
+    EXPECT_EQ(result[Number<0>{}], 1);
+    EXPECT_EQ(result[Number<1>{}], 2);
+    EXPECT_EQ(result[Number<2>{}], 3);
+}
diff --git a/test/util/unit_sequence.cpp b/test/util/unit_sequence.cpp
@@ -185,6 +185,54 @@ TEST(Sequence, ReorderGivenOld2New)
     EXPECT_TRUE((is_same<Result, Expected>::value));
 }
 
+// Test sequence_gen with custom functor
+TEST(SequenceGen, SequenceGenWithDoubleFunctor)
+{
+    struct DoubleFunctor
+    {
+        __host__ __device__ constexpr index_t operator()(index_t i) const { return i * 2; }
+    };
+    using Result   = typename sequence_gen<5, DoubleFunctor>::type;
+    using Expected = Sequence<0, 2, 4, 6, 8>;
+    EXPECT_TRUE((is_same<Result, Expected>::value));
+}
+
+TEST(SequenceGen, SequenceGenWithSquareFunctor)
+{
+    struct SquareFunctor
+    {
+        __host__ __device__ constexpr index_t operator()(index_t i) const { return i * i; }
+    };
+    using Result   = typename sequence_gen<5, SquareFunctor>::type;
+    using Expected = Sequence<0, 1, 4, 9, 16>;
+    EXPECT_TRUE((is_same<Result, Expected>::value));
+}
+
+TEST(SequenceGen, SequenceGenZeroSize)
+{
+    struct IdentityFunctor
+    {
+        __host__ __device__ constexpr index_t operator()(index_t i) const { return i; }
+    };
+    using Result   = typename sequence_gen<0, IdentityFunctor>::type;
+    using Expected = Sequence<>;
+    EXPECT_TRUE((is_same<Result, Expected>::value));
+    // Also verify non-zero size works with identity
+    using Result5 = typename sequence_gen<5, IdentityFunctor>::type;
+    EXPECT_TRUE((is_same<Result5, Sequence<0, 1, 2, 3, 4>>::value));
+}
+
+TEST(SequenceGen, SequenceGenSingleElement)
+{
+    struct ConstantFunctor
+    {
+        __host__ __device__ constexpr index_t operator()(index_t) const { return 42; }
+    };
+    using Result   = typename sequence_gen<1, ConstantFunctor>::type;
+    using Expected = Sequence<42>;
+    EXPECT_TRUE((is_same<Result, Expected>::value));
+}
+
 // Test arithmetic_sequence_gen
 TEST(SequenceGen, ArithmeticSequence)
 {
diff --git a/test/util/unit_sequence_helper.cpp b/test/util/unit_sequence_helper.cpp
@@ -0,0 +1,142 @@
+// Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
+// SPDX-License-Identifier: MIT
+
+#include <gtest/gtest.h>
+#include "ck/utility/sequence.hpp"
+#include "ck/utility/sequence_helper.hpp"
+#include "ck/utility/tuple_helper.hpp"
+
+using namespace ck;
+
+// Test generate_identity_sequences
+TEST(GenerateIdentitySequences, Size5)
+{
+    constexpr auto result = generate_identity_sequences<5>();
+    // Should produce Tuple<Sequence<0>, Sequence<1>, Sequence<2>, Sequence<3>, Sequence<4>>
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<0>{}])>, Sequence<0>>::value));
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<1>{}])>, Sequence<1>>::value));
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<2>{}])>, Sequence<2>>::value));
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<3>{}])>, Sequence<3>>::value));
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<4>{}])>, Sequence<4>>::value));
+}
+
+TEST(GenerateIdentitySequences, Size1)
+{
+    constexpr auto result = generate_identity_sequences<1>();
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<0>{}])>, Sequence<0>>::value));
+    EXPECT_EQ(result.Size(), 1);
+}
+
+TEST(GenerateIdentitySequences, Size0)
+{
+    constexpr auto result = generate_identity_sequences<0>();
+    EXPECT_EQ(result.Size(), 0);
+}
+
+TEST(GenerateIdentitySequences, WithNumber)
+{
+    constexpr auto result = generate_identity_sequences(Number<3>{});
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<0>{}])>, Sequence<0>>::value));
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<1>{}])>, Sequence<1>>::value));
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result[Number<2>{}])>, Sequence<2>>::value));
+    EXPECT_EQ(result.Size(), 3);
+}
+
+// Test sequence_find_value
+TEST(SequenceFindValue, FindExistingElement)
+{
+    constexpr auto result = sequence_find_value<3>(Sequence<1, 2, 3, 4, 5>{});
+    EXPECT_EQ(result, 2); // 3 is at index 2
+}
+
+TEST(SequenceFindValue, FindFirstElement)
+{
+    constexpr auto result = sequence_find_value<10>(Sequence<10, 20, 30>{});
+    EXPECT_EQ(result, 0);
+}
+
+TEST(SequenceFindValue, FindLastElement)
+{
+    constexpr auto result = sequence_find_value<30>(Sequence<10, 20, 30>{});
+    EXPECT_EQ(result, 2);
+}
+
+TEST(SequenceFindValue, ElementNotFound)
+{
+    constexpr auto result = sequence_find_value<99>(Sequence<1, 2, 3, 4, 5>{});
+    EXPECT_EQ(result, -1);
+}
+
+TEST(SequenceFindValue, EmptySequence)
+{
+    constexpr auto result = sequence_find_value<1>(Sequence<>{});
+    EXPECT_EQ(result, -1);
+}
+
+// Test find_in_tuple_of_sequences
+TEST(FindInTupleOfSequences, FindInFirstSequence)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<0, 1>{}, Sequence<2, 3>{}, Sequence<4, 5>{});
+    constexpr auto result        = find_in_tuple_of_sequences<1>(tuple_of_seqs);
+    EXPECT_EQ(result.itran, 0);   // Found in first sequence (index 0)
+    EXPECT_EQ(result.idim_up, 1); // At position 1 within that sequence
+    EXPECT_TRUE(result.found);
+}
+
+TEST(FindInTupleOfSequences, FindInMiddleSequence)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<0, 1>{}, Sequence<2, 3>{}, Sequence<4, 5>{});
+    constexpr auto result        = find_in_tuple_of_sequences<3>(tuple_of_seqs);
+    EXPECT_EQ(result.itran, 1);   // Found in second sequence (index 1)
+    EXPECT_EQ(result.idim_up, 1); // At position 1 within that sequence
+    EXPECT_TRUE(result.found);
+}
+
+TEST(FindInTupleOfSequences, FindInLastSequence)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<0, 1>{}, Sequence<2, 3>{}, Sequence<4, 5>{});
+    constexpr auto result        = find_in_tuple_of_sequences<5>(tuple_of_seqs);
+    EXPECT_EQ(result.itran, 2);   // Found in third sequence (index 2)
+    EXPECT_EQ(result.idim_up, 1); // At position 1 within that sequence
+    EXPECT_TRUE(result.found);
+}
+
+TEST(FindInTupleOfSequences, NotFound)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<0, 1>{}, Sequence<2, 3>{}, Sequence<4, 5>{});
+    constexpr auto result        = find_in_tuple_of_sequences<99>(tuple_of_seqs);
+    EXPECT_FALSE(result.found);
+}
+
+TEST(FindInTupleOfSequences, EmptyTuple)
+{
+    constexpr auto tuple_of_seqs = make_tuple();
+    constexpr auto result        = find_in_tuple_of_sequences<1>(tuple_of_seqs);
+    EXPECT_FALSE(result.found);
+}
+
+TEST(FindInTupleOfSequences, SingleSequence)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<10, 20, 30>{});
+    constexpr auto result        = find_in_tuple_of_sequences<20>(tuple_of_seqs);
+    EXPECT_EQ(result.itran, 0);
+    EXPECT_EQ(result.idim_up, 1);
+    EXPECT_TRUE(result.found);
+}
+
+// Test unpack_and_merge_sequences
+TEST(UnpackAndMergeSequences, MergeMultipleSequences)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<1, 2>{}, Sequence<3, 4>{}, Sequence<5, 6>{});
+    constexpr auto result        = unpack_and_merge_sequences(tuple_of_seqs);
+    using Expected               = Sequence<1, 2, 3, 4, 5, 6>;
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result)>, Expected>::value));
+}
+
+TEST(UnpackAndMergeSequences, SingleSequence)
+{
+    constexpr auto tuple_of_seqs = make_tuple(Sequence<1, 2, 3>{});
+    constexpr auto result        = unpack_and_merge_sequences(tuple_of_seqs);
+    using Expected               = Sequence<1, 2, 3>;
+    EXPECT_TRUE((is_same<remove_cvref_t<decltype(result)>, Expected>::value));
+}
diff --git a/test/util/unit_tensor_descriptor_helper.cpp b/test/util/unit_tensor_descriptor_helper.cpp
