Export of internal Abseil changes.

--
eca34da4ccb7bb6a580f1364dff9ca053418fa3b by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 214305433

--
35393bdd21a87c4286f945fd34dda93afc4e0cd6 by Abseil Team <absl-team@google.com>:

Move some implementation details of string_view around to facilitate compiling on NVCC.

Abseil does not officially support NVCC as a reminder.

PiperOrigin-RevId: 214184876

--
61846cab9ab9476a4676ecade7173f68978cd038 by Jorg Brown <jorg@google.com>:

Move the initialization values for constants back to their declaration.

PiperOrigin-RevId: 214135927

--
7ac7df6c5f78f2faf419268c04618b936cb26065 by Abseil Team <absl-team@google.com>:

Performance improvements on format parser.

PiperOrigin-RevId: 214032366

--
90b4c0cf20e9feaa257a7ece40adaf7db40a60a7 by Xiaoyi Zhang <zhangxy@google.com>:

Add static_assert check to absl::visit to make sure all overloads of the visitor return the same type, as required by the C++ standard.

PiperOrigin-RevId: 213677001

--
787995342101b4c181291cde9ecea3048536e4bd by Abseil Team <absl-team@google.com>:

Update comment to indicate finite durations are less than InfiniteDuration.

PiperOrigin-RevId: 213660328

--
d78f0dce7cc31218807e96d93b9e8513b6c80b24 by Jon Cohen <cohenjon@google.com>:

s/invariant/contract in the exceptions safety testing framework.  This is a better term as these can be type invariants or function post conditions.  They also are very similar ground as to what is covered by c++20 Contracts (and could even be replaced by them.

PiperOrigin-RevId: 213631019

--
0b3ff1a640de9a7391a6c233568802cf86245b0e by Abseil Team <absl-team@google.com>:

Add noinline attribute for GetStackTrace/GetStackFrames/... so the skipped frames will not change because of inlining difference.

PiperOrigin-RevId: 213009637
GitOrigin-RevId: eca34da4ccb7bb6a580f1364dff9ca053418fa3b
Change-Id: Iff1022fd24e440fcbdf3c4ab2a915ca8954daa31

1 files changed, 47 insertions, 47 deletions

diff --git a/absl/types/variant_exception_safety_test.cc b/absl/types/variant_exception_safety_test.cc
index a3c9eac..58436f0 100644
--- a/absl/types/variant_exception_safety_test.cc
+++ b/absl/types/variant_exception_safety_test.cc
@@ -59,7 +59,7 @@ void ToValuelessByException(ThrowingVariant& v) {  // NOLINT
 }
 
 // Check that variant is still in a usable state after an exception is thrown.
-testing::AssertionResult CheckInvariants(ThrowingVariant* v) {
+testing::AssertionResult VariantInvariants(ThrowingVariant* v) {
   using testing::AssertionFailure;
   using testing::AssertionSuccess;
 
@@ -213,8 +213,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
         MakeExceptionSafetyTester()
             .WithInitialValue(WithThrower())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
-    EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
   {
     const ThrowingVariant rhs(ExpectedThrowerVec());
@@ -222,8 +222,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
         MakeExceptionSafetyTester()
             .WithInitialValue(WithThrowerVec())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
-    EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
   // libstdc++ std::variant has bugs on copy assignment regarding exception
   // safety.
@@ -251,12 +251,12 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
             .WithInitialValue(WithCopyNoThrow())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
     EXPECT_TRUE(tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
 #endif  // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
   {
@@ -268,7 +268,7 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
     const ThrowingVariant rhs(MoveNothrow{});
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants, strong_guarantee)
+                    .WithContracts(VariantInvariants, strong_guarantee)
                     .Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }));
   }
 }
@@ -304,11 +304,11 @@ TEST(VariantExceptionSafetyTest, MoveAssign) {
                         *lhs = std::move(copy);
                       });
     EXPECT_TRUE(tester
-                    .WithInvariants(
-                        CheckInvariants,
+                    .WithContracts(
+                        VariantInvariants,
                         [&](ThrowingVariant* lhs) { return lhs->index() == j; })
                     .Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
   {
     // - otherwise (index() != j), equivalent to
@@ -318,10 +318,10 @@ TEST(VariantExceptionSafetyTest, MoveAssign) {
     ThrowingVariant rhs(CopyNothrow{});
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       *lhs = std::move(copy);
@@ -347,12 +347,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
             .WithInitialValue(WithThrower())
             .WithOperation([rhs](ThrowingVariant* lhs) { *lhs = rhs; });
     EXPECT_TRUE(copy_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return !lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return !lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test());
     // move assign
     auto move_tester = MakeExceptionSafetyTester()
                            .WithInitialValue(WithThrower())
@@ -361,13 +361,13 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
                              *lhs = std::move(copy);
                            });
     EXPECT_TRUE(move_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return !lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return !lhs->valueless_by_exception();
+                                   })
                     .Test());
 
-    EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test());
   }
   // Otherwise (*this holds something else), if is_nothrow_constructible_v<Tj,
   // T> || !is_nothrow_move_constructible_v<Tj> is true, equivalent to
@@ -400,12 +400,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
             .WithInitialValue(WithCopyNoThrow())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
     EXPECT_TRUE(copy_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test());
     // move
     auto move_tester = MakeExceptionSafetyTester()
                            .WithInitialValue(WithCopyNoThrow())
@@ -413,12 +413,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
                              *lhs = ExpectedThrower(testing::nothrow_ctor);
                            });
     EXPECT_TRUE(move_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test());
   }
   // Otherwise (if is_nothrow_constructible_v<Tj, T> == false &&
   // is_nothrow_move_constructible<Tj> == true),
@@ -432,7 +432,7 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
     MoveNothrow rhs;
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants, strong_guarantee)
+                    .WithContracts(VariantInvariants, strong_guarantee)
                     .Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }));
   }
 #endif  // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
@@ -450,12 +450,12 @@ TEST(VariantExceptionSafetyTest, Emplace) {
                         v->emplace<Thrower>(args);
                       });
     EXPECT_TRUE(tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* v) {
-                                      return v->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* v) {
+                                     return v->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
 }
 
@@ -472,7 +472,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
     ThrowingVariant rhs = ExpectedThrower();
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants)
+                    .WithContracts(VariantInvariants)
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       lhs->swap(copy);
@@ -486,7 +486,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
     ThrowingVariant rhs = ExpectedThrower();
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithCopyNoThrow())
-                    .WithInvariants(CheckInvariants)
+                    .WithContracts(VariantInvariants)
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       lhs->swap(copy);
@@ -496,7 +496,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
     ThrowingVariant rhs = ExpectedThrower();
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithCopyNoThrow())
-                    .WithInvariants(CheckInvariants)
+                    .WithContracts(VariantInvariants)
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       copy.swap(*lhs);