1 files changed, 14 insertions, 7 deletions

diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h
index adee848b2e90..a0cd33b4d00a 100644
--- a/absl/base/internal/exception_safety_testing.h
+++ b/absl/base/internal/exception_safety_testing.h
@@ -37,7 +37,7 @@
 namespace absl {
 struct InternalAbslNamespaceFinder {};
 
-struct AllocInspector;
+struct ConstructorTracker;
 
 // A configuration enum for Throwing*.  Operations whose flags are set will
 // throw, everything else won't.  This isn't meant to be exhaustive, more flags
@@ -125,7 +125,7 @@ class TrackedObject {
     }
   }
 
-  friend struct ::absl::AllocInspector;
+  friend struct ::absl::ConstructorTracker;
 };
 
 template <typename Factory>
@@ -594,6 +594,8 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
       const ThrowingAllocator<U, Flags>& other) noexcept
       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
 
+  // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
+  // allocator shall not exit via an exception, thus they are marked noexcept.
   ThrowingAllocator(const ThrowingAllocator& other) noexcept
       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
 
@@ -607,6 +609,11 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
 
   ~ThrowingAllocator() noexcept = default;
 
+  ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept {
+    dummy_ = other.State();
+    return *this;
+  }
+
   template <typename U>
   ThrowingAllocator& operator=(
       const ThrowingAllocator<U, Flags>& other) noexcept {
@@ -704,11 +711,11 @@ int ThrowingAllocator<T, Throws>::next_id_ = 0;
 // Inspects the constructions and destructions of anything inheriting from
 // TrackedObject.  Place this as a member variable in a test fixture to ensure
 // that every ThrowingValue was constructed and destroyed correctly.  This also
-// allows us to safely "leak" TrackedObjects, as AllocInspector will destroy
+// allows us to safely "leak" TrackedObjects, as ConstructorTracker will destroy
 // everything left over in its destructor.
-struct AllocInspector {
-  AllocInspector() = default;
-  ~AllocInspector() {
+struct ConstructorTracker {
+  ConstructorTracker() = default;
+  ~ConstructorTracker() {
     auto& allocs = exceptions_internal::TrackedObject::GetAllocs();
     for (const auto& kv : allocs) {
       ADD_FAILURE() << "Object at address " << static_cast<void*>(kv.first)
@@ -720,7 +727,7 @@ struct AllocInspector {
 
 // Tests for resource leaks by attempting to construct a T using args repeatedly
 // until successful, using the countdown method.  Side effects can then be
-// tested for resource leaks.  If an AllocInspector is present in the test
+// tested for resource leaks.  If a ConstructorTracker is present in the test
 // fixture, then this will also test that memory resources are not leaked as
 // long as T allocates TrackedObjects.
 template <typename T, typename... Args>