WIP: test fmt

catchorg · Dec 10, 2023 · d53777a · d53777a
1 parent fb6abcf
commit d53777a
Show file tree

Hide file tree

Showing 2 changed files with 57 additions and 3 deletions.
diff --git a/src/catch2/internal/catch_uniform_floating_point_distribution.hpp b/src/catch2/internal/catch_uniform_floating_point_distribution.hpp
@@ -10,10 +10,10 @@
 #define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
 
 #include <catch2/internal/catch_random_floating_point_helpers.hpp>
+#include <catch2/internal/catch_uniform_integer_distribution.hpp>
 
 #include <cmath>
 #include <type_traits>
-#include <random>
 
 namespace Catch {
 
@@ -76,8 +76,7 @@ class uniform_floating_point_distribution {
     FloatType m_a, m_b;
     FloatType m_ulp_magnitude;
     WidthType m_floats_in_range;
-    // TODO: we want to eventually replace this distribution with our own for reproducibility
-    std::uniform_int_distribution<WidthType> m_int_dist;
+    uniform_integer_distribution<WidthType> m_int_dist;
 
     // In specific cases, we can overflow into `inf` when computing the
     // `steps * g` offset. To avoid this, we don't offset by more than this

diff --git a/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp b/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp
@@ -16,6 +16,12 @@
 #include <catch2/generators/catch_generators.hpp>
 #include <catch2/matchers/catch_matchers_range_equals.hpp>
 
+#include <random>
+
+
+#include <format>
+#include <iostream>
+
 TEST_CASE("Our PCG implementation provides expected results for known seeds", "[rng]") {
     Catch::SimplePcg32 rng;
     SECTION("Default seeded") {
@@ -489,3 +495,52 @@ TEMPLATE_TEST_CASE( "uniform_integer_distribution is reproducible",
 
     REQUIRE_THAT(generated, Catch::Matchers::RangeEquals(uniform_integer_test_params<TestType>::expected));
 }
+
+
+namespace {
+    template <typename T>
+    struct uniform_fp_test_params;
+
+    template<>
+    struct uniform_fp_test_params<float> {
+        // We picked these to be exactly representable
+        static constexpr float lowest = -256.125f;
+        static constexpr float highest = 385.125f;
+        static constexpr float expected[] = { 0.0f };
+    };
+    template <>
+    struct uniform_fp_test_params<double> {
+        static constexpr double lowest = 111;
+        static constexpr double highest = 123;
+        static constexpr double expected[] = { 0.0 };
+    };
+
+// We need these definitions for C++14 and earlier, but
+// GCC will complain about them in newer C++ standards
+#if __cplusplus <= 201402L
+    constexpr float uniform_fp_test_params<float>::expected[];
+    constexpr double uniform_fp_test_params<double>::expected[];
+#endif
+} // namespace
+
+TEMPLATE_TEST_CASE( "uniform_floating_point_distribution is reproducible",
+                    "[rng][distribution][floating-point][approvals]",
+                    float,
+                    double ) {
+    Catch::SimplePcg32 pcg( 0xaabb'aabb );
+
+    const auto lowest = uniform_fp_test_params<TestType>::lowest;
+    const auto highest = uniform_fp_test_params<TestType>::highest;
+    Catch::uniform_floating_point_distribution<TestType> dist( lowest, highest );
+
+    constexpr auto iters = 15;
+    std::array<TestType, iters> generated;
+    for ( int i = 0; i < iters; ++i ) {
+        generated[i] = dist( pcg );
+        std::cout << std::format( "{}\n", generated[i] );
+    }
+
+
+
+//    REQUIRE_THAT( generated, Catch::Matchers::RangeEquals( uniform_fp_test_params<TestType>::expected ) );
+}