From ae0cef35ae5a7bfd873fb87babdd4900cbdb073c Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Wed, 22 Nov 2017 07:42:54 -0800 Subject: Changes imported from Abseil "staging" branch: - 55c7dd8ad1570b4e6ce2103ed4d4b6becdea0d96 Remove line continuations which require CMake >= 3.0. Al... by Jon Cohen - ee66ad72a90259d6286bbfea7241ed976bb0f6fb Change absl::ParseDuration() to avoid double. This allow... by Abseil Team - 89cf4cd49d8ff25cb3d29f06b2090029a2024e89 Internal change by Gennadiy Rozental - cdb5879bf6aaf6bbd2ad1fe4a2b144bbdf0389c7 Internal change by Gennadiy Rozental - e7b29d11bf24a63bf7637689ada8be7d619844fc Internal change by Gennadiy Rozental - 2d4fc08d5d64a7760ad6230eccdb5b8014c2b0c3 Update the exception-safety testing framework. by Jon Cohen GitOrigin-RevId: 55c7dd8ad1570b4e6ce2103ed4d4b6becdea0d96 Change-Id: I6b560cbc4570dfc5aa9a2f90e84d69904df7eac5 --- absl/base/BUILD.bazel | 1 + absl/base/exception_safety_testing_test.cc | 185 +++++++++++++++++++++---- absl/base/internal/exception_safety_testing.cc | 4 +- absl/base/internal/exception_safety_testing.h | 185 ++++++++++++++++--------- 4 files changed, 280 insertions(+), 95 deletions(-) (limited to 'absl/base') diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel index 64057f6c9816..e528463345b8 100644 --- a/absl/base/BUILD.bazel +++ b/absl/base/BUILD.bazel @@ -238,6 +238,7 @@ cc_library( deps = [ ":config", ":pretty_function", + "//absl/memory", "//absl/meta:type_traits", "//absl/strings", "@com_google_googletest//:gtest", diff --git a/absl/base/exception_safety_testing_test.cc b/absl/base/exception_safety_testing_test.cc index 365732c6721a..c1b5df265467 100644 --- a/absl/base/exception_safety_testing_test.cc +++ b/absl/base/exception_safety_testing_test.cc @@ -14,10 +14,6 @@ namespace absl { namespace { using ::absl::exceptions_internal::TestException; -void SetCountdown() { exceptions_internal::countdown = 0; } - -void UnsetCountdown() { exceptions_internal::countdown = -1; } - // EXPECT_NO_THROW can't inspect the thrown inspection in general. template void ExpectNoThrow(const F& f) { @@ -395,12 +391,15 @@ struct FailsBasicGuarantee { ++i; } - bool operator!=(const FailsBasicGuarantee& other) const { + bool operator==(const FailsBasicGuarantee& other) const { return i != other.i; } - friend bool AbslCheckInvariants(const FailsBasicGuarantee& g) { - return g.i >= 0; + friend testing::AssertionResult AbslCheckInvariants( + const FailsBasicGuarantee& g) { + if (g.i >= 0) return testing::AssertionSuccess(); + return testing::AssertionFailure() + << "i should be non-negative but is " << g.i; } int i = 0; @@ -408,7 +407,7 @@ struct FailsBasicGuarantee { TEST(ExceptionCheckTest, BasicGuaranteeFailure) { FailsBasicGuarantee g; - EXPECT_FALSE(TestBasicGuarantee(&g, CallOperator{})); + EXPECT_FALSE(TestExceptionSafety(&g, CallOperator{})); } struct FollowsBasicGuarantee { @@ -417,12 +416,15 @@ struct FollowsBasicGuarantee { ThrowingValue<> bomb; } - bool operator!=(const FollowsBasicGuarantee& other) const { - return i != other.i; + bool operator==(const FollowsBasicGuarantee& other) const { + return i == other.i; } - friend bool AbslCheckInvariants(const FollowsBasicGuarantee& g) { - return g.i >= 0; + friend testing::AssertionResult AbslCheckInvariants( + const FollowsBasicGuarantee& g) { + if (g.i >= 0) return testing::AssertionSuccess(); + return testing::AssertionFailure() + << "i should be non-negative but is " << g.i; } int i = 0; @@ -430,30 +432,79 @@ struct FollowsBasicGuarantee { TEST(ExceptionCheckTest, BasicGuarantee) { FollowsBasicGuarantee g; - EXPECT_TRUE(TestBasicGuarantee(&g, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety(&g, CallOperator{})); } TEST(ExceptionCheckTest, StrongGuaranteeFailure) { { FailsBasicGuarantee g; - EXPECT_FALSE(TestStrongGuarantee(&g, CallOperator{})); + EXPECT_FALSE(TestExceptionSafety(&g, CallOperator{}, StrongGuarantee(g))); } { FollowsBasicGuarantee g; - EXPECT_FALSE(TestStrongGuarantee(&g, CallOperator{})); + EXPECT_FALSE(TestExceptionSafety(&g, CallOperator{}, StrongGuarantee(g))); + } +} + +struct BasicGuaranteeWithExtraInvariants { + // After operator(), i is incremented. If operator() throws, i is set to 9999 + void operator()() { + int old_i = i; + i = kExceptionSentinel; + ThrowingValue<> bomb; + i = ++old_i; + } + + bool operator==(const FollowsBasicGuarantee& other) const { + return i == other.i; + } + + friend testing::AssertionResult AbslCheckInvariants( + const BasicGuaranteeWithExtraInvariants& g) { + if (g.i >= 0) return testing::AssertionSuccess(); + return testing::AssertionFailure() + << "i should be non-negative but is " << g.i; + } + + int i = 0; + static constexpr int kExceptionSentinel = 9999; +}; +constexpr int BasicGuaranteeWithExtraInvariants::kExceptionSentinel; + +TEST(ExceptionCheckTest, BasicGuaranteeWithInvariants) { + { + BasicGuaranteeWithExtraInvariants g; + EXPECT_TRUE(TestExceptionSafety(&g, CallOperator{})); + } + + { + BasicGuaranteeWithExtraInvariants g; + EXPECT_TRUE(TestExceptionSafety( + &g, CallOperator{}, [](const BasicGuaranteeWithExtraInvariants& w) { + if (w.i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) { + return testing::AssertionSuccess(); + } + return testing::AssertionFailure() + << "i should be " + << BasicGuaranteeWithExtraInvariants::kExceptionSentinel + << ", but is " << w.i; + })); } } struct FollowsStrongGuarantee { void operator()() { ThrowingValue<> bomb; } - bool operator!=(const FollowsStrongGuarantee& other) const { - return i != other.i; + bool operator==(const FollowsStrongGuarantee& other) const { + return i == other.i; } - friend bool AbslCheckInvariants(const FollowsStrongGuarantee& g) { - return g.i >= 0; + friend testing::AssertionResult AbslCheckInvariants( + const FollowsStrongGuarantee& g) { + if (g.i >= 0) return testing::AssertionSuccess(); + return testing::AssertionFailure() + << "i should be non-negative but is " << g.i; } int i = 0; @@ -461,8 +512,65 @@ struct FollowsStrongGuarantee { TEST(ExceptionCheckTest, StrongGuarantee) { FollowsStrongGuarantee g; - EXPECT_TRUE(TestBasicGuarantee(&g, CallOperator{})); - EXPECT_TRUE(TestStrongGuarantee(&g, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety(&g, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety(&g, CallOperator{}, StrongGuarantee(g))); +} + +struct NonCopyable { + NonCopyable(const NonCopyable&) = delete; + explicit NonCopyable(int ii) : i(ii) {} + + void operator()() { ThrowingValue<> bomb; } + + bool operator==(const NonCopyable& other) const { return i == other.i; } + + friend testing::AssertionResult AbslCheckInvariants(const NonCopyable& g) { + if (g.i >= 0) return testing::AssertionSuccess(); + return testing::AssertionFailure() + << "i should be non-negative but is " << g.i; + } + + int i; +}; + +TEST(ExceptionCheckTest, NonCopyable) { + NonCopyable g(0); + EXPECT_TRUE(TestExceptionSafety(&g, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety( + &g, CallOperator{}, + PointeeStrongGuarantee(absl::make_unique(g.i)))); +} + +struct NonEqualityComparable { + void operator()() { ThrowingValue<> bomb; } + + void ModifyOnThrow() { + ++i; + ThrowingValue<> bomb; + static_cast(bomb); + --i; + } + + friend testing::AssertionResult AbslCheckInvariants( + const NonEqualityComparable& g) { + if (g.i >= 0) return testing::AssertionSuccess(); + return testing::AssertionFailure() + << "i should be non-negative but is " << g.i; + } + + int i = 0; +}; + +TEST(ExceptionCheckTest, NonEqualityComparable) { + NonEqualityComparable g; + auto comp = [](const NonEqualityComparable& a, + const NonEqualityComparable& b) { return a.i == b.i; }; + EXPECT_TRUE(TestExceptionSafety(&g, CallOperator{})); + EXPECT_TRUE( + TestExceptionSafety(&g, CallOperator{}, absl::StrongGuarantee(g, comp))); + EXPECT_FALSE(TestExceptionSafety( + &g, [&](NonEqualityComparable* n) { n->ModifyOnThrow(); }, + absl::StrongGuarantee(g, comp))); } template @@ -480,11 +588,14 @@ struct InstructionCounter { ++counter; } - bool operator!=(const InstructionCounter>& other) const { - return false; + bool operator==(const InstructionCounter>&) const { + return true; } - friend bool AbslCheckInvariants(const InstructionCounter&) { return true; } + friend testing::AssertionResult AbslCheckInvariants( + const InstructionCounter&) { + return testing::AssertionSuccess(); + } static int counter; }; @@ -493,18 +604,38 @@ int InstructionCounter::counter = 0; TEST(ExceptionCheckTest, Exhaustiveness) { InstructionCounter int_factory; - EXPECT_TRUE(TestBasicGuarantee(&int_factory, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety(&int_factory, CallOperator{})); EXPECT_EQ(InstructionCounter::counter, 4); InstructionCounter> bomb_factory; - EXPECT_TRUE(TestBasicGuarantee(&bomb_factory, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety(&bomb_factory, CallOperator{})); EXPECT_EQ(InstructionCounter>::counter, 10); InstructionCounter>::counter = 0; - EXPECT_TRUE(TestStrongGuarantee(&bomb_factory, CallOperator{})); + EXPECT_TRUE(TestExceptionSafety(&bomb_factory, CallOperator{}, + StrongGuarantee(bomb_factory))); EXPECT_EQ(InstructionCounter>::counter, 10); } +struct LeaksIfCtorThrows : private exceptions_internal::TrackedObject { + LeaksIfCtorThrows() : TrackedObject(ABSL_PRETTY_FUNCTION) { + ++counter; + ThrowingValue<> v; + static_cast(v); + --counter; + } + LeaksIfCtorThrows(const LeaksIfCtorThrows&) noexcept + : TrackedObject(ABSL_PRETTY_FUNCTION) {} + static int counter; +}; +int LeaksIfCtorThrows::counter = 0; + +TEST(ExceptionCheckTest, TestLeakyCtor) { + absl::TestThrowingCtor(); + EXPECT_EQ(LeaksIfCtorThrows::counter, 1); + LeaksIfCtorThrows::counter = 0; +} + struct Tracked : private exceptions_internal::TrackedObject { Tracked() : TrackedObject(ABSL_PRETTY_FUNCTION) {} }; diff --git a/absl/base/internal/exception_safety_testing.cc b/absl/base/internal/exception_safety_testing.cc index 383c9c595251..32d904ed23fa 100644 --- a/absl/base/internal/exception_safety_testing.cc +++ b/absl/base/internal/exception_safety_testing.cc @@ -4,6 +4,7 @@ #include "absl/meta/type_traits.h" namespace absl { +exceptions_internal::NoThrowTag no_throw_ctor; namespace exceptions_internal { int countdown = -1; @@ -14,8 +15,7 @@ void MaybeThrow(absl::string_view msg) { testing::AssertionResult FailureMessage(const TestException& e, int countdown) noexcept { - return testing::AssertionFailure() - << "Exception number " << countdown + 1 << " thrown from " << e.what(); + return testing::AssertionFailure() << "Exception thrown from " << e.what(); } } // namespace exceptions_internal } // namespace absl diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h index d2742456fec3..a0a70d91d2d9 100644 --- a/absl/base/internal/exception_safety_testing.h +++ b/absl/base/internal/exception_safety_testing.h @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -13,6 +14,7 @@ #include "gtest/gtest.h" #include "absl/base/config.h" #include "absl/base/internal/pretty_function.h" +#include "absl/memory/memory.h" #include "absl/meta/type_traits.h" #include "absl/strings/string_view.h" #include "absl/strings/substitute.h" @@ -43,6 +45,8 @@ constexpr NoThrow operator&(NoThrow a, NoThrow b) { } namespace exceptions_internal { +struct NoThrowTag {}; + constexpr bool ThrowingAllowed(NoThrow flags, NoThrow flag) { return !static_cast(flags & flag); } @@ -92,8 +96,46 @@ class TrackedObject { friend struct ::absl::AllocInspector; }; + +template +testing::AssertionResult TestInvariants(const T& t, const TestException& e, + int count, + const Checkers&... checkers) { + auto out = AbslCheckInvariants(t); + // Don't bother with the checkers if the class invariants are already broken. + bool dummy[] = {true, + (out && (out = testing::AssertionResult(checkers(t))))...}; + static_cast(dummy); + + return out ? out + : out << " Caused by exception " << count << "thrown by " + << e.what(); +} + +template +class StrongGuaranteeTester { + public: + explicit StrongGuaranteeTester(std::unique_ptr t_ptr, EqualTo eq) noexcept + : val_(std::move(t_ptr)), eq_(eq) {} + + testing::AssertionResult operator()(const T& other) const { + return eq_(*val_, other) ? testing::AssertionSuccess() + : testing::AssertionFailure() << "State changed"; + } + + private: + std::unique_ptr val_; + EqualTo eq_; +}; } // namespace exceptions_internal +extern exceptions_internal::NoThrowTag no_throw_ctor; + +// These are useful for tests which just construct objects and make sure there +// are no leaks. +inline void SetCountdown() { exceptions_internal::countdown = 0; } +inline void UnsetCountdown() { exceptions_internal::countdown = -1; } + // A test class which is contextually convertible to bool. The conversion can // be instrumented to throw at a controlled time. class ThrowingBool { @@ -152,6 +194,9 @@ class ThrowingValue : private exceptions_internal::TrackedObject { dummy_ = i; } + ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept + : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(i) {} + // absl expects nothrow destructors ~ThrowingValue() noexcept = default; @@ -173,22 +218,22 @@ class ThrowingValue : private exceptions_internal::TrackedObject { // Arithmetic Operators ThrowingValue operator+(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ + other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ + other.dummy_, no_throw_ctor); } ThrowingValue operator+() const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_, NoThrowTag{}); + return ThrowingValue(dummy_, no_throw_ctor); } ThrowingValue operator-(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ - other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ - other.dummy_, no_throw_ctor); } ThrowingValue operator-() const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(-dummy_, NoThrowTag{}); + return ThrowingValue(-dummy_, no_throw_ctor); } ThrowingValue& operator++() { @@ -199,7 +244,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject { ThrowingValue operator++(int) { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - auto out = ThrowingValue(dummy_, NoThrowTag{}); + auto out = ThrowingValue(dummy_, no_throw_ctor); ++dummy_; return out; } @@ -212,34 +257,34 @@ class ThrowingValue : private exceptions_internal::TrackedObject { ThrowingValue operator--(int) { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - auto out = ThrowingValue(dummy_, NoThrowTag{}); + auto out = ThrowingValue(dummy_, no_throw_ctor); --dummy_; return out; } ThrowingValue operator*(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ * other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ * other.dummy_, no_throw_ctor); } ThrowingValue operator/(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ / other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ / other.dummy_, no_throw_ctor); } ThrowingValue operator%(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ % other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ % other.dummy_, no_throw_ctor); } ThrowingValue operator<<(int shift) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ << shift, NoThrowTag{}); + return ThrowingValue(dummy_ << shift, no_throw_ctor); } ThrowingValue operator>>(int shift) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ >> shift, NoThrowTag{}); + return ThrowingValue(dummy_ >> shift, no_throw_ctor); } // Comparison Operators @@ -293,22 +338,22 @@ class ThrowingValue : private exceptions_internal::TrackedObject { // Bitwise Logical Operators ThrowingValue operator~() const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(~dummy_, NoThrowTag{}); + return ThrowingValue(~dummy_, no_throw_ctor); } ThrowingValue operator&(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ & other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ & other.dummy_, no_throw_ctor); } ThrowingValue operator|(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ | other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ | other.dummy_, no_throw_ctor); } ThrowingValue operator^(const ThrowingValue& other) const { exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION); - return ThrowingValue(dummy_ ^ other.dummy_, NoThrowTag{}); + return ThrowingValue(dummy_ ^ other.dummy_, no_throw_ctor); } // Compound Assignment operators @@ -434,10 +479,6 @@ class ThrowingValue : private exceptions_internal::TrackedObject { const int& Get() const noexcept { return dummy_; } private: - struct NoThrowTag {}; - ThrowingValue(int i, NoThrowTag) noexcept - : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(i) {} - int dummy_; }; // While not having to do with exceptions, explicitly delete comma operator, to @@ -596,7 +637,9 @@ int ThrowingAllocator::next_id_ = 0; // Inspects the constructions and destructions of anything inheriting from // TrackedObject. Place this as a member variable in a test fixture to ensure -// that every ThrowingValue was constructed and destroyed correctly. +// that every ThrowingValue was constructed and destroyed correctly. This also +// allows us to safely "leak" TrackedObjects, as AllocInspector will destroy +// everything left over in its destructor. struct AllocInspector { AllocInspector() = default; ~AllocInspector() { @@ -609,69 +652,79 @@ struct AllocInspector { } }; -// Tests that performing operation Op on a T follows the basic exception safety -// guarantee. -// -// Parameters: -// * T: the type under test. -// * FunctionFromTPtrToVoid: A functor exercising the function under test. It -// should take a T* and return void. -// -// There must also be a function named `AbslCheckInvariants` in an associated -// namespace of T which takes a const T& and returns true if the T's class -// invariants hold, and false if they don't. -template -testing::AssertionResult TestBasicGuarantee(T* t, FunctionFromTPtrToVoid&& op) { +// Tests for resource leaks by attempting to construct a T using args repeatedly +// until successful, using the countdown method. Side effects can then be +// tested for resource leaks. If an AllocInspector is present in the test +// fixture, then this will also test that memory resources are not leaked as +// long as T allocates TrackedObjects. +template +T TestThrowingCtor(Args&&... args) { + struct Cleanup { + ~Cleanup() { UnsetCountdown(); } + }; + Cleanup c; for (int countdown = 0;; ++countdown) { exceptions_internal::countdown = countdown; try { - op(t); - break; - } catch (const exceptions_internal::TestException& e) { - if (!AbslCheckInvariants(*t)) { - return exceptions_internal::FailureMessage(e, countdown) - << " broke invariants."; - } + return T(std::forward(args)...); + } catch (const exceptions_internal::TestException&) { } } - exceptions_internal::countdown = -1; - return testing::AssertionSuccess(); } -// Tests that performing operation Op on a T follows the strong exception safety -// guarantee. +// Tests that performing operation Op on a T follows exception safety +// guarantees. By default only tests the basic guarantee. // // Parameters: -// * T: the type under test. T must be copy-constructable and -// equality-comparible. +// * T: the type under test. // * FunctionFromTPtrToVoid: A functor exercising the function under test. It -// should take a T* and return void. -// -// There must also be a function named `AbslCheckInvariants` in an associated -// namespace of T which takes a const T& and returns true if the T's class -// invariants hold, and false if they don't. -template -testing::AssertionResult TestStrongGuarantee(T* t, - FunctionFromTPtrToVoid&& op) { - exceptions_internal::countdown = -1; - for (auto countdown = 0;; ++countdown) { - T dup = *t; +// should take a T* and return void. +// * Checkers: Any number of functions taking a const T& and returning +// anything contextually convertible to bool. If a testing::AssertionResult +// is used then the error message is kept. These test invariants related to +// the operation. To test the strong guarantee, pass +// absl::StrongGuarantee(...) as one of these arguments if T has operator==. +// Some types for which the strong guarantee makes sense don't have operator== +// (eg std::any). A function capturing *t or a T equal to it, taking a const +// T&, and returning contextually-convertible-to-bool may be passed instead. +template +testing::AssertionResult TestExceptionSafety(T* t, FunctionFromTPtrToVoid&& op, + const Checkers&... checkers) { + auto out = testing::AssertionSuccess(); + for (int countdown = 0;; ++countdown) { exceptions_internal::countdown = countdown; try { op(t); break; } catch (const exceptions_internal::TestException& e) { - if (!AbslCheckInvariants(*t)) { - return exceptions_internal::FailureMessage(e, countdown) - << " broke invariants."; - } - if (dup != *t) - return exceptions_internal::FailureMessage(e, countdown) - << " changed state."; + out = exceptions_internal::TestInvariants(*t, e, countdown, checkers...); + if (!out) return out; } } - exceptions_internal::countdown = -1; - return testing::AssertionSuccess(); + UnsetCountdown(); + return out; +} + +// Returns a functor to test for the strong exception-safety guarantee. If T is +// copyable, use the const T& overload, otherwise pass a unique_ptr. +// Equality comparisons are made against the T provided and default to using +// operator==. See the documentation for TestExceptionSafety if T doesn't have +// operator== but the strong guarantee still makes sense for it. +// +// Parameters: +// * T: The type under test. +template > +exceptions_internal::StrongGuaranteeTester StrongGuarantee( + const T& t, EqualTo eq = EqualTo()) { + return exceptions_internal::StrongGuaranteeTester( + absl::make_unique(t), eq); +} + +template > +exceptions_internal::StrongGuaranteeTester PointeeStrongGuarantee( + std::unique_ptr t_ptr, EqualTo eq = EqualTo()) { + return exceptions_internal::StrongGuaranteeTester( + std::move(t_ptr), eq); } } // namespace absl -- cgit 1.4.1