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