diff options
Diffstat (limited to 'absl')
-rw-r--r-- | absl/base/internal/invoke.h | 131 | ||||
-rw-r--r-- | absl/base/invoke_test.cc | 34 | ||||
-rw-r--r-- | absl/functional/bind_front_test.cc | 19 | ||||
-rw-r--r-- | absl/random/CMakeLists.txt | 17 | ||||
-rw-r--r-- | absl/random/bit_gen_ref.h | 2 | ||||
-rw-r--r-- | absl/random/internal/BUILD.bazel | 11 | ||||
-rw-r--r-- | absl/random/internal/distribution_caller.h | 18 | ||||
-rw-r--r-- | absl/random/internal/mock_helpers.h | 127 | ||||
-rw-r--r-- | absl/random/internal/mock_overload_set.h | 27 | ||||
-rw-r--r-- | absl/random/mocking_bit_gen.h | 7 |
10 files changed, 210 insertions, 183 deletions
diff --git a/absl/base/internal/invoke.h b/absl/base/internal/invoke.h index ab5ad910..c4eceebd 100644 --- a/absl/base/internal/invoke.h +++ b/absl/base/internal/invoke.h @@ -18,19 +18,16 @@ // [func.require] // Define INVOKE (f, t1, t2, ..., tN) as follows: // 1. (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T -// and is_base_of_v<T, remove_reference_t<decltype(t1)>> is true; -// 2. (t1.get().*f)(t2, ..., tN) when f is a pointer to a member function of a -// class T and remove_cvref_t<decltype(t1)> is a specialization of -// reference_wrapper; -// 3. ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a -// class T and t1 does not satisfy the previous two items; -// 4. t1.*f when N == 1 and f is a pointer to data member of a class T and -// is_base_of_v<T, remove_reference_t<decltype(t1)>> is true; -// 5. t1.get().*f when N == 1 and f is a pointer to data member of a class T and -// remove_cvref_t<decltype(t1)> is a specialization of reference_wrapper; -// 6. (*t1).*f when N == 1 and f is a pointer to data member of a class T and t1 -// does not satisfy the previous two items; -// 7. f(t1, t2, ..., tN) in all other cases. +// and t1 is an object of type T or a reference to an object of type T or a +// reference to an object of a type derived from T; +// 2. ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a +// class T and t1 is not one of the types described in the previous item; +// 3. t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is +// an object of type T or a reference to an object of type T or a reference +// to an object of a type derived from T; +// 4. (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 +// is not one of the types described in the previous item; +// 5. f(t1, t2, ..., tN) in all other cases. // // The implementation is SFINAE-friendly: substitution failure within Invoke() // isn't an error. @@ -51,16 +48,7 @@ namespace absl { ABSL_NAMESPACE_BEGIN namespace base_internal { -template <typename T> -struct IsReferenceWrapper : std::false_type {}; -template <typename T> -struct IsReferenceWrapper<std::reference_wrapper<T>> : std::true_type {}; - -template <typename T> -using RemoveCvrefT = - typename std::remove_cv<typename std::remove_reference<T>::type>::type; - -// The seven classes below each implement one of the clauses from the definition +// The five classes below each implement one of the clauses from the definition // of INVOKE. The inner class template Accept<F, Args...> checks whether the // clause is applicable; static function template Invoke(f, args...) does the // invocation. @@ -84,10 +72,9 @@ struct MemFunAndRef : StrippedAccept<MemFunAndRef> { template <typename MemFunType, typename C, typename Obj, typename... Args> struct AcceptImpl<MemFunType C::*, Obj, Args...> - : std::integral_constant< - bool, std::is_base_of< - C, typename std::remove_reference<Obj>::type>::value && - absl::is_function<MemFunType>::value> {}; + : std::integral_constant<bool, std::is_base_of<C, Obj>::value && + absl::is_function<MemFunType>::value> { + }; template <typename MemFun, typename Obj, typename... Args> static decltype((std::declval<Obj>().* @@ -98,41 +85,17 @@ struct MemFunAndRef : StrippedAccept<MemFunAndRef> { } }; -// (t1.get().*f)(t2, ..., tN) when f is a pointer to a member function of a -// class T and remove_cvref_t<decltype(t1)> is a specialization of -// reference_wrapper; -struct MemFunAndRefWrap : StrippedAccept<MemFunAndRefWrap> { - template <typename... Args> - struct AcceptImpl : std::false_type {}; - - template <typename MemFunType, typename C, typename RefWrap, typename... Args> - struct AcceptImpl<MemFunType C::*, RefWrap, Args...> - : std::integral_constant< - bool, IsReferenceWrapper<RemoveCvrefT<RefWrap>>::value && - absl::is_function<MemFunType>::value> {}; - - template <typename MemFun, typename RefWrap, typename... Args> - static decltype((std::declval<RefWrap>().get().* - std::declval<MemFun>())(std::declval<Args>()...)) - Invoke(MemFun&& mem_fun, RefWrap&& ref_wrap, Args&&... args) { - return (std::forward<RefWrap>(ref_wrap).get().* - std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...); - } -}; - // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a -// class T and t1 does not satisfy the previous two items; +// class T and t1 is not one of the types described in the previous item. struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> { template <typename... Args> struct AcceptImpl : std::false_type {}; template <typename MemFunType, typename C, typename Ptr, typename... Args> struct AcceptImpl<MemFunType C::*, Ptr, Args...> - : std::integral_constant< - bool, !std::is_base_of< - C, typename std::remove_reference<Ptr>::type>::value && - !IsReferenceWrapper<RemoveCvrefT<Ptr>>::value && - absl::is_function<MemFunType>::value> {}; + : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value && + absl::is_function<MemFunType>::value> { + }; template <typename MemFun, typename Ptr, typename... Args> static decltype(((*std::declval<Ptr>()).* @@ -143,18 +106,17 @@ struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> { } }; -// t1.*f when N == 1 and f is a pointer to data member of a class T and -// is_base_of_v<T, remove_reference_t<decltype(t1)>> is true; +// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is +// an object of type T or a reference to an object of type T or a reference +// to an object of a type derived from T. struct DataMemAndRef : StrippedAccept<DataMemAndRef> { template <typename... Args> struct AcceptImpl : std::false_type {}; template <typename R, typename C, typename Obj> struct AcceptImpl<R C::*, Obj> - : std::integral_constant< - bool, std::is_base_of< - C, typename std::remove_reference<Obj>::type>::value && - !absl::is_function<R>::value> {}; + : std::integral_constant<bool, std::is_base_of<C, Obj>::value && + !absl::is_function<R>::value> {}; template <typename DataMem, typename Ref> static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke( @@ -163,39 +125,16 @@ struct DataMemAndRef : StrippedAccept<DataMemAndRef> { } }; -// t1.get().*f when N == 1 and f is a pointer to data member of a class T and -// remove_cvref_t<decltype(t1)> is a specialization of reference_wrapper; -struct DataMemAndRefWrap : StrippedAccept<DataMemAndRefWrap> { - template <typename... Args> - struct AcceptImpl : std::false_type {}; - - template <typename R, typename C, typename RefWrap> - struct AcceptImpl<R C::*, RefWrap> - : std::integral_constant< - bool, IsReferenceWrapper<RemoveCvrefT<RefWrap>>::value && - !absl::is_function<R>::value> {}; - - template <typename DataMem, typename RefWrap> - static decltype(std::declval<RefWrap>().get().*std::declval<DataMem>()) - Invoke(DataMem&& data_mem, RefWrap&& ref_wrap) { - return std::forward<RefWrap>(ref_wrap).get().* - std::forward<DataMem>(data_mem); - } -}; - -// (*t1).*f when N == 1 and f is a pointer to data member of a class T and t1 -// does not satisfy the previous two items; +// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 +// is not one of the types described in the previous item. struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> { template <typename... Args> struct AcceptImpl : std::false_type {}; template <typename R, typename C, typename Ptr> struct AcceptImpl<R C::*, Ptr> - : std::integral_constant< - bool, !std::is_base_of< - C, typename std::remove_reference<Ptr>::type>::value && - !IsReferenceWrapper<RemoveCvrefT<Ptr>>::value && - !absl::is_function<R>::value> {}; + : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value && + !absl::is_function<R>::value> {}; template <typename DataMem, typename Ptr> static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke( @@ -221,18 +160,12 @@ struct Invoker { typedef typename std::conditional< MemFunAndRef::Accept<Args...>::value, MemFunAndRef, typename std::conditional< - MemFunAndRefWrap::Accept<Args...>::value, MemFunAndRefWrap, + MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr, typename std::conditional< - MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr, - typename std::conditional< - DataMemAndRef::Accept<Args...>::value, DataMemAndRef, - typename std::conditional< - DataMemAndRefWrap::Accept<Args...>::value, - DataMemAndRefWrap, - typename std::conditional< - DataMemAndPtr::Accept<Args...>::value, DataMemAndPtr, - Callable>::type>::type>::type>::type>::type>::type - type; + DataMemAndRef::Accept<Args...>::value, DataMemAndRef, + typename std::conditional<DataMemAndPtr::Accept<Args...>::value, + DataMemAndPtr, Callable>::type>::type>:: + type>::type type; }; // The result type of Invoke<F, Args...>. diff --git a/absl/base/invoke_test.cc b/absl/base/invoke_test.cc index 994d36b9..6aa613c9 100644 --- a/absl/base/invoke_test.cc +++ b/absl/base/invoke_test.cc @@ -158,56 +158,31 @@ TEST(InvokeTest, MemberFunction) { std::unique_ptr<const Class> cp(new Class); std::unique_ptr<volatile Class> vp(new Class); - Class c; - std::reference_wrapper<Class> ref(c); - std::reference_wrapper<const Class> ref_const(c); - const std::reference_wrapper<Class> const_ref(c); - std::reference_wrapper<volatile Class> ref_volatile(c); - EXPECT_EQ(1, Invoke(&Class::Method, p, 3, 2)); EXPECT_EQ(1, Invoke(&Class::Method, p.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::Method, *p, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::Method, ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::Method, const_ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::Method, std::move(ref), 3, 2)); EXPECT_EQ(1, Invoke(&Class::RefMethod, p, 3, 2)); EXPECT_EQ(1, Invoke(&Class::RefMethod, p.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::RefMethod, *p, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::RefMethod, ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::RefMethod, const_ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::RefMethod, std::move(ref), 3, 2)); EXPECT_EQ(1, Invoke(&Class::RefRefMethod, std::move(*p), 3, 2)); // NOLINT EXPECT_EQ(1, Invoke(&Class::NoExceptMethod, p, 3, 2)); EXPECT_EQ(1, Invoke(&Class::NoExceptMethod, p.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::NoExceptMethod, *p, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::NoExceptMethod, ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::NoExceptMethod, const_ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::NoExceptMethod, std::move(ref), 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, p, 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, p.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, *p, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::ConstMethod, ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::ConstMethod, const_ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::ConstMethod, std::move(ref), 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, cp, 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, cp.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, *cp, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::ConstMethod, ref_const, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::ConstMethod, std::move(ref_const), 3, 2)); EXPECT_EQ(1, Invoke(&Class::VolatileMethod, p, 3, 2)); EXPECT_EQ(1, Invoke(&Class::VolatileMethod, p.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::VolatileMethod, *p, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::VolatileMethod, ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::VolatileMethod, const_ref, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::VolatileMethod, std::move(ref), 3, 2)); EXPECT_EQ(1, Invoke(&Class::VolatileMethod, vp, 3, 2)); EXPECT_EQ(1, Invoke(&Class::VolatileMethod, vp.get(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::VolatileMethod, *vp, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::VolatileMethod, ref_volatile, 3, 2)); - EXPECT_EQ(1, Invoke(&Class::VolatileMethod, std::move(ref_volatile), 3, 2)); EXPECT_EQ(1, Invoke(&Class::Method, make_unique<Class>(), 3, 2)); EXPECT_EQ(1, Invoke(&Class::ConstMethod, make_unique<Class>(), 3, 2)); @@ -217,15 +192,8 @@ TEST(InvokeTest, MemberFunction) { TEST(InvokeTest, DataMember) { std::unique_ptr<Class> p(new Class{42}); std::unique_ptr<const Class> cp(new Class{42}); - Class c{42}; - std::reference_wrapper<Class> ref(c); - std::reference_wrapper<const Class> ref_const(c); - const std::reference_wrapper<Class> const_ref(c); EXPECT_EQ(42, Invoke(&Class::member, p)); EXPECT_EQ(42, Invoke(&Class::member, *p)); - EXPECT_EQ(42, Invoke(&Class::member, ref)); - EXPECT_EQ(42, Invoke(&Class::member, const_ref)); - EXPECT_EQ(42, Invoke(&Class::member, std::move(ref))); EXPECT_EQ(42, Invoke(&Class::member, p.get())); Invoke(&Class::member, p) = 42; @@ -233,8 +201,6 @@ TEST(InvokeTest, DataMember) { EXPECT_EQ(42, Invoke(&Class::member, cp)); EXPECT_EQ(42, Invoke(&Class::member, *cp)); - EXPECT_EQ(42, Invoke(&Class::member, ref_const)); - EXPECT_EQ(42, Invoke(&Class::member, std::move(ref_const))); EXPECT_EQ(42, Invoke(&Class::member, cp.get())); } diff --git a/absl/functional/bind_front_test.cc b/absl/functional/bind_front_test.cc index 92b6e8e5..4801a81c 100644 --- a/absl/functional/bind_front_test.cc +++ b/absl/functional/bind_front_test.cc @@ -228,23 +228,4 @@ TEST(BindTest, Mangling) { absl::bind_front(ManglingCall{}, 1, 3.3)("A"); } -struct Adder { - int add(int v2) const { return v + v2; } - int v; -}; - -TEST(BindTest, InvokeSemantics) { - Struct s1 = {"value"}; - auto f1 = absl::bind_front(&Struct::value); - EXPECT_EQ(f1(s1), "value"); - EXPECT_EQ(f1(&s1), "value"); - EXPECT_EQ(f1(std::ref(s1)), "value"); - - Adder add_100 = {100}; - auto f2 = absl::bind_front(&Adder::add); - EXPECT_EQ(f2(add_100, 23), 123); - EXPECT_EQ(f2(&add_100, 45), 145); - EXPECT_EQ(f2(std::ref(add_100), 67), 167); -} - } // namespace diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt index 8875b309..ade9ea10 100644 --- a/absl/random/CMakeLists.txt +++ b/absl/random/CMakeLists.txt @@ -69,6 +69,21 @@ absl_cc_test( # Internal-only target, do not depend on directly. absl_cc_library( NAME + random_internal_mock_helpers + HDRS + "internal/mock_helpers.h" + COPTS + ${ABSL_DEFAULT_COPTS} + LINKOPTS + ${ABSL_DEFAULT_LINKOPTS} + DEPS + absl::fast_type_id + absl::optional +) + +# Internal-only target, do not depend on directly. +absl_cc_library( + NAME random_internal_mock_overload_set HDRS "internal/mock_overload_set.h" @@ -78,7 +93,7 @@ absl_cc_library( ${ABSL_DEFAULT_LINKOPTS} DEPS absl::random_mocking_bit_gen - absl::fast_type_id + absl::random_internal_mock_helpers TESTONLY ) diff --git a/absl/random/bit_gen_ref.h b/absl/random/bit_gen_ref.h index 00e36248..9555460f 100644 --- a/absl/random/bit_gen_ref.h +++ b/absl/random/bit_gen_ref.h @@ -53,6 +53,7 @@ struct is_urbg< template <typename> struct DistributionCaller; +class MockHelpers; } // namespace random_internal @@ -171,6 +172,7 @@ class BitGenRef { template <typename> friend struct ::absl::random_internal::DistributionCaller; // for InvokeMock + friend class ::absl::random_internal::MockHelpers; // for InvokeMock }; ABSL_NAMESPACE_END diff --git a/absl/random/internal/BUILD.bazel b/absl/random/internal/BUILD.bazel index 3ab1177d..d81477ff 100644 --- a/absl/random/internal/BUILD.bazel +++ b/absl/random/internal/BUILD.bazel @@ -485,11 +485,20 @@ cc_test( ) cc_library( + name = "mock_helpers", + hdrs = ["mock_helpers.h"], + deps = [ + "//absl/base:fast_type_id", + "//absl/types:optional", + ], +) + +cc_library( name = "mock_overload_set", testonly = 1, hdrs = ["mock_overload_set.h"], deps = [ - "//absl/base:fast_type_id", + ":mock_helpers", "//absl/random:mocking_bit_gen", "@com_google_googletest//:gtest", ], diff --git a/absl/random/internal/distribution_caller.h b/absl/random/internal/distribution_caller.h index 87a76845..fc81b787 100644 --- a/absl/random/internal/distribution_caller.h +++ b/absl/random/internal/distribution_caller.h @@ -52,23 +52,25 @@ struct DistributionCaller { // Default implementation of distribution caller. template <typename DistrT, typename... Args> - static inline typename DistrT::result_type Impl(std::false_type, URBG* urbg, - Args&&... args) { + static typename DistrT::result_type Impl(std::false_type, URBG* urbg, + Args&&... args) { DistrT dist(std::forward<Args>(args)...); return dist(*urbg); } // Mock implementation of distribution caller. + // The underlying KeyT must match the KeyT constructed by MockOverloadSet. template <typename DistrT, typename... Args> - static inline typename DistrT::result_type Impl(std::true_type, URBG* urbg, - Args&&... args) { + static typename DistrT::result_type Impl(std::true_type, URBG* urbg, + Args&&... args) { using ResultT = typename DistrT::result_type; using ArgTupleT = std::tuple<absl::decay_t<Args>...>; + using KeyT = ResultT(DistrT, ArgTupleT); + ArgTupleT arg_tuple(std::forward<Args>(args)...); ResultT result; - if (!urbg->InvokeMock( - ::absl::base_internal::FastTypeId<ResultT(DistrT, ArgTupleT)>(), - &arg_tuple, &result)) { + if (!urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple, + &result)) { auto dist = absl::make_from_tuple<DistrT>(arg_tuple); result = dist(*urbg); } @@ -77,7 +79,7 @@ struct DistributionCaller { // Default implementation of distribution caller. template <typename DistrT, typename... Args> - static inline typename DistrT::result_type Call(URBG* urbg, Args&&... args) { + static typename DistrT::result_type Call(URBG* urbg, Args&&... args) { return Impl<DistrT, Args...>(HasInvokeMock{}, urbg, std::forward<Args>(args)...); } diff --git a/absl/random/internal/mock_helpers.h b/absl/random/internal/mock_helpers.h new file mode 100644 index 00000000..9af27ab3 --- /dev/null +++ b/absl/random/internal/mock_helpers.h @@ -0,0 +1,127 @@ +// +// Copyright 2019 The Abseil Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_ +#define ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_ + +#include <tuple> +#include <type_traits> + +#include "absl/base/internal/fast_type_id.h" +#include "absl/types/optional.h" + +namespace absl { +ABSL_NAMESPACE_BEGIN +namespace random_internal { + +// MockHelpers works in conjunction with MockOverloadSet, MockingBitGen, and +// BitGenRef to enable the mocking capability for absl distribution functions. +// +// MockingBitGen registers mocks based on the typeid of a mock signature, KeyT, +// which is used to generate a unique id. +// +// KeyT is a signature of the form: +// result_type(discriminator_type, std::tuple<args...>) +// The mocked function signature will be composed from KeyT as: +// result_type(args...) +// +class MockHelpers { + using IdType = ::absl::base_internal::FastTypeIdType; + + // Given a key signature type used to index the mock, extract the components. + // KeyT is expected to have the form: + // result_type(discriminator_type, arg_tuple_type) + template <typename KeyT> + struct KeySignature; + + template <typename ResultT, typename DiscriminatorT, typename ArgTupleT> + struct KeySignature<ResultT(DiscriminatorT, ArgTupleT)> { + using result_type = ResultT; + using discriminator_type = DiscriminatorT; + using arg_tuple_type = ArgTupleT; + }; + + // Detector for InvokeMock. + template <class T> + using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock( + std::declval<IdType>(), std::declval<void*>(), std::declval<void*>())); + + // Empty implementation of InvokeMock. + template <typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG, + typename... Args> + static absl::optional<ReturnT> InvokeMockImpl(char, URBG*, Args&&...) { + return absl::nullopt; + } + + // Non-empty implementation of InvokeMock. + template <typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG, + typename = invoke_mock_t<URBG>, typename... Args> + static absl::optional<ReturnT> InvokeMockImpl(int, URBG* urbg, + Args&&... args) { + ArgTupleT arg_tuple(std::forward<Args>(args)...); + ReturnT result; + if (urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple, + &result)) { + return result; + } + return absl::nullopt; + } + + public: + // Invoke a mock for the KeyT (may or may not be a signature). + // + // KeyT is used to generate a typeid-based lookup key for the mock. + // KeyT is a signature of the form: + // result_type(discriminator_type, std::tuple<args...>) + // The mocked function signature will be composed from KeyT as: + // result_type(args...) + // + // An instance of arg_tuple_type must be constructable from Args..., since + // the underlying mechanism requires a pointer to an argument tuple. + template <typename KeyT, typename URBG, typename... Args> + static auto MaybeInvokeMock(URBG* urbg, Args&&... args) + -> absl::optional<typename KeySignature<KeyT>::result_type> { + // Use function overloading to dispatch to the implemenation since + // more modern patterns (e.g. require + constexpr) are not supported in all + // compiler configurations. + return InvokeMockImpl<KeyT, typename KeySignature<KeyT>::result_type, + typename KeySignature<KeyT>::arg_tuple_type, URBG>( + 0, urbg, std::forward<Args>(args)...); + } + + // Acquire a mock for the KeyT (may or may not be a signature). + // + // KeyT is used to generate a typeid-based lookup for the mock. + // KeyT is a signature of the form: + // result_type(discriminator_type, std::tuple<args...>) + // The mocked function signature will be composed from KeyT as: + // result_type(args...) + template <typename KeyT, typename MockURBG> + static auto MockFor(MockURBG& m) -> decltype( + std::declval<MockURBG>() + .template RegisterMock<typename KeySignature<KeyT>::result_type, + typename KeySignature<KeyT>::arg_tuple_type>( + std::declval<IdType>())) { + return m.template RegisterMock<typename KeySignature<KeyT>::result_type, + typename KeySignature<KeyT>::arg_tuple_type>( + ::absl::base_internal::FastTypeId<KeyT>()); + } +}; + +} // namespace random_internal +ABSL_NAMESPACE_END +} // namespace absl + +#endif // ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_ diff --git a/absl/random/internal/mock_overload_set.h b/absl/random/internal/mock_overload_set.h index 60561b51..dccc6cee 100644 --- a/absl/random/internal/mock_overload_set.h +++ b/absl/random/internal/mock_overload_set.h @@ -20,7 +20,7 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/base/internal/fast_type_id.h" +#include "absl/random/internal/mock_helpers.h" #include "absl/random/mocking_bit_gen.h" namespace absl { @@ -37,22 +37,19 @@ struct MockSingleOverload; // `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 Ret, typename... Args> struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)> { static_assert(std::is_same<typename DistrT::result_type, Ret>::value, "Overload signature must have return type matching the " "distribution result_type."); - using ArgTupleT = std::tuple<Args...>; + using KeyT = Ret(DistrT, std::tuple<Args...>); auto gmock_Call( absl::MockingBitGen& gen, // NOLINT(google-runtime-references) const ::testing::Matcher<Args>&... matchers) - -> decltype(gen.RegisterMock<Ret, ArgTupleT>( - std::declval<::absl::base_internal::FastTypeIdType>()) - .gmock_Call(matchers...)) { - return gen - .RegisterMock<Ret, ArgTupleT>( - ::absl::base_internal::FastTypeId<Ret(DistrT, ArgTupleT)>()) - .gmock_Call(matchers...); + -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...)) { + return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...); } }; @@ -61,18 +58,14 @@ struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)> { static_assert(std::is_same<typename DistrT::result_type, Ret>::value, "Overload signature must have return type matching the " "distribution result_type."); - using ArgTupleT = std::tuple<Arg, Args...>; + using KeyT = Ret(DistrT, std::tuple<Arg, Args...>); auto gmock_Call( const ::testing::Matcher<Arg>& matcher, absl::MockingBitGen& gen, // NOLINT(google-runtime-references) const ::testing::Matcher<Args>&... matchers) - -> decltype(gen.RegisterMock<Ret, ArgTupleT>( - std::declval<::absl::base_internal::FastTypeIdType>()) - .gmock_Call(matcher, matchers...)) { - return gen - .RegisterMock<Ret, ArgTupleT>( - ::absl::base_internal::FastTypeId<Ret(DistrT, ArgTupleT)>()) - .gmock_Call(matcher, matchers...); + -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, + matchers...)) { + return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...); } }; diff --git a/absl/random/mocking_bit_gen.h b/absl/random/mocking_bit_gen.h index c3c7d44d..6d2f2c83 100644 --- a/absl/random/mocking_bit_gen.h +++ b/absl/random/mocking_bit_gen.h @@ -53,10 +53,9 @@ namespace absl { ABSL_NAMESPACE_BEGIN namespace random_internal { -template <typename, typename> -struct MockSingleOverload; template <typename> struct DistributionCaller; +class MockHelpers; } // namespace random_internal class BitGenRef; @@ -216,11 +215,11 @@ class MockingBitGen { std::vector<std::function<void()>> deleters_; absl::BitGen gen_; - template <typename, typename> - friend struct ::absl::random_internal::MockSingleOverload; // for Register template <typename> friend struct ::absl::random_internal::DistributionCaller; // for InvokeMock friend class ::absl::BitGenRef; // for InvokeMock + friend class ::absl::random_internal::MockHelpers; // for RegisterMock, + // InvokeMock }; ABSL_NAMESPACE_END |