feat: Add tests for algorithms module including hash and limits functionality

Signed-off-by: FrozenlemonTee <1115306170@qq.com>

Author: FrozenLemonTee

tests/basic/CMakeLists.txt

@@ -28,6 +28,7 @@ function(add_basic_suite target_name suite_pattern)
 endfunction()
 
 add_basic_suite(basic_conversion_tests "conversion/**/test_*.cpp")
+add_basic_suite(basic_algorithms_tests "algorithms/**/test_*.cpp")
 add_basic_suite(basic_operations_tests "operations/**/test_*.cpp")
 add_basic_suite(basic_policy_tests "policy/**/test_*.cpp")
 add_basic_suite(basic_primitive_tests "primitive/**/test_*.cpp")
@@ -36,6 +37,7 @@ add_basic_suite(basic_underlying_tests "underlying/**/test_*.cpp")
 add_custom_target(basic_tests)
 add_dependencies(basic_tests
     basic_conversion_tests
+    basic_algorithms_tests
     basic_operations_tests
     basic_policy_tests
     basic_primitive_tests

tests/basic/algorithms/hash/test_hash.cpp

@@ -0,0 +1,35 @@
+#include <functional>
+#include <gtest/gtest.h>
+#include <type_traits>
+
+import mcpplibs.primitives.algorithms;
+import mcpplibs.primitives.underlying;
+
+#include "../../support/underlying_custom_types.hpp"
+
+using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::test_support::underlying;
+
+TEST(AlgorithmHashTest, BuiltinHashDelegatesToStdHash) {
+  static_assert(algorithms::hashable<int>);
+  static_assert(std::same_as<algorithms::hash_result_t<int>, std::size_t>);
+
+  auto const value = 42;
+  EXPECT_EQ(algorithms::hash<int>{}(value), std::hash<int>{}(value));
+  EXPECT_EQ(algorithms::hash_value(value), std::hash<int>{}(value));
+}
+
+TEST(AlgorithmHashTest, CustomUnderlyingHashesThroughRepType) {
+  static_assert(algorithms::hashable<UserInteger>);
+
+  auto const value = UserInteger{42};
+  auto const expected = std::hash<int>{}(42);
+
+  EXPECT_EQ(algorithms::hash<UserInteger>{}(value), expected);
+  EXPECT_EQ(algorithms::hash_value(value), expected);
+}
+
+TEST(AlgorithmHashTest, UnsupportedSelfRepresentedRepRemainsDisabled) {
+  static_assert(!algorithms::hashable<BigIntLike>);
+  SUCCEED();
+}

tests/basic/algorithms/limits/test_limits.cpp

@@ -0,0 +1,63 @@
+#include <cmath>
+#include <concepts>
+#include <gtest/gtest.h>
+#include <limits>
+#include <type_traits>
+
+import mcpplibs.primitives.algorithms;
+import mcpplibs.primitives.underlying;
+
+#include "../../support/underlying_custom_types.hpp"
+
+using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::test_support::underlying;
+
+TEST(AlgorithmLimitsTest, BuiltinIntegerLimitsFollowNumericLimitsShape) {
+  using limits_t = algorithms::limits<int>;
+
+  static_assert(limits_t::enabled);
+  static_assert(limits_t::is_specialized);
+  static_assert(std::same_as<typename limits_t::rep_type, int>);
+  static_assert(limits_t::kind == underlying::category::integer);
+  static_assert(limits_t::digits == std::numeric_limits<int>::digits);
+  static_assert(limits_t::radix == std::numeric_limits<int>::radix);
+  static_assert(algorithms::limited_type<int>);
+
+  EXPECT_EQ(limits_t::lowest(), std::numeric_limits<int>::lowest());
+  EXPECT_EQ(limits_t::max(), std::numeric_limits<int>::max());
+  EXPECT_EQ(algorithms::min_value<int>(), std::numeric_limits<int>::min());
+}
+
+TEST(AlgorithmLimitsTest, BuiltinFloatingLimitsExposeSpecialValues) {
+  using limits_t = algorithms::limits<double>;
+
+  static_assert(limits_t::enabled);
+  static_assert(limits_t::has_quiet_nan);
+  static_assert(limits_t::has_infinity);
+  static_assert(limits_t::kind == underlying::category::floating);
+  static_assert(limits_t::is_iec559);
+
+  EXPECT_EQ(algorithms::epsilon_value<double>(),
+            std::numeric_limits<double>::epsilon());
+  EXPECT_EQ(algorithms::infinity_value<double>(),
+            std::numeric_limits<double>::infinity());
+  EXPECT_TRUE(std::isnan(algorithms::quiet_nan_value<double>()));
+}
+
+TEST(AlgorithmLimitsTest, CustomUnderlyingUsesRepBackedLimits) {
+  using limits_t = algorithms::limits<UserInteger>;
+
+  static_assert(limits_t::enabled);
+  static_assert(std::same_as<typename limits_t::rep_type, int>);
+  static_assert(limits_t::kind == underlying::category::integer);
+
+  EXPECT_EQ(underlying::traits<UserInteger>::to_rep(limits_t::lowest()),
+            std::numeric_limits<int>::lowest());
+  EXPECT_EQ(underlying::traits<UserInteger>::to_rep(limits_t::max()),
+            std::numeric_limits<int>::max());
+}
+
+TEST(AlgorithmLimitsTest, SelfRepresentedCustomRepNeedsExplicitLimitsSpecialization) {
+  static_assert(!algorithms::limits<BigIntLike>::enabled);
+  SUCCEED();
+}