Fix MockingBitGen bad-downcast UB and mock validator edge cases.

`absl::MockingBitGen` and `absl::MockUniform` previously triggered undefined
behavior or spurious crashes in valid tests:
* Registering expectations on `StrictMock<MockingBitGen>` or
  `NiceMock<MockingBitGen>` and invoking distributions through a
  `MockingBitGen&` reference cast between unrelated sibling classes (UBSan
  `bad-cast`) or lost the mock's strictness policy.
* When an unsatisfied gMock expectation failed and returned a default `0`,
  range validators still ran and aborted the test on out-of-range assertions
  instead of letting gMock report the expectation failure cleanly;
  cv/ref-qualified mock signatures also missed overload lookup keys.
* `MockUniform` rejected valid closed `DBL_MAX` bounds and skipped bounds
  validation on non-open adjacent floats.

PiperOrigin-RevId: 1022541353
diff --git a/absl/random/BUILD.bazel b/absl/random/BUILD.bazel
index 162e328..d8c87fd 100644
--- a/absl/random/BUILD.bazel
+++ b/absl/random/BUILD.bazel
@@ -498,6 +498,8 @@
         ":mock_distributions",
         ":mocking_bit_gen",
         ":random",
+        "//absl/random/internal:distribution_caller",
+        "//absl/random/internal:mock_overload_set",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
@@ -519,6 +521,7 @@
         ":mocking_bit_gen",
         ":random",
         "//absl/numeric:int128",
+        "//absl/random/internal:mock_validators",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index cef4ab5..20565c3 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -157,6 +157,7 @@
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::random_distributions
+    absl::random_internal_mock_validators
     absl::random_mocking_bit_gen
     absl::random_random
     GTest::gmock
@@ -174,6 +175,8 @@
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::random_bit_gen_ref
+    absl::random_internal_distribution_caller
+    absl::random_internal_mock_overload_set
     absl::random_mocking_bit_gen
     absl::random_random
     GTest::gmock
@@ -1231,6 +1234,7 @@
     absl::random_internal_iostream_state_saver
     absl::random_internal_uniform_helper
     absl::raw_logging_internal
+    absl::str_format
     absl::string_view
     absl::strings
   TESTONLY
diff --git a/absl/random/internal/BUILD.bazel b/absl/random/internal/BUILD.bazel
index 04f9a27..7cabf78 100644
--- a/absl/random/internal/BUILD.bazel
+++ b/absl/random/internal/BUILD.bazel
@@ -806,6 +806,7 @@
         "//absl/base:config",
         "//absl/base:raw_logging_internal",
         "//absl/strings",
+        "//absl/strings:str_format",
         "//absl/strings:string_view",
     ],
 )
diff --git a/absl/random/internal/mock_overload_set.h b/absl/random/internal/mock_overload_set.h
index a3b15ee..f641156 100644
--- a/absl/random/internal/mock_overload_set.h
+++ b/absl/random/internal/mock_overload_set.h
@@ -29,19 +29,15 @@
 namespace random_internal {
 
 template <typename DistrT, typename ValidatorT, typename Fn>
-struct MockSingleOverload;
+struct MockSingleOverloadImpl;
 
-// MockSingleOverload
-//
-// MockSingleOverload hooks in to gMock's `ON_CALL` and `EXPECT_CALL` macros.
-// EXPECT_CALL(mock_single_overload, Call(...))` will expand to a call to
-// `mock_single_overload.gmock_Call(...)`. Because expectations are stored on
-// the MockingBitGen (an argument passed inside `Call(...)`), this forwards to
-// arguments to MockingBitGen::Register.
-//
-// The underlying KeyT must match the KeyT constructed by DistributionCaller.
+// MockSingleOverloadImpl expects its signature parameter types to already be
+// decayed so that KeyT and Matcher<...> use plain template parameters (avoiding
+// an MSVC template substitution bug with std::decay_t packs in trailing return
+// types).
 template <typename DistrT, typename ValidatorT, typename Ret, typename... Args>
-struct MockSingleOverload<DistrT, ValidatorT, Ret(MockingBitGen&, Args...)> {
+struct MockSingleOverloadImpl<DistrT, ValidatorT,
+                              Ret(MockingBitGen&, Args...)> {
   static_assert(std::is_same_v<typename DistrT::result_type, Ret>,
                 "Overload signature must have return type matching the "
                 "distribution result_type.");
@@ -60,8 +56,8 @@
 
 template <typename DistrT, typename ValidatorT, typename Ret, typename Arg,
           typename... Args>
-struct MockSingleOverload<DistrT, ValidatorT,
-                          Ret(Arg, MockingBitGen&, Args...)> {
+struct MockSingleOverloadImpl<DistrT, ValidatorT,
+                              Ret(Arg, MockingBitGen&, Args...)> {
   static_assert(std::is_same_v<typename DistrT::result_type, Ret>,
                 "Overload signature must have return type matching the "
                 "distribution result_type.");
@@ -79,6 +75,45 @@
   }
 };
 
+template <typename DistrT, typename ValidatorT, typename Fn>
+struct MockSingleOverload;
+
+// MockSingleOverload
+//
+// MockSingleOverload hooks in to gMock's `ON_CALL` and `EXPECT_CALL` macros.
+// EXPECT_CALL(mock_single_overload, Call(...))` will expand to a call to
+// `mock_single_overload.gmock_Call(...)`. Because expectations are stored on
+// the MockingBitGen (an argument passed inside `Call(...)`), this forwards to
+// arguments to MockingBitGen::Register.
+//
+// The underlying KeyT must match the KeyT constructed by DistributionCaller.
+template <typename DistrT, typename ValidatorT, typename Ret, typename... Args>
+struct MockSingleOverload<DistrT, ValidatorT, Ret(MockingBitGen&, Args...)>
+    : public MockSingleOverloadImpl<DistrT, ValidatorT,
+                                    Ret(MockingBitGen&,
+                                        typename std::decay<Args>::type...)> {
+  using Base = MockSingleOverloadImpl<DistrT, ValidatorT,
+                                      Ret(MockingBitGen&,
+                                          typename std::decay<Args>::type...)>;
+  using Base::gmock_Call;
+  using typename Base::KeyT;
+};
+
+template <typename DistrT, typename ValidatorT, typename Ret, typename Arg,
+          typename... Args>
+struct MockSingleOverload<DistrT, ValidatorT, Ret(Arg, MockingBitGen&, Args...)>
+    : public MockSingleOverloadImpl<DistrT, ValidatorT,
+                                    Ret(typename std::decay<Arg>::type,
+                                        MockingBitGen&,
+                                        typename std::decay<Args>::type...)> {
+  using Base =
+      MockSingleOverloadImpl<DistrT, ValidatorT,
+                             Ret(typename std::decay<Arg>::type, MockingBitGen&,
+                                 typename std::decay<Args>::type...)>;
+  using Base::gmock_Call;
+  using typename Base::KeyT;
+};
+
 // MockOverloadSetWithValidator
 //
 // MockOverloadSetWithValidator is a wrapper around MockOverloadSet which takes
diff --git a/absl/random/internal/mock_validators.h b/absl/random/internal/mock_validators.h
index d76d169..2fe55b7 100644
--- a/absl/random/internal/mock_validators.h
+++ b/absl/random/internal/mock_validators.h
@@ -15,6 +15,7 @@
 #ifndef ABSL_RANDOM_INTERNAL_MOCK_VALIDATORS_H_
 #define ABSL_RANDOM_INTERNAL_MOCK_VALIDATORS_H_
 
+#include <limits>
 #include <type_traits>
 
 #include "absl/base/config.h"
@@ -22,6 +23,7 @@
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/uniform_helper.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
 namespace absl {
@@ -62,17 +64,54 @@
   static absl::string_view TagUbBound(IntervalClosedClosedTag) { return "]"; }
   static absl::string_view TagUbBound(IntervalOpenClosedTag) { return "]"; }
 
+  static bool CheckLowerBound(IntervalClosedOpenTag, NumType x, NumType lo) {
+    return lo <= x;
+  }
+  static bool CheckLowerBound(IntervalClosedClosedTag, NumType x, NumType lo) {
+    return lo <= x;
+  }
+  static bool CheckLowerBound(IntervalOpenOpenTag, NumType x, NumType lo) {
+    return lo < x;
+  }
+  static bool CheckLowerBound(IntervalOpenClosedTag, NumType x, NumType lo) {
+    return lo < x;
+  }
+  static bool CheckUpperBound(IntervalClosedOpenTag, NumType x, NumType hi) {
+    return x < hi;
+  }
+  static bool CheckUpperBound(IntervalOpenOpenTag, NumType x, NumType hi) {
+    return x < hi;
+  }
+  static bool CheckUpperBound(IntervalClosedClosedTag, NumType x, NumType hi) {
+    return x <= hi;
+  }
+  static bool CheckUpperBound(IntervalOpenClosedTag, NumType x, NumType hi) {
+    return x <= hi;
+  }
+
   template <typename TagType>
   static void ValidateImpl(std::true_type /* is_floating_point */, NumType x,
                            TagType tag, NumType lo, NumType hi) {
-    UniformDistributionWrapper<NumType> dist(tag, lo, hi);
-    NumType lb = dist.a();
-    NumType ub = dist.b();
-    // uniform_real_distribution is always closed-open, so the upper bound is
-    // always non-inclusive.
-    ABSL_INTERNAL_CHECK(lb <= x && x < ub,
-                        absl::StrCat(x, " is not in ", TagLbBound(tag), lo,
-                                     ", ", hi, TagUbBound(tag)));
+    if (lo > hi && (x == lo || x == hi)) {
+      return;
+    }
+    // For open intervals between adjacent floats (e.g. (1, nextafter(1, 2))),
+    // no representable value lies strictly inside (lo, hi); allow either bound.
+    if constexpr (std::is_same_v<TagType, IntervalOpenOpenTag>) {
+      if (uniform_lower_bound(tag, lo, hi) >=
+              uniform_upper_bound(tag, lo, hi) &&
+          (x == lo || x == hi)) {
+        return;
+      }
+    }
+    auto fmt = [](NumType v) {
+      return absl::StrFormat("%.*g", std::numeric_limits<NumType>::max_digits10,
+                             v);
+    };
+    ABSL_INTERNAL_CHECK(
+        CheckLowerBound(tag, x, lo) && CheckUpperBound(tag, x, hi),
+        absl::StrCat(fmt(x), " is not in ", TagLbBound(tag), fmt(lo), ", ",
+                     fmt(hi), TagUbBound(tag)));
   }
 
   template <typename TagType>
@@ -81,9 +120,11 @@
     using stream_type =
         typename random_internal::stream_format_type<NumType>::type;
 
-    UniformDistributionWrapper<NumType> dist(tag, lo, hi);
-    NumType lb = dist.a();
-    NumType ub = dist.b();
+    const NumType lb = uniform_lower_bound(tag, lo, hi);
+    const NumType ub = uniform_upper_bound(tag, lo, hi);
+    if (lb > ub && (x == lo || x == hi)) {
+      return;
+    }
     ABSL_INTERNAL_CHECK(
         lb <= x && x <= ub,
         absl::StrCat(stream_type{x}, " is not in ", TagLbBound(tag),
diff --git a/absl/random/mock_distributions_test.cc b/absl/random/mock_distributions_test.cc
index 93af3f9..2631a4d 100644
--- a/absl/random/mock_distributions_test.cc
+++ b/absl/random/mock_distributions_test.cc
@@ -18,9 +18,11 @@
 #include <limits>
 
 #include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 #include "absl/numeric/int128.h"
 #include "absl/random/distributions.h"
+#include "absl/random/internal/mock_validators.h"
 #include "absl/random/mocking_bit_gen.h"
 #include "absl/random/random.h"
 
@@ -106,6 +108,55 @@
           Return(std::nextafter(1.0, std::numeric_limits<double>::infinity())));
   EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, 10.0),
             std::nextafter(1.0, std::numeric_limits<double>::infinity()));
+
+  constexpr double kMax = (std::numeric_limits<double>::max)();
+  EXPECT_CALL(absl::MockUniform<double>(),
+              Call(absl::IntervalClosed, gen, 0.0, kMax))
+      .WillOnce(Return(kMax));
+  EXPECT_EQ(absl::Uniform<double>(absl::IntervalClosed, gen, 0.0, kMax), kMax);
+
+  EXPECT_CALL(absl::MockUniform<double>(),
+              Call(absl::IntervalOpenClosed, gen, 0.0, kMax))
+      .WillOnce(Return(kMax));
+  EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpenClosed, gen, 0.0, kMax),
+            kMax);
+
+  const double prev_max = std::nextafter(kMax, 0.0);
+  EXPECT_CALL(absl::MockUniform<double>(),
+              Call(absl::IntervalOpenClosed, gen, prev_max, kMax))
+      .WillOnce(Return(kMax));
+  EXPECT_EQ(
+      absl::Uniform<double>(absl::IntervalOpenClosed, gen, prev_max, kMax),
+      kMax);
+
+  const double next = std::nextafter(1.0, 2.0);
+  EXPECT_CALL(absl::MockUniform<double>(),
+              Call(absl::IntervalOpen, gen, 1.0, next))
+      .WillOnce(Return(1.0))
+      .WillOnce(Return(next));
+  EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, next), 1.0);
+  EXPECT_EQ(absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, next), next);
+}
+
+TEST(MockDistributions, UniformValidatorHandlesDegenerateRangesDirectly) {
+  using IntValidator = absl::random_internal::UniformDistributionValidator<int>;
+  using DoubleValidator =
+      absl::random_internal::UniformDistributionValidator<double>;
+
+  // Inverted, boundary-overflowing, or degenerate ranges must return cleanly
+  // without hitting distribution debug assertions or crashing.
+  EXPECT_NO_FATAL_FAILURE({
+    IntValidator::Validate(1, absl::IntervalOpen, 1, 2);
+    IntValidator::Validate(2, absl::IntervalOpen, 1, 2);
+    IntValidator::Validate(10, absl::IntervalClosedOpen, 10, 1);
+    IntValidator::Validate(1, absl::IntervalClosedOpen, 10, 1);
+
+    DoubleValidator::Validate(10.0, absl::IntervalClosedOpen, 10.0, 1.0);
+    DoubleValidator::Validate(1.0, absl::IntervalClosedOpen, 10.0, 1.0);
+    constexpr double kMax = (std::numeric_limits<double>::max)();
+    DoubleValidator::Validate(0.0, absl::IntervalClosed, -kMax, kMax);
+    DoubleValidator::Validate(kMax, absl::IntervalClosed, -kMax, kMax);
+  });
 }
 
 TEST(MockDistributions, UniformDoubleEmptyRangesAllowTheBoundary) {
@@ -276,6 +327,177 @@
                   1.0);
       },
       " 1 is not in \\(1, 10\\)");
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalClosed, gen, 1.0, 10.0))
+            .WillOnce(Return(0.5));
+        absl::Uniform<double>(absl::IntervalClosed, gen, 1.0, 10.0);
+      },
+      " 0.5 is not in \\[1, 10\\]");
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalClosed, gen, 1.0, 10.0))
+            .WillOnce(Return(10.5));
+        absl::Uniform<double>(absl::IntervalClosed, gen, 1.0, 10.0);
+      },
+      " 10.5 is not in \\[1, 10\\]");
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalOpenClosed, gen, 1.0, 10.0))
+            .WillOnce(Return(1.0));
+        absl::Uniform<double>(absl::IntervalOpenClosed, gen, 1.0, 10.0);
+      },
+      " 1 is not in \\(1, 10\\]");
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalOpenClosed, gen, 1.0, 10.0))
+            .WillOnce(Return(10.5));
+        absl::Uniform<double>(absl::IntervalOpenClosed, gen, 1.0, 10.0);
+      },
+      " 10.5 is not in \\(1, 10\\]");
+
+  constexpr double kMax = (std::numeric_limits<double>::max)();
+  const double prev_max = std::nextafter(kMax, 0.0);
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalOpenClosed, gen, prev_max, kMax))
+            .WillOnce(Return(prev_max));
+        absl::Uniform<double>(absl::IntervalOpenClosed, gen, prev_max, kMax);
+      },
+      "1\\.7976931348623155e\\+308 is not in "
+      "\\(1\\.7976931348623155e\\+308, 1\\.7976931348623157e\\+308\\]");
+
+  const double next = std::nextafter(1.0, 2.0);
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalOpen, gen, 1.0, next))
+            .WillOnce(Return(0.5));
+        absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, next);
+      },
+      " 0.5 is not in \\(1, 1\\.0000000000000002\\)");
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        EXPECT_CALL(absl::MockUniform<double>(),
+                    Call(absl::IntervalOpen, gen, 1.0, next))
+            .WillOnce(Return(2.0));
+        absl::Uniform<double>(absl::IntervalOpen, gen, 1.0, next);
+      },
+      " 2 is not in \\(1, 1\\.0000000000000002\\)");
+}
+
+TEST(MockUniformDeathTest, SucceedInCallbackDoesNotSkipValidation) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        absl::MockingBitGen gen;
+        EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+            .WillOnce([](int, int) {
+              SUCCEED();
+              return 0;
+            });
+        absl::Uniform<int>(gen, 10, 100);
+      },
+      " 0 is not in \\[10, 100\\)");
+}
+
+TEST(MockUniformDeathTest, NestedCallsDoNotSuppressOuterValidation) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        absl::MockingBitGen gen;
+        EXPECT_CALL(absl::MockUniform<double>(), Call(gen, 1.0, 2.0))
+            .WillOnce(Return(1.5));
+        EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+            .WillOnce([&gen](int, int) {
+              // Consumed failure inside an inner scope must not suppress
+              // validation on the enclosing call.
+              EXPECT_NONFATAL_FAILURE(
+                  (void)absl::Uniform<double>(gen, 5.0, 10.0),
+                  "Unexpected mock function call");
+              return 0;
+            });
+        absl::Uniform<int>(gen, 10, 100);
+      },
+      " 0 is not in \\[10, 100\\)");
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        ::testing::NiceMock<absl::MockingBitGen> gen;
+        ON_CALL(absl::MockUniform<double>(), Call(gen, 1.0, 2.0))
+            .WillByDefault(Return(1.5));
+        EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+            .WillOnce([&gen](int, int) {
+              // Non-failing default action returning in-range 0.0 must not
+              // suppress validation on the enclosing call.
+              EXPECT_EQ(absl::Uniform<double>(gen, 0.0, 10.0), 0.0);
+              return 0;
+            });
+        absl::Uniform<int>(gen, 10, 100);
+      },
+      " 0 is not in \\[10, 100\\)");
+}
+
+TEST(MockUniformDeathTest, SilentDefaultActionsStillValidate) {
+  // Naggy (default) uninteresting call returns default 0 and must abort.
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        absl::MockingBitGen gen;
+        ON_CALL(absl::MockUniform<int>(), Call(gen, 1, 10))
+            .WillByDefault(Return(5));
+        absl::Uniform<int>(gen, 20, 30);
+      },
+      " 0 is not in \\[20, 30\\)");
+
+  // NiceMock uninteresting call returns default 0 and must abort.
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        ::testing::NiceMock<absl::MockingBitGen> gen;
+        ON_CALL(absl::MockUniform<int>(), Call(gen, 1, 10))
+            .WillByDefault(Return(5));
+        absl::Uniform<int>(gen, 20, 30);
+      },
+      " 0 is not in \\[20, 30\\)");
+
+  // EXPECT_CALL with no action returns default 0 and must abort.
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        absl::MockingBitGen gen;
+        EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100));
+        absl::Uniform<int>(gen, 10, 100);
+      },
+      " 0 is not in \\[10, 100\\)");
+
+  // EXPECT_CALL with explicit DoDefault() returns default 0 and must abort.
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        absl::MockingBitGen gen;
+        EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+            .WillOnce(::testing::DoDefault());
+        absl::Uniform<int>(gen, 10, 100);
+      },
+      " 0 is not in \\[10, 100\\)");
+
+  // Exhausted .Times(2).WillOnce(...) below upper bound returns default 0 and
+  // must abort.
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        absl::MockingBitGen gen;
+        EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+            .Times(2)
+            .WillOnce(Return(42));
+        EXPECT_EQ(absl::Uniform<int>(gen, 10, 100), 42);
+        absl::Uniform<int>(gen, 10, 100);
+      },
+      " 0 is not in \\[10, 100\\)");
 }
 
 }  // namespace
diff --git a/absl/random/mocking_bit_gen.h b/absl/random/mocking_bit_gen.h
index 2e3c606..d4fdfec 100644
--- a/absl/random/mocking_bit_gen.h
+++ b/absl/random/mocking_bit_gen.h
@@ -34,6 +34,7 @@
 #include <utility>
 
 #include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
 #include "absl/base/config.h"
 #include "absl/base/fast_type_id.h"
 #include "absl/container/flat_hash_map.h"
@@ -121,9 +122,33 @@
   struct MockFnCaller<MockFnType, ValidatorT, ResultT, std::tuple<Args...>> {
     MockFnType* fn;
     inline ResultT operator()(Args... args) {
-      ResultT result = fn->Call(args...);
-      ValidatorT::Validate(result, args...);
-      return result;
+      if constexpr (std::is_same_v<ValidatorT,
+                                   random_internal::NoOpValidator>) {
+        return fn->Call(args...);
+      } else {
+        MockFnType* const fn_ptr = fn;
+        ::testing::TestPartResultArray parts;
+        ResultT result = [&]() {
+          ::testing::ScopedFakeTestPartResultReporter reporter(
+              ::testing::ScopedFakeTestPartResultReporter::
+                  INTERCEPT_ONLY_CURRENT_THREAD,
+              &parts);
+          return fn_ptr->Call(args...);
+        }();
+        bool has_failure = false;
+        for (int i = 0; i < parts.size(); ++i) {
+          const ::testing::TestPartResult& part = parts.GetTestPartResult(i);
+          if (part.failed()) {
+            has_failure = true;
+          }
+          GTEST_MESSAGE_AT_(part.file_name(), part.line_number(),
+                            part.summary(), part.type());
+        }
+        if (!has_failure) {
+          ValidatorT::Validate(result, args...);
+        }
+        return result;
+      }
     }
   };
 
@@ -140,20 +165,29 @@
                        /*ResultT*/ void* result) = 0;
   };
 
-  template <typename MockFnType, typename ValidatorT, typename ResultT,
-            typename ArgTupleT>
-  class FunctionHolderImpl final : public FunctionHolder {
+  template <typename BaseMockFnType>
+  class TypedFunctionHolder : public FunctionHolder {
    public:
+    virtual BaseMockFnType& GetMockFn() = 0;
+  };
+
+  template <typename WrappedFnType, typename BaseMockFnType,
+            typename ValidatorT, typename ResultT, typename ArgTupleT>
+  class FunctionHolderImpl final : public TypedFunctionHolder<BaseMockFnType> {
+   public:
+    BaseMockFnType& GetMockFn() final { return mock_fn_; }
+
     void Apply(void* args_tuple, void* result) final {
       // Requires tuple_args to point to a ArgTupleT, which is a
       // std::tuple<Args...> used to invoke the mock function. Requires result
       // to point to a ResultT, which is the result of the call.
       *static_cast<ResultT*>(result) = std::apply(
-          MockFnCaller<MockFnType, ValidatorT, ResultT, ArgTupleT>{&mock_fn_},
+          MockFnCaller<BaseMockFnType, ValidatorT, ResultT, ArgTupleT>{
+              &mock_fn_},
           *static_cast<ArgTupleT*>(args_tuple));
     }
 
-    MockFnType mock_fn_;
+    WrappedFnType mock_fn_;
   };
 
   // MockingBitGen::RegisterMock
@@ -166,31 +200,33 @@
   //
   // The returned MockFunction<...> type can be used to setup additional
   // distribution parameters of the expectation.
+  // SelfT is retained for the MockHelpers::MockFor call shape; strictness is
+  // detected dynamically below via ::testing::Mock::IsNice/IsStrict(this).
   template <typename ResultT, typename ArgTupleT, typename SelfT,
             typename ValidatorT>
   auto RegisterMock(SelfT&, FastTypeIdType type, ValidatorT)
       -> decltype(GetMockFnType(std::declval<ResultT>(),
                                 std::declval<ArgTupleT>()))& {
-    using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
-                                              std::declval<ArgTupleT>()));
-
-    using WrappedFnType = std::conditional_t<
-        std::is_same_v<SelfT, ::testing::NiceMock<MockingBitGen>>,
-        ::testing::NiceMock<MockFnType>,
-        std::conditional_t<
-            std::is_same_v<SelfT, ::testing::NaggyMock<MockingBitGen>>,
-            ::testing::NaggyMock<MockFnType>,
-            std::conditional_t<
-                std::is_same_v<SelfT, ::testing::StrictMock<MockingBitGen>>,
-                ::testing::StrictMock<MockFnType>, MockFnType>>>;
-
-    using ImplT =
-        FunctionHolderImpl<WrappedFnType, ValidatorT, ResultT, ArgTupleT>;
+    using BaseMockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
+                                                  std::declval<ArgTupleT>()));
     auto& mock = mocks_[type];
     if (!mock) {
-      mock = std::make_unique<ImplT>();
+      if (::testing::Mock::IsNice(this)) {
+        mock = std::make_unique<FunctionHolderImpl<
+            ::testing::NiceMock<BaseMockFnType>, BaseMockFnType, ValidatorT,
+            ResultT, ArgTupleT>>();
+      } else if (::testing::Mock::IsStrict(this)) {
+        mock = std::make_unique<FunctionHolderImpl<
+            ::testing::StrictMock<BaseMockFnType>, BaseMockFnType, ValidatorT,
+            ResultT, ArgTupleT>>();
+      } else {
+        mock = std::make_unique<FunctionHolderImpl<
+            ::testing::NaggyMock<BaseMockFnType>, BaseMockFnType, ValidatorT,
+            ResultT, ArgTupleT>>();
+      }
     }
-    return static_cast<ImplT*>(mock.get())->mock_fn_;
+    return static_cast<TypedFunctionHolder<BaseMockFnType>*>(mock.get())
+        ->GetMockFn();
   }
 
   // MockingBitGen::InvokeMock
diff --git a/absl/random/mocking_bit_gen_test.cc b/absl/random/mocking_bit_gen_test.cc
index 26e673a..b716d19 100644
--- a/absl/random/mocking_bit_gen_test.cc
+++ b/absl/random/mocking_bit_gen_test.cc
@@ -20,12 +20,16 @@
 #include <cstdint>
 #include <iterator>
 #include <numeric>
+#include <string>
+#include <thread>  // NOLINT
 #include <vector>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 #include "absl/random/bit_gen_ref.h"
+#include "absl/random/internal/distribution_caller.h"
+#include "absl/random/internal/mock_overload_set.h"
 #include "absl/random/mock_distributions.h"
 #include "absl/random/random.h"
 
@@ -400,4 +404,155 @@
       "over-saturated and active");
 }
 
+TEST(MockingBitGen, MixedStrictAndBaseReferenceNoBadDowncast) {
+  ::testing::StrictMock<absl::MockingBitGen> strict_gen;
+  absl::MockingBitGen& base_ref = strict_gen;
+
+  ON_CALL(absl::MockUniform<int>(), Call(strict_gen, 1, 100))
+      .WillByDefault(Return(10));
+  EXPECT_CALL(absl::MockUniform<int>(), Call(base_ref, 1, 100))
+      .WillOnce(Return(42));
+  EXPECT_EQ(absl::Uniform(strict_gen, 1, 100), 42);
+}
+
+TEST(MockingBitGen, StrictMockRegisteredViaBaseReferenceStaysStrict) {
+  ::testing::StrictMock<absl::MockingBitGen> strict_gen;
+  absl::MockingBitGen& base_ref = strict_gen;
+
+  ON_CALL(absl::MockUniform<int>(), Call(base_ref, 1, 100))
+      .WillByDefault(Return(10));
+  EXPECT_NONFATAL_FAILURE(
+      [&]() { EXPECT_EQ(absl::Uniform(strict_gen, 1, 100), 10); }(),
+      "Uninteresting mock function call");
+
+  EXPECT_CALL(absl::MockUniform<int>(), Call(strict_gen, 1, 100))
+      .WillOnce(Return(42));
+  EXPECT_EQ(absl::Uniform(base_ref, 1, 100), 42);
+}
+
+TEST(MockingBitGen, NiceMockRegisteredViaBaseReference) {
+  ::testing::NiceMock<absl::MockingBitGen> nice_gen;
+  absl::MockingBitGen& base_ref = nice_gen;
+
+  ON_CALL(absl::MockUniform<int>(), Call(base_ref, 1, 100))
+      .WillByDefault(Return(10));
+  EXPECT_EQ(absl::Uniform(nice_gen, 1, 100), 10);
+}
+
+TEST(MockingBitGen, FailedExpectationSkipsValidation) {
+  absl::MockingBitGen gen;
+
+  EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+      .WillOnce(Return(42));
+  EXPECT_EQ(absl::Uniform(gen, 10, 100), 42);
+
+  // Over-saturated expectation returns default value 0, which is outside
+  // [10, 100); validation must be skipped instead of aborting.
+  EXPECT_NONFATAL_FAILURE(
+      [&]() { EXPECT_EQ(absl::Uniform(gen, 10, 100), 0); }(),
+      "over-saturated and active");
+
+  // Unmatched call also falls back to default value 0 without aborting.
+  EXPECT_NONFATAL_FAILURE(
+      [&]() { EXPECT_EQ(absl::Uniform(gen, 200, 300), 0); }(),
+      "Unexpected mock function call");
+
+  // Non-fatal failure inside an action callback also skips validation.
+  EXPECT_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+      .WillOnce([](int, int) {
+        ADD_FAILURE() << "callback failure";
+        return 0;
+      });
+  EXPECT_NONFATAL_FAILURE(
+      [&]() { EXPECT_EQ(absl::Uniform(gen, 10, 100), 0); }(),
+      "callback failure");
+}
+
+TEST(MockingBitGen, ConcurrentMockCallsAreThreadSafe) {
+  absl::MockingBitGen gen;
+  ON_CALL(absl::MockUniform<int>(), Call(gen, 10, 100))
+      .WillByDefault(Return(42));
+
+  static constexpr int kIterations = 200;
+  std::vector<std::thread> threads;
+  threads.reserve(5);
+  for (int i = 0; i < 3; ++i) {
+    threads.emplace_back([&gen]() {
+      for (int j = 0; j < kIterations; ++j) {
+        EXPECT_EQ(absl::Uniform(gen, 10, 100), 42);
+      }
+    });
+  }
+  threads.emplace_back([]() {
+    for (int j = 0; j < kIterations; ++j) {
+      SUCCEED();
+    }
+  });
+  threads.emplace_back([]() {
+    ::testing::StrictMock<absl::MockingBitGen> local_gen;
+    EXPECT_CALL(absl::MockUniform<int>(), Call(local_gen, 1, 5)).Times(0);
+    for (int j = 0; j < 20; ++j) {
+      EXPECT_NONFATAL_FAILURE(
+          [&]() { EXPECT_EQ(absl::Uniform(local_gen, 10, 100), 0); }(),
+          "Unexpected mock function call");
+    }
+  });
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+struct NonDecayedParamDistribution {
+  using result_type = int;
+
+  explicit NonDecayedParamDistribution(const std::string& s)
+      : value(static_cast<int>(s.size())) {}
+  NonDecayedParamDistribution(int x, int y) : value(x + y) {}
+  explicit NonDecayedParamDistribution(const int* arr)
+      : value(arr[0] + arr[1] + arr[2]) {}
+  NonDecayedParamDistribution(const std::string& tag, int x)
+      : value(static_cast<int>(tag.size()) + x) {}
+
+  template <typename URBG>
+  int operator()(URBG&) const {
+    return value;
+  }
+
+  int value = 0;
+};
+
+using MockNonDecayedParamDistribution = absl::random_internal::MockOverloadSet<
+    NonDecayedParamDistribution, int(absl::MockingBitGen&, const std::string&),
+    int(absl::MockingBitGen&, int&, const int),
+    int(absl::MockingBitGen&, const int (&)[3]),
+    int(const std::string&, absl::MockingBitGen&, const int&)>;
+
+TEST(MockOverloadSet, DecaysParameterTypesForMatchers) {
+  absl::MockingBitGen gen;
+  using Caller = absl::random_internal::DistributionCaller<absl::MockingBitGen>;
+
+  ON_CALL(MockNonDecayedParamDistribution(), Call(gen, std::string("hello")))
+      .WillByDefault(Return(101));
+  std::string s = "hello";
+  EXPECT_EQ(Caller::Call<NonDecayedParamDistribution>(&gen, s), 101);
+
+  int x = 7;
+  const int y = 8;
+  EXPECT_CALL(MockNonDecayedParamDistribution(), Call(gen, 7, 8))
+      .WillOnce(Return(202));
+  EXPECT_EQ(Caller::Call<NonDecayedParamDistribution>(&gen, x, y), 202);
+
+  const int arr[3] = {1, 2, 3};
+  EXPECT_CALL(MockNonDecayedParamDistribution(), Call(gen, &arr[0]))
+      .WillOnce(Return(303));
+  EXPECT_EQ(Caller::Call<NonDecayedParamDistribution>(&gen, arr), 303);
+
+  const std::string tag = "tag";
+  const int z = 9;
+  EXPECT_CALL(MockNonDecayedParamDistribution(),
+              Call(std::string("tag"), gen, 9))
+      .WillOnce(Return(404));
+  EXPECT_EQ(Caller::Call<NonDecayedParamDistribution>(&gen, tag, z), 404);
+}
+
 }  // namespace