From 8b727aa7aba86ce396da8e4886e40ea3e4357e27 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Fri, 1 Dec 2017 12:15:49 -0800 Subject: Changes imported from Abseil "staging" branch: - 5d8235b05f4ea2b33a138712f463a30b6ae75719 Incorporate PR https://github.com/abseil/abseil-cpp/pull/... by Xiaoyi Zhang - f2bc653acdaa983aa2765693476c17cd1142d59b Run the StrSplit WorksWithLargeStrings test in all configs. by Matt Armstrong - 43aed1ea7dffcd656e1916c2d5637650fc3a8de3 Incorporate PR https://github.com/abseil/abseil-cpp/pull/... by Xiaoyi Zhang - d58511d60904c7090e44638339ba63b97ca96f1a Add a new simple Mutex lifetime test, to be extended later. by Greg Falcon - db5c86c186c09ad57963bcbd2b6182f62bce8ed0 Actually use the exception in TestCheckerAtCountdown by Jon Cohen - 29c01a72b62d9a4b90f9bd935e3575adbafd85ed Use factories instead of explicitly passing pointers to T... by Jon Cohen - 54d5526ee6ab7784992845f6e6e2c7d48ba008a5 Fix uint128 ostream operator and improve ostream test. by Alex Strelnikov - 4e49abe7e569cf6bd0eae95ce2b2fe2faa051fa2 Fix documentation: strings::PairFormatter -> absl::PairFo... by Derek Mauro - 4044297f0e1a8a6c6ae3f781a65080e0d57c6751 Cut the memory used by the StrSplit WorksWithLargeStrings... by Jorg Brown GitOrigin-RevId: 5d8235b05f4ea2b33a138712f463a30b6ae75719 Change-Id: Ib6b6b0161c26e5326b53a126454754e33678eefc --- absl/base/internal/exception_safety_testing.h | 128 ++++++++++++++++---------- 1 file changed, 77 insertions(+), 51 deletions(-) (limited to 'absl/base/internal') diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h index a0a70d91..05bcd0ab 100644 --- a/absl/base/internal/exception_safety_testing.h +++ b/absl/base/internal/exception_safety_testing.h @@ -18,6 +18,7 @@ #include "absl/meta/type_traits.h" #include "absl/strings/string_view.h" #include "absl/strings/substitute.h" +#include "absl/types/optional.h" namespace absl { struct AllocInspector; @@ -97,19 +98,50 @@ 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); +template +using FactoryType = typename absl::result_of_t::element_type; + +// Returns an optional with the result of the check if op fails, or an empty +// optional if op passes +template +absl::optional TestCheckerAtCountdown( + Factory factory, const Op& op, int count, const Checker& check) { + exceptions_internal::countdown = count; + auto t_ptr = factory(); + absl::optional out; + try { + op(t_ptr.get()); + } catch (const exceptions_internal::TestException& e) { + out.emplace(check(t_ptr.get())); + if (!*out) { + *out << " caused by exception thrown by " << e.what(); + } + } + return out; +} + +template +int UpdateOut(Factory factory, const Op& op, int count, const Checker& checker, + testing::AssertionResult* out) { + if (*out) *out = *TestCheckerAtCountdown(factory, op, count, checker); + return 0; +} + +// Returns an optional with the result of the check if op fails, or an empty +// optional if op passes +template +absl::optional TestAtCountdown( + Factory factory, const Op& op, int count, const Checkers&... checkers) { // 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); + auto out = TestCheckerAtCountdown( + factory, op, count, + [](FactoryType* t_ptr) { return AbslCheckInvariants(t_ptr); }); + if (!out.has_value()) return out; - return out ? out - : out << " Caused by exception " << count << "thrown by " - << e.what(); + // Run each checker, short circuiting after the first failure + int dummy[] = {0, (UpdateOut(factory, op, count, checkers, &*out))...}; + static_cast(dummy); + return out; } template @@ -118,9 +150,9 @@ class StrongGuaranteeTester { 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"; + testing::AssertionResult operator()(T* other) const { + return eq_(*val_, *other) ? testing::AssertionSuccess() + : testing::AssertionFailure() << "State changed"; } private: @@ -673,58 +705,52 @@ T TestThrowingCtor(Args&&... args) { } // Tests that performing operation Op on a T follows exception safety -// guarantees. By default only tests the basic guarantee. +// guarantees. By default only tests the basic guarantee. There must be a +// function, AbslCheckInvariants(T*) which returns +// anything convertible to bool and which makes sure the invariants of the type +// are upheld. This is called before any of the checkers. // // Parameters: -// * T: the type under test. +// * TFactory: operator() returns a unique_ptr to the type under test (T). It +// should always return pointers to values which compare equal. // * FunctionFromTPtrToVoid: A functor exercising the function under test. It // should take a T* and return void. -// * Checkers: Any number of functions taking a const T& and returning +// * Checkers: Any number of functions taking a 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, +// absl::StrongGuarantee(factory). A checker may freely modify the passed-in +// T, for example to make sure the T can be set to a known state. +template +testing::AssertionResult TestExceptionSafety(TFactory factory, + 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) { - out = exceptions_internal::TestInvariants(*t, e, countdown, checkers...); - if (!out) return out; + auto out = exceptions_internal::TestAtCountdown(factory, op, countdown, + checkers...); + if (!out.has_value()) { + UnsetCountdown(); + return testing::AssertionSuccess(); } + if (!*out) return *out; } - 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. +// Returns a functor to test for the strong exception-safety guarantee. +// Equality comparisons are made against the T provided by the factory and +// default to using operator==. // // 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); +// * TFactory: operator() returns a unique_ptr to the type under test. It +// should always return pointers to values which compare equal. +template >> +exceptions_internal::StrongGuaranteeTester< + exceptions_internal::FactoryType, EqualTo> +StrongGuarantee(TFactory factory, EqualTo eq = EqualTo()) { + return exceptions_internal::StrongGuaranteeTester< + exceptions_internal::FactoryType, EqualTo>(factory(), eq); } } // namespace absl -- cgit v1.2.3