| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758 | 
							- // Utilities for testing exception-safety
 
- #ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
 
- #define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
 
- #include <cstddef>
 
- #include <cstdint>
 
- #include <functional>
 
- #include <initializer_list>
 
- #include <iosfwd>
 
- #include <string>
 
- #include <unordered_map>
 
- #include "gtest/gtest.h"
 
- #include "absl/base/config.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/types/optional.h"
 
- namespace absl {
 
- struct AllocInspector;
 
- // 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
 
- // can always be made in the future.
 
- enum class NoThrow : uint8_t {
 
-   kNone = 0,
 
-   kMoveCtor = 1,
 
-   kMoveAssign = 1 << 1,
 
-   kAllocation = 1 << 2,
 
-   kIntCtor = 1 << 3,
 
-   kNoThrow = static_cast<uint8_t>(-1)
 
- };
 
- constexpr NoThrow operator|(NoThrow a, NoThrow b) {
 
-   using T = absl::underlying_type_t<NoThrow>;
 
-   return static_cast<NoThrow>(static_cast<T>(a) | static_cast<T>(b));
 
- }
 
- constexpr NoThrow operator&(NoThrow a, NoThrow b) {
 
-   using T = absl::underlying_type_t<NoThrow>;
 
-   return static_cast<NoThrow>(static_cast<T>(a) & static_cast<T>(b));
 
- }
 
- namespace exceptions_internal {
 
- struct NoThrowTag {};
 
- constexpr bool ThrowingAllowed(NoThrow flags, NoThrow flag) {
 
-   return !static_cast<bool>(flags & flag);
 
- }
 
- // 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) {}
 
-   absl::string_view what() const { return msg_; }
 
-  private:
 
-   std::string msg_;
 
- };
 
- extern int countdown;
 
- void MaybeThrow(absl::string_view msg);
 
- testing::AssertionResult FailureMessage(const TestException& e,
 
-                                         int countdown) noexcept;
 
- class TrackedObject {
 
-  protected:
 
-   explicit TrackedObject(absl::string_view 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>();
 
-     return *m;
 
-   }
 
-   ~TrackedObject() noexcept {
 
-     if (GetAllocs().erase(this) == 0) {
 
-       ADD_FAILURE() << "Object at address " << static_cast<void*>(this)
 
-                     << " destroyed improperly";
 
-     }
 
-   }
 
-   friend struct ::absl::AllocInspector;
 
- };
 
- template <typename Factory>
 
- using FactoryType = typename absl::result_of_t<Factory()>::element_type;
 
- // 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 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 {
 
-     op(t_ptr.get());
 
-   } catch (const exceptions_internal::TestException& e) {
 
-     out.emplace(check(t_ptr.get()));
 
-     if (!*out) {
 
-       *out << " caused by exception thrown by " << e.what();
 
-     }
 
-   }
 
-   return out;
 
- }
 
- template <typename Factory, typename Op, typename Checker>
 
- int UpdateOut(Factory factory, const Op& op, int count, const Checker& checker,
 
-               testing::AssertionResult* out) {
 
-   if (*out) *out = *TestCheckerAtCountdown(factory, op, count, checker);
 
-   return 0;
 
- }
 
- // 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>
 
- 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); });
 
-   if (!out.has_value()) return out;
 
-   // Run each checker, short circuiting after the first failure
 
-   int dummy[] = {0, (UpdateOut(factory, op, count, checkers, &*out))...};
 
-   static_cast<void>(dummy);
 
-   return out;
 
- }
 
- template <typename T, typename EqualTo>
 
- class StrongGuaranteeTester {
 
-  public:
 
-   explicit StrongGuaranteeTester(std::unique_ptr<T> t_ptr, EqualTo eq) noexcept
 
-       : val_(std::move(t_ptr)), eq_(eq) {}
 
-   testing::AssertionResult operator()(T* other) const {
 
-     return eq_(*val_, *other) ? testing::AssertionSuccess()
 
-                               : testing::AssertionFailure() << "State changed";
 
-   }
 
-  private:
 
-   std::unique_ptr<T> val_;
 
-   EqualTo eq_;
 
- };
 
- }  // namespace exceptions_internal
 
- extern exceptions_internal::NoThrowTag no_throw_ctor;
 
- // These are useful for tests which just construct objects and make sure there
 
- // are no leaks.
 
- inline void SetCountdown() { exceptions_internal::countdown = 0; }
 
- inline void UnsetCountdown() { exceptions_internal::countdown = -1; }
 
- // A test class which is contextually 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)
 
-   explicit operator bool() const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return b_;
 
-   }
 
-  private:
 
-   bool b_;
 
- };
 
- // 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 flag template arguments.  That is, to make an
 
- // ThrowingValue which has a noexcept move constructor and noexcept move
 
- // assignment, use
 
- // ThrowingValue<absl::NoThrow::kMoveCtor | absl::NoThrow::kMoveAssign>.
 
- template <NoThrow Flags = NoThrow::kNone>
 
- class ThrowingValue : private exceptions_internal::TrackedObject {
 
-  public:
 
-   ThrowingValue() : TrackedObject(ABSL_PRETTY_FUNCTION) {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     dummy_ = 0;
 
-   }
 
-   ThrowingValue(const ThrowingValue& other)
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION) {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     dummy_ = other.dummy_;
 
-   }
 
-   ThrowingValue(ThrowingValue&& other) noexcept(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveCtor))
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION) {
 
-     if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveCtor)) {
 
-       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     }
 
-     dummy_ = other.dummy_;
 
-   }
 
-   explicit ThrowingValue(int i) noexcept(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kIntCtor))
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION) {
 
-     if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kIntCtor)) {
 
-       exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     }
 
-     dummy_ = i;
 
-   }
 
-   ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(i) {}
 
-   // absl expects nothrow destructors
 
-   ~ThrowingValue() noexcept = default;
 
-   ThrowingValue& operator=(const ThrowingValue& other) {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     dummy_ = other.dummy_;
 
-     return *this;
 
-   }
 
-   ThrowingValue& operator=(ThrowingValue&& other) noexcept(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveAssign)) {
 
-     if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveAssign)) {
 
-       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_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator+() const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator-(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ - other.dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator-() const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(-dummy_, no_throw_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_, no_throw_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_, no_throw_ctor);
 
-     --dummy_;
 
-     return out;
 
-   }
 
-   ThrowingValue operator*(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ * other.dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator/(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ / other.dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator%(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ % other.dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator<<(int shift) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ << shift, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator>>(int shift) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ >> shift, no_throw_ctor);
 
-   }
 
-   // Comparison Operators
 
-   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_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator&(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ & other.dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator|(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ | other.dummy_, no_throw_ctor);
 
-   }
 
-   ThrowingValue operator^(const ThrowingValue& other) const {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return ThrowingValue(dummy_ ^ other.dummy_, no_throw_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&) {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return os;
 
-   }
 
-   friend std::istream& operator>>(std::istream& is, const ThrowingValue&) {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return is;
 
-   }
 
-   // Memory management operators
 
-   // Args.. allows us to overload regular and placement new in one shot
 
-   template <typename... Args>
 
-   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);
 
-     }
 
-     return ::operator new(s, std::forward<Args>(args)...);
 
-   }
 
-   template <typename... Args>
 
-   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);
 
-     }
 
-     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.
 
-   //
 
-   // We provide both regular and templated operator delete because if only the
 
-   // templated version is provided as we did with operator new, the compiler has
 
-   // no way of knowing which overload of operator delete to call. See
 
-   // http://en.cppreference.com/w/cpp/memory/new/operator_delete and
 
-   // http://en.cppreference.com/w/cpp/language/delete for the gory details.
 
-   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:
 
-   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 <NoThrow N, typename T>
 
- void operator,(const ThrowingValue<N>& ef, T&& t) = delete;
 
- template <NoThrow N, typename T>
 
- void operator,(T&& t, const ThrowingValue<N>& ef) = delete;
 
- // An allocator type which is instrumented to throw at a controlled time, or not
 
- // to throw, using NoThrow.  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, NoThrow Flags = NoThrow::kNone>
 
- class ThrowingAllocator : private exceptions_internal::TrackedObject {
 
-   static_assert(Flags == NoThrow::kNone || Flags == NoThrow::kNoThrow,
 
-                 "Invalid flag");
 
-  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, Flags == NoThrow::kNoThrow>;
 
-   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(ABSL_PRETTY_FUNCTION) {
 
-     exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     dummy_ = std::make_shared<const int>(next_id_++);
 
-   }
 
-   template <typename U>
 
-   ThrowingAllocator(  // NOLINT
 
-       const ThrowingAllocator<U, Flags>& other) noexcept
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
 
-   ThrowingAllocator(const ThrowingAllocator& other) noexcept
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
 
-   template <typename U>
 
-   ThrowingAllocator(  // NOLINT
 
-       ThrowingAllocator<U, Flags>&& other) noexcept
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(std::move(other.State())) {}
 
-   ThrowingAllocator(ThrowingAllocator&& other) noexcept
 
-       : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(std::move(other.State())) {}
 
-   ~ThrowingAllocator() noexcept = default;
 
-   template <typename U>
 
-   ThrowingAllocator& operator=(
 
-       const ThrowingAllocator<U, Flags>& other) noexcept {
 
-     dummy_ = other.State();
 
-     return *this;
 
-   }
 
-   template <typename U>
 
-   ThrowingAllocator& operator=(ThrowingAllocator<U, Flags>&& other) noexcept {
 
-     dummy_ = std::move(other.State());
 
-     return *this;
 
-   }
 
-   template <typename U>
 
-   struct rebind {
 
-     using other = ThrowingAllocator<U, Flags>;
 
-   };
 
-   pointer allocate(size_type n) noexcept(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
 
-     ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return static_cast<pointer>(::operator new(n * sizeof(T)));
 
-   }
 
-   pointer allocate(size_type n, const_void_pointer) noexcept(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
 
-     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(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
 
-     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(!exceptions_internal::ThrowingAllowed(Flags,
 
-                                                      NoThrow::kNoThrow)) {
 
-     ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return std::numeric_limits<difference_type>::max() / sizeof(value_type);
 
-   }
 
-   ThrowingAllocator select_on_container_copy_construction() noexcept(
 
-       !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
 
-     auto& out = *this;
 
-     ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
 
-     return out;
 
-   }
 
-   template <typename U>
 
-   bool operator==(const ThrowingAllocator<U, Flags>& other) const noexcept {
 
-     return dummy_ == other.dummy_;
 
-   }
 
-   template <typename U>
 
-   bool operator!=(const ThrowingAllocator<U, Flags>& other) const noexcept {
 
-     return dummy_ != other.dummy_;
 
-   }
 
-   template <typename U, NoThrow B>
 
-   friend class ThrowingAllocator;
 
-  private:
 
-   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 (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
 
-       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, NoThrow Throws>
 
- 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
 
- // everything left over in its destructor.
 
- struct AllocInspector {
 
-   AllocInspector() = default;
 
-   ~AllocInspector() {
 
-     auto& allocs = exceptions_internal::TrackedObject::GetAllocs();
 
-     for (const auto& kv : allocs) {
 
-       ADD_FAILURE() << "Object at address " << static_cast<void*>(kv.first)
 
-                     << " constructed from " << kv.second << " not destroyed";
 
-     }
 
-     allocs.clear();
 
-   }
 
- };
 
- // 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
 
- // fixture, then this will also test that memory resources are not leaked as
 
- // long as T allocates TrackedObjects.
 
- template <typename T, typename... Args>
 
- T TestThrowingCtor(Args&&... args) {
 
-   struct Cleanup {
 
-     ~Cleanup() { UnsetCountdown(); }
 
-   };
 
-   Cleanup c;
 
-   for (int countdown = 0;; ++countdown) {
 
-     exceptions_internal::countdown = countdown;
 
-     try {
 
-       return T(std::forward<Args>(args)...);
 
-     } catch (const exceptions_internal::TestException&) {
 
-     }
 
-   }
 
- }
 
- // 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.
 
- //
 
- // Parameters:
 
- //   * TFactory: operator() returns a unique_ptr to the type under test (T).  It
 
- //   should always return pointers to values which compare equal.
 
- //   * FunctionFromTPtrToVoid: A functor exercising the function under test.  It
 
- //   should take a T* and return void.
 
- //   * Checkers: Any number of functions taking a T* and returning
 
- //   anything contextually convertible to bool.  If a testing::AssertionResult
 
- //   is used then the error message is kept.  These test invariants related to
 
- //   the operation. To test the strong guarantee, pass
 
- //   absl::StrongGuarantee(factory).  A checker may freely modify the passed-in
 
- //   T, for example to make sure the T can be set to a known state.
 
- template <typename TFactory, typename FunctionFromTPtrToVoid,
 
-           typename... Checkers>
 
- testing::AssertionResult TestExceptionSafety(TFactory factory,
 
-                                              FunctionFromTPtrToVoid&& op,
 
-                                              const Checkers&... checkers) {
 
-   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;
 
-   }
 
- }
 
- // Returns a functor to test for the strong exception-safety guarantee.
 
- // Equality comparisons are made against the T provided by the factory and
 
- // default to using operator==.
 
- //
 
- // Parameters:
 
- //   * TFactory: operator() returns a unique_ptr to the type under test.  It
 
- //   should always return pointers to values which compare equal.
 
- template <typename TFactory, typename EqualTo = std::equal_to<
 
-                                  exceptions_internal::FactoryType<TFactory>>>
 
- exceptions_internal::StrongGuaranteeTester<
 
-     exceptions_internal::FactoryType<TFactory>, EqualTo>
 
- StrongGuarantee(TFactory factory, EqualTo eq = EqualTo()) {
 
-   return exceptions_internal::StrongGuaranteeTester<
 
-       exceptions_internal::FactoryType<TFactory>, EqualTo>(factory(), eq);
 
- }
 
- }  // namespace absl
 
- #endif  // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
 
 
  |