EIC code displayed by LXR master/​include/​absl/​base/​internal/​exception_safety_testing.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2024-11-15 09:00:51

 // 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
 //
 //      https://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.
 
 // Utilities for testing exception-safety
 
 #ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
 #define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
 
 #include "absl/base/config.h"
 
 #ifdef ABSL_HAVE_EXCEPTIONS
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <initializer_list>
 #include <iosfwd>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 
 #include "gtest/gtest.h"
 #include "absl/base/internal/pretty_function.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/substitute.h"
 #include "absl/utility/utility.h"
 
 namespace testing {
 
 enum class TypeSpec;
 enum class AllocSpec;
 
 constexpr TypeSpec operator|(TypeSpec a, TypeSpec b) {
   using T = absl::underlying_type_t<TypeSpec>;
   return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b));
 }
 
 constexpr TypeSpec operator&(TypeSpec a, TypeSpec b) {
   using T = absl::underlying_type_t<TypeSpec>;
   return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b));
 }
 
 constexpr AllocSpec operator|(AllocSpec a, AllocSpec b) {
   using T = absl::underlying_type_t<AllocSpec>;
   return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b));
 }
 
 constexpr AllocSpec operator&(AllocSpec a, AllocSpec b) {
   using T = absl::underlying_type_t<AllocSpec>;
   return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b));
 }
 
 namespace exceptions_internal {
 
 std::string GetSpecString(TypeSpec);
 std::string GetSpecString(AllocSpec);
 
 struct NoThrowTag {};
 struct StrongGuaranteeTagType {};
 
 // A simple exception class.  We throw this so that test code can catch
 // exceptions specifically thrown by ThrowingValue.
 class TestException {
  public:
   explicit TestException(absl::string_view msg) : msg_(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;
 
 // Allows the countdown variable to be set manually (defaulting to the initial
 // value of 0)
 inline void SetCountdown(int i = 0) { countdown = i; }
 // Sets the countdown to the terminal value -1
 inline void UnsetCountdown() { SetCountdown(-1); }
 
 void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
 
 testing::AssertionResult FailureMessage(const TestException& e,
                                         int countdown) noexcept;
 
 struct TrackedAddress {
   bool is_alive;
   std::string description;
 };
 
 // Inspects the constructions and destructions of anything inheriting from
 // TrackedObject. This allows us to safely "leak" TrackedObjects, as
 // ConstructorTracker will destroy everything left over in its destructor.
 class ConstructorTracker {
  public:
   explicit ConstructorTracker(int count) : countdown_(count) {
     assert(current_tracker_instance_ == nullptr);
     current_tracker_instance_ = this;
   }
 
   ~ConstructorTracker() {
     assert(current_tracker_instance_ == this);
     current_tracker_instance_ = nullptr;
 
     for (auto& it : address_map_) {
       void* address = it.first;
       TrackedAddress& tracked_address = it.second;
       if (tracked_address.is_alive) {
         ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
                                       countdown_, "Object was not destroyed.");
       }
     }
   }
 
   static void ObjectConstructed(void* address, std::string description) {
     if (!CurrentlyTracking()) return;
 
     TrackedAddress& tracked_address =
         current_tracker_instance_->address_map_[address];
     if (tracked_address.is_alive) {
       ADD_FAILURE() << ErrorMessage(
           address, tracked_address.description,
           current_tracker_instance_->countdown_,
           "Object was re-constructed. Current object was constructed by " +
               description);
     }
     tracked_address = {true, std::move(description)};
   }
 
   static void ObjectDestructed(void* address) {
     if (!CurrentlyTracking()) return;
 
     auto it = current_tracker_instance_->address_map_.find(address);
     // Not tracked. Ignore.
     if (it == current_tracker_instance_->address_map_.end()) return;
 
     TrackedAddress& tracked_address = it->second;
     if (!tracked_address.is_alive) {
       ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
                                     current_tracker_instance_->countdown_,
                                     "Object was re-destroyed.");
     }
     tracked_address.is_alive = false;
   }
 
  private:
   static bool CurrentlyTracking() {
     return current_tracker_instance_ != nullptr;
   }
 
   static std::string ErrorMessage(void* address,
                                   const std::string& address_description,
                                   int countdown,
                                   const std::string& error_description) {
     return absl::Substitute(
         "With coundtown at $0:\n"
         "  $1\n"
         "  Object originally constructed by $2\n"
         "  Object address: $3\n",
         countdown, error_description, address_description, address);
   }
 
   std::unordered_map<void*, TrackedAddress> address_map_;
   int countdown_;
 
   static ConstructorTracker* current_tracker_instance_;
 };
 
 class TrackedObject {
  public:
   TrackedObject(const TrackedObject&) = delete;
   TrackedObject(TrackedObject&&) = delete;
 
  protected:
   explicit TrackedObject(std::string description) {
     ConstructorTracker::ObjectConstructed(this, std::move(description));
   }
 
   ~TrackedObject() noexcept { ConstructorTracker::ObjectDestructed(this); }
 };
 }  // namespace exceptions_internal
 
 extern exceptions_internal::NoThrowTag nothrow_ctor;
 
 extern exceptions_internal::StrongGuaranteeTagType strong_guarantee;
 
 // A test class which is convertible to bool.  The conversion can be
 // instrumented to throw at a controlled time.
 class ThrowingBool {
  public:
   ThrowingBool(bool b) noexcept : b_(b) {}  // NOLINT(runtime/explicit)
   operator bool() const {                   // NOLINT
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return b_;
   }
 
  private:
   bool b_;
 };
 
 /*
  * Configuration enum for the ThrowingValue type that defines behavior for the
  * lifetime of the instance. Use testing::nothrow_ctor to prevent the integer
  * constructor from throwing.
  *
  * kEverythingThrows: Every operation can throw an exception
  * kNoThrowCopy: Copy construction and copy assignment will not throw
  * kNoThrowMove: Move construction and move assignment will not throw
  * kNoThrowNew: Overloaded operators new and new[] will not throw
  */
 enum class TypeSpec {
   kEverythingThrows = 0,
   kNoThrowCopy = 1,
   kNoThrowMove = 1 << 1,
   kNoThrowNew = 1 << 2,
 };
 
 /*
  * A testing class instrumented to throw an exception at a controlled time.
  *
  * ThrowingValue implements a slightly relaxed version of the Regular concept --
  * that is it's a value type with the expected semantics.  It also implements
  * arithmetic operations.  It doesn't implement member and pointer operators
  * like operator-> or operator[].
  *
  * ThrowingValue can be instrumented to have certain operations be noexcept by
  * using compile-time bitfield template arguments.  That is, to make an
  * ThrowingValue which has noexcept move construction/assignment and noexcept
  * copy construction/assignment, use the following:
  *   ThrowingValue<testing::kNoThrowMove | testing::kNoThrowCopy> my_thrwr{val};
  */
 template <TypeSpec Spec = TypeSpec::kEverythingThrows>
 class ThrowingValue : private exceptions_internal::TrackedObject {
   static constexpr bool IsSpecified(TypeSpec spec) {
     return static_cast<bool>(Spec & spec);
   }
 
   static constexpr int kDefaultValue = 0;
   static constexpr int kBadValue = 938550620;
 
  public:
   ThrowingValue() : TrackedObject(GetInstanceString(kDefaultValue)) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ = kDefaultValue;
   }
 
   ThrowingValue(const ThrowingValue& other) noexcept(
       IsSpecified(TypeSpec::kNoThrowCopy))
       : TrackedObject(GetInstanceString(other.dummy_)) {
     if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
   }
 
   ThrowingValue(ThrowingValue&& other) noexcept(
       IsSpecified(TypeSpec::kNoThrowMove))
       : TrackedObject(GetInstanceString(other.dummy_)) {
     if (!IsSpecified(TypeSpec::kNoThrowMove)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
   }
 
   explicit ThrowingValue(int i) : TrackedObject(GetInstanceString(i)) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ = i;
   }
 
   ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
       : TrackedObject(GetInstanceString(i)), dummy_(i) {}
 
   // absl expects nothrow destructors
   ~ThrowingValue() noexcept = default;
 
   ThrowingValue& operator=(const ThrowingValue& other) noexcept(
       IsSpecified(TypeSpec::kNoThrowCopy)) {
     dummy_ = kBadValue;
     if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator=(ThrowingValue&& other) noexcept(
       IsSpecified(TypeSpec::kNoThrowMove)) {
     dummy_ = kBadValue;
     if (!IsSpecified(TypeSpec::kNoThrowMove)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
     return *this;
   }
 
   // Arithmetic Operators
   ThrowingValue operator+(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ + other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator+() const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator-(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ - other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator-() const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(-dummy_, nothrow_ctor);
   }
 
   ThrowingValue& operator++() {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     ++dummy_;
     return *this;
   }
 
   ThrowingValue operator++(int) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     auto out = ThrowingValue(dummy_, nothrow_ctor);
     ++dummy_;
     return out;
   }
 
   ThrowingValue& operator--() {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     --dummy_;
     return *this;
   }
 
   ThrowingValue operator--(int) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     auto out = ThrowingValue(dummy_, nothrow_ctor);
     --dummy_;
     return out;
   }
 
   ThrowingValue operator*(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ * other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator/(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ / other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator%(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ % other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator<<(int shift) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ << shift, nothrow_ctor);
   }
 
   ThrowingValue operator>>(int shift) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ >> shift, nothrow_ctor);
   }
 
   // Comparison Operators
   // NOTE: We use `ThrowingBool` instead of `bool` because most STL
   // types/containers requires T to be convertible to bool.
   friend ThrowingBool operator==(const ThrowingValue& a,
                                  const ThrowingValue& b) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return a.dummy_ == b.dummy_;
   }
   friend ThrowingBool operator!=(const ThrowingValue& a,
                                  const ThrowingValue& b) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return a.dummy_ != b.dummy_;
   }
   friend ThrowingBool operator<(const ThrowingValue& a,
                                 const ThrowingValue& b) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return a.dummy_ < b.dummy_;
   }
   friend ThrowingBool operator<=(const ThrowingValue& a,
                                  const ThrowingValue& b) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return a.dummy_ <= b.dummy_;
   }
   friend ThrowingBool operator>(const ThrowingValue& a,
                                 const ThrowingValue& b) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return a.dummy_ > b.dummy_;
   }
   friend ThrowingBool operator>=(const ThrowingValue& a,
                                  const ThrowingValue& b) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return a.dummy_ >= b.dummy_;
   }
 
   // Logical Operators
   ThrowingBool operator!() const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return !dummy_;
   }
 
   ThrowingBool operator&&(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return dummy_ && other.dummy_;
   }
 
   ThrowingBool operator||(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return dummy_ || other.dummy_;
   }
 
   // Bitwise Logical Operators
   ThrowingValue operator~() const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(~dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator&(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ & other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator|(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ | other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator^(const ThrowingValue& other) const {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ ^ other.dummy_, nothrow_ctor);
   }
 
   // Compound Assignment operators
   ThrowingValue& operator+=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ += other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator-=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ -= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator*=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ *= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator/=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ /= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator%=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ %= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator&=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ &= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator|=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ |= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator^=(const ThrowingValue& other) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ ^= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator<<=(int shift) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ <<= shift;
     return *this;
   }
 
   ThrowingValue& operator>>=(int shift) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ >>= shift;
     return *this;
   }
 
   // Pointer operators
   void operator&() const = delete;  // NOLINT(runtime/operator)
 
   // Stream operators
   friend std::ostream& operator<<(std::ostream& os, const ThrowingValue& tv) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return os << GetInstanceString(tv.dummy_);
   }
 
   friend std::istream& operator>>(std::istream& is, const ThrowingValue&) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     return is;
   }
 
   // Memory management operators
   static void* operator new(size_t s) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new(s);
   }
 
   static void* operator new[](size_t s) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new[](s);
   }
 
   template <typename... Args>
   static void* operator new(size_t s, Args&&... args) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new(s, std::forward<Args>(args)...);
   }
 
   template <typename... Args>
   static void* operator new[](size_t s, Args&&... args) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new[](s, std::forward<Args>(args)...);
   }
 
   // Abseil doesn't support throwing overloaded operator delete.  These are
   // provided so a throwing operator-new can clean up after itself.
   void operator delete(void* p) noexcept { ::operator delete(p); }
 
   template <typename... Args>
   void operator delete(void* p, Args&&... args) noexcept {
     ::operator delete(p, std::forward<Args>(args)...);
   }
 
   void operator delete[](void* p) noexcept { return ::operator delete[](p); }
 
   template <typename... Args>
   void operator delete[](void* p, Args&&... args) noexcept {
     return ::operator delete[](p, std::forward<Args>(args)...);
   }
 
   // Non-standard access to the actual contained value.  No need for this to
   // throw.
   int& Get() noexcept { return dummy_; }
   const int& Get() const noexcept { return dummy_; }
 
  private:
   static std::string GetInstanceString(int dummy) {
     return absl::StrCat("ThrowingValue<",
                         exceptions_internal::GetSpecString(Spec), ">(", dummy,
                         ")");
   }
 
   int dummy_;
 };
 // While not having to do with exceptions, explicitly delete comma operator, to
 // make sure we don't use it on user-supplied types.
 template <TypeSpec Spec, typename T>
 void operator,(const ThrowingValue<Spec>&, T&&) = delete;
 template <TypeSpec Spec, typename T>
 void operator,(T&&, const ThrowingValue<Spec>&) = delete;
 
 /*
  * Configuration enum for the ThrowingAllocator type that defines behavior for
  * the lifetime of the instance.
  *
  * kEverythingThrows: Calls to the member functions may throw
  * kNoThrowAllocate: Calls to the member functions will not throw
  */
 enum class AllocSpec {
   kEverythingThrows = 0,
   kNoThrowAllocate = 1,
 };
 
 /*
  * An allocator type which is instrumented to throw at a controlled time, or not
  * to throw, using AllocSpec. The supported settings are the default of every
  * function which is allowed to throw in a conforming allocator possibly
  * throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
  * configuration macro.
  */
 template <typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
 class ThrowingAllocator : private exceptions_internal::TrackedObject {
   static constexpr bool IsSpecified(AllocSpec spec) {
     return static_cast<bool>(Spec & spec);
   }
 
  public:
   using pointer = T*;
   using const_pointer = const T*;
   using reference = T&;
   using const_reference = const T&;
   using void_pointer = void*;
   using const_void_pointer = const void*;
   using value_type = T;
   using size_type = size_t;
   using difference_type = ptrdiff_t;
 
   using is_nothrow =
       std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>;
   using propagate_on_container_copy_assignment = std::true_type;
   using propagate_on_container_move_assignment = std::true_type;
   using propagate_on_container_swap = std::true_type;
   using is_always_equal = std::false_type;
 
   ThrowingAllocator() : TrackedObject(GetInstanceString(next_id_)) {
     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
     dummy_ = std::make_shared<const int>(next_id_++);
   }
 
   template <typename U>
   ThrowingAllocator(const ThrowingAllocator<U, Spec>& other) noexcept  // NOLINT
       : TrackedObject(GetInstanceString(*other.State())),
         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(GetInstanceString(*other.State())),
         dummy_(other.State()) {}
 
   template <typename U>
   ThrowingAllocator(ThrowingAllocator<U, Spec>&& other) noexcept  // NOLINT
       : TrackedObject(GetInstanceString(*other.State())),
         dummy_(std::move(other.State())) {}
 
   ThrowingAllocator(ThrowingAllocator&& other) noexcept
       : TrackedObject(GetInstanceString(*other.State())),
         dummy_(std::move(other.State())) {}
 
   ~ThrowingAllocator() noexcept = default;
 
   ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept {
     dummy_ = other.State();
     return *this;
   }
 
   template <typename U>
   ThrowingAllocator& operator=(
       const ThrowingAllocator<U, Spec>& other) noexcept {
     dummy_ = other.State();
     return *this;
   }
 
   template <typename U>
   ThrowingAllocator& operator=(ThrowingAllocator<U, Spec>&& other) noexcept {
     dummy_ = std::move(other.State());
     return *this;
   }
 
   template <typename U>
   struct rebind {
     using other = ThrowingAllocator<U, Spec>;
   };
 
   pointer allocate(size_type n) noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
     ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
     return static_cast<pointer>(::operator new(n * sizeof(T)));
   }
 
   pointer allocate(size_type n, const_void_pointer) noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
     return allocate(n);
   }
 
   void deallocate(pointer ptr, size_type) noexcept {
     ReadState();
     ::operator delete(static_cast<void*>(ptr));
   }
 
   template <typename U, typename... Args>
   void construct(U* ptr, Args&&... args) noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
     ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
     ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
   }
 
   template <typename U>
   void destroy(U* p) noexcept {
     ReadState();
     p->~U();
   }
 
   size_type max_size() const noexcept {
     return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
   }
 
   ThrowingAllocator select_on_container_copy_construction() noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
     ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
     return *this;
   }
 
   template <typename U>
   bool operator==(const ThrowingAllocator<U, Spec>& other) const noexcept {
     return dummy_ == other.dummy_;
   }
 
   template <typename U>
   bool operator!=(const ThrowingAllocator<U, Spec>& other) const noexcept {
     return dummy_ != other.dummy_;
   }
 
   template <typename, AllocSpec>
   friend class ThrowingAllocator;
 
  private:
   static std::string GetInstanceString(int dummy) {
     return absl::StrCat("ThrowingAllocator<",
                         exceptions_internal::GetSpecString(Spec), ">(", dummy,
                         ")");
   }
 
   const std::shared_ptr<const int>& State() const { return dummy_; }
   std::shared_ptr<const int>& State() { return dummy_; }
 
   void ReadState() {
     // we know that this will never be true, but the compiler doesn't, so this
     // should safely force a read of the value.
     if (*dummy_ < 0) std::abort();
   }
 
   void ReadStateAndMaybeThrow(absl::string_view msg) const {
     if (!IsSpecified(AllocSpec::kNoThrowAllocate)) {
       exceptions_internal::MaybeThrow(
           absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg));
     }
   }
 
   static int next_id_;
   std::shared_ptr<const int> dummy_;
 };
 
 template <typename T, AllocSpec Spec>
 int ThrowingAllocator<T, Spec>::next_id_ = 0;
 
 // 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.
 template <typename T, typename... Args>
 void TestThrowingCtor(Args&&... args) {
   struct Cleanup {
     ~Cleanup() { exceptions_internal::UnsetCountdown(); }
   } c;
   for (int count = 0;; ++count) {
     exceptions_internal::ConstructorTracker ct(count);
     exceptions_internal::SetCountdown(count);
     try {
       T temp(std::forward<Args>(args)...);
       static_cast<void>(temp);
       break;
     } catch (const exceptions_internal::TestException&) {
     }
   }
 }
 
 // Tests the nothrow guarantee of the provided nullary operation. If the an
 // exception is thrown, the result will be AssertionFailure(). Otherwise, it
 // will be AssertionSuccess().
 template <typename Operation>
 testing::AssertionResult TestNothrowOp(const Operation& operation) {
   struct Cleanup {
     Cleanup() { exceptions_internal::SetCountdown(); }
     ~Cleanup() { exceptions_internal::UnsetCountdown(); }
   } c;
   try {
     operation();
     return testing::AssertionSuccess();
   } catch (const exceptions_internal::TestException&) {
     return testing::AssertionFailure()
            << "TestException thrown during call to operation() when nothrow "
               "guarantee was expected.";
   } catch (...) {
     return testing::AssertionFailure()
            << "Unknown exception thrown during call to operation() when "
               "nothrow guarantee was expected.";
   }
 }
 
 namespace exceptions_internal {
 
 // Dummy struct for ExceptionSafetyTestBuilder<> partial state.
 struct UninitializedT {};
 
 template <typename T>
 class DefaultFactory {
  public:
   explicit DefaultFactory(const T& t) : t_(t) {}
   std::unique_ptr<T> operator()() const { return absl::make_unique<T>(t_); }
 
  private:
   T t_;
 };
 
 template <size_t LazyContractsCount, typename LazyFactory,
           typename LazyOperation>
 using EnableIfTestable = typename absl::enable_if_t<
     LazyContractsCount != 0 &&
     !std::is_same<LazyFactory, UninitializedT>::value &&
     !std::is_same<LazyOperation, UninitializedT>::value>;
 
 template <typename Factory = UninitializedT,
           typename Operation = UninitializedT, typename... Contracts>
 class ExceptionSafetyTestBuilder;
 
 }  // namespace exceptions_internal
 
 /*
  * Constructs an empty ExceptionSafetyTestBuilder. All
  * ExceptionSafetyTestBuilder objects are immutable and all With[thing] mutation
  * methods return new instances of ExceptionSafetyTestBuilder.
  *
  * In order to test a T for exception safety, a factory for that T, a testable
  * operation, and at least one contract callback returning an assertion
  * result must be applied using the respective methods.
  */
 exceptions_internal::ExceptionSafetyTestBuilder<> MakeExceptionSafetyTester();
 
 namespace exceptions_internal {
 template <typename T>
 struct IsUniquePtr : std::false_type {};
 
 template <typename T, typename D>
 struct IsUniquePtr<std::unique_ptr<T, D>> : std::true_type {};
 
 template <typename Factory>
 struct FactoryPtrTypeHelper {
   using type = decltype(std::declval<const Factory&>()());
 
   static_assert(IsUniquePtr<type>::value, "Factories must return a unique_ptr");
 };
 
 template <typename Factory>
 using FactoryPtrType = typename FactoryPtrTypeHelper<Factory>::type;
 
 template <typename Factory>
 using FactoryElementType = typename FactoryPtrType<Factory>::element_type;
 
 template <typename T>
 class ExceptionSafetyTest {
   using Factory = std::function<std::unique_ptr<T>()>;
   using Operation = std::function<void(T*)>;
   using Contract = std::function<AssertionResult(T*)>;
 
  public:
   template <typename... Contracts>
   explicit ExceptionSafetyTest(const Factory& f, const Operation& op,
                                const Contracts&... contracts)
       : factory_(f), operation_(op), contracts_{WrapContract(contracts)...} {}
 
   AssertionResult Test() const {
     for (int count = 0;; ++count) {
       exceptions_internal::ConstructorTracker ct(count);
 
       for (const auto& contract : contracts_) {
         auto t_ptr = factory_();
         try {
           SetCountdown(count);
           operation_(t_ptr.get());
           // Unset for the case that the operation throws no exceptions, which
           // would leave the countdown set and break the *next* exception safety
           // test after this one.
           UnsetCountdown();
           return AssertionSuccess();
         } catch (const exceptions_internal::TestException& e) {
           if (!contract(t_ptr.get())) {
             return AssertionFailure() << e.what() << " failed contract check";
           }
         }
       }
     }
   }
 
  private:
   template <typename ContractFn>
   Contract WrapContract(const ContractFn& contract) {
     return [contract](T* t_ptr) { return AssertionResult(contract(t_ptr)); };
   }
 
   Contract WrapContract(StrongGuaranteeTagType) {
     return [this](T* t_ptr) { return AssertionResult(*factory_() == *t_ptr); };
   }
 
   Factory factory_;
   Operation operation_;
   std::vector<Contract> contracts_;
 };
 
 /*
  * Builds a tester object that tests if performing a operation on a T follows
  * exception safety guarantees. Verification is done via contract assertion
  * callbacks applied to T instances post-throw.
  *
  * Template parameters for ExceptionSafetyTestBuilder:
  *
  * - Factory: The factory object (passed in via tester.WithFactory(...) or
  *   tester.WithInitialValue(...)) must be invocable with the signature
  *   `std::unique_ptr<T> operator()() const` where T is the type being tested.
  *   It is used for reliably creating identical T instances to test on.
  *
  * - Operation: The operation object (passed in via tester.WithOperation(...)
  *   or tester.Test(...)) must be invocable with the signature
  *   `void operator()(T*) const` where T is the type being tested. It is used
  *   for performing steps on a T instance that may throw and that need to be
  *   checked for exception safety. Each call to the operation will receive a
  *   fresh T instance so it's free to modify and destroy the T instances as it
  *   pleases.
  *
  * - Contracts...: The contract assertion callback objects (passed in via
  *   tester.WithContracts(...)) must be invocable with the signature
  *   `testing::AssertionResult operator()(T*) const` where T is the type being
  *   tested. Contract assertion callbacks are provided T instances post-throw.
  *   They must return testing::AssertionSuccess when the type contracts of the
  *   provided T instance hold. If the type contracts of the T instance do not
  *   hold, they must return testing::AssertionFailure. Execution order of
  *   Contracts... is unspecified. They will each individually get a fresh T
  *   instance so they are free to modify and destroy the T instances as they
  *   please.
  */
 template <typename Factory, typename Operation, typename... Contracts>
 class ExceptionSafetyTestBuilder {
  public:
   /*
    * Returns a new ExceptionSafetyTestBuilder with an included T factory based
    * on the provided T instance. The existing factory will not be included in
    * the newly created tester instance. The created factory returns a new T
    * instance by copy-constructing the provided const T& t.
    *
    * Preconditions for tester.WithInitialValue(const T& t):
    *
    * - The const T& t object must be copy-constructible where T is the type
    *   being tested. For non-copy-constructible objects, use the method
    *   tester.WithFactory(...).
    */
   template <typename T>
   ExceptionSafetyTestBuilder<DefaultFactory<T>, Operation, Contracts...>
   WithInitialValue(const T& t) const {
     return WithFactory(DefaultFactory<T>(t));
   }
 
   /*
    * Returns a new ExceptionSafetyTestBuilder with the provided T factory
    * included. The existing factory will not be included in the newly-created
    * tester instance. This method is intended for use with types lacking a copy
    * constructor. Types that can be copy-constructed should instead use the
    * method tester.WithInitialValue(...).
    */
   template <typename NewFactory>
   ExceptionSafetyTestBuilder<absl::decay_t<NewFactory>, Operation, Contracts...>
   WithFactory(const NewFactory& new_factory) const {
     return {new_factory, operation_, contracts_};
   }
 
   /*
    * Returns a new ExceptionSafetyTestBuilder with the provided testable
    * operation included. The existing operation will not be included in the
    * newly created tester.
    */
   template <typename NewOperation>
   ExceptionSafetyTestBuilder<Factory, absl::decay_t<NewOperation>, Contracts...>
   WithOperation(const NewOperation& new_operation) const {
     return {factory_, new_operation, contracts_};
   }
 
   /*
    * Returns a new ExceptionSafetyTestBuilder with the provided MoreContracts...
    * combined with the Contracts... that were already included in the instance
    * on which the method was called. Contracts... cannot be removed or replaced
    * once added to an ExceptionSafetyTestBuilder instance. A fresh object must
    * be created in order to get an empty Contracts... list.
    *
    * In addition to passing in custom contract assertion callbacks, this method
    * accepts `testing::strong_guarantee` as an argument which checks T instances
    * post-throw against freshly created T instances via operator== to verify
    * that any state changes made during the execution of the operation were
    * properly rolled back.
    */
   template <typename... MoreContracts>
   ExceptionSafetyTestBuilder<Factory, Operation, Contracts...,
                              absl::decay_t<MoreContracts>...>
   WithContracts(const MoreContracts&... more_contracts) const {
     return {
         factory_, operation_,
         std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>(
                                        more_contracts...))};
   }
 
   /*
    * Returns a testing::AssertionResult that is the reduced result of the
    * exception safety algorithm. The algorithm short circuits and returns
    * AssertionFailure after the first contract callback returns an
    * AssertionFailure. Otherwise, if all contract callbacks return an
    * AssertionSuccess, the reduced result is AssertionSuccess.
    *
    * The passed-in testable operation will not be saved in a new tester instance
    * nor will it modify/replace the existing tester instance. This is useful
    * when each operation being tested is unique and does not need to be reused.
    *
    * Preconditions for tester.Test(const NewOperation& new_operation):
    *
    * - May only be called after at least one contract assertion callback and a
    *   factory or initial value have been provided.
    */
   template <
       typename NewOperation,
       typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>>
   testing::AssertionResult Test(const NewOperation& new_operation) const {
     return TestImpl(new_operation, absl::index_sequence_for<Contracts...>());
   }
 
   /*
    * Returns a testing::AssertionResult that is the reduced result of the
    * exception safety algorithm. The algorithm short circuits and returns
    * AssertionFailure after the first contract callback returns an
    * AssertionFailure. Otherwise, if all contract callbacks return an
    * AssertionSuccess, the reduced result is AssertionSuccess.
    *
    * Preconditions for tester.Test():
    *
    * - May only be called after at least one contract assertion callback, a
    *   factory or initial value and a testable operation have been provided.
    */
   template <
       typename LazyOperation = Operation,
       typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>>
   testing::AssertionResult Test() const {
     return Test(operation_);
   }
 
  private:
   template <typename, typename, typename...>
   friend class ExceptionSafetyTestBuilder;
 
   friend ExceptionSafetyTestBuilder<> testing::MakeExceptionSafetyTester();
 
   ExceptionSafetyTestBuilder() {}
 
   ExceptionSafetyTestBuilder(const Factory& f, const Operation& o,
                              const std::tuple<Contracts...>& i)
       : factory_(f), operation_(o), contracts_(i) {}
 
   template <typename SelectedOperation, size_t... Indices>
   testing::AssertionResult TestImpl(SelectedOperation selected_operation,
                                     absl::index_sequence<Indices...>) const {
     return ExceptionSafetyTest<FactoryElementType<Factory>>(
                factory_, selected_operation, std::get<Indices>(contracts_)...)
         .Test();
   }
 
   Factory factory_;
   Operation operation_;
   std::tuple<Contracts...> contracts_;
 };
 
 }  // namespace exceptions_internal
 
 }  // namespace testing
 
 #endif  // ABSL_HAVE_EXCEPTIONS
 
 #endif  // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_

This page was automatically generated by the 2.3.7 LXR engine. The LXR team