summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CMake/AbseilDll.cmake3
-rw-r--r--absl/base/internal/invoke.h131
-rw-r--r--absl/base/invoke_test.cc34
-rw-r--r--absl/functional/bind_front_test.cc19
-rw-r--r--absl/random/CMakeLists.txt17
-rw-r--r--absl/random/bit_gen_ref.h2
-rw-r--r--absl/random/internal/BUILD.bazel11
-rw-r--r--absl/random/internal/distribution_caller.h18
-rw-r--r--absl/random/internal/mock_helpers.h127
-rw-r--r--absl/random/internal/mock_overload_set.h27
-rw-r--r--absl/random/mocking_bit_gen.h7
11 files changed, 212 insertions, 184 deletions
diff --git a/CMake/AbseilDll.cmake b/CMake/AbseilDll.cmake
index 07ae20fe..e25174a3 100644
--- a/CMake/AbseilDll.cmake
+++ b/CMake/AbseilDll.cmake
@@ -137,11 +137,12 @@ set(ABSL_INTERNAL_DLL_FILES
"random/gaussian_distribution.cc"
"random/gaussian_distribution.h"
"random/internal/distribution_caller.h"
- "random/internal/fast_uniform_bits.h"
"random/internal/fastmath.h"
+ "random/internal/fast_uniform_bits.h"
"random/internal/gaussian_distribution_gentables.cc"
"random/internal/generate_real.h"
"random/internal/iostream_state_saver.h"
+ "random/internal/mock_helpers.h"
"random/internal/nonsecure_base.h"
"random/internal/pcg_engine.h"
"random/internal/platform.h"
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
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-05 11:49:00 +0000