mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Changes imported from Abseil "staging" branch:

Browse source 
- 5e874e644191fbf99f5636d6303de2b28b23392c Adds a absl::apply function, similar to c++17's std::apply. by Abseil Team <absl-team@google.com>
  - 16373c438d16a09725dace03ab7ba0f7c2337279 Add debugging_internal::StackTraceWorksForTest by Abseil Team <absl-team@google.com>
  - a623257aaaff8a5fba3377f34f92f319a104e444 Update absl::CondVar documentation in response to GitHub ... by Derek Mauro <dmauro@google.com>
  - 87d58a25bc4ecd46165dd1c417121c86cbc07be0 Add assert against uint128 negative bit shift undefined b... by Alex Strelnikov <strel@google.com>
  - af155c0d2a3556b56a9bcd6f9ee7416277185df8 Fix comment typos. by Abseil Team <absl-team@google.com>
  - 1824ae832eb75d447dea730b5968d952897e135a Rollback of: Add debugging_internal::StackTraceWorksForTest by Abseil Team <absl-team@google.com>
  - 97318f087ce63dd5acf1e0d3d697cd90a7d6ebfd Add debugging_internal::StackTraceWorksForTest by Abseil Team <absl-team@google.com>
  - 9dd1d17dca17f0ded3bda336b7521fd57d08a5cc Move log_severity.h out of internal. by Abseil Team <absl-team@google.com>
  - 2212bb56b1a8365d2303ff0983441298d08444e5 Internal change. by Alex Strelnikov <strel@google.com>

GitOrigin-RevId: 5e874e644191fbf99f5636d6303de2b28b23392c
Change-Id: Ic270393ac1f15866afb64617d28269cd829030f6
This commit is contained in:
Abseil Team 2018-01-17 09:53:47 -08:00 committed by vslashg
parent be40fdf1a8
commit 5a8de8a37e
19 changed files with 326 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
absl/base/BUILD.bazel
View file

@ -151,7 +151,6 @@ cc_library(
"casts.h",
"internal/atomic_hook.h",
"internal/cycleclock.h",
"internal/log_severity.h",
"internal/low_level_scheduling.h",
"internal/per_thread_tls.h",
"internal/raw_logging.h",
@ -160,6 +159,7 @@ cc_library(
"internal/thread_identity.h",
"internal/tsan_mutex_interface.h",
"internal/unscaledcycleclock.h",
"log_severity.h",
],
copts = ABSL_DEFAULT_COPTS,
deps = [

2
absl/base/CMakeLists.txt
View file

@ -20,6 +20,7 @@ list(APPEND BASE_PUBLIC_HEADERS
"casts.h"
"config.h"
"dynamic_annotations.h"
"log_severity.h"
"macros.h"
"optimization.h"
"policy_checks.h"
@ -36,7 +37,6 @@ list(APPEND BASE_INTERNAL_HEADERS
"internal/exception_safety_testing.h"
"internal/identity.h"
"internal/invoke.h"
"internal/log_severity.h"
"internal/low_level_alloc.h"
"internal/low_level_scheduling.h"
"internal/malloc_extension.h"

2
absl/base/internal/raw_logging.cc
View file

@ -22,7 +22,7 @@
#include "absl/base/config.h"
#include "absl/base/internal/atomic_hook.h"
#include "absl/base/internal/log_severity.h"
#include "absl/base/log_severity.h"
// We know how to perform low-level writes to stderr in POSIX and Windows. For
// these platforms, we define the token ABSL_LOW_LEVEL_WRITE_SUPPORTED.

2
absl/base/internal/raw_logging.h
View file

@ -20,7 +20,7 @@
#define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
#include "absl/base/attributes.h"
#include "absl/base/internal/log_severity.h"
#include "absl/base/log_severity.h"
#include "absl/base/macros.h"
#include "absl/base/port.h"

0
absl/base/internal/log_severity.h → absl/base/log_severity.h
View file

8
absl/debugging/internal/stacktrace_aarch64-inl.inc
View file

@ -178,4 +178,12 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
return n;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return true;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_

8
absl/debugging/internal/stacktrace_arm-inl.inc
View file

@ -112,4 +112,12 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
return n;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return false;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_

8
absl/debugging/internal/stacktrace_generic-inl.inc
View file

@ -48,4 +48,12 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
return result_count;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return true;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_

8
absl/debugging/internal/stacktrace_powerpc-inl.inc
View file

@ -232,4 +232,12 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
return n;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return true;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_

8
absl/debugging/internal/stacktrace_unimplemented-inl.inc
View file

@ -11,4 +11,12 @@ static int UnwindImpl(void** /* result */, int* /* sizes */,
return 0;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return false;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_

8
absl/debugging/internal/stacktrace_win32-inl.inc
View file

@ -72,4 +72,12 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
return n;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return false;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_

8
absl/debugging/internal/stacktrace_x86-inl.inc
View file

@ -326,4 +326,12 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
return n;
}
namespace absl {
namespace debugging_internal {
bool StackTraceWorksForTest() {
return true;
}
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_

7
absl/debugging/stacktrace.h
View file

@ -155,6 +155,13 @@ extern int DefaultStackUnwinder(void** pcs, int* sizes, int max_depth,
int skip_count, const void* uc,
int* min_dropped_frames);
namespace debugging_internal {
// Returns true for platforms which are expected to have functioning stack trace
// implementations. Intended to be used for tests which want to exclude
// verification of logic known to be broken because stack traces are not
// working.
extern bool StackTraceWorksForTest();
} // namespace debugging_internal
} // namespace absl
#endif // ABSL_DEBUGGING_STACKTRACE_H_

8
absl/numeric/int128.h
View file

@ -511,8 +511,8 @@ inline uint128& uint128::operator^=(uint128 other) {
// Shift and arithmetic assign operators.
inline uint128& uint128::operator<<=(int amount) {
// Shifts of >= 128 are undefined.
assert(amount < 128);
assert(amount >= 0); // Negative shifts are undefined.
assert(amount < 128); // Shifts of >= 128 are undefined.
// uint64_t shifts of >= 64 are undefined, so we will need some
// special-casing.
@ -529,8 +529,8 @@ inline uint128& uint128::operator<<=(int amount) {
}
inline uint128& uint128::operator>>=(int amount) {
// Shifts of >= 128 are undefined.
assert(amount < 128);
assert(amount >= 0); // Negative shifts are undefined.
assert(amount < 128); // Shifts of >= 128 are undefined.
// uint64_t shifts of >= 64 are undefined, so we will need some
// special-casing.

41
absl/synchronization/mutex.h
View file

@ -713,7 +713,7 @@ class Condition {
// The implementation may deliver signals to any condition variable at
// any time, even when no call to `Signal()` or `SignalAll()` is made; as a
// result, upon being awoken, you must check the logical condition you have
// been waiting upon. The implementation wakes waiters in the FIFO order.
// been waiting upon.
//
// Examples:
//
@ -742,29 +742,19 @@ class CondVar {
// CondVar::Wait()
//
// Atomically releases a `Mutex` and blocks on this condition variable. After
// blocking, the thread will unblock, reacquire the `Mutex`, and return if
// either:
// - this condition variable is signalled with `SignalAll()`, or
// - this condition variable is signalled in any manner and this thread
// was the most recently blocked thread that has not yet woken.
// Atomically releases a `Mutex` and blocks on this condition variable.
// Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
// spurious wakeup), then reacquires the `Mutex` and returns.
//
// Requires and ensures that the current thread holds the `Mutex`.
void Wait(Mutex *mu);
// CondVar::WaitWithTimeout()
//
// Atomically releases a `Mutex`, blocks on this condition variable, and
// attempts to reacquire the mutex upon being signalled, or upon reaching the
// timeout.
//
// After blocking, the thread will unblock, reacquire the `Mutex`, and return
// for any of the following:
// - this condition variable is signalled with `SignalAll()`
// - the timeout has expired
// - this condition variable is signalled in any manner and this thread
// was the most recently blocked thread that has not yet woken.
//
// Negative timeouts are equivalent to a zero timeout.
// Atomically releases a `Mutex` and blocks on this condition variable.
// Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
// spurious wakeup), or until the timeout has expired, then reacquires
// the `Mutex` and returns.
//
// Returns true if the timeout has expired without this `CondVar`
// being signalled in any manner. If both the timeout has expired
@ -776,15 +766,10 @@ class CondVar {
// CondVar::WaitWithDeadline()
//
// Atomically releases a `Mutex`, blocks on this condition variable, and
// attempts to reacquire the mutex within the provided deadline.
//
// After blocking, the thread will unblock, reacquire the `Mutex`, and return
// for any of the following:
// - this condition variable is signalled with `SignalAll()`
// - the deadline has passed
// - this condition variable is signalled in any manner and this thread
// was the most recently blocked thread that has not yet woken.
// Atomically releases a `Mutex` and blocks on this condition variable.
// Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
// spurious wakeup), or until the deadline has passed, then reacquires
// the `Mutex` and returns.
//
// Deadlines in the past are equivalent to an immediate deadline.
//

4
absl/types/optional.h
View file

@ -496,7 +496,7 @@ class optional : private optional_internal::optional_data<T>,
// default constructed `T`.
constexpr optional() noexcept {}
// Construct an` optional` initialized with `nullopt` to hold an empty value.
// Construct an `optional` initialized with `nullopt` to hold an empty value.
constexpr optional(nullopt_t) noexcept {} // NOLINT(runtime/explicit)
// Copy constructor, standard semantics
@ -515,7 +515,7 @@ class optional : private optional_internal::optional_data<T>,
constexpr explicit optional(in_place_t, Args&&... args)
: data_base(in_place_t(), absl::forward<Args>(args)...) {}
// Constructs a non-empty `optional' direct-initialized value of type `T` from
// Constructs a non-empty `optional` direct-initialized value of type `T` from
// the arguments of an initializer_list and `std::forward<Args>(args)...`.
// (The `in_place_t` is a tag used to indicate that the contained object
// should be constructed in-place.)

3
absl/utility/BUILD.bazel
View file

@ -14,6 +14,7 @@ cc_library(
hdrs = ["utility.h"],
copts = ABSL_DEFAULT_COPTS,
deps = [
"//absl/base:base_internal",
"//absl/base:config",
"//absl/meta:type_traits",
],
@ -26,6 +27,8 @@ cc_test(
deps = [
":utility",
"//absl/base:core_headers",
"//absl/memory",
"//absl/strings",
"@com_google_googletest//:gtest_main",
],
)

79
absl/utility/utility.h
View file

@ -23,6 +23,7 @@
// * make_integer_sequence<T, N> == std::make_integer_sequence<T, N>
// * make_index_sequence<N> == std::make_index_sequence<N>
// * index_sequence_for<Ts...> == std::index_sequence_for<Ts...>
// * apply<Functor, Tuple> == std::apply<Functor, Tuple>
//
// This header file also provides the tag types `in_place_t`, `in_place_type_t`,
// and `in_place_index_t`, as well as the constant `in_place`, and
@ -31,34 +32,20 @@
// References:
//
// http://en.cppreference.com/w/cpp/utility/integer_sequence
// http://en.cppreference.com/w/cpp/utility/apply
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
//
//
// Example:
// // Unpack a tuple for use as a function call's argument list.
//
// template <typename F, typename Tup, size_t... Is>
// auto Impl(F f, const Tup& tup, absl::index_sequence<Is...>)
// -> decltype(f(std::get<Is>(tup) ...)) {
// return f(std::get<Is>(tup) ...);
// }
//
// template <typename Tup>
// using TupIdxSeq = absl::make_index_sequence<std::tuple_size<Tup>::value>;
//
// template <typename F, typename Tup>
// auto ApplyFromTuple(F f, const Tup& tup)
// -> decltype(Impl(f, tup, TupIdxSeq<Tup>{})) {
// return Impl(f, tup, TupIdxSeq<Tup>{});
// }
#ifndef ABSL_UTILITY_UTILITY_H_
#define ABSL_UTILITY_UTILITY_H_
#include <cstddef>
#include <cstdlib>
#include <tuple>
#include <utility>
#include "absl/base/config.h"
#include "absl/base/internal/invoke.h"
#include "absl/meta/type_traits.h"
namespace absl {
@ -214,6 +201,62 @@ constexpr T&& forward(
return static_cast<T&&>(t);
}
namespace utility_internal {
// Helper method for expanding tuple into a called method.
template <typename Functor, typename Tuple, std::size_t... Indexes>
auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
-> decltype(absl::base_internal::Invoke(
absl::forward<Functor>(functor),
std::get<Indexes>(absl::forward<Tuple>(t))...)) {
return absl::base_internal::Invoke(
absl::forward<Functor>(functor),
std::get<Indexes>(absl::forward<Tuple>(t))...);
}
} // namespace utility_internal
// apply
//
// Invokes a Callable using elements of a tuple as its arguments.
// Each element of the tuple corresponds to an argument of the call (in order).
// Both the Callable argument and the tuple argument are perfect-forwarded.
// For member-function Callables, the first tuple element acts as the `this`
// pointer. `absl::apply` is designed to be a drop-in replacement for C++17's
// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
//
// Example:
//
// class Foo{void Bar(int);};
// void user_function(int, std::string);
// void user_function(std::unique_ptr<Foo>);
//
// int main()
// {
// std::tuple<int, std::string> tuple1(42, "bar");
// // Invokes the user function overload on int, std::string.
// absl::apply(&user_function, tuple1);
//
// auto foo = absl::make_unique<Foo>();
// std::tuple<Foo*, int> tuple2(foo.get(), 42);
// // Invokes the method Bar on foo with one argument 42.
// absl::apply(&Foo::Bar, foo.get(), 42);
//
// std::tuple<std::unique_ptr<Foo>> tuple3(absl::make_unique<Foo>());
// // Invokes the user function that takes ownership of the unique
// // pointer.
// absl::apply(&user_function, std::move(tuple));
// }
template <typename Functor, typename Tuple>
auto apply(Functor&& functor, Tuple&& t)
-> decltype(utility_internal::apply_helper(
absl::forward<Functor>(functor), absl::forward<Tuple>(t),
absl::make_index_sequence<std::tuple_size<
typename std::remove_reference<Tuple>::type>::value>{})) {
return utility_internal::apply_helper(
absl::forward<Functor>(functor), absl::forward<Tuple>(t),
absl::make_index_sequence<std::tuple_size<
typename std::remove_reference<Tuple>::type>::value>{});
}
} // namespace absl
#endif // ABSL_UTILITY_UTILITY_H_

178
absl/utility/utility_test.cc
View file

@ -23,6 +23,8 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/base/attributes.h"
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
namespace {
@ -38,8 +40,9 @@ namespace {
#pragma warning( disable : 4101 ) // unreferenced local variable
#endif // _MSC_VER
using testing::StaticAssertTypeEq;
using testing::ElementsAre;
using ::testing::ElementsAre;
using ::testing::Pointee;
using ::testing::StaticAssertTypeEq;
TEST(IntegerSequenceTest, ValueType) {
StaticAssertTypeEq<int, absl::integer_sequence<int>::value_type>();
@ -159,5 +162,176 @@ TEST(IndexSequenceForTest, Example) {
ElementsAre("12", "abc", "3.14"));
}
int Function(int a, int b) { return a - b; }
int Sink(std::unique_ptr<int> p) { return *p; }
std::unique_ptr<int> Factory(int n) { return absl::make_unique<int>(n); }
void NoOp() {}
struct ConstFunctor {
int operator()(int a, int b) const { return a - b; }
};
struct MutableFunctor {
int operator()(int a, int b) { return a - b; }
};
struct EphemeralFunctor {
EphemeralFunctor() {}
EphemeralFunctor(const EphemeralFunctor&) {}
EphemeralFunctor(EphemeralFunctor&&) {}
int operator()(int a, int b) && { return a - b; }
};
struct OverloadedFunctor {
OverloadedFunctor() {}
OverloadedFunctor(const OverloadedFunctor&) {}
OverloadedFunctor(OverloadedFunctor&&) {}
template <typename... Args>
std::string operator()(const Args&... args) & {
return absl::StrCat("&", args...);
}
template <typename... Args>
std::string operator()(const Args&... args) const& {
return absl::StrCat("const&", args...);
}
template <typename... Args>
std::string operator()(const Args&... args) && {
return absl::StrCat("&&", args...);
}
};
struct Class {
int Method(int a, int b) { return a - b; }
int ConstMethod(int a, int b) const { return a - b; }
int member;
};
struct FlipFlop {
int ConstMethod() const { return member; }
FlipFlop operator*() const { return {-member}; }
int member;
};
TEST(ApplyTest, Function) {
EXPECT_EQ(1, absl::apply(Function, std::make_tuple(3, 2)));
EXPECT_EQ(1, absl::apply(&Function, std::make_tuple(3, 2)));
}
TEST(ApplyTest, NonCopyableArgument) {
EXPECT_EQ(42, absl::apply(Sink, std::make_tuple(absl::make_unique<int>(42))));
}
TEST(ApplyTest, NonCopyableResult) {
EXPECT_THAT(absl::apply(Factory, std::make_tuple(42)),
::testing::Pointee(42));
}
TEST(ApplyTest, VoidResult) { absl::apply(NoOp, std::tuple<>()); }
TEST(ApplyTest, ConstFunctor) {
EXPECT_EQ(1, absl::apply(ConstFunctor(), std::make_tuple(3, 2)));
}
TEST(ApplyTest, MutableFunctor) {
MutableFunctor f;
EXPECT_EQ(1, absl::apply(f, std::make_tuple(3, 2)));
EXPECT_EQ(1, absl::apply(MutableFunctor(), std::make_tuple(3, 2)));
}
TEST(ApplyTest, EphemeralFunctor) {
EphemeralFunctor f;
EXPECT_EQ(1, absl::apply(std::move(f), std::make_tuple(3, 2)));
EXPECT_EQ(1, absl::apply(EphemeralFunctor(), std::make_tuple(3, 2)));
}
TEST(ApplyTest, OverloadedFunctor) {
OverloadedFunctor f;
const OverloadedFunctor& cf = f;
EXPECT_EQ("&", absl::apply(f, std::tuple<>{}));
EXPECT_EQ("& 42", absl::apply(f, std::make_tuple(" 42")));
EXPECT_EQ("const&", absl::apply(cf, std::tuple<>{}));
EXPECT_EQ("const& 42", absl::apply(cf, std::make_tuple(" 42")));
EXPECT_EQ("&&", absl::apply(std::move(f), std::tuple<>{}));
OverloadedFunctor f2;
EXPECT_EQ("&& 42", absl::apply(std::move(f2), std::make_tuple(" 42")));
}
TEST(ApplyTest, ReferenceWrapper) {
ConstFunctor cf;
MutableFunctor mf;
EXPECT_EQ(1, absl::apply(std::cref(cf), std::make_tuple(3, 2)));
EXPECT_EQ(1, absl::apply(std::ref(cf), std::make_tuple(3, 2)));
EXPECT_EQ(1, absl::apply(std::ref(mf), std::make_tuple(3, 2)));
}
TEST(ApplyTest, MemberFunction) {
std::unique_ptr<Class> p(new Class);
std::unique_ptr<const Class> cp(new Class);
EXPECT_EQ(
1, absl::apply(&Class::Method,
std::tuple<std::unique_ptr<Class>&, int, int>(p, 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::Method,
std::tuple<Class*, int, int>(p.get(), 3, 2)));
EXPECT_EQ(
1, absl::apply(&Class::Method, std::tuple<Class&, int, int>(*p, 3, 2)));
EXPECT_EQ(
1, absl::apply(&Class::ConstMethod,
std::tuple<std::unique_ptr<Class>&, int, int>(p, 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::ConstMethod,
std::tuple<Class*, int, int>(p.get(), 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::ConstMethod,
std::tuple<Class&, int, int>(*p, 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::ConstMethod,
std::tuple<std::unique_ptr<const Class>&, int, int>(
cp, 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::ConstMethod,
std::tuple<const Class*, int, int>(cp.get(), 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::ConstMethod,
std::tuple<const Class&, int, int>(*cp, 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::Method,
std::make_tuple(absl::make_unique<Class>(), 3, 2)));
EXPECT_EQ(1, absl::apply(&Class::ConstMethod,
std::make_tuple(absl::make_unique<Class>(), 3, 2)));
EXPECT_EQ(
1, absl::apply(&Class::ConstMethod,
std::make_tuple(absl::make_unique<const Class>(), 3, 2)));
}
TEST(ApplyTest, DataMember) {
std::unique_ptr<Class> p(new Class{42});
std::unique_ptr<const Class> cp(new Class{42});
EXPECT_EQ(
42, absl::apply(&Class::member, std::tuple<std::unique_ptr<Class>&>(p)));
EXPECT_EQ(42, absl::apply(&Class::member, std::tuple<Class&>(*p)));
EXPECT_EQ(42, absl::apply(&Class::member, std::tuple<Class*>(p.get())));
absl::apply(&Class::member, std::tuple<std::unique_ptr<Class>&>(p)) = 42;
absl::apply(&Class::member, std::tuple<Class*>(p.get())) = 42;
absl::apply(&Class::member, std::tuple<Class&>(*p)) = 42;
EXPECT_EQ(42, absl::apply(&Class::member,
std::tuple<std::unique_ptr<const Class>&>(cp)));
EXPECT_EQ(42, absl::apply(&Class::member, std::tuple<const Class&>(*cp)));
EXPECT_EQ(42,
absl::apply(&Class::member, std::tuple<const Class*>(cp.get())));
}
TEST(ApplyTest, FlipFlop) {
FlipFlop obj = {42};
// This call could resolve to (obj.*&FlipFlop::ConstMethod)() or
// ((*obj).*&FlipFlop::ConstMethod)(). We verify that it's the former.
EXPECT_EQ(42, absl::apply(&FlipFlop::ConstMethod, std::make_tuple(obj)));
EXPECT_EQ(42, absl::apply(&FlipFlop::member, std::make_tuple(obj)));
}
} // namespace