Add more unit tests.

test/utils/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_gtest_executable(test_sequencies test_sequencies.cpp)
+add_gtest_executable(test_vector_buffers test_vector_buffers.cpp)
 if(result EQUAL 0)
   target_link_libraries(test_sequencies PRIVATE utility)
 endif()

test/utils/test_sequencies.cpp

@@ -33,3 +33,53 @@ TEST(Sequence, TestCreatingAccessSequence)
 
     EXPECT_TRUE(is_valid);
 }
+
+TEST(Sequence, TestCreatingSequenceFromTuple)
+{
+    constexpr ck::index_t I0 = 0;
+    constexpr ck::index_t I1 = 1;
+
+    constexpr auto seq = to_sequence(make_tuple(Number<I0>{}, Number<I1>{}));
+
+    EXPECT_EQ(seq[0], I0);
+    EXPECT_EQ(seq[1], I1);
+}
+
+TEST(Sequence, TestCreatingSequenceFromStaticFor)
+{
+    constexpr ck::index_t num_pairs = 2;
+    constexpr auto I1 = Number<1>{};
+    constexpr auto I2 = Number<2>{};
+    static_for<0, num_pairs, 1>{}([&](auto i_pair) 
+    {
+        constexpr auto idx_1d_0 = I2 * i_pair;
+        constexpr auto idx_1d_1 = I2 * i_pair + I1;
+
+        constexpr auto seq = to_sequence(make_tuple(idx_1d_0, idx_1d_1));
+
+        if constexpr(i_pair == 0)
+        {
+            EXPECT_EQ(seq[0], 0);
+            EXPECT_EQ(seq[1], 1);    
+        }
+        else if constexpr(i_pair == 1)
+        {
+            EXPECT_EQ(seq[0], 2);
+            EXPECT_EQ(seq[1], 3);    
+        }
+    });
+}
+
+TEST(Sequence, TestSumOfElements)
+{
+    constexpr auto seq = Sequence<1, 2, 3, 4>{};
+    index_t sum = reduce_on_sequence(seq, math::plus<index_t>{}, Number<0>{});
+    EXPECT_EQ(sum, 10);
+}
+
+TEST(Sequence, TestMultiplyOfElements)
+{
+    constexpr auto seq = Sequence<1, 2, 3, 4>{};
+    index_t sum = reduce_on_sequence(seq, math::multiplies{}, Number<1>{});
+    EXPECT_EQ(sum, 24);
+}

test/utils/test_vector_buffers.cpp

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025, Advanced Micro Devices, Inc. All rights reserved.
+
+#include "gtest/gtest.h"
+
+#include "ck/utility/common_header.hpp"
+#include "ck/utility/sequence.hpp"
+#include "ck/utility/sequence_helper.hpp"
+#include "ck/utility/number.hpp"
+#include "ck/utility/amd_address_space.hpp"
+#include "ck/tensor/static_tensor.hpp"
+#include "ck/tensor_description/tensor_descriptor_helper.hpp"
+
+using namespace ck;
+
+TEST(StaticBufferTupleOfVector, TestConstruction)
+{
+  constexpr index_t num_vector = 8;
+  constexpr index_t vector_size = 2;
+  StaticBufferTupleOfVector<AddressSpaceEnum::Vgpr,
+                                        ck::bhalf_t,
+                                        num_vector,
+                                        vector_size,
+                                        true> buffer;
+  EXPECT_EQ(buffer.s_per_v, vector_size);
+  EXPECT_EQ(buffer.num_of_v_, num_vector);
+  EXPECT_EQ(buffer.s_per_buf, num_vector * vector_size);
+}
+
+TEST(StaticBufferTupleOfVector, TestAccess)
+{
+  constexpr auto I2 = Number<2>{};
+
+  constexpr index_t num_vector = 2;
+  constexpr index_t vector_size = 2;
+  StaticBufferTupleOfVector<AddressSpaceEnum::Vgpr,
+                                        ck::bhalf_t,
+                                        num_vector,
+                                        vector_size,
+                                        true> buffer;
+  
+  const ck::bhalf2_t val1{1, 2};
+  const ck::bhalf2_t val2{3, 4};
+
+  static_for<0, num_vector, 1>{}([&](auto i_pair) 
+  {
+      const auto val = (i_pair == 0) ? val1 : val2;
+      constexpr auto offset = I2 * i_pair;
+      buffer.template SetAsType<ck::bhalf2_t>(Number<offset>{}, val);
+  });
+
+  // Test vectorized read and verify values
+  static_for<0, num_vector, 1>{}([&](auto i_pair) 
+  {
+      constexpr auto offset = I2 * i_pair;
+      const auto read_val = buffer.template GetAsType<ck::bhalf2_t>(Number<offset>{});
+      if constexpr(i_pair == 0)
+      {
+          EXPECT_EQ(read_val[0], val1[0]);
+          EXPECT_EQ(read_val[1], val1[1]);
+      }
+      else
+      {
+          EXPECT_EQ(read_val[0], val2[0]);
+          EXPECT_EQ(read_val[1], val2[1]);
+      }
+  });
+}