Apply clang-format to unit_tensor_descriptor_functors.cpp

Co-Authored-By: Claude <noreply@anthropic.com>

Author: tenpercent

test/util/unit_tensor_descriptor_functors.cpp

@@ -15,8 +15,8 @@ TEST(ConvertVisibleToHiddenId, SimplePackedDescriptor3D)
 {
     // For a 3D packed descriptor created via make_naive_tensor_descriptor_packed,
     // the visible dimension IDs are Sequence<1, 2, 3> (hidden dim 0 is the element space)
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);
 
@@ -43,8 +43,8 @@ TEST(ConvertVisibleToHiddenId, SimplePackedDescriptor3D)
 
 TEST(ConvertVisibleToHiddenId, SimplePackedDescriptor2D)
 {
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<32>{}, Number<64>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<32>{}, Number<64>{}));
 
     using DescType = decltype(desc);
 
@@ -60,8 +60,7 @@ TEST(ConvertVisibleToHiddenId, SimplePackedDescriptor2D)
 
 TEST(ConvertVisibleToHiddenId, SimplePackedDescriptor1D)
 {
-    constexpr auto desc =
-        make_naive_tensor_descriptor_packed(make_tuple(Number<128>{}));
+    constexpr auto desc = make_naive_tensor_descriptor_packed(make_tuple(Number<128>{}));
 
     using DescType = decltype(desc);
 
@@ -94,23 +93,23 @@ TEST(ConvertVisibleToHiddenId, SimplePackedDescriptor4D)
 
 TEST(ConvertVisibleIdsToHiddenIds, SingleElement)
 {
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);
 
     constexpr auto functor = convert_visible_ids_to_hidden_ids<DescType>{};
 
     // Convert single visible ID
-    constexpr auto result   = functor(Sequence<0>{});
-    using ExpectedResult    = Sequence<1>;
+    constexpr auto result = functor(Sequence<0>{});
+    using ExpectedResult  = Sequence<1>;
     EXPECT_TRUE((is_same<decltype(result), const ExpectedResult>::value));
 }
 
 TEST(ConvertVisibleIdsToHiddenIds, MultipleElements)
 {
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);
 
@@ -124,8 +123,8 @@ TEST(ConvertVisibleIdsToHiddenIds, MultipleElements)
 
 TEST(ConvertVisibleIdsToHiddenIds, AllElements)
 {
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);
 
@@ -139,8 +138,8 @@ TEST(ConvertVisibleIdsToHiddenIds, AllElements)
 
 TEST(ConvertVisibleIdsToHiddenIds, ReversedOrder)
 {
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);
 
@@ -154,8 +153,8 @@ TEST(ConvertVisibleIdsToHiddenIds, ReversedOrder)
 
 TEST(ConvertVisibleIdsToHiddenIds, EmptySequence)
 {
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);
 
@@ -190,13 +189,13 @@ TEST(GenerateArithmeticSequenceFromScan, SingleRange)
 {
     // Scan sequence: <0, 3> means:
     //   - Index 0: range from (base + 0) to (base + 3) = Sequence<base, base+1, base+2>
-    using ScanSeq               = Sequence<0, 3>;
-    constexpr index_t base      = 5;
+    using ScanSeq          = Sequence<0, 3>;
+    constexpr index_t base = 5;
 
     constexpr auto functor = generate_arithmetic_sequence_from_scan<base, ScanSeq>{};
 
-    constexpr auto result    = functor(Number<0>{});
-    using ExpectedResult     = Sequence<5, 6, 7>;
+    constexpr auto result = functor(Number<0>{});
+    using ExpectedResult  = Sequence<5, 6, 7>;
     EXPECT_TRUE((is_same<decltype(result), const ExpectedResult>::value));
 }
 
@@ -205,100 +204,100 @@ TEST(GenerateArithmeticSequenceFromScan, MultipleRanges)
     // Scan sequence: <0, 2, 5> means:
     //   - Index 0: range from (base + 0) to (base + 2) = 2 elements
     //   - Index 1: range from (base + 2) to (base + 5) = 3 elements
-    using ScanSeq               = Sequence<0, 2, 5>;
-    constexpr index_t base      = 3;
+    using ScanSeq          = Sequence<0, 2, 5>;
+    constexpr index_t base = 3;
 
     constexpr auto functor = generate_arithmetic_sequence_from_scan<base, ScanSeq>{};
 
     // First range: base + [0, 2) = Sequence<3, 4>
-    constexpr auto result_0  = functor(Number<0>{});
-    using ExpectedResult0    = Sequence<3, 4>;
+    constexpr auto result_0 = functor(Number<0>{});
+    using ExpectedResult0   = Sequence<3, 4>;
     EXPECT_TRUE((is_same<decltype(result_0), const ExpectedResult0>::value));
 
     // Second range: base + [2, 5) = Sequence<5, 6, 7>
-    constexpr auto result_1  = functor(Number<1>{});
-    using ExpectedResult1    = Sequence<5, 6, 7>;
+    constexpr auto result_1 = functor(Number<1>{});
+    using ExpectedResult1   = Sequence<5, 6, 7>;
     EXPECT_TRUE((is_same<decltype(result_1), const ExpectedResult1>::value));
 }
 
 TEST(GenerateArithmeticSequenceFromScan, SingleElementRanges)
 {
     // Scan sequence with single-element ranges: <0, 1, 2, 3>
-    using ScanSeq               = Sequence<0, 1, 2, 3>;
-    constexpr index_t base      = 10;
+    using ScanSeq          = Sequence<0, 1, 2, 3>;
+    constexpr index_t base = 10;
 
     constexpr auto functor = generate_arithmetic_sequence_from_scan<base, ScanSeq>{};
 
     // Each range contains exactly one element
-    constexpr auto result_0  = functor(Number<0>{});
-    using ExpectedResult0    = Sequence<10>;
+    constexpr auto result_0 = functor(Number<0>{});
+    using ExpectedResult0   = Sequence<10>;
     EXPECT_TRUE((is_same<decltype(result_0), const ExpectedResult0>::value));
 
-    constexpr auto result_1  = functor(Number<1>{});
-    using ExpectedResult1    = Sequence<11>;
+    constexpr auto result_1 = functor(Number<1>{});
+    using ExpectedResult1   = Sequence<11>;
     EXPECT_TRUE((is_same<decltype(result_1), const ExpectedResult1>::value));
 
-    constexpr auto result_2  = functor(Number<2>{});
-    using ExpectedResult2    = Sequence<12>;
+    constexpr auto result_2 = functor(Number<2>{});
+    using ExpectedResult2   = Sequence<12>;
     EXPECT_TRUE((is_same<decltype(result_2), const ExpectedResult2>::value));
 }
 
 TEST(GenerateArithmeticSequenceFromScan, ZeroBase)
 {
     // Test with base = 0
-    using ScanSeq               = Sequence<0, 2, 4>;
-    constexpr index_t base      = 0;
+    using ScanSeq          = Sequence<0, 2, 4>;
+    constexpr index_t base = 0;
 
     constexpr auto functor = generate_arithmetic_sequence_from_scan<base, ScanSeq>{};
 
-    constexpr auto result_0  = functor(Number<0>{});
-    using ExpectedResult0    = Sequence<0, 1>;
+    constexpr auto result_0 = functor(Number<0>{});
+    using ExpectedResult0   = Sequence<0, 1>;
     EXPECT_TRUE((is_same<decltype(result_0), const ExpectedResult0>::value));
 
-    constexpr auto result_1  = functor(Number<1>{});
-    using ExpectedResult1    = Sequence<2, 3>;
+    constexpr auto result_1 = functor(Number<1>{});
+    using ExpectedResult1   = Sequence<2, 3>;
     EXPECT_TRUE((is_same<decltype(result_1), const ExpectedResult1>::value));
 }
 
 TEST(GenerateArithmeticSequenceFromScan, VariableSizeRanges)
 {
     // Scan sequence with variable-size ranges: <0, 1, 4, 6, 10>
-    using ScanSeq               = Sequence<0, 1, 4, 6, 10>;
-    constexpr index_t base      = 2;
+    using ScanSeq          = Sequence<0, 1, 4, 6, 10>;
+    constexpr index_t base = 2;
 
     constexpr auto functor = generate_arithmetic_sequence_from_scan<base, ScanSeq>{};
 
     // Range 0: [2+0, 2+1) = Sequence<2>
-    constexpr auto result_0  = functor(Number<0>{});
-    using ExpectedResult0    = Sequence<2>;
+    constexpr auto result_0 = functor(Number<0>{});
+    using ExpectedResult0   = Sequence<2>;
     EXPECT_TRUE((is_same<decltype(result_0), const ExpectedResult0>::value));
 
     // Range 1: [2+1, 2+4) = Sequence<3, 4, 5>
-    constexpr auto result_1  = functor(Number<1>{});
-    using ExpectedResult1    = Sequence<3, 4, 5>;
+    constexpr auto result_1 = functor(Number<1>{});
+    using ExpectedResult1   = Sequence<3, 4, 5>;
     EXPECT_TRUE((is_same<decltype(result_1), const ExpectedResult1>::value));
 
     // Range 2: [2+4, 2+6) = Sequence<6, 7>
-    constexpr auto result_2  = functor(Number<2>{});
-    using ExpectedResult2    = Sequence<6, 7>;
+    constexpr auto result_2 = functor(Number<2>{});
+    using ExpectedResult2   = Sequence<6, 7>;
     EXPECT_TRUE((is_same<decltype(result_2), const ExpectedResult2>::value));
 
     // Range 3: [2+6, 2+10) = Sequence<8, 9, 10, 11>
-    constexpr auto result_3  = functor(Number<3>{});
-    using ExpectedResult3    = Sequence<8, 9, 10, 11>;
+    constexpr auto result_3 = functor(Number<3>{});
+    using ExpectedResult3   = Sequence<8, 9, 10, 11>;
     EXPECT_TRUE((is_same<decltype(result_3), const ExpectedResult3>::value));
 }
 
 TEST(GenerateArithmeticSequenceFromScan, LargeBase)
 {
     // Test with a larger base value
-    using ScanSeq               = Sequence<0, 3>;
-    constexpr index_t base      = 100;
+    using ScanSeq          = Sequence<0, 3>;
+    constexpr index_t base = 100;
 
     constexpr auto functor = generate_arithmetic_sequence_from_scan<base, ScanSeq>{};
 
-    constexpr auto result    = functor(Number<0>{});
-    using ExpectedResult     = Sequence<100, 101, 102>;
+    constexpr auto result = functor(Number<0>{});
+    using ExpectedResult  = Sequence<100, 101, 102>;
     EXPECT_TRUE((is_same<decltype(result), const ExpectedResult>::value));
 }
 
@@ -309,8 +308,7 @@ TEST(GenerateArithmeticSequenceFromScan, LargeBase)
 TEST(TensorDescriptorFunctorsIntegration, TransformPreservesMapping)
 {
     // Create a simple packed 2D descriptor
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}));
+    constexpr auto desc = make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}));
 
     using DescType = decltype(desc);
 
@@ -333,8 +331,8 @@ TEST(TensorDescriptorFunctorsIntegration, TransformPreservesMapping)
 TEST(TensorDescriptorFunctorsIntegration, ConvertIdsMatchDirectAccess)
 {
     // Verify that the functor produces the same result as direct access
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<2>{}, Number<4>{}, Number<8>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<2>{}, Number<4>{}, Number<8>{}));
 
     using DescType = decltype(desc);
 
@@ -350,8 +348,8 @@ TEST(TensorDescriptorFunctorsIntegration, ConvertIdsMatchDirectAccess)
 TEST(TensorDescriptorFunctorsIntegration, BatchConvertMatchesSingle)
 {
     // Verify that batch conversion produces the same result as individual conversions
-    constexpr auto desc = make_naive_tensor_descriptor_packed(
-        make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
+    constexpr auto desc =
+        make_naive_tensor_descriptor_packed(make_tuple(Number<4>{}, Number<8>{}, Number<16>{}));
 
     using DescType = decltype(desc);