test: Split basic tests trying to resolve issue#17

Author: FrozenLemonTee

tests/basic/conversion/traits/test_numeric_risk.cpp

@@ -0,0 +1,30 @@
+#include <cstdint>
+#include <gtest/gtest.h>
+#include <limits>
+
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.conversion.underlying;
+
+using namespace mcpplibs::primitives;
+
+TEST(ConversionRiskTest, NumericRiskDetectsOverflowAndUnderflow) {
+  auto const overflow = conversion::numeric_risk<std::uint16_t>(70000);
+  ASSERT_TRUE(overflow.has_value());
+  EXPECT_EQ(*overflow, conversion::risk::kind::overflow);
+
+  auto const underflow = conversion::numeric_risk<std::uint16_t>(-1);
+  ASSERT_TRUE(underflow.has_value());
+  EXPECT_EQ(*underflow, conversion::risk::kind::underflow);
+}
+
+TEST(ConversionRiskTest, NumericRiskDetectsDomainAndPrecisionLoss) {
+  auto const domain =
+      conversion::numeric_risk<int>(std::numeric_limits<double>::quiet_NaN());
+  ASSERT_TRUE(domain.has_value());
+  EXPECT_EQ(*domain, conversion::risk::kind::domain_error);
+
+  auto const precision =
+      conversion::numeric_risk<float>(std::numeric_limits<std::int64_t>::max());
+  ASSERT_TRUE(precision.has_value());
+  EXPECT_EQ(*precision, conversion::risk::kind::precision_loss);
+}

tests/basic/conversion/traits/test_result_types.cpp

@@ -0,0 +1,11 @@
+#include <expected>
+#include <gtest/gtest.h>
+
+import mcpplibs.primitives.conversion.traits;
+
+using namespace mcpplibs::primitives;
+
+TEST(ConversionTypeTest, ResultTypesMatchContracts) {
+  static_assert(std::same_as<conversion::cast_result<int>,
+                             std::expected<int, conversion::risk::kind>>);
+}

tests/basic/conversion/underlying/test_builtin_casts.cpp

@@ -0,0 +1,23 @@
+#include <cstdint>
+#include <gtest/gtest.h>
+#include <limits>
+
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.conversion.underlying;
+import mcpplibs.primitives.underlying;
+
+using namespace mcpplibs::primitives;
+
+#if defined(_MSC_VER)
+TEST(ConversionCastTest, CheckedCastSmokeOnMSVC) { SUCCEED(); }
+#else
+TEST(ConversionCastTest, CheckedCastReportsErrorForInvalidInput) {
+  auto const ok = conversion::checked_cast<int>(42u);
+  ASSERT_TRUE(ok.has_value());
+  EXPECT_EQ(*ok, 42);
+
+  auto const bad = conversion::checked_cast<std::uint16_t>(-7);
+  ASSERT_FALSE(bad.has_value());
+  EXPECT_EQ(bad.error(), conversion::risk::kind::underflow);
+}
+#endif

tests/basic/conversion/underlying/test_builtin_casts_ext.cpp

@@ -0,0 +1,21 @@
+#include <cstdint>
+#include <gtest/gtest.h>
+#include <limits>
+
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.conversion.underlying;
+import mcpplibs.primitives.underlying;
+
+using namespace mcpplibs::primitives;
+
+#if defined(_MSC_VER)
+TEST(ConversionCastTest, SaturatingCastSmokeOnMSVC) { SUCCEED(); }
+#else
+TEST(ConversionCastTest, SaturatingCastClampsAndHandlesNaN) {
+  EXPECT_EQ(conversion::saturating_cast<std::int16_t>(100000),
+            std::numeric_limits<std::int16_t>::max());
+  EXPECT_EQ(conversion::saturating_cast<int>(
+                std::numeric_limits<double>::quiet_NaN()),
+            0);
+}
+#endif

tests/basic/conversion/underlying/test_underlying_casts.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <limits>
+
+import mcpplibs.primitives.underlying;
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.conversion.underlying;
+
+#include "../../support/conversion_box_types.hpp"
+
+using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::test_support::conversion;
+
+TEST(ConversionUnderlyingTest, CheckedCastUsesRepBridge) {
+  auto const ok = conversion::checked_cast<UnsignedBox>(SignedBox{42});
+  ASSERT_TRUE(ok.has_value());
+  EXPECT_EQ(ok->value, 42);
+
+  auto const bad = conversion::checked_cast<UnsignedBox>(SignedBox{-1});
+  ASSERT_FALSE(bad.has_value());
+  EXPECT_EQ(bad.error(), conversion::risk::kind::underflow);
+}
+
+TEST(ConversionUnderlyingTest, SaturatingCastClampsByUnderlyingRep) {
+  auto const saturated =
+      conversion::saturating_cast<UnsignedBox>(SignedBox{
+          std::numeric_limits<long long>::max()});
+  EXPECT_EQ(saturated.value, std::numeric_limits<std::uint16_t>::max());
+}
+
+TEST(ConversionUnderlyingTest, TruncatingAndExactCastSupportFloatingSources) {
+  auto const truncated = conversion::truncating_cast<SignedBox>(FloatBox{12.75});
+  EXPECT_EQ(truncated.value, 12);
+
+  auto const exact = conversion::exact_cast<SignedBox>(FloatBox{12.0});
+  ASSERT_TRUE(exact.has_value());
+  EXPECT_EQ(exact->value, 12);
+}

tests/basic/main.cpp

@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+auto main(int argc, char **argv) -> int {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}