Changes imported from Abseil "staging" branch:

  - 5d8235b05f4ea2b33a138712f463a30b6ae75719 Incorporate PR https://github.com/abseil/abseil-cpp/pull/... by Xiaoyi Zhang <zhangxy@google.com>
  - f2bc653acdaa983aa2765693476c17cd1142d59b Run the StrSplit WorksWithLargeStrings test in all configs. by Matt Armstrong <marmstrong@google.com>
  - 43aed1ea7dffcd656e1916c2d5637650fc3a8de3 Incorporate PR https://github.com/abseil/abseil-cpp/pull/... by Xiaoyi Zhang <zhangxy@google.com>
  - d58511d60904c7090e44638339ba63b97ca96f1a Add a new simple Mutex lifetime test, to be extended later. by Greg Falcon <gfalcon@google.com>
  - db5c86c186c09ad57963bcbd2b6182f62bce8ed0 Actually use the exception in TestCheckerAtCountdown by Jon Cohen <cohenjon@google.com>
  - 29c01a72b62d9a4b90f9bd935e3575adbafd85ed Use factories instead of explicitly passing pointers to T... by Jon Cohen <cohenjon@google.com>
  - 54d5526ee6ab7784992845f6e6e2c7d48ba008a5 Fix uint128 ostream operator and improve ostream test. by Alex Strelnikov <strel@google.com>
  - 4e49abe7e569cf6bd0eae95ce2b2fe2faa051fa2 Fix documentation: strings::PairFormatter -> absl::PairFo... by Derek Mauro <dmauro@google.com>
  - 4044297f0e1a8a6c6ae3f781a65080e0d57c6751 Cut the memory used by the StrSplit WorksWithLargeStrings... by Jorg Brown <jorg@google.com>

GitOrigin-RevId: 5d8235b05f4ea2b33a138712f463a30b6ae75719
Change-Id: Ib6b6b0161c26e5326b53a126454754e33678eefc

1 files changed, 77 insertions, 51 deletions

diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h
index a0a70d91d2d9..05bcd0ab59d6 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 <typename T, typename... Checkers>
-testing::AssertionResult TestInvariants(const T& t, const TestException& e,
-                                        int count,
-                                        const Checkers&... checkers) {
-  auto out = AbslCheckInvariants(t);
+template <typename Factory>
+using FactoryType = typename absl::result_of_t<Factory()>::element_type;
+
+// Returns an optional with the result of the check if op fails, or an empty
+// optional if op passes
+template <typename Factory, typename Op, typename Checker>
+absl::optional<testing::AssertionResult> TestCheckerAtCountdown(
+    Factory factory, const Op& op, int count, const Checker& check) {
+  exceptions_internal::countdown = count;
+  auto t_ptr = factory();
+  absl::optional<testing::AssertionResult> 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 <typename Factory, typename Op, typename Checker>
+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 <typename Factory, typename Op, typename... Checkers>
+absl::optional<testing::AssertionResult> 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<void>(dummy);
+  auto out = TestCheckerAtCountdown(
+      factory, op, count,
+      [](FactoryType<Factory>* 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<void>(dummy);
+  return out;
 }
 
 template <typename T, typename EqualTo>
@@ -118,9 +150,9 @@ class StrongGuaranteeTester {
   explicit StrongGuaranteeTester(std::unique_ptr<T> 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 <typename T, typename FunctionFromTPtrToVoid, typename... Checkers>
-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 <typename TFactory, typename FunctionFromTPtrToVoid,
+          typename... Checkers>
+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<T>.
-// 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 <typename T, typename EqualTo = std::equal_to<T>>
-exceptions_internal::StrongGuaranteeTester<T, EqualTo> StrongGuarantee(
-    const T& t, EqualTo eq = EqualTo()) {
-  return exceptions_internal::StrongGuaranteeTester<T, EqualTo>(
-      absl::make_unique<T>(t), eq);
-}
-
-template <typename T, typename EqualTo = std::equal_to<T>>
-exceptions_internal::StrongGuaranteeTester<T, EqualTo> PointeeStrongGuarantee(
-    std::unique_ptr<T> t_ptr, EqualTo eq = EqualTo()) {
-  return exceptions_internal::StrongGuaranteeTester<T, EqualTo>(
-      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 <typename TFactory, typename EqualTo = std::equal_to<
+                                 exceptions_internal::FactoryType<TFactory>>>
+exceptions_internal::StrongGuaranteeTester<
+    exceptions_internal::FactoryType<TFactory>, EqualTo>
+StrongGuarantee(TFactory factory, EqualTo eq = EqualTo()) {
+  return exceptions_internal::StrongGuaranteeTester<
+      exceptions_internal::FactoryType<TFactory>, EqualTo>(factory(), eq);
 }
 
 }  // namespace absl