remove #if 0 chuck

Author: wusatosi

tests/beman/inplace_vector/spec.test.cpp

@@ -2386,263 +2386,4 @@ TYPED_TEST(Erasure, ByPred) {
   GTEST_SKIP() << "Not implemented";
 }
 
-#if 0
-
-template <typename T> class InplaceVectorSMFs : public ::testing::Test {
-public:
-  using IV = beman::inplace_vector::inplace_vector<T, 10>;
-  using IV0 = beman::inplace_vector::inplace_vector<T, 0>;
-
-  struct InputIterator {
-    using difference_type = std::ptrdiff_t;
-    using value_type = T;
-    using iterator_category = std::input_iterator_tag;
-
-    T step;
-    explicit constexpr InputIterator(T n) noexcept : step(n) {}
-    constexpr InputIterator &operator++() noexcept {
-      ++step.value;
-      return *this;
-    }
-    constexpr InputIterator operator++(int) noexcept {
-      auto prev = *this;
-      ++(*this);
-      return prev;
-    }
-    constexpr T operator*() const noexcept { return step; }
-    constexpr bool operator==(InputIterator const &) const noexcept = default;
-  };
-  static_assert(std::input_iterator<InputIterator>);
-};
-
-using AllTypes =
-    ::testing::Types<Trivial, NonTriviallyDefaultConstructible,
-                     NonTriviallyCopyConstructible,
-                     NonTriviallyMoveConstructible, NonTriviallyCopyAssignable,
-                     NonTriviallyMoveAssignable, TriviallyAssignable,
-                     TriviallyDestructible, NonTrivial>;
-TYPED_TEST_SUITE(InplaceVectorSMFs, AllTypes);
-
-// [containers.sequences.inplace.vector.cons]
-TYPED_TEST(InplaceVectorSMFs, ConsDefault) {
-  using IV = TestFixture::IV;
-  using IV0 = TestFixture::IV0;
-
-  IV v;
-  EXPECT_EQ(v.size(), 0u);
-
-  IV0 v0;
-  EXPECT_EQ(v0.size(), 0u);
-
-  if constexpr (std::is_trivial_v<TypeParam>) {
-    constexpr IV cv;
-    static_assert(cv.size() == 0u);
-
-    constexpr IV0 cv0;
-    static_assert(cv0.size() == 0u);
-  }
-}
-
-// [containers.sequences.inplace.vector.cons]
-TYPED_TEST(InplaceVectorSMFs, ConsSize) {
-  using IV = TestFixture::IV;
-  using IV0 = TestFixture::IV0;
-  using T = TypeParam;
-
-  IV v(IV::capacity());
-  EXPECT_EQ(v.size(), IV::capacity());
-  for (auto const &elem : v) {
-    EXPECT_EQ(elem, T{});
-  }
-
-  IV0 v0(0u);
-  EXPECT_EQ(v0.size(), 0u);
-
-  if constexpr (false && /* TODO */ std::is_trivial_v<TypeParam>) {
-    constexpr IV cv(IV::capacity());
-    static_assert(IV::capacity());
-    constexpr auto default_inserted = [](IV const &v) {
-      for (auto const &elem : v) {
-        if (elem != T{}) {
-          return false;
-        }
-      }
-      return true;
-    };
-    static_assert(default_inserted(cv));
-
-    constexpr IV0 cv0(0);
-    static_assert(cv0.size() == 0u);
-  }
-
-  // [containers.sequences.inplace.vector.overview]
-  // 5. Any member function of inplace_vector<T, N> that would cause the size to
-  // exceed N throws an exception of type bad_alloc.
-  EXPECT_THROW(IV v(IV::capacity() + 1u), std::bad_alloc);
-  EXPECT_THROW(IV0 v0(1u), std::bad_alloc);
-}
-
-// [containers.sequences.inplace.vector.cons]
-TYPED_TEST(InplaceVectorSMFs, ConsSizeValue) {
-  using IV = TestFixture::IV;
-  using IV0 = TestFixture::IV0;
-  using T = TypeParam;
-
-  IV v(IV::capacity(), T{42});
-  // [sequence.reqmts]
-  EXPECT_EQ(static_cast<IV::size_type>(std::distance(v.begin(), v.end())),
-            IV::capacity());
-  for (auto const &elem : v) {
-    EXPECT_EQ(elem, T{42});
-  }
-
-  IV0 v0(0u, T{42});
-  EXPECT_EQ(v0.size(), 0u);
-
-  if constexpr (false && /* TODO */ std::is_trivial_v<TypeParam>) {
-    constexpr IV cv(IV::capacity(), T{42});
-    // [sequence.reqmts]
-    static_assert(std::distance(v.begin(), v.end()) == IV::capacity());
-    constexpr auto all_of = [](IV const &v, T const &x) {
-      for (auto const &elem : v) {
-        if (elem != x) {
-          return false;
-        }
-      }
-      return true;
-    };
-    static_assert(all_of(cv, T{42}));
-
-    constexpr IV0 cv0(0);
-    static_assert(cv0.size() == 0u);
-  }
-
-  // [containers.sequences.inplace.vector.overview]
-  // 5. Any member function of inplace_vector<T, N> that would cause the size to
-  // exceed N throws an exception of type bad_alloc.
-  EXPECT_THROW(IV v(IV::capacity() + 1u, T{5}), std::bad_alloc);
-  EXPECT_THROW(IV0 v0(1u, T{5}), std::bad_alloc);
-}
-
-// [containers.sequences.inplace.vector.cons]
-TYPED_TEST(InplaceVectorSMFs, ConsIterator) {
-  using IV = TestFixture::IV;
-  using IV0 = TestFixture::IV0;
-  using T = TypeParam;
-  using InputIterator = TestFixture::InputIterator;
-
-  constexpr auto first = InputIterator{T{0}};
-  constexpr auto last = InputIterator{T{5}};
-  IV v(first, last);
-  EXPECT_EQ(std::distance(v.begin(), v.end()), std::distance(first, last));
-  for (int i = 0; i < v.size(); ++i) {
-    EXPECT_EQ(v[i], T{i});
-  }
-
-  IV0 v0(first, first);
-  EXPECT_EQ(v0.size(), 0u);
-
-  if constexpr (false && /* TODO */ std::is_trivial_v<TypeParam>) {
-    constexpr IV cv(first, last);
-    static_assert(std::distance(cv.begin(), cv.end()) ==
-                  std::distance(first, last));
-    static_assert(cv[0] == T{0});
-    static_assert(cv[1] == T{1});
-    static_assert(cv[2] == T{2});
-    static_assert(cv[3] == T{3});
-    static_assert(cv[4] == T{4});
-
-    constexpr IV0 cv0(first, first);
-    static_assert(cv0.size() == 0u);
-  }
-
-  // [containers.sequences.inplace.vector.overview]
-  // 5. Any member function of inplace_vector<T, N> that would cause the size to
-  // exceed N throws an exception of type bad_alloc.
-  EXPECT_THROW(IV v(first, InputIterator{T{IV::capacity() + 1}}),
-               std::bad_alloc);
-  EXPECT_THROW(IV0 v0(first, last), std::bad_alloc);
-}
-
-// [containers.sequences.inplace.vector.cons]
-#if defined(__cpp_lib_containers_ranges)
-TYPED_TEST(InplaceVectorSMFs, ConsRange) {
-  using IV = TestFixture::IV;
-  using IV0 = TestFixture::IV0;
-  using T = TypeParam;
-  using Range = std::array<T, IV::capacity()>;
-  using Range0 = std::array<T, 0>;
-  using Range_too_large = std::array<T, IV::capacity() + 1>;
-
-  Range r;
-  r.fill(T{42});
-  IV v(std::from_range, r);
-  EXPECT_EQ(v.size(), r.size());
-  for (std::size_t idx = 0u; idx < v.size(); ++idx) {
-    EXPECT_EQ(v[idx], r[idx]);
-  }
-
-  constexpr Range0 const r0;
-  IV0 v0(std::from_range, r0);
-  EXPECT_EQ(v0.size(), 0u);
-
-  if constexpr (/*false && TODO */ std::is_trivial_v<TypeParam>) {
-    constexpr Range cr{42, 99, 3, 4, 7, 1024};
-    constexpr IV cv(std::from_range, r);
-    static_assert(v.size() == r.size());
-    constexpr auto range_equal = [](auto const &r1, auto const &r2) {
-      auto f1 = std::begin(r1);
-      auto f2 = std::begin(r2);
-      auto const l1 = std::end(r1);
-      auto const l2 = std::end(r2);
-      for (; f1 != l1 && f2 != l2; ++f1, ++f2) {
-        if (*f1 != *f2) {
-          return false;
-        }
-      }
-      return (f1 == l1) && (f2 == l2);
-    };
-    static_assert(range_equal(cv, r));
-
-    constexpr IV0 cv0(std::from_range, r0);
-    static_assert(cv0.size() == 0u);
-  }
-
-  // [containers.sequences.inplace.vector.overview]
-  // 5. Any member function of inplace_vector<T, N> that would cause the size to
-  // exceed N throws an exception of type bad_alloc.
-  EXPECT_THROW(IV v(std::from_range, Range_too_large{}), std::bad_alloc);
-  EXPECT_THROW(IV0 v0(std::from_range, r), std::bad_alloc);
-}
-#endif // defined(__cpp_lib_containers_ranges)
-
-// [sequence.reqmts]
-TYPED_TEST(InplaceVectorSMFs, ConsInitList) {
-  using IV = TestFixture::IV;
-  using IV0 = TestFixture::IV0;
-  using T = TypeParam;
-
-  std::initializer_list<T> const il = {T{0}, T{1}, T{2}, T{3}, T{4},
-                                       T{5}, T{6}, T{7}, T{8}, T{9}};
-  IV v(il);
-  EXPECT_EQ(std::distance(v.begin(), v.end()),
-            std::distance(il.begin(), il.end()));
-  for (std::size_t i = 0; i < v.size(); ++i) {
-    EXPECT_EQ(v[i], T(i));
-  }
-
-  constexpr std::initializer_list<T> il0 = {};
-  IV0 v0(il0);
-  EXPECT_EQ(v0.size(), 0u);
-
-  // [containers.sequences.inplace.vector.overview]
-  // 5. Any member function of inplace_vector<T, N> that would cause the size to
-  // exceed N throws an exception of type bad_alloc.
-  std::initializer_list<T> const il_too_large = {
-      T{0}, T{1}, T{2}, T{3}, T{4}, T{5}, T{6}, T{7}, T{8}, T{9}, T{10}};
-  EXPECT_THROW(IV v(il_too_large), std::bad_alloc);
-  EXPECT_THROW(IV0 v0(il), std::bad_alloc);
-}
-#endif
-
 } // namespace