From 92020a042c0cd46979db9f6f0cb32783dc07765e Mon Sep 17 00:00:00 2001
From: Abseil Team <absl-team@google.com>
Date: Fri, 8 Jun 2018 08:14:48 -0700
Subject:   - abacaab4b11a69dd4db627bd183571d7cabb8def Refinement to previous
 time.h edit (in this same github p... by Greg Falcon <gfalcon@google.com>   -
 64db19b773134c6c8004e3b23c9ca892efbf8bae Move SpinLock's adaptive spin count
 computation from a st... by Derek Mauro <dmauro@google.com>   -
 6f9533fb44a52485a7c2bbb9b4efc7bf8d6c359a Import of CCTZ from GitHub. by
 Abseil Team <absl-team@google.com>   -
 a211d7255c986e8dd4ceada362c0d054a6a1969a Cleanup exception flags by Abseil
 Team <absl-team@google.com>   - babdb29c590126fe9bba5229fe91034b5b5c358a
 Release time benchmarks. by Alex Strelnikov <strel@google.com>   -
 5803b32a3ff123d1fb57a0c471d199c818357c9f Release memutil microbenchmarks. by
 Alex Strelnikov <strel@google.com>   -
 5357d4890d30e80c53beb05af32500fb20e9402b Add parens around expansion of
 ABSL_PREDICT_{FALSE,TRUE} ... by Abseil Team <absl-team@google.com>   -
 32023f61a239a5f6b1c59e577bfe81b179bbcd2d Reformat build rule tag. by Alex
 Strelnikov <strel@google.com>   - 833758ecf2b0cf7a42bbd50b5b127e416425c168
 Release uint128 microbenchmarks. by Alex Strelnikov <strel@google.com>   -
 c115a9bca1f944b90fdc78a56b2de176466b124f Disambiguate bitwise-not of
 size_type by Abseil Team <absl-team@google.com>   -
 f6905f5b5f6e425792de646edafde440548d9346 Updates ConstructorTracker and
 TrackedObjects with 1) a m... by Abseil Team <absl-team@google.com>   -
 147c553bdd5d2db20a38f75c4d1ef973d6c709c5 Changes the absl::Duration factory
 functions to disallow ... by Greg Miller <jgm@google.com>   -
 dba2b96d11b5264546b283ba452f2de1303b0f07 White space fix by Alex Strelnikov
 <strel@google.com>

GitOrigin-RevId: abacaab4b11a69dd4db627bd183571d7cabb8def
Change-Id: I6fa34f20d0b2f898e7b5475a603111413bb80a67
---
 absl/base/exception_safety_testing_test.cc | 71 +++++++++++++++++++++++++-----
 1 file changed, 60 insertions(+), 11 deletions(-)

(limited to 'absl/base/exception_safety_testing_test.cc')

diff --git a/absl/base/exception_safety_testing_test.cc b/absl/base/exception_safety_testing_test.cc
index a8b82b73..97c8d6f8 100644
--- a/absl/base/exception_safety_testing_test.cc
+++ b/absl/base/exception_safety_testing_test.cc
@@ -168,8 +168,58 @@ TEST(ThrowingValueTest, ThrowingCompoundAssignmentOps) {
 TEST(ThrowingValueTest, ThrowingStreamOps) {
   ThrowingValue<> bomb;
 
-  TestOp([&]() { std::cin >> bomb; });
-  TestOp([&]() { std::cout << bomb; });
+  TestOp([&]() {
+    std::istringstream stream;
+    stream >> bomb;
+  });
+  TestOp([&]() {
+    std::stringstream stream;
+    stream << bomb;
+  });
+}
+
+// Tests the operator<< of ThrowingValue by forcing ConstructorTracker to emit
+// a nonfatal failure that contains the std::string representation of the Thrower
+TEST(ThrowingValueTest, StreamOpsOutput) {
+  using ::testing::TypeSpec;
+  exceptions_internal::ConstructorTracker ct(exceptions_internal::countdown);
+
+  // Test default spec list (kEverythingThrows)
+  EXPECT_NONFATAL_FAILURE(
+      {
+        using Thrower = ThrowingValue<TypeSpec{}>;
+        auto thrower = Thrower(123);
+        thrower.~Thrower();
+      },
+      "ThrowingValue<>(123)");
+
+  // Test with one item in spec list (kNoThrowCopy)
+  EXPECT_NONFATAL_FAILURE(
+      {
+        using Thrower = ThrowingValue<TypeSpec::kNoThrowCopy>;
+        auto thrower = Thrower(234);
+        thrower.~Thrower();
+      },
+      "ThrowingValue<kNoThrowCopy>(234)");
+
+  // Test with multiple items in spec list (kNoThrowMove, kNoThrowNew)
+  EXPECT_NONFATAL_FAILURE(
+      {
+        using Thrower =
+            ThrowingValue<TypeSpec::kNoThrowMove | TypeSpec::kNoThrowNew>;
+        auto thrower = Thrower(345);
+        thrower.~Thrower();
+      },
+      "ThrowingValue<kNoThrowMove | kNoThrowNew>(345)");
+
+  // Test with all items in spec list (kNoThrowCopy, kNoThrowMove, kNoThrowNew)
+  EXPECT_NONFATAL_FAILURE(
+      {
+        using Thrower = ThrowingValue<static_cast<TypeSpec>(-1)>;
+        auto thrower = Thrower(456);
+        thrower.~Thrower();
+      },
+      "ThrowingValue<kNoThrowCopy | kNoThrowMove | kNoThrowNew>(456)");
 }
 
 template <typename F>
@@ -653,20 +703,20 @@ struct BasicGuaranteeWithExtraInvariants : public NonNegative {
 };
 constexpr int BasicGuaranteeWithExtraInvariants::kExceptionSentinel;
 
-TEST(ExceptionCheckTest, BasicGuaranteeWithInvariants) {
+TEST(ExceptionCheckTest, BasicGuaranteeWithExtraInvariants) {
   auto tester_with_val =
       tester.WithInitialValue(BasicGuaranteeWithExtraInvariants{});
   EXPECT_TRUE(tester_with_val.Test());
   EXPECT_TRUE(
       tester_with_val
-          .WithInvariants([](BasicGuaranteeWithExtraInvariants* w) {
-            if (w->i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) {
+          .WithInvariants([](BasicGuaranteeWithExtraInvariants* o) {
+            if (o->i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) {
               return testing::AssertionSuccess();
             }
             return testing::AssertionFailure()
                    << "i should be "
                    << BasicGuaranteeWithExtraInvariants::kExceptionSentinel
-                   << ", but is " << w->i;
+                   << ", but is " << o->i;
           })
           .Test());
 }
@@ -846,29 +896,28 @@ TEST(ConstructorTrackerTest, NotDestroyedAfter) {
         new (&storage) Tracked;
       },
       "not destroyed");
-
-  // Manual destruction of the Tracked instance is not required because
-  // ~ConstructorTracker() handles that automatically when a leak is found
 }
 
 TEST(ConstructorTrackerTest, DestroyedTwice) {
+  exceptions_internal::ConstructorTracker ct(exceptions_internal::countdown);
   EXPECT_NONFATAL_FAILURE(
       {
         Tracked t;
         t.~Tracked();
       },
-      "destroyed improperly");
+      "re-destroyed");
 }
 
 TEST(ConstructorTrackerTest, ConstructedTwice) {
+  exceptions_internal::ConstructorTracker ct(exceptions_internal::countdown);
   absl::aligned_storage_t<sizeof(Tracked), alignof(Tracked)> storage;
   EXPECT_NONFATAL_FAILURE(
       {
         new (&storage) Tracked;
         new (&storage) Tracked;
+        reinterpret_cast<Tracked*>(&storage)->~Tracked();
       },
       "re-constructed");
-  reinterpret_cast<Tracked*>(&storage)->~Tracked();
 }
 
 TEST(ThrowingValueTraitsTest, RelationalOperators) {
-- 
cgit v1.2.3