about summary refs log tree commit diff
path: root/absl
diff options
context:
space:
mode:
Diffstat (limited to 'absl')
-rw-r--r--absl/base/BUILD.bazel1
-rw-r--r--absl/base/CMakeLists.txt19
-rw-r--r--absl/base/exception_safety_testing_test.cc25
-rw-r--r--absl/base/internal/exception_safety_testing.cc7
-rw-r--r--absl/base/internal/exception_safety_testing.h61
-rw-r--r--absl/meta/type_traits.h66
-rw-r--r--absl/meta/type_traits_test.cc337
-rw-r--r--absl/strings/internal/stl_type_traits.h121
-rw-r--r--absl/strings/string_view.h2
-rw-r--r--absl/strings/string_view_test.cc25
-rw-r--r--absl/strings/strip_test.cc20
-rw-r--r--absl/types/BUILD.bazel13
-rw-r--r--absl/types/CMakeLists.txt17
-rw-r--r--absl/types/any_exception_safety_test.cc201
14 files changed, 724 insertions, 191 deletions
diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel
index f6d6c3d24caf..609d78ad6287 100644
--- a/absl/base/BUILD.bazel
+++ b/absl/base/BUILD.bazel
@@ -235,6 +235,7 @@ cc_library(
     hdrs = ["internal/exception_safety_testing.h"],
     copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
     deps = [
+        ":base",
         ":config",
         ":pretty_function",
         "//absl/memory",
diff --git a/absl/base/CMakeLists.txt b/absl/base/CMakeLists.txt
index 1b24fd1bb60b..cb0daa69ffdc 100644
--- a/absl/base/CMakeLists.txt
+++ b/absl/base/CMakeLists.txt
@@ -33,6 +33,7 @@ list(APPEND BASE_INTERNAL_HEADERS
   "internal/cycleclock.h"
   "internal/endian.h"
   "internal/exception_testing.h"
+  "internal/exception_safety_testing.h"
   "internal/identity.h"
   "internal/invoke.h"
   "internal/log_severity.h"
@@ -43,6 +44,7 @@ list(APPEND BASE_INTERNAL_HEADERS
   "internal/malloc_hook.h"
   "internal/malloc_hook_invoke.h"
   "internal/per_thread_tls.h"
+  "internal/pretty_function.h"
   "internal/raw_logging.h"
   "internal/scheduling_mode.h"
   "internal/spinlock.h"
@@ -57,8 +59,9 @@ list(APPEND BASE_INTERNAL_HEADERS
 
 
 # absl_base main library
-list(APPEND BASE_SRC 
+list(APPEND BASE_SRC
   "internal/cycleclock.cc"
+  "internal/exception_safety_testing.cc"
   "internal/raw_logging.cc"
   "internal/spinlock.cc"
   "internal/sysinfo.cc"
@@ -318,6 +321,20 @@ absl_test(
     ${THREAD_IDENTITY_TEST_PUBLIC_LIBRARIES}
 )
 
+#test exceptions_safety_testing_test
+set(EXCEPTION_SAFETY_TESTING_TEST_SRC "exception_safety_testing_test.cc")
+set(EXCEPTION_SAFETY_TESTING_TEST_PUBLIC_LIBRARIES absl::base absl::memory absl::meta absl::strings absl::optional)
+
+absl_test(
+  TARGET
+    absl_exception_safety_testing_test
+  SOURCES
+    ${EXCEPTION_SAFETY_TESTING_TEST_SRC}
+  PUBLIC_LIBRARIES
+    ${EXCEPTION_SAFETY_TESTING_TEST_PUBLIC_LIBRARIES}
+  PRIVATE_COMPILE_FLAGS
+    ${ABSL_EXCEPTIONS_FLAG}
+)
 
 # test absl_malloc_extension_system_malloc_test
 set(MALLOC_EXTENSION_SYSTEM_MALLOC_TEST_SRC "internal/malloc_extension_test.cc")
diff --git a/absl/base/exception_safety_testing_test.cc b/absl/base/exception_safety_testing_test.cc
index 1fc03861784e..5477b40a5bed 100644
--- a/absl/base/exception_safety_testing_test.cc
+++ b/absl/base/exception_safety_testing_test.cc
@@ -63,7 +63,7 @@ TEST_F(ThrowingValueTest, Throws) {
 // the countdown doesn't hit 0, and doesn't modify the state of the
 // ThrowingValue if it throws
 template <typename F>
-void TestOp(F&& f) {
+void TestOp(const F& f) {
   UnsetCountdown();
   ExpectNoThrow(f);
 
@@ -153,11 +153,21 @@ TEST_F(ThrowingValueTest, ThrowingStreamOps) {
   TestOp([&]() { std::cout << bomb; });
 }
 
+template <typename F>
+void TestAllocatingOp(const F& f) {
+  UnsetCountdown();
+  ExpectNoThrow(f);
+
+  SetCountdown();
+  EXPECT_THROW(f(), exceptions_internal::TestBadAllocException);
+  UnsetCountdown();
+}
+
 TEST_F(ThrowingValueTest, ThrowingAllocatingOps) {
   // make_unique calls unqualified operator new, so these exercise the
   // ThrowingValue overloads.
-  TestOp([]() { return absl::make_unique<ThrowingValue<>>(1); });
-  TestOp([]() { return absl::make_unique<ThrowingValue<>[]>(2); });
+  TestAllocatingOp([]() { return absl::make_unique<ThrowingValue<>>(1); });
+  TestAllocatingOp([]() { return absl::make_unique<ThrowingValue<>[]>(2); });
 }
 
 TEST_F(ThrowingValueTest, NonThrowingMoveCtor) {
@@ -399,7 +409,8 @@ struct CallOperator {
 };
 
 struct NonNegative {
-  friend testing::AssertionResult AbslCheckInvariants(NonNegative* g) {
+  friend testing::AssertionResult AbslCheckInvariants(
+      NonNegative* g, absl::InternalAbslNamespaceFinder) {
     if (g->i >= 0) return testing::AssertionSuccess();
     return testing::AssertionFailure()
            << "i should be non-negative but is " << g->i;
@@ -503,7 +514,8 @@ struct HasReset : public NonNegative {
 
   void reset() { i = 0; }
 
-  friend bool AbslCheckInvariants(HasReset* h) {
+  friend bool AbslCheckInvariants(HasReset* h,
+                                  absl::InternalAbslNamespaceFinder) {
     h->reset();
     return h->i == 0;
   }
@@ -591,7 +603,8 @@ struct ExhaustivenessTester {
     return true;
   }
 
-  friend testing::AssertionResult AbslCheckInvariants(ExhaustivenessTester*) {
+  friend testing::AssertionResult AbslCheckInvariants(
+      ExhaustivenessTester*, absl::InternalAbslNamespaceFinder) {
     return testing::AssertionSuccess();
   }
 
diff --git a/absl/base/internal/exception_safety_testing.cc b/absl/base/internal/exception_safety_testing.cc
index ab8d6c9fb4d0..821438ecc28c 100644
--- a/absl/base/internal/exception_safety_testing.cc
+++ b/absl/base/internal/exception_safety_testing.cc
@@ -23,8 +23,11 @@ namespace exceptions_internal {
 
 int countdown = -1;
 
-void MaybeThrow(absl::string_view msg) {
-  if (countdown-- == 0) throw TestException(msg);
+void MaybeThrow(absl::string_view msg, bool throw_bad_alloc) {
+  if (countdown-- == 0) {
+    if (throw_bad_alloc) throw TestBadAllocException(msg);
+    throw TestException(msg);
+  }
 }
 
 testing::AssertionResult FailureMessage(const TestException& e,
diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h
index a0127a8819fa..8eac2264884f 100644
--- a/absl/base/internal/exception_safety_testing.h
+++ b/absl/base/internal/exception_safety_testing.h
@@ -35,6 +35,8 @@
 #include "absl/types/optional.h"
 
 namespace absl {
+struct InternalAbslNamespaceFinder {};
+
 struct AllocInspector;
 
 // A configuration enum for Throwing*.  Operations whose flags are set will
@@ -71,31 +73,45 @@ constexpr bool ThrowingAllowed(NoThrow flags, NoThrow flag) {
 class TestException {
  public:
   explicit TestException(absl::string_view msg) : msg_(msg) {}
-  absl::string_view what() const { return msg_; }
+  virtual ~TestException() {}
+  virtual const char* what() const noexcept { return msg_.c_str(); }
 
  private:
   std::string msg_;
 };
 
+// TestBadAllocException exists because allocation functions must throw an
+// exception which can be caught by a handler of std::bad_alloc.  We use a child
+// class of std::bad_alloc so we can customise the error message, and also
+// derive from TestException so we don't accidentally end up catching an actual
+// bad_alloc exception in TestExceptionSafety.
+class TestBadAllocException : public std::bad_alloc, public TestException {
+ public:
+  explicit TestBadAllocException(absl::string_view msg)
+      : TestException(msg) {}
+  using TestException::what;
+};
+
 extern int countdown;
 
-void MaybeThrow(absl::string_view msg);
+void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
 
 testing::AssertionResult FailureMessage(const TestException& e,
                                         int countdown) noexcept;
 
 class TrackedObject {
+ public:
+  TrackedObject(const TrackedObject&) = delete;
+  TrackedObject(TrackedObject&&) = delete;
+
  protected:
-  explicit TrackedObject(absl::string_view child_ctor) {
+  explicit TrackedObject(const char* child_ctor) {
     if (!GetAllocs().emplace(this, child_ctor).second) {
       ADD_FAILURE() << "Object at address " << static_cast<void*>(this)
                     << " re-constructed in ctor " << child_ctor;
     }
   }
 
-  TrackedObject(const TrackedObject&) = delete;
-  TrackedObject(TrackedObject&&) = delete;
-
   static std::unordered_map<TrackedObject*, absl::string_view>& GetAllocs() {
     static auto* m =
         new std::unordered_map<TrackedObject*, absl::string_view>();
@@ -120,10 +136,10 @@ using FactoryType = typename absl::result_of_t<Factory()>::element_type;
 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 {
+    exceptions_internal::countdown = count;
     op(t_ptr.get());
   } catch (const exceptions_internal::TestException& e) {
     out.emplace(check(t_ptr.get()));
@@ -141,6 +157,10 @@ int UpdateOut(Factory factory, const Op& op, int count, const Checker& checker,
   return 0;
 }
 
+// Declare AbslCheckInvariants so that it can be found eventually via ADL.
+// Taking `...` gives it the lowest possible precedence.
+void AbslCheckInvariants(...);
+
 // 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>
@@ -148,8 +168,9 @@ 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.
   auto out = TestCheckerAtCountdown(
-      factory, op, count,
-      [](FactoryType<Factory>* t_ptr) { return AbslCheckInvariants(t_ptr); });
+      factory, op, count, [](FactoryType<Factory>* t_ptr) {
+        return AbslCheckInvariants(t_ptr, InternalAbslNamespaceFinder());
+      });
   if (!out.has_value()) return out;
 
   // Run each checker, short circuiting after the first failure
@@ -483,7 +504,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   static void* operator new(size_t s, Args&&... args) noexcept(
       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
     if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new(s, std::forward<Args>(args)...);
   }
@@ -492,7 +513,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   static void* operator new[](size_t s, Args&&... args) noexcept(
       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
     if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new[](s, std::forward<Args>(args)...);
   }
@@ -630,10 +651,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
     p->~U();
   }
 
-  size_type max_size() const
-      noexcept(!exceptions_internal::ThrowingAllowed(Flags,
-                                                     NoThrow::kNoThrow)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+  size_type max_size() const noexcept {
     return std::numeric_limits<difference_type>::max() / sizeof(value_type);
   }
 
@@ -720,9 +738,12 @@ T TestThrowingCtor(Args&&... args) {
 
 // Tests that performing operation Op on a T follows exception safety
 // 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.
+// function, AbslCheckInvariants(T*, absl::InternalAbslNamespaceFinder) 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.  The
+// InternalAbslNamespaceFinder is unused, and just helps find
+// AbslCheckInvariants for absl types which become aliases to std::types in
+// C++17.
 //
 // Parameters:
 //   * TFactory: operator() returns a unique_ptr to the type under test (T).  It
@@ -740,11 +761,13 @@ template <typename TFactory, typename FunctionFromTPtrToVoid,
 testing::AssertionResult TestExceptionSafety(TFactory factory,
                                              FunctionFromTPtrToVoid&& op,
                                              const Checkers&... checkers) {
+  struct Cleanup {
+    ~Cleanup() { UnsetCountdown(); }
+  } c;
   for (int countdown = 0;; ++countdown) {
     auto out = exceptions_internal::TestAtCountdown(factory, op, countdown,
                                                     checkers...);
     if (!out.has_value()) {
-      UnsetCountdown();
       return testing::AssertionSuccess();
     }
     if (!*out) return *out;
diff --git a/absl/meta/type_traits.h b/absl/meta/type_traits.h
index 6f7138c2d8db..f36a59aa7777 100644
--- a/absl/meta/type_traits.h
+++ b/absl/meta/type_traits.h
@@ -148,11 +148,16 @@ struct negation : std::integral_constant<bool, !T::value> {};
 template <typename T>
 struct is_trivially_destructible
     : std::integral_constant<bool, __has_trivial_destructor(T) &&
-                                       std::is_destructible<T>::value> {
+                                   std::is_destructible<T>::value> {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
-  static_assert(std::is_trivially_destructible<T>::value ==
-                    is_trivially_destructible::value,
-                "Not compliant with std::is_trivially_destructible");
+  static constexpr bool compliant = std::is_trivially_destructible<T>::value ==
+                                    is_trivially_destructible::value;
+  static_assert(compliant || std::is_trivially_destructible<T>::value,
+                "Not compliant with std::is_trivially_destructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_destructible<T>::value,
+                "Not compliant with std::is_trivially_destructible; "
+                "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
 };
 
@@ -186,18 +191,23 @@ struct is_trivially_destructible
 // GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
 // LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116.
 //
-// "T obj();" need to be well-formed and not call any non-trivial operation.
+// "T obj();" need to be well-formed and not call any nontrivial operation.
 // Nontrivally destructible types will cause the expression to be nontrivial.
 template <typename T>
 struct is_trivially_default_constructible
-    : std::integral_constant<bool,
-                             __has_trivial_constructor(T) &&
-                                 std::is_default_constructible<T>::value &&
-                                 is_trivially_destructible<T>::value> {
+    : std::integral_constant<bool, __has_trivial_constructor(T) &&
+                                   std::is_default_constructible<T>::value &&
+                                   is_trivially_destructible<T>::value> {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-  static_assert(std::is_trivially_default_constructible<T>::value ==
-                    is_trivially_default_constructible::value,
-                "Not compliant with std::is_trivially_default_constructible");
+  static constexpr bool compliant =
+      std::is_trivially_default_constructible<T>::value ==
+      is_trivially_default_constructible::value;
+  static_assert(compliant || std::is_trivially_default_constructible<T>::value,
+                "Not compliant with std::is_trivially_default_constructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_default_constructible<T>::value,
+                "Not compliant with std::is_trivially_default_constructible; "
+                "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
 };
 
@@ -217,12 +227,18 @@ struct is_trivially_default_constructible
 template <typename T>
 struct is_trivially_copy_constructible
     : std::integral_constant<bool, __has_trivial_copy(T) &&
-                                       std::is_copy_constructible<T>::value &&
-                                       is_trivially_destructible<T>::value> {
+                                   std::is_copy_constructible<T>::value &&
+                                   is_trivially_destructible<T>::value> {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-  static_assert(std::is_trivially_copy_constructible<T>::value ==
-                    is_trivially_copy_constructible::value,
-                "Not compliant with std::is_trivially_copy_constructible");
+  static constexpr bool compliant =
+      std::is_trivially_copy_constructible<T>::value ==
+      is_trivially_copy_constructible::value;
+  static_assert(compliant || std::is_trivially_copy_constructible<T>::value,
+                "Not compliant with std::is_trivially_copy_constructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_copy_constructible<T>::value,
+                "Not compliant with std::is_trivially_copy_constructible; "
+                "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
 };
 
@@ -240,15 +256,21 @@ struct is_trivially_copy_constructible
 // `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
 // operand. `is_trivially_assignable<T, U>` requires the assignment to call no
 // operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
-// `is_trivially_assignable<T, const T&>`.
+// `is_trivially_assignable<T&, const T&>`.
 template <typename T>
 struct is_trivially_copy_assignable
     : std::integral_constant<bool, __has_trivial_assign(T) &&
-                                       std::is_copy_assignable<T>::value> {
+                                   std::is_copy_assignable<T>::value> {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
-  static_assert(std::is_trivially_copy_assignable<T>::value ==
-                    is_trivially_copy_assignable::value,
-                "Not compliant with std::is_trivially_copy_assignable");
+  static constexpr bool compliant =
+      std::is_trivially_copy_assignable<T>::value ==
+      is_trivially_copy_assignable::value;
+  static_assert(compliant || std::is_trivially_copy_assignable<T>::value,
+                "Not compliant with std::is_trivially_copy_assignable; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_copy_assignable<T>::value,
+                "Not compliant with std::is_trivially_copy_assignable; "
+                "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
 };
 
diff --git a/absl/meta/type_traits_test.cc b/absl/meta/type_traits_test.cc
index 67d1c4555c4a..c44d1c5ff850 100644
--- a/absl/meta/type_traits_test.cc
+++ b/absl/meta/type_traits_test.cc
@@ -99,6 +99,18 @@ class Trivial {
   int n_;
 };
 
+struct TrivialDestructor {
+  ~TrivialDestructor() = default;
+};
+
+struct NontrivialDestructor {
+  ~NontrivialDestructor() {}
+};
+
+struct DeletedDestructor {
+  ~DeletedDestructor() = delete;
+};
+
 class TrivialDefaultCtor {
  public:
   TrivialDefaultCtor() = default;
@@ -108,6 +120,23 @@ class TrivialDefaultCtor {
   int n_;
 };
 
+class NontrivialDefaultCtor {
+ public:
+  NontrivialDefaultCtor() : n_(1) {}
+
+ private:
+  int n_;
+};
+
+class DeletedDefaultCtor {
+ public:
+  DeletedDefaultCtor() = delete;
+  explicit DeletedDefaultCtor(int n) : n_(n) {}
+
+ private:
+  int n_;
+};
+
 class TrivialCopyCtor {
  public:
   explicit TrivialCopyCtor(int n) : n_(n) {}
@@ -121,22 +150,57 @@ class TrivialCopyCtor {
   int n_;
 };
 
+class NontrivialCopyCtor {
+ public:
+  explicit NontrivialCopyCtor(int n) : n_(n) {}
+  NontrivialCopyCtor(const NontrivialCopyCtor& t) : n_(t.n_) {}
+  NontrivialCopyCtor& operator=(const NontrivialCopyCtor&) = default;
+
+ private:
+  int n_;
+};
+
+class DeletedCopyCtor {
+ public:
+  explicit DeletedCopyCtor(int n) : n_(n) {}
+  DeletedCopyCtor(const DeletedCopyCtor&) = delete;
+  DeletedCopyCtor& operator=(const DeletedCopyCtor&) = default;
+
+ private:
+  int n_;
+};
+
 class TrivialCopyAssign {
  public:
   explicit TrivialCopyAssign(int n) : n_(n) {}
   TrivialCopyAssign(const TrivialCopyAssign& t) : n_(t.n_) {}
   TrivialCopyAssign& operator=(const TrivialCopyAssign& t) = default;
-  ~TrivialCopyAssign() {}  // can have non trivial destructor
+  ~TrivialCopyAssign() {}  // can have nontrivial destructor
  private:
   int n_;
 };
 
-struct NonTrivialDestructor {
-  ~NonTrivialDestructor() {}
+class NontrivialCopyAssign {
+ public:
+  explicit NontrivialCopyAssign(int n) : n_(n) {}
+  NontrivialCopyAssign(const NontrivialCopyAssign&) = default;
+  NontrivialCopyAssign& operator=(const NontrivialCopyAssign& t) {
+    n_ = t.n_;
+    return *this;
+  }
+
+ private:
+  int n_;
 };
 
-struct TrivialDestructor {
-  ~TrivialDestructor() = default;
+class DeletedCopyAssign {
+ public:
+  explicit DeletedCopyAssign(int n) : n_(n) {}
+  DeletedCopyAssign(const DeletedCopyAssign&) = default;
+  DeletedCopyAssign& operator=(const DeletedCopyAssign&) = delete;
+
+ private:
+  int n_;
 };
 
 struct NonCopyable {
@@ -152,19 +216,105 @@ class Base {
 
 // In GCC/Clang, std::is_trivially_constructible requires that the destructor is
 // trivial. However, MSVC doesn't require that. This results in different
-// behavior when checking is_trivially_constructible on any type with nontrivial
-// destructor. Since absl::is_trivially_default_constructible and
+// behavior when checking is_trivially_constructible on any type with
+// nontrivial destructor. Since absl::is_trivially_default_constructible and
 // absl::is_trivially_copy_constructible both follows Clang/GCC's interpretation
 // and check is_trivially_destructible, it results in inconsistency with
 // std::is_trivially_xxx_constructible on MSVC. This macro is used to work
 // around this issue in test. In practice, a trivially constructible type
 // should also be trivially destructible.
 // GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
-// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116.
-#ifdef _MSC_VER
-#define ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
+// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116
+#ifndef _MSC_VER
+#define ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 1
 #endif
 
+// Old versions of libc++, around Clang 3.5 to 3.6, consider deleted destructors
+// as also being trivial. With the resolution of CWG 1928 and CWG 1734, this
+// is no longer considered true and has thus been amended.
+// Compiler Explorer: https://godbolt.org/g/zT59ZL
+// CWG issue 1734: http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1734
+// CWG issue 1928: http://open-std.org/JTC1/SC22/WG21/docs/cwg_closed.html#1928
+#if !defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 3700
+#define ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL 1
+#endif
+
+// As of the moment, GCC versions >5.1 have a problem compiling for
+// std::is_trivially_default_constructible<NontrivialDestructor[10]>, where
+// NontrivialDestructor is a struct with a custom nontrivial destructor. Note
+// that this problem only occurs for arrays of a known size, so something like
+// std::is_trivially_default_constructible<NontrivialDestructor[]> does not
+// have any problems.
+// Compiler Explorer: https://godbolt.org/g/dXRbdK
+// GCC bug 83689: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83689
+#if defined(__clang__) || defined(_MSC_VER) || \
+    (defined(__GNUC__) && __GNUC__ < 5)
+#define ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL 1
+#endif
+
+TEST(TypeTraitsTest, TestTrivialDestructor) {
+  // Verify that arithmetic types and pointers have trivial destructors.
+  EXPECT_TRUE(absl::is_trivially_destructible<bool>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<char>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<unsigned char>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<signed char>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<wchar_t>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<int>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<unsigned int>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<int16_t>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<uint16_t>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<int64_t>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<uint64_t>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<float>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<double>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<long double>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<std::string*>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<Trivial*>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<const std::string*>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<const Trivial*>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<std::string**>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<Trivial**>::value);
+
+  // classes with destructors
+  EXPECT_TRUE(absl::is_trivially_destructible<Trivial>::value);
+  EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor>::value);
+
+  // Verify that types with a nontrivial or deleted destructor
+  // are marked as such.
+  EXPECT_FALSE(absl::is_trivially_destructible<NontrivialDestructor>::value);
+#ifdef ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL
+  EXPECT_FALSE(absl::is_trivially_destructible<DeletedDestructor>::value);
+#endif
+
+  // simple_pair of such types is trivial
+  EXPECT_TRUE((absl::is_trivially_destructible<simple_pair<int, int>>::value));
+  EXPECT_TRUE((absl::is_trivially_destructible<
+               simple_pair<Trivial, TrivialDestructor>>::value));
+
+  // Verify that types without trivial destructors are correctly marked as such.
+  EXPECT_FALSE(absl::is_trivially_destructible<std::string>::value);
+  EXPECT_FALSE(absl::is_trivially_destructible<std::vector<int>>::value);
+
+  // Verify that simple_pairs of types without trivial destructors
+  // are not marked as trivial.
+  EXPECT_FALSE((absl::is_trivially_destructible<
+                simple_pair<int, std::string>>::value));
+  EXPECT_FALSE((absl::is_trivially_destructible<
+                simple_pair<std::string, int>>::value));
+
+  // array of such types is trivial
+  using int10 = int[10];
+  EXPECT_TRUE(absl::is_trivially_destructible<int10>::value);
+  using Trivial10 = Trivial[10];
+  EXPECT_TRUE(absl::is_trivially_destructible<Trivial10>::value);
+  using TrivialDestructor10 = TrivialDestructor[10];
+  EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor10>::value);
+
+  // Conversely, the opposite also holds.
+  using NontrivialDestructor10 = NontrivialDestructor[10];
+  EXPECT_FALSE(absl::is_trivially_destructible<NontrivialDestructor10>::value);
+}
+
 TEST(TypeTraitsTest, TestTrivialDefaultCtor) {
   // arithmetic types and pointers have trivial default constructors.
   EXPECT_TRUE(absl::is_trivially_default_constructible<bool>::value);
@@ -184,42 +334,67 @@ TEST(TypeTraitsTest, TestTrivialDefaultCtor) {
   EXPECT_TRUE(absl::is_trivially_default_constructible<std::string*>::value);
   EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial*>::value);
   EXPECT_TRUE(
-      absl::is_trivially_default_constructible<const TrivialCopyCtor*>::value);
-  EXPECT_TRUE(
-      absl::is_trivially_default_constructible<TrivialCopyCtor**>::value);
+      absl::is_trivially_default_constructible<const std::string*>::value);
+  EXPECT_TRUE(absl::is_trivially_default_constructible<const Trivial*>::value);
+  EXPECT_TRUE(absl::is_trivially_default_constructible<std::string**>::value);
+  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial**>::value);
 
   // types with compiler generated default ctors
   EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial>::value);
   EXPECT_TRUE(
       absl::is_trivially_default_constructible<TrivialDefaultCtor>::value);
 
-#ifndef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
-  // types with non trivial destructor are non trivial
+  // Verify that types without them are not.
   EXPECT_FALSE(
-      absl::is_trivially_default_constructible<NonTrivialDestructor>::value);
+      absl::is_trivially_default_constructible<NontrivialDefaultCtor>::value);
+  EXPECT_FALSE(
+      absl::is_trivially_default_constructible<DeletedDefaultCtor>::value);
+
+#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
+  // types with nontrivial destructor are nontrivial
+  EXPECT_FALSE(
+      absl::is_trivially_default_constructible<NontrivialDestructor>::value);
 #endif
 
   // types with vtables
   EXPECT_FALSE(absl::is_trivially_default_constructible<Base>::value);
 
-  // Verify that arrays of such types are trivially default constructible
-  typedef int int10[10];
-  EXPECT_TRUE(absl::is_trivially_default_constructible<int10>::value);
-  typedef Trivial Trivial10[10];
-  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial10>::value);
-  typedef Trivial TrivialDefaultCtor10[10];
-  EXPECT_TRUE(
-      absl::is_trivially_default_constructible<TrivialDefaultCtor10>::value);
-
   // Verify that simple_pair has trivial constructors where applicable.
   EXPECT_TRUE((absl::is_trivially_default_constructible<
                simple_pair<int, char*>>::value));
+  EXPECT_TRUE((absl::is_trivially_default_constructible<
+               simple_pair<int, Trivial>>::value));
+  EXPECT_TRUE((absl::is_trivially_default_constructible<
+               simple_pair<int, TrivialDefaultCtor>>::value));
 
   // Verify that types without trivial constructors are
   // correctly marked as such.
   EXPECT_FALSE(absl::is_trivially_default_constructible<std::string>::value);
   EXPECT_FALSE(
       absl::is_trivially_default_constructible<std::vector<int>>::value);
+
+  // Verify that simple_pairs of types without trivial constructors
+  // are not marked as trivial.
+  EXPECT_FALSE((absl::is_trivially_default_constructible<
+                simple_pair<int, std::string>>::value));
+  EXPECT_FALSE((absl::is_trivially_default_constructible<
+                simple_pair<std::string, int>>::value));
+
+  // Verify that arrays of such types are trivially default constructible
+  using int10 = int[10];
+  EXPECT_TRUE(absl::is_trivially_default_constructible<int10>::value);
+  using Trivial10 = Trivial[10];
+  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial10>::value);
+  using TrivialDefaultCtor10 = TrivialDefaultCtor[10];
+  EXPECT_TRUE(
+      absl::is_trivially_default_constructible<TrivialDefaultCtor10>::value);
+
+  // Conversely, the opposite also holds.
+#ifdef ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL
+  using NontrivialDefaultCtor10 = NontrivialDefaultCtor[10];
+  EXPECT_FALSE(
+      absl::is_trivially_default_constructible<NontrivialDefaultCtor10>::value);
+#endif
 }
 
 TEST(TypeTraitsTest, TestTrivialCopyCtor) {
@@ -241,18 +416,26 @@ TEST(TypeTraitsTest, TestTrivialCopyCtor) {
   EXPECT_TRUE(absl::is_trivially_copy_constructible<long double>::value);
   EXPECT_TRUE(absl::is_trivially_copy_constructible<std::string*>::value);
   EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial*>::value);
-  EXPECT_TRUE(
-      absl::is_trivially_copy_constructible<const TrivialCopyCtor*>::value);
-  EXPECT_TRUE(absl::is_trivially_copy_constructible<TrivialCopyCtor**>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_constructible<const std::string*>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_constructible<const Trivial*>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_constructible<std::string**>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial**>::value);
 
   // types with compiler generated copy ctors
   EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial>::value);
   EXPECT_TRUE(absl::is_trivially_copy_constructible<TrivialCopyCtor>::value);
 
-#ifndef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
-  // type with non-trivial destructor are non-trivial copy construbtible
+  // Verify that types without them (i.e. nontrivial or deleted) are not.
+  EXPECT_FALSE(
+      absl::is_trivially_copy_constructible<NontrivialCopyCtor>::value);
+  EXPECT_FALSE(absl::is_trivially_copy_constructible<DeletedCopyCtor>::value);
+  EXPECT_FALSE(
+      absl::is_trivially_copy_constructible<NonCopyable>::value);
+
+#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
+  // type with nontrivial destructor are nontrivial copy construbtible
   EXPECT_FALSE(
-      absl::is_trivially_copy_constructible<NonTrivialDestructor>::value);
+      absl::is_trivially_copy_constructible<NontrivialDestructor>::value);
 #endif
 
   // types with vtables
@@ -266,9 +449,10 @@ TEST(TypeTraitsTest, TestTrivialCopyCtor) {
   EXPECT_TRUE((absl::is_trivially_copy_constructible<
                simple_pair<int, TrivialCopyCtor>>::value));
 
-  // Verify that arrays are not
-  typedef int int10[10];
-  EXPECT_FALSE(absl::is_trivially_copy_constructible<int10>::value);
+  // Verify that types without trivial copy constructors are
+  // correctly marked as such.
+  EXPECT_FALSE(absl::is_trivially_copy_constructible<std::string>::value);
+  EXPECT_FALSE(absl::is_trivially_copy_constructible<std::vector<int>>::value);
 
   // Verify that simple_pairs of types without trivial copy constructors
   // are not marked as trivial.
@@ -277,18 +461,14 @@ TEST(TypeTraitsTest, TestTrivialCopyCtor) {
   EXPECT_FALSE((absl::is_trivially_copy_constructible<
                 simple_pair<std::string, int>>::value));
 
-  // Verify that types without trivial copy constructors are
-  // correctly marked as such.
-  EXPECT_FALSE(absl::is_trivially_copy_constructible<std::string>::value);
-  EXPECT_FALSE(absl::is_trivially_copy_constructible<std::vector<int>>::value);
-
-  // types with deleted copy constructors are not copy constructible
-  EXPECT_FALSE(absl::is_trivially_copy_constructible<NonCopyable>::value);
+  // Verify that arrays are not
+  using int10 = int[10];
+  EXPECT_FALSE(absl::is_trivially_copy_constructible<int10>::value);
 }
 
 TEST(TypeTraitsTest, TestTrivialCopyAssign) {
   // Verify that arithmetic types and pointers have trivial copy
-  // constructors.
+  // assignment operators.
   EXPECT_TRUE(absl::is_trivially_copy_assignable<bool>::value);
   EXPECT_TRUE(absl::is_trivially_copy_assignable<char>::value);
   EXPECT_TRUE(absl::is_trivially_copy_assignable<unsigned char>::value);
@@ -305,9 +485,10 @@ TEST(TypeTraitsTest, TestTrivialCopyAssign) {
   EXPECT_TRUE(absl::is_trivially_copy_assignable<long double>::value);
   EXPECT_TRUE(absl::is_trivially_copy_assignable<std::string*>::value);
   EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial*>::value);
-  EXPECT_TRUE(
-      absl::is_trivially_copy_assignable<const TrivialCopyCtor*>::value);
-  EXPECT_TRUE(absl::is_trivially_copy_assignable<TrivialCopyCtor**>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_assignable<const std::string*>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_assignable<const Trivial*>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_assignable<std::string**>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial**>::value);
 
   // const qualified types are not assignable
   EXPECT_FALSE(absl::is_trivially_copy_assignable<const int>::value);
@@ -316,65 +497,37 @@ TEST(TypeTraitsTest, TestTrivialCopyAssign) {
   EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial>::value);
   EXPECT_TRUE(absl::is_trivially_copy_assignable<TrivialCopyAssign>::value);
 
+  // Verify that types without them (i.e. nontrivial or deleted) are not.
+  EXPECT_FALSE(absl::is_trivially_copy_assignable<NontrivialCopyAssign>::value);
+  EXPECT_FALSE(absl::is_trivially_copy_assignable<DeletedCopyAssign>::value);
+  EXPECT_FALSE(absl::is_trivially_copy_assignable<NonCopyable>::value);
+
   // types with vtables
   EXPECT_FALSE(absl::is_trivially_copy_assignable<Base>::value);
 
-  // Verify that arrays are not trivially copy assignable
-  typedef int int10[10];
-  EXPECT_FALSE(absl::is_trivially_copy_assignable<int10>::value);
-
   // Verify that simple_pair is trivially assignable
   EXPECT_TRUE(
       (absl::is_trivially_copy_assignable<simple_pair<int, char*>>::value));
+  EXPECT_TRUE(
+      (absl::is_trivially_copy_assignable<simple_pair<int, Trivial>>::value));
+  EXPECT_TRUE((absl::is_trivially_copy_assignable<
+               simple_pair<int, TrivialCopyAssign>>::value));
 
-  // Verify that types without trivial copy constructors are
+  // Verify that types not trivially copy assignable are
   // correctly marked as such.
   EXPECT_FALSE(absl::is_trivially_copy_assignable<std::string>::value);
   EXPECT_FALSE(absl::is_trivially_copy_assignable<std::vector<int>>::value);
 
-  // types with deleted copy assignment are not copy assignable
-  EXPECT_FALSE(absl::is_trivially_copy_assignable<NonCopyable>::value);
-}
-
-TEST(TypeTraitsTest, TestTrivialDestructor) {
-  // Verify that arithmetic types and pointers have trivial copy
-  // constructors.
-  EXPECT_TRUE(absl::is_trivially_destructible<bool>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<char>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<unsigned char>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<signed char>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<wchar_t>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<int>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<unsigned int>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<int16_t>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<uint16_t>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<int64_t>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<uint64_t>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<float>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<double>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<long double>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<std::string*>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<Trivial*>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<const TrivialCopyCtor*>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<TrivialCopyCtor**>::value);
-
-  // classes with destructors
-  EXPECT_TRUE(absl::is_trivially_destructible<Trivial>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor>::value);
-  EXPECT_FALSE(absl::is_trivially_destructible<NonTrivialDestructor>::value);
-
-  // simple_pair of such types is trivial
-  EXPECT_TRUE((absl::is_trivially_destructible<simple_pair<int, int>>::value));
-  EXPECT_TRUE((absl::is_trivially_destructible<
-               simple_pair<Trivial, TrivialDestructor>>::value));
+  // Verify that simple_pairs of types not trivially copy assignable
+  // are not marked as trivial.
+  EXPECT_FALSE((absl::is_trivially_copy_assignable<
+                simple_pair<int, std::string>>::value));
+  EXPECT_FALSE((absl::is_trivially_copy_assignable<
+                simple_pair<std::string, int>>::value));
 
-  // array of such types is trivial
-  typedef int int10[10];
-  EXPECT_TRUE(absl::is_trivially_destructible<int10>::value);
-  typedef TrivialDestructor TrivialDestructor10[10];
-  EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor10>::value);
-  typedef NonTrivialDestructor NonTrivialDestructor10[10];
-  EXPECT_FALSE(absl::is_trivially_destructible<NonTrivialDestructor10>::value);
+  // Verify that arrays are not trivially copy assignable
+  using int10 = int[10];
+  EXPECT_FALSE(absl::is_trivially_copy_assignable<int10>::value);
 }
 
 #define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name, ...)          \
diff --git a/absl/strings/internal/stl_type_traits.h b/absl/strings/internal/stl_type_traits.h
index 8c3d877e6356..04c4a5323b86 100644
--- a/absl/strings/internal/stl_type_traits.h
+++ b/absl/strings/internal/stl_type_traits.h
@@ -79,31 +79,48 @@ struct IsSTLContainer
 
 template <typename C, template <typename...> class T, typename = void>
 struct IsBaseOfSpecializationImpl : std::false_type {};
-// IsBaseOfSpecializationImpl must have three partial specializations,
-// because we must only compare templates that take the same number of
-// arguments. Otherwise, for example, std::vector can be compared with std::map,
-// and fail to compile because of too few or too many template arguments.
-//
-// We must also SFINAE on the existence of an allocator_type. Otherwise, we may
-// try to compare, for example, a std::pair<std::string, std::string> with a
-// std::vector<std::string, std:std::string>. This would fail to compile, because
-// of expected properties of the type passed in as the allocator.
-template <template <typename, typename> class U,
-          template <typename, typename> class T, typename... Args>
+// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
+// on the existence of container dependent types and plug them into the STL
+// template.
+template <typename C, template <typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+    : std::is_base_of<C,
+                      T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
 struct IsBaseOfSpecializationImpl<
-    U<Args...>, T, absl::void_t<typename U<Args...>::allocator_type>>
-    : std::is_base_of<U<Args...>, T<Args...>> {};
-template <template <typename, typename, typename> class U,
-          template <typename, typename, typename> class T, typename... Args>
+    C, T,
+    absl::void_t<typename C::key_type, typename C::key_compare,
+                 typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
+                           typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::key_compare, typename C::allocator_type>>
+    : std::is_base_of<C,
+                      T<typename C::key_type, typename C::mapped_type,
+                        typename C::key_compare, typename C::allocator_type>> {
+};
+template <typename C, template <typename, typename, typename, typename> class T>
 struct IsBaseOfSpecializationImpl<
-    U<Args...>, T, absl::void_t<typename U<Args...>::allocator_type>>
-    : std::is_base_of<U<Args...>, T<Args...>> {};
-template <template <typename, typename, typename, typename> class U,
-          template <typename, typename, typename, typename> class T,
-          typename... Args>
+    C, T,
+    absl::void_t<typename C::key_type, typename C::hasher,
+                 typename C::key_equal, typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::hasher,
+                           typename C::key_equal, typename C::allocator_type>> {
+};
+template <typename C,
+          template <typename, typename, typename, typename, typename> class T>
 struct IsBaseOfSpecializationImpl<
-    U<Args...>, T, absl::void_t<typename U<Args...>::allocator_type>>
-    : std::is_base_of<U<Args...>, T<Args...>> {};
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::hasher, typename C::key_equal,
+                 typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
+                           typename C::hasher, typename C::key_equal,
+                           typename C::allocator_type>> {};
 template <typename C, template <typename...> class T>
 using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
 
@@ -140,31 +157,47 @@ struct IsBaseOfSTLContainer
 
 template <typename C, template <typename...> class T, typename = void>
 struct IsConvertibleToSpecializationImpl : std::false_type {};
-// IsConvertibleToSpecializationImpl must have three partial specializations,
-// because we must only compare templates that take the same number of
-// arguments. Otherwise, for example, std::vector can be compared with std::map,
-// and fail to compile because of too few or too many template arguments.
-//
-// We must also SFINAE on the existence of an allocator_type. Otherwise, we may
-// try to compare, for example, a std::pair<std::string, std::string> with a
-// std::vector<std::string, std:std::string>. This would fail to compile, because
-// of expected properties of the type passed in as the allocator.
-template <template <typename, typename> class U,
-          template <typename, typename> class T, typename... Args>
+// IsConvertibleToSpecializationImpl needs multiple partial specializations to
+// SFINAE on the existence of container dependent types and plug them into the
+// STL template.
+template <typename C, template <typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::key_compare,
+                 typename C::allocator_type>>
+    : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
+                               typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
 struct IsConvertibleToSpecializationImpl<
-    U<Args...>, T, absl::void_t<typename U<Args...>::allocator_type>>
-    : std::is_convertible<U<Args...>, T<Args...>> {};
-template <template <typename, typename, typename> class U,
-          template <typename, typename, typename> class T, typename... Args>
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::key_compare, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::key_type, typename C::mapped_type,
+               typename C::key_compare, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
 struct IsConvertibleToSpecializationImpl<
-    U<Args...>, T, absl::void_t<typename U<Args...>::allocator_type>>
-    : std::is_convertible<U<Args...>, T<Args...>> {};
-template <template <typename, typename, typename, typename> class U,
-          template <typename, typename, typename, typename> class T,
-          typename... Args>
+    C, T,
+    absl::void_t<typename C::key_type, typename C::hasher,
+                 typename C::key_equal, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::key_type, typename C::hasher, typename C::key_equal,
+               typename C::allocator_type>> {};
+template <typename C,
+          template <typename, typename, typename, typename, typename> class T>
 struct IsConvertibleToSpecializationImpl<
-    U<Args...>, T, absl::void_t<typename U<Args...>::allocator_type>>
-    : std::is_convertible<U<Args...>, T<Args...>> {};
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::hasher, typename C::key_equal,
+                 typename C::allocator_type>>
+    : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
+                               typename C::hasher, typename C::key_equal,
+                               typename C::allocator_type>> {};
 template <typename C, template <typename...> class T>
 using IsConvertibleToSpecialization =
     IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
diff --git a/absl/strings/string_view.h b/absl/strings/string_view.h
index c3acd7290993..ddc89341f9ad 100644
--- a/absl/strings/string_view.h
+++ b/absl/strings/string_view.h
@@ -419,7 +419,7 @@ class string_view {
   size_type rfind(string_view s, size_type pos = npos) const
       noexcept;
 
-  // Overload of `string_view::rfind()` for finding the given character `c`
+  // Overload of `string_view::rfind()` for finding the last given character `c`
   // within the `string_view`.
   size_type rfind(char c, size_type pos = npos) const noexcept;
 
diff --git a/absl/strings/string_view_test.cc b/absl/strings/string_view_test.cc
index 13fc214b841c..df307ac7cfab 100644
--- a/absl/strings/string_view_test.cc
+++ b/absl/strings/string_view_test.cc
@@ -796,11 +796,25 @@ TEST(StringViewTest, FrontBackSingleChar) {
   EXPECT_EQ(&c, &csp.back());
 }
 
+// `std::string_view::string_view(const char*)` calls
+// `std::char_traits<char>::length(const char*)` to get the std::string length. In
+// libc++, it doesn't allow `nullptr` in the constexpr context, with the error
+// "read of dereferenced null pointer is not allowed in a constant expression".
+// At run time, the behavior of `std::char_traits::length()` on `nullptr` is
+// undefined by the standard and usually results in crash with libc++. This
+// conforms to the standard, but `absl::string_view` implements a different
+// behavior for historical reasons. We work around tests that construct
+// `string_view` from `nullptr` when using libc++.
+#if !defined(ABSL_HAVE_STD_STRING_VIEW) || !defined(_LIBCPP_VERSION)
+#define ABSL_HAVE_STRING_VIEW_FROM_NULLPTR 1
+#endif  // !defined(ABSL_HAVE_STD_STRING_VIEW) || !defined(_LIBCPP_VERSION)
+
 TEST(StringViewTest, NULLInput) {
   absl::string_view s;
   EXPECT_EQ(s.data(), nullptr);
   EXPECT_EQ(s.size(), 0);
 
+#ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
   s = absl::string_view(nullptr);
   EXPECT_EQ(s.data(), nullptr);
   EXPECT_EQ(s.size(), 0);
@@ -808,6 +822,7 @@ TEST(StringViewTest, NULLInput) {
   // .ToString() on a absl::string_view with nullptr should produce the empty
   // std::string.
   EXPECT_EQ("", std::string(s));
+#endif  // ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
 }
 
 TEST(StringViewTest, Comparisons2) {
@@ -879,7 +894,9 @@ TEST(StringViewTest, NullSafeStringView) {
 
 TEST(StringViewTest, ConstexprCompiles) {
   constexpr absl::string_view sp;
+#ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
   constexpr absl::string_view cstr(nullptr);
+#endif
   constexpr absl::string_view cstr_len("cstr", 4);
 
 #if defined(ABSL_HAVE_STD_STRING_VIEW)
@@ -923,10 +940,12 @@ TEST(StringViewTest, ConstexprCompiles) {
   constexpr absl::string_view::iterator const_end_empty = sp.end();
   EXPECT_EQ(const_begin_empty, const_end_empty);
 
+#ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
   constexpr absl::string_view::iterator const_begin_nullptr = cstr.begin();
   constexpr absl::string_view::iterator const_end_nullptr = cstr.end();
   EXPECT_EQ(const_begin_nullptr, const_end_nullptr);
-#endif
+#endif  // ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
+#endif  // !defined(__clang__) || ...
 
   constexpr absl::string_view::iterator const_begin = cstr_len.begin();
   constexpr absl::string_view::iterator const_end = cstr_len.end();
@@ -1042,11 +1061,11 @@ TEST(HugeStringView, TwoPointTwoGB) {
 }
 #endif  // THREAD_SANITIZER
 
-#ifndef NDEBUG
+#if !defined(NDEBUG) && !defined(ABSL_HAVE_STD_STRING_VIEW)
 TEST(NonNegativeLenTest, NonNegativeLen) {
   EXPECT_DEATH_IF_SUPPORTED(absl::string_view("xyz", -1), "len <= kMaxSize");
 }
-#endif  // NDEBUG
+#endif  // !defined(NDEBUG) && !defined(ABSL_HAVE_STD_STRING_VIEW)
 
 class StringViewStreamTest : public ::testing::Test {
  public:
diff --git a/absl/strings/strip_test.cc b/absl/strings/strip_test.cc
index ff0e7f1c2024..205c160c1929 100644
--- a/absl/strings/strip_test.cc
+++ b/absl/strings/strip_test.cc
@@ -178,4 +178,24 @@ TEST(String, StripLeadingAsciiWhitespace) {
   EXPECT_EQ(absl::string_view(), absl::StripLeadingAsciiWhitespace(orig));
 }
 
+TEST(Strip, StripAsciiWhitespace) {
+  std::string test2 = "\t  \f\r\n\vfoo \t\f\r\v\n";
+  absl::StripAsciiWhitespace(&test2);
+  EXPECT_EQ(test2, "foo");
+  std::string test3 = "bar";
+  absl::StripAsciiWhitespace(&test3);
+  EXPECT_EQ(test3, "bar");
+  std::string test4 = "\t  \f\r\n\vfoo";
+  absl::StripAsciiWhitespace(&test4);
+  EXPECT_EQ(test4, "foo");
+  std::string test5 = "foo \t\f\r\v\n";
+  absl::StripAsciiWhitespace(&test5);
+  EXPECT_EQ(test5, "foo");
+  absl::string_view test6("\t  \f\r\n\vfoo \t\f\r\v\n");
+  test6 = absl::StripAsciiWhitespace(test6);
+  EXPECT_EQ(test6, "foo");
+  test6 = absl::StripAsciiWhitespace(test6);
+  EXPECT_EQ(test6, "foo");  // already stripped
+}
+
 }  // namespace
diff --git a/absl/types/BUILD.bazel b/absl/types/BUILD.bazel
index f98d9af429ce..60d6a60fa881 100644
--- a/absl/types/BUILD.bazel
+++ b/absl/types/BUILD.bazel
@@ -28,7 +28,7 @@ licenses(["notice"])  # Apache 2.0
 cc_library(
     name = "any",
     hdrs = ["any.h"],
-    copts = ABSL_DEFAULT_COPTS,
+    copts = ABSL_DEFAULT_COPTS + ABSL_EXCEPTIONS_FLAG,
     deps = [
         ":bad_any_cast",
         "//absl/base:config",
@@ -83,6 +83,17 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "any_exception_safety_test",
+    srcs = ["any_exception_safety_test.cc"],
+    copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+    deps = [
+        ":any",
+        "//absl/base:exception_safety_testing",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "span",
     hdrs = ["span.h"],
diff --git a/absl/types/CMakeLists.txt b/absl/types/CMakeLists.txt
index 3e4644974921..b2d95b48fbe7 100644
--- a/absl/types/CMakeLists.txt
+++ b/absl/types/CMakeLists.txt
@@ -29,6 +29,8 @@ absl_header_library(
     absl_any
   PUBLIC_LIBRARIES
     absl::utility
+  PRIVATE_COMPILE_FLAGS
+    ${ABSL_EXCEPTIONS_FLAG}
   EXPORT_NAME
     any
 )
@@ -126,6 +128,21 @@ absl_test(
     ${ANY_TEST_PUBLIC_LIBRARIES}
 )
 
+# test any_exception_safety_test
+set(ANY_EXCEPTION_SAFETY_TEST_SRC "any_exception_safety_test.cc")
+set(ANY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES absl::any absl::base)
+
+absl_test(
+  TARGET
+    any_exception_safety_test
+  SOURCES
+    ${ANY_EXCEPTION_SAFETY_TEST_SRC}
+  PUBLIC_LIBRARIES
+    ${ANY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES}
+  PRIVATE_COMPILE_FLAGS
+    ${ABSL_EXCEPTIONS_FLAG}
+)
+
 
 # test span_test
 set(SPAN_TEST_SRC "span_test.cc")
diff --git a/absl/types/any_exception_safety_test.cc b/absl/types/any_exception_safety_test.cc
new file mode 100644
index 000000000000..eadba3080437
--- /dev/null
+++ b/absl/types/any_exception_safety_test.cc
@@ -0,0 +1,201 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/any.h"
+
+#include <typeinfo>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/exception_safety_testing.h"
+
+using Thrower = absl::ThrowingValue<>;
+using ThrowerList = std::initializer_list<Thrower>;
+using ThrowerVec = std::vector<Thrower>;
+using ThrowingAlloc = absl::ThrowingAllocator<Thrower>;
+using ThrowingThrowerVec = std::vector<Thrower, ThrowingAlloc>;
+
+namespace absl {
+
+testing::AssertionResult AbslCheckInvariants(absl::any* a,
+                                             InternalAbslNamespaceFinder) {
+  using testing::AssertionFailure;
+  using testing::AssertionSuccess;
+
+  if (a->has_value()) {
+    if (a->type() == typeid(void)) {
+      return AssertionFailure()
+             << "A non-empty any should not have type `void`";
+    }
+  } else {
+    if (a->type() != typeid(void)) {
+      return AssertionFailure()
+             << "An empty any should have type void, but has type "
+             << a->type().name();
+    }
+  }
+
+  //  Make sure that reset() changes any to a valid state.
+  a->reset();
+  if (a->has_value()) {
+    return AssertionFailure() << "A reset `any` should be valueless";
+  }
+  if (a->type() != typeid(void)) {
+    return AssertionFailure() << "A reset `any` should have type() of `void`, "
+                                 "but instead has type "
+                              << a->type().name();
+  }
+  try {
+    auto unused = absl::any_cast<Thrower>(*a);
+    static_cast<void>(unused);
+    return AssertionFailure()
+           << "A reset `any` should not be able to be any_cast";
+  } catch (absl::bad_any_cast) {
+  } catch (...) {
+    return AssertionFailure()
+           << "Unexpected exception thrown from absl::any_cast";
+  }
+  return AssertionSuccess();
+}
+
+}  // namespace absl
+
+namespace {
+
+class AnyExceptionSafety : public ::testing::Test {
+ private:
+  absl::AllocInspector inspector_;
+};
+
+testing::AssertionResult AnyIsEmpty(absl::any* a) {
+  if (!a->has_value()) return testing::AssertionSuccess();
+  return testing::AssertionFailure()
+         << "a should be empty, but instead has value "
+         << absl::any_cast<Thrower>(*a).Get();
+}
+
+TEST_F(AnyExceptionSafety, Ctors) {
+  Thrower val(1);
+  auto with_val = absl::TestThrowingCtor<absl::any>(val);
+  auto copy = absl::TestThrowingCtor<absl::any>(with_val);
+  auto in_place =
+      absl::TestThrowingCtor<absl::any>(absl::in_place_type_t<Thrower>(), 1);
+  auto in_place_list = absl::TestThrowingCtor<absl::any>(
+      absl::in_place_type_t<ThrowerVec>(), ThrowerList{val});
+  auto in_place_list_again =
+      absl::TestThrowingCtor<absl::any,
+                             absl::in_place_type_t<ThrowingThrowerVec>,
+                             ThrowerList, ThrowingAlloc>(
+          absl::in_place_type_t<ThrowingThrowerVec>(), {val}, ThrowingAlloc());
+}
+
+struct OneFactory {
+  std::unique_ptr<absl::any> operator()() const {
+    return absl::make_unique<absl::any>(absl::in_place_type_t<Thrower>(), 1,
+                                        absl::no_throw_ctor);
+  }
+};
+
+struct EmptyFactory {
+  std::unique_ptr<absl::any> operator()() const {
+    return absl::make_unique<absl::any>();
+  }
+};
+
+TEST_F(AnyExceptionSafety, Assignment) {
+  auto thrower_comp = [](const absl::any& l, const absl::any& r) {
+    return absl::any_cast<Thrower>(l) == absl::any_cast<Thrower>(r);
+  };
+
+  OneFactory one_factory;
+
+  absl::ThrowingValue<absl::NoThrow::kMoveCtor | absl::NoThrow::kMoveAssign>
+      moveable_val(2);
+  Thrower val(2);
+  absl::any any_val(val);
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      one_factory, [&any_val](absl::any* ap) { *ap = any_val; },
+      absl::StrongGuarantee(one_factory, thrower_comp)));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      one_factory, [&val](absl::any* ap) { *ap = val; },
+      absl::StrongGuarantee(one_factory, thrower_comp)));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      one_factory, [&val](absl::any* ap) { *ap = std::move(val); },
+      absl::StrongGuarantee(one_factory, thrower_comp)));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      one_factory,
+      [&moveable_val](absl::any* ap) { *ap = std::move(moveable_val); },
+      absl::StrongGuarantee(one_factory, thrower_comp)));
+
+  EmptyFactory empty_factory;
+  auto empty_comp = [](const absl::any& l, const absl::any& r) {
+    return !(l.has_value() || r.has_value());
+  };
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      empty_factory, [&any_val](absl::any* ap) { *ap = any_val; },
+      absl::StrongGuarantee(empty_factory, empty_comp)));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      empty_factory, [&val](absl::any* ap) { *ap = val; },
+      absl::StrongGuarantee(empty_factory, empty_comp)));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      empty_factory, [&val](absl::any* ap) { *ap = std::move(val); },
+      absl::StrongGuarantee(empty_factory, empty_comp)));
+}
+// libstdc++ std::any fails this test
+#if !defined(ABSL_HAVE_STD_ANY)
+TEST_F(AnyExceptionSafety, Emplace) {
+  OneFactory one_factory;
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      one_factory, [](absl::any* ap) { ap->emplace<Thrower>(2); }, AnyIsEmpty));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      one_factory,
+      [](absl::any* ap) {
+        ap->emplace<absl::ThrowingValue<absl::NoThrow::kMoveCtor |
+                                        absl::NoThrow::kMoveAssign>>(2);
+      },
+      AnyIsEmpty));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(one_factory,
+                                        [](absl::any* ap) {
+                                          std::initializer_list<Thrower> il{
+                                              Thrower(2, absl::no_throw_ctor)};
+                                          ap->emplace<ThrowerVec>(il);
+                                        },
+                                        AnyIsEmpty));
+
+  EmptyFactory empty_factory;
+  EXPECT_TRUE(absl::TestExceptionSafety(
+      empty_factory, [](absl::any* ap) { ap->emplace<Thrower>(2); },
+      AnyIsEmpty));
+
+  EXPECT_TRUE(absl::TestExceptionSafety(empty_factory,
+                                        [](absl::any* ap) {
+                                          std::initializer_list<Thrower> il{
+                                              Thrower(2, absl::no_throw_ctor)};
+                                          ap->emplace<ThrowerVec>(il);
+                                        },
+                                        AnyIsEmpty));
+}
+#endif  // ABSL_HAVE_STD_ANY
+
+}  // namespace
generated by cgit-pink 1.4.1 (git 2.44.2) at 2024-11-05T06ยท34+0000