NFC: Move shared validation helpers into HLSLTestDataTypes.h

Move isFloatingPointType, ValidationType, ValidationConfig,
DefaultValidation, StrictValidation, and doValuesMatch overloads
from LongVectors.cpp and LinearAlgebra.cpp into the shared header.
Both files now use 'using' declarations to reference them.

Co-authored-by: Copilot <[email protected]>

Author: alsepkow

tools/clang/unittests/HLSLExec/HLSLTestDataTypes.h

@@ -5,11 +5,13 @@
 #include <cstdint>
 #include <limits>
 #include <ostream>
+#include <type_traits>
 
 #include <DirectXMath.h>
 #include <DirectXPackedVector.h>
 
 #include "dxc/Support/Global.h"
+#include "HlslTestUtils.h"
 
 // Shared HLSL type wrappers for use in execution tests.
 // These types bridge the gap between C++ and HLSL type representations.
@@ -490,6 +492,112 @@ struct F8E5M2_t {
   }
 };
 
+//
+// Shared type traits and validation infrastructure.
+//
+
+template <typename T> constexpr bool isFloatingPointType() {
+  return std::is_same_v<T, float> || std::is_same_v<T, double> ||
+         std::is_same_v<T, HLSLHalf_t>;
+}
+
+enum class ValidationType {
+  Epsilon,
+  Ulp,
+};
+
+struct ValidationConfig {
+  double Tolerance = 0.0;
+  ValidationType Type = ValidationType::Epsilon;
+
+  static ValidationConfig Epsilon(double Tolerance) {
+    return ValidationConfig{Tolerance, ValidationType::Epsilon};
+  }
+
+  static ValidationConfig Ulp(double Tolerance) {
+    return ValidationConfig{Tolerance, ValidationType::Ulp};
+  }
+};
+
+// Default validation: ULP for floating point, exact for integers.
+template <typename T> struct DefaultValidation {
+  ValidationConfig ValidationConfig;
+
+  DefaultValidation() {
+    if constexpr (isFloatingPointType<T>())
+      ValidationConfig = ValidationConfig::Ulp(1.0f);
+  }
+};
+
+// Strict validation: exact match by default.
+struct StrictValidation {
+  ValidationConfig ValidationConfig;
+};
+
+//
+// Value comparison overloads used by both LongVector and LinearAlgebra tests.
+//
+
+template <typename T>
+inline bool doValuesMatch(T A, T B, double Tolerance, ValidationType) {
+  if (Tolerance == 0.0)
+    return A == B;
+
+  T Diff = A > B ? A - B : B - A;
+  return Diff <= Tolerance;
+}
+
+inline bool doValuesMatch(HLSLBool_t A, HLSLBool_t B, double,
+                          ValidationType) {
+  return A == B;
+}
+
+inline bool doValuesMatch(HLSLHalf_t A, HLSLHalf_t B, double Tolerance,
+                          ValidationType VType) {
+  switch (VType) {
+  case ValidationType::Epsilon:
+    return CompareHalfEpsilon(A.Val, B.Val, static_cast<float>(Tolerance));
+  case ValidationType::Ulp:
+    return CompareHalfULP(A.Val, B.Val, static_cast<float>(Tolerance));
+  default:
+    hlsl_test::LogErrorFmt(
+        L"Invalid ValidationType. Expecting Epsilon or ULP.");
+    return false;
+  }
+}
+
+inline bool doValuesMatch(float A, float B, double Tolerance,
+                          ValidationType VType) {
+  switch (VType) {
+  case ValidationType::Epsilon:
+    return CompareFloatEpsilon(A, B, static_cast<float>(Tolerance));
+  case ValidationType::Ulp: {
+    const int IntTolerance = static_cast<int>(Tolerance);
+    return CompareFloatULP(A, B, IntTolerance);
+  }
+  default:
+    hlsl_test::LogErrorFmt(
+        L"Invalid ValidationType. Expecting Epsilon or ULP.");
+    return false;
+  }
+}
+
+inline bool doValuesMatch(double A, double B, double Tolerance,
+                          ValidationType VType) {
+  switch (VType) {
+  case ValidationType::Epsilon:
+    return CompareDoubleEpsilon(A, B, Tolerance);
+  case ValidationType::Ulp: {
+    const int64_t IntTolerance = static_cast<int64_t>(Tolerance);
+    return CompareDoubleULP(A, B, IntTolerance);
+  }
+  default:
+    hlsl_test::LogErrorFmt(
+        L"Invalid ValidationType. Expecting Epsilon or ULP.");
+    return false;
+  }
+}
+
 } // namespace HLSLTestDataTypes
 
 #endif // HLSLTESTDATATYPES_H

tools/clang/unittests/HLSLExec/LinearAlgebra.cpp

@@ -22,8 +22,6 @@
 #include <type_traits>
 #include <vector>
 
-using namespace HLSLTestDataTypes; // For HLSLHalf_t, HLSLBool_t
-
 namespace LinearAlgebra {
 
 //
@@ -89,89 +87,13 @@ DATA_TYPE(uint32_t, "uint", "ComponentType::U32", 4, false)
 
 #undef DATA_TYPE
 
-template <typename T> constexpr bool isFloatingPointType() {
-  return std::is_same_v<T, float> || std::is_same_v<T, double> ||
-         std::is_same_v<T, HLSLHalf_t>;
-}
-
-//
-// Validation
-//
-
-enum class ValidationType { Epsilon, Ulp };
-
-struct ValidationConfig {
-  double Tolerance = 0.0;
-  ValidationType Type = ValidationType::Epsilon;
-
-  static ValidationConfig Epsilon(double Tol) {
-    return {Tol, ValidationType::Epsilon};
-  }
-
-  static ValidationConfig Ulp(double Tol) { return {Tol, ValidationType::Ulp}; }
-};
-
-// Default validation: ULP for floating point, exact for integers.
-template <typename T> struct DefaultValidation {
-  ValidationConfig ValidationConfig;
-
-  DefaultValidation() {
-    if constexpr (isFloatingPointType<T>())
-      ValidationConfig = ValidationConfig::Ulp(1.0);
-  }
-};
-
-// Strict validation: exact match.
-struct StrictValidation {
-  ValidationConfig ValidationConfig;
-};
-
-//
-// Value comparison overloads following LongVector patterns.
-//
-
-template <typename T>
-bool doValuesMatch(T A, T B, double Tolerance, ValidationType) {
-  if (Tolerance == 0.0)
-    return A == B;
-
-  T Diff = A > B ? A - B : B - A;
-  return Diff <= Tolerance;
-}
-
-bool doValuesMatch(HLSLHalf_t A, HLSLHalf_t B, double Tolerance,
-                   ValidationType VType) {
-  switch (VType) {
-  case ValidationType::Epsilon:
-    return CompareHalfEpsilon(A.Val, B.Val, static_cast<float>(Tolerance));
-  case ValidationType::Ulp:
-    return CompareHalfULP(A.Val, B.Val, static_cast<float>(Tolerance));
-  default:
-    return false;
-  }
-}
-
-bool doValuesMatch(float A, float B, double Tolerance, ValidationType VType) {
-  switch (VType) {
-  case ValidationType::Epsilon:
-    return CompareFloatEpsilon(A, B, static_cast<float>(Tolerance));
-  case ValidationType::Ulp:
-    return CompareFloatULP(A, B, static_cast<int>(Tolerance));
-  default:
-    return false;
-  }
-}
-
-bool doValuesMatch(double A, double B, double Tolerance, ValidationType VType) {
-  switch (VType) {
-  case ValidationType::Epsilon:
-    return CompareDoubleEpsilon(A, B, Tolerance);
-  case ValidationType::Ulp:
-    return CompareDoubleULP(A, B, static_cast<int64_t>(Tolerance));
-  default:
-    return false;
-  }
-}
+using HLSLTestDataTypes::isFloatingPointType;
+using HLSLTestDataTypes::ValidationType;
+using HLSLTestDataTypes::ValidationConfig;
+using HLSLTestDataTypes::DefaultValidation;
+using HLSLTestDataTypes::StrictValidation;
+using HLSLTestDataTypes::doValuesMatch;
+using HLSLTestDataTypes::HLSLHalf_t;
 
 template <typename T>
 bool doVectorsMatch(const std::vector<T> &Actual,

tools/clang/unittests/HLSLExec/LongVectors.cpp

@@ -64,10 +64,12 @@ DATA_TYPE(double, "double", 8)
 
 #undef DATA_TYPE
 
-template <typename T> constexpr bool isFloatingPointType() {
-  return std::is_same_v<T, float> || std::is_same_v<T, double> ||
-         std::is_same_v<T, HLSLHalf_t>;
-}
+using HLSLTestDataTypes::isFloatingPointType;
+using HLSLTestDataTypes::ValidationType;
+using HLSLTestDataTypes::ValidationConfig;
+using HLSLTestDataTypes::DefaultValidation;
+using HLSLTestDataTypes::StrictValidation;
+using HLSLTestDataTypes::doValuesMatch;
 
 //
 // Operation Types
@@ -186,72 +188,6 @@ void logLongVector(const std::vector<T> &Values, const std::wstring &Name) {
   hlsl_test::LogCommentFmt(Wss.str().c_str());
 }
 
-enum class ValidationType {
-  Epsilon,
-  Ulp,
-};
-
-template <typename T>
-bool doValuesMatch(T A, T B, double Tolerance, ValidationType) {
-  if (Tolerance == 0.0)
-    return A == B;
-
-  T Diff = A > B ? A - B : B - A;
-  return Diff <= Tolerance;
-}
-
-bool doValuesMatch(HLSLBool_t A, HLSLBool_t B, double, ValidationType) {
-  return A == B;
-}
-
-bool doValuesMatch(HLSLHalf_t A, HLSLHalf_t B, double Tolerance,
-                   ValidationType ValidationType) {
-  switch (ValidationType) {
-  case ValidationType::Epsilon:
-    return CompareHalfEpsilon(A.Val, B.Val, static_cast<float>(Tolerance));
-  case ValidationType::Ulp:
-    return CompareHalfULP(A.Val, B.Val, static_cast<float>(Tolerance));
-  default:
-    hlsl_test::LogErrorFmt(
-        L"Invalid ValidationType. Expecting Epsilon or ULP.");
-    return false;
-  }
-}
-
-bool doValuesMatch(float A, float B, double Tolerance,
-                   ValidationType ValidationType) {
-  switch (ValidationType) {
-  case ValidationType::Epsilon:
-    return CompareFloatEpsilon(A, B, static_cast<float>(Tolerance));
-  case ValidationType::Ulp: {
-    // Tolerance is in ULPs. Convert to int for the comparison.
-    const int IntTolerance = static_cast<int>(Tolerance);
-    return CompareFloatULP(A, B, IntTolerance);
-  };
-  default:
-    hlsl_test::LogErrorFmt(
-        L"Invalid ValidationType. Expecting Epsilon or ULP.");
-    return false;
-  }
-}
-
-bool doValuesMatch(double A, double B, double Tolerance,
-                   ValidationType ValidationType) {
-  switch (ValidationType) {
-  case ValidationType::Epsilon:
-    return CompareDoubleEpsilon(A, B, Tolerance);
-  case ValidationType::Ulp: {
-    // Tolerance is in ULPs. Convert to int64_t for the comparison.
-    const int64_t IntTolerance = static_cast<int64_t>(Tolerance);
-    return CompareDoubleULP(A, B, IntTolerance);
-  };
-  default:
-    hlsl_test::LogErrorFmt(
-        L"Invalid ValidationType. Expecting Epsilon or ULP.");
-    return false;
-  }
-}
-
 template <typename T>
 bool doVectorsMatch(const std::vector<T> &ActualValues,
                     const std::vector<T> &ExpectedValues, double Tolerance,
@@ -563,19 +499,6 @@ InputSets<T> buildTestInputs(size_t VectorSize, const InputSet OpInputSets[3],
   return Inputs;
 }
 
-struct ValidationConfig {
-  double Tolerance = 0.0;
-  ValidationType Type = ValidationType::Epsilon;
-
-  static ValidationConfig Epsilon(double Tolerance) {
-    return ValidationConfig{Tolerance, ValidationType::Epsilon};
-  }
-
-  static ValidationConfig Ulp(double Tolerance) {
-    return ValidationConfig{Tolerance, ValidationType::Ulp};
-  }
-};
-
 template <typename T, typename OUT_TYPE>
 void runAndVerify(
     ID3D12Device *D3DDevice, bool VerboseLogging, const Operation &Operation,
@@ -614,23 +537,6 @@ template <OpType OP, typename T, size_t Arity> struct Op;
 // member functions.
 template <OpType OP, typename T> struct ExpectedBuilder;
 
-// Default Validation configuration - ULP for floating point types, exact
-// matches for everything else.
-template <typename T> struct DefaultValidation {
-  ValidationConfig ValidationConfig;
-
-  DefaultValidation() {
-    if constexpr (isFloatingPointType<T>())
-      ValidationConfig = ValidationConfig::Ulp(1.0f);
-  }
-};
-
-// Strict Validation - Defaults to exact matches.
-// Tolerance can be set to a non-zero value to allow for a wider range.
-struct StrictValidation {
-  ValidationConfig ValidationConfig;
-};
-
 // Macros to build up common patterns of Op definitions
 
 #define OP_1(OP, VALIDATION, IMPL)                                             \