react-native-windows 0.84.0 → 0.85.0-preview.2

package/external/folly/folly/container/test/TrackingTypes.h

@@ -0,0 +1,584 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <ostream>
+
+#include <folly/Function.h>
+#include <folly/hash/Hash.h>
+#include <folly/lang/SafeAssert.h>
+#include <folly/portability/Asm.h>
+
+namespace folly {
+namespace test {
+
+struct MoveOnlyTestInt {
+  int x;
+  bool destroyed{false};
+
+  MoveOnlyTestInt() noexcept : x(0) {}
+  /* implicit */ MoveOnlyTestInt(int x0) : x(x0) {}
+  MoveOnlyTestInt(MoveOnlyTestInt&& rhs) noexcept : x(rhs.x) {}
+  MoveOnlyTestInt(MoveOnlyTestInt const&) = delete;
+  MoveOnlyTestInt& operator=(MoveOnlyTestInt&& rhs) noexcept {
+    FOLLY_SAFE_CHECK(!rhs.destroyed, "");
+    x = rhs.x;
+    return *this;
+  }
+  MoveOnlyTestInt& operator=(MoveOnlyTestInt const&) = delete;
+
+  ~MoveOnlyTestInt() {
+    FOLLY_SAFE_CHECK(!destroyed, "");
+    destroyed = true;
+    asm_volatile_memory(); // try to keep compiler from eliding the store
+  }
+
+  bool operator==(MoveOnlyTestInt const& rhs) const {
+    FOLLY_SAFE_CHECK(!destroyed, "");
+    FOLLY_SAFE_CHECK(!rhs.destroyed, "");
+    return x == rhs.x && destroyed == rhs.destroyed;
+  }
+  bool operator!=(MoveOnlyTestInt const& rhs) const { return !(*this == rhs); }
+};
+
+struct ThrowOnCopyTestInt {
+  int x{0};
+
+  ThrowOnCopyTestInt() {}
+
+  [[noreturn]] ThrowOnCopyTestInt(const ThrowOnCopyTestInt& other)
+      : x(other.x) {
+    throw std::exception{};
+  }
+
+  ThrowOnCopyTestInt& operator=(const ThrowOnCopyTestInt&) {
+    throw std::exception{};
+  }
+
+  bool operator==(const ThrowOnCopyTestInt& other) const {
+    return x == other.x;
+  }
+
+  bool operator!=(const ThrowOnCopyTestInt& other) const {
+    return !(x == other.x);
+  }
+};
+
+struct PermissiveConstructorTestInt {
+  int x;
+
+  PermissiveConstructorTestInt() noexcept : x(0) {}
+  /* implicit */ PermissiveConstructorTestInt(int x0) : x(x0) {}
+
+  template <typename T>
+  /* implicit */ PermissiveConstructorTestInt(T&& src)
+      : x(std::forward<T>(src)) {}
+
+  PermissiveConstructorTestInt(PermissiveConstructorTestInt&& rhs) noexcept
+      : x(rhs.x) {}
+  PermissiveConstructorTestInt(PermissiveConstructorTestInt const&) = delete;
+  PermissiveConstructorTestInt& operator=(
+      PermissiveConstructorTestInt&& rhs) noexcept {
+    x = rhs.x;
+    return *this;
+  }
+  PermissiveConstructorTestInt& operator=(PermissiveConstructorTestInt const&) =
+      delete;
+
+  bool operator==(PermissiveConstructorTestInt const& rhs) const {
+    return x == rhs.x;
+  }
+  bool operator!=(PermissiveConstructorTestInt const& rhs) const {
+    return !(*this == rhs);
+  }
+};
+
+// Tracked is implicitly constructible across tags
+struct Counts {
+  uint64_t copyConstruct{0};
+  uint64_t moveConstruct{0};
+  uint64_t copyConvert{0};
+  uint64_t moveConvert{0};
+  uint64_t copyAssign{0};
+  uint64_t moveAssign{0};
+  uint64_t defaultConstruct{0};
+  uint64_t destroyed{0};
+
+  explicit Counts(
+      uint64_t copConstr = 0,
+      uint64_t movConstr = 0,
+      uint64_t copConv = 0,
+      uint64_t movConv = 0,
+      uint64_t copAssign = 0,
+      uint64_t movAssign = 0,
+      uint64_t def = 0,
+      uint64_t destr = 0)
+      : copyConstruct{copConstr},
+        moveConstruct{movConstr},
+        copyConvert{copConv},
+        moveConvert{movConv},
+        copyAssign{copAssign},
+        moveAssign{movAssign},
+        defaultConstruct{def},
+        destroyed{destr} {}
+
+  int64_t liveCount() const {
+    return copyConstruct + moveConstruct + copyConvert + moveConvert +
+        defaultConstruct - destroyed;
+  }
+
+  // dist ignores destroyed count
+  uint64_t dist(Counts const& rhs) const {
+    auto d = [](uint64_t x, uint64_t y) { return (x - y) * (x - y); };
+    return d(copyConstruct, rhs.copyConstruct) +
+        d(moveConstruct, rhs.moveConstruct) + d(copyConvert, rhs.copyConvert) +
+        d(moveConvert, rhs.moveConvert) + d(copyAssign, rhs.copyAssign) +
+        d(moveAssign, rhs.moveAssign) +
+        d(defaultConstruct, rhs.defaultConstruct);
+  }
+
+  bool operator==(Counts const& rhs) const {
+    return dist(rhs) == 0 && destroyed == rhs.destroyed;
+  }
+  bool operator!=(Counts const& rhs) const { return !(*this == rhs); }
+};
+
+inline std::ostream& operator<<(std::ostream& xo, Counts const& counts) {
+  xo << "[";
+  std::string glue = "";
+  if (counts.copyConstruct > 0) {
+    xo << glue << counts.copyConstruct << " copy";
+    glue = ", ";
+  }
+  if (counts.moveConstruct > 0) {
+    xo << glue << counts.moveConstruct << " move";
+    glue = ", ";
+  }
+  if (counts.copyConvert > 0) {
+    xo << glue << counts.copyConvert << " copy convert";
+    glue = ", ";
+  }
+  if (counts.moveConvert > 0) {
+    xo << glue << counts.moveConvert << " move convert";
+    glue = ", ";
+  }
+  if (counts.copyAssign > 0) {
+    xo << glue << counts.copyAssign << " copy assign";
+    glue = ", ";
+  }
+  if (counts.moveAssign > 0) {
+    xo << glue << counts.moveAssign << " move assign";
+    glue = ", ";
+  }
+  if (counts.defaultConstruct > 0) {
+    xo << glue << counts.defaultConstruct << " default construct";
+    glue = ", ";
+  }
+  if (counts.destroyed > 0) {
+    xo << glue << counts.destroyed << " destroyed";
+    glue = ", ";
+  }
+  xo << "]";
+  return xo;
+}
+
+inline Counts& sumCounts() {
+  static thread_local Counts value{};
+  return value;
+}
+
+template <int Tag>
+struct Tracked {
+  static_assert(Tag <= 5, "Need to extend Tracked<Tag> in TestUtil.cpp");
+
+  static Counts& counts() {
+    static thread_local Counts value{};
+    return value;
+  }
+
+  uint64_t val_;
+
+  Tracked() : val_{0} {
+    sumCounts().defaultConstruct++;
+    counts().defaultConstruct++;
+  }
+  /* implicit */ Tracked(uint64_t const& val) : val_{val} {
+    sumCounts().copyConvert++;
+    counts().copyConvert++;
+  }
+  /* implicit */ Tracked(uint64_t&& val) : val_{val} {
+    sumCounts().moveConvert++;
+    counts().moveConvert++;
+  }
+  Tracked(Tracked const& rhs) : val_{rhs.val_} {
+    sumCounts().copyConstruct++;
+    counts().copyConstruct++;
+  }
+  Tracked(Tracked&& rhs) noexcept : val_{rhs.val_} {
+    sumCounts().moveConstruct++;
+    counts().moveConstruct++;
+  }
+  Tracked& operator=(Tracked const& rhs) {
+    val_ = rhs.val_;
+    sumCounts().copyAssign++;
+    counts().copyAssign++;
+    return *this;
+  }
+  Tracked& operator=(Tracked&& rhs) noexcept {
+    val_ = rhs.val_;
+    sumCounts().moveAssign++;
+    counts().moveAssign++;
+    return *this;
+  }
+
+  template <int T>
+  /* implicit */ Tracked(Tracked<T> const& rhs) : val_{rhs.val_} {
+    sumCounts().copyConvert++;
+    counts().copyConvert++;
+  }
+
+  template <int T>
+  /* implicit */ Tracked(Tracked<T>&& rhs) : val_{rhs.val_} {
+    sumCounts().moveConvert++;
+    counts().moveConvert++;
+  }
+
+  ~Tracked() {
+    sumCounts().destroyed++;
+    counts().destroyed++;
+  }
+
+  bool operator==(Tracked const& rhs) const { return val_ == rhs.val_; }
+  bool operator!=(Tracked const& rhs) const { return !(*this == rhs); }
+};
+
+template <int Tag>
+struct TransparentTrackedHash {
+  using is_transparent = void;
+
+  size_t operator()(Tracked<Tag> const& tracked) const {
+    return tracked.val_ ^ Tag;
+  }
+  size_t operator()(uint64_t v) const { return v ^ Tag; }
+};
+
+template <int Tag>
+struct TransparentTrackedEqual {
+  using is_transparent = void;
+
+  uint64_t unwrap(Tracked<Tag> const& v) const { return v.val_; }
+  uint64_t unwrap(uint64_t v) const { return v; }
+
+  template <typename A, typename B>
+  bool operator()(A const& lhs, B const& rhs) const {
+    return unwrap(lhs) == unwrap(rhs);
+  }
+};
+
+inline size_t& testAllocatedMemorySize() {
+  static thread_local size_t value{0};
+  return value;
+}
+
+inline size_t& testAllocatedBlockCount() {
+  static thread_local size_t value{0};
+  return value;
+}
+
+inline size_t& testAllocationCount() {
+  static thread_local size_t value{0};
+  return value;
+}
+
+inline size_t& testAllocationMaxCount() {
+  static thread_local size_t value{std::numeric_limits<std::size_t>::max()};
+  return value;
+}
+
+inline void limitTestAllocations(std::size_t allocationsBeforeException = 0) {
+  testAllocationMaxCount() = testAllocationCount() + allocationsBeforeException;
+}
+
+inline void unlimitTestAllocations() {
+  testAllocationMaxCount() = std::numeric_limits<std::size_t>::max();
+}
+
+inline void resetTracking() {
+  sumCounts() = Counts{};
+  Tracked<0>::counts() = Counts{};
+  Tracked<1>::counts() = Counts{};
+  Tracked<2>::counts() = Counts{};
+  Tracked<3>::counts() = Counts{};
+  Tracked<4>::counts() = Counts{};
+  Tracked<5>::counts() = Counts{};
+  testAllocatedMemorySize() = 0;
+  testAllocatedBlockCount() = 0;
+  testAllocationCount() = 0;
+  testAllocationMaxCount() = std::numeric_limits<std::size_t>::max();
+}
+
+template <class T>
+class SwapTrackingAlloc {
+ public:
+  using Alloc = std::allocator<T>;
+  using AllocTraits = std::allocator_traits<Alloc>;
+  using value_type = typename AllocTraits::value_type;
+
+  using pointer = typename AllocTraits::pointer;
+  using const_pointer = typename AllocTraits::const_pointer;
+  using reference = value_type&;
+  using const_reference = value_type const&;
+  using size_type = typename AllocTraits::size_type;
+
+  using propagate_on_container_swap = std::true_type;
+  using propagate_on_container_copy_assignment = std::true_type;
+  using propagate_on_container_move_assignment = std::true_type;
+
+  SwapTrackingAlloc() {}
+
+  template <class U>
+  /* implicit */ SwapTrackingAlloc(SwapTrackingAlloc<U> const& other) noexcept
+      : a_(other.a_), t_(other.t_) {}
+
+  template <class U>
+  SwapTrackingAlloc& operator=(SwapTrackingAlloc<U> const& other) noexcept {
+    a_ = other.a_;
+    t_ = other.t_;
+    return *this;
+  }
+
+  template <class U>
+  /* implicit */ SwapTrackingAlloc(SwapTrackingAlloc<U>&& other) noexcept
+      : a_(std::move(other.a_)), t_(std::move(other.t_)) {}
+
+  template <class U>
+  SwapTrackingAlloc& operator=(SwapTrackingAlloc<U>&& other) noexcept {
+    a_ = std::move(other.a_);
+    t_ = std::move(other.t_);
+    return *this;
+  }
+
+  T* allocate(size_t n) {
+    if (testAllocationCount() >= testAllocationMaxCount()) {
+      throw std::bad_alloc();
+    }
+    ++testAllocationCount();
+    testAllocatedMemorySize() += n * sizeof(T);
+    ++testAllocatedBlockCount();
+    std::size_t extra =
+        std::max<std::size_t>(1, sizeof(std::size_t) / sizeof(T));
+    T* p = a_.allocate(extra + n);
+    void* raw = static_cast<void*>(p);
+    *static_cast<std::size_t*>(raw) = n;
+    return p + extra;
+  }
+  void deallocate(T* p, size_t n) {
+    testAllocatedMemorySize() -= n * sizeof(T);
+    --testAllocatedBlockCount();
+    std::size_t extra =
+        std::max<std::size_t>(1, sizeof(std::size_t) / sizeof(T));
+    std::size_t check;
+    void* raw = static_cast<void*>(p - extra);
+    check = *static_cast<std::size_t*>(raw);
+    FOLLY_SAFE_CHECK(check == n, "");
+    a_.deallocate(p - extra, n + extra);
+  }
+
+ private:
+  std::allocator<T> a_;
+  Tracked<0> t_;
+
+  template <class U>
+  friend class SwapTrackingAlloc;
+};
+
+template <class T>
+void swap(SwapTrackingAlloc<T>&, SwapTrackingAlloc<T>&) noexcept {
+  // For argument dependent lookup:
+  // This function will be called if the custom swap functions of a container
+  // is used. Otherwise, std::swap() will do 1 move construct and 2 move
+  // assigns which will get tracked by t_.
+}
+
+template <class T1, class T2>
+bool operator==(SwapTrackingAlloc<T1> const&, SwapTrackingAlloc<T2> const&) {
+  return true;
+}
+
+template <class T1, class T2>
+bool operator!=(SwapTrackingAlloc<T1> const&, SwapTrackingAlloc<T2> const&) {
+  return false;
+}
+
+template <class T>
+class GenericAlloc {
+ public:
+  using value_type = T;
+
+  using pointer = T*;
+  using const_pointer = T const*;
+  using reference = T&;
+  using const_reference = T const&;
+  using size_type = std::size_t;
+
+  using propagate_on_container_swap = std::true_type;
+  using propagate_on_container_copy_assignment = std::true_type;
+  using propagate_on_container_move_assignment = std::true_type;
+
+  using AllocBytesFunc = folly::Function<void*(std::size_t)>;
+  using DeallocBytesFunc = folly::Function<void(void*, std::size_t)>;
+
+  GenericAlloc() = delete;
+
+  template <typename A, typename D>
+  GenericAlloc(A&& alloc, D&& dealloc)
+      : alloc_{std::make_shared<AllocBytesFunc>(std::forward<A>(alloc))},
+        dealloc_{std::make_shared<DeallocBytesFunc>(std::forward<D>(dealloc))} {
+  }
+
+  template <class U>
+  /* implicit */ GenericAlloc(GenericAlloc<U> const& other) noexcept
+      : alloc_{other.alloc_}, dealloc_{other.dealloc_} {}
+
+  template <class U>
+  GenericAlloc& operator=(GenericAlloc<U> const& other) noexcept {
+    alloc_ = other.alloc_;
+    dealloc_ = other.dealloc_;
+    return *this;
+  }
+
+  template <class U>
+  /* implicit */ GenericAlloc(GenericAlloc<U>&& other) noexcept
+      : alloc_(std::move(other.alloc_)), dealloc_(std::move(other.dealloc_)) {}
+
+  template <class U>
+  GenericAlloc& operator=(GenericAlloc<U>&& other) noexcept {
+    alloc_ = std::move(other.alloc_);
+    dealloc_ = std::move(other.dealloc_);
+    return *this;
+  }
+
+  T* allocate(size_t n) { return static_cast<T*>((*alloc_)(n * sizeof(T))); }
+  void deallocate(T* p, size_t n) {
+    (*dealloc_)(static_cast<void*>(p), n * sizeof(T));
+  }
+
+  template <typename U>
+  bool operator==(GenericAlloc<U> const& rhs) const {
+    return alloc_ == rhs.alloc_;
+  }
+
+  template <typename U>
+  bool operator!=(GenericAlloc<U> const& rhs) const {
+    return !(*this == rhs);
+  }
+
+ private:
+  std::shared_ptr<AllocBytesFunc> alloc_;
+  std::shared_ptr<DeallocBytesFunc> dealloc_;
+
+  template <class U>
+  friend class GenericAlloc;
+};
+
+template <typename T>
+class GenericEqual {
+ public:
+  using EqualFunc = folly::Function<bool(T const&, T const&)>;
+
+  GenericEqual() = delete;
+
+  template <typename E>
+  /* implicit */ GenericEqual(E&& equal)
+      : equal_{std::make_shared<EqualFunc>(std::forward<E>(equal))} {}
+
+  bool operator()(T const& lhs, T const& rhs) const {
+    return (*equal_)(lhs, rhs);
+  }
+
+ private:
+  std::shared_ptr<EqualFunc> equal_;
+};
+
+template <typename T>
+class GenericHasher {
+ public:
+  using HasherFunc = folly::Function<std::size_t(T const&)>;
+
+  GenericHasher() = delete;
+
+  template <typename H>
+  /* implicit */ GenericHasher(H&& hasher)
+      : hasher_{std::make_shared<HasherFunc>(std::forward<H>(hasher))} {}
+
+  std::size_t operator()(T const& val) const { return (*hasher_)(val); }
+
+ private:
+  std::shared_ptr<HasherFunc> hasher_;
+};
+
+struct HashFirst {
+  template <typename P>
+  std::size_t operator()(P const& p) const {
+    return folly::Hash{}(p.first);
+  }
+};
+
+struct EqualFirst {
+  template <typename P>
+  bool operator()(P const& lhs, P const& rhs) const {
+    return lhs.first == rhs.first;
+  }
+};
+
+} // namespace test
+} // namespace folly
+
+namespace std {
+template <>
+struct hash<folly::test::MoveOnlyTestInt> {
+  std::size_t operator()(folly::test::MoveOnlyTestInt const& val) const {
+    FOLLY_SAFE_CHECK(!val.destroyed, "");
+    return val.x;
+  }
+};
+
+template <>
+struct hash<folly::test::ThrowOnCopyTestInt> {
+  std::size_t operator()(folly::test::ThrowOnCopyTestInt const& val) const {
+    return val.x;
+  }
+};
+
+template <>
+struct hash<folly::test::PermissiveConstructorTestInt> {
+  std::size_t operator()(
+      folly::test::PermissiveConstructorTestInt const& val) const {
+    return val.x;
+  }
+};
+
+template <int Tag>
+struct hash<folly::test::Tracked<Tag>> {
+  size_t operator()(folly::test::Tracked<Tag> const& tracked) const {
+    return tracked.val_ ^ Tag;
+  }
+};
+} // namespace std