fix non google-test tests

Author: wusatosi

tests/beman/inplace_vector/inplace_vector.test.cpp

@@ -6,8 +6,22 @@ using namespace beman;
 
 template <typename T> constexpr void test() {
   using vec = inplace_vector<T, 42>;
+#if !BEMAN_INPLACE_VECTOR_FREESTANDING_DELETED()
   vec range{T(1), T(1337), T(42), T(12), T(0), T(-1)};
   const vec const_range{T(0), T(42), T(1337), T(42), T(5), T(-42)};
+#else
+  vec range;
+  for (auto &ele : {T(1), T(1337), T(42), T(12), T(0), T(-1)}) {
+    range.unchecked_push_back(ele);
+  }
+
+  vec const_range_builder;
+  for (auto &ele : {T(0), T(42), T(1337), T(42), T(5), T(-42)}) {
+    const_range_builder.unchecked_push_back(ele);
+  }
+
+  const vec const_range = const_range_builder;
+#endif
 
   auto &&bracket = range[3];
   static_assert(std::is_same<decltype(bracket), typename vec::reference>::value,

tests/beman/inplace_vector/ref_impl.test.cpp

@@ -180,6 +180,7 @@ template <typename T, int N> struct vec {
   vec(std::initializer_list<T> /*il*/) {}
 };
 
+#if !BEMAN_INPLACE_VECTOR_FREESTANDING_DELETED()
 template <typename T, std::size_t N> constexpr void test_il_constructor() {
   auto v = [] {
     switch (N) {
@@ -240,6 +241,7 @@ template <typename T, std::size_t N> constexpr void test_il_assignment() {
                  std::bad_alloc);
   }
 }
+#endif
 
 template <typename T, std::size_t N> constexpr void test_default_constructor() {
   vector<T, N> v;
@@ -252,13 +254,20 @@ template <typename T, std::size_t N>
 constexpr void
 test_default_constructor_bounds_and_contiguous_iterators(std::size_t sz) {
   CHECK(sz <= N);
+#if !BEMAN_INPLACE_VECTOR_FREESTANDING_DELETED()
   vector<T, N> v(sz);
   CHECK(v.size() == sz);
   CHECK(v.max_size() == N);
   CHECK(v.capacity() == N);
   for (std::size_t i = 0; i != sz; ++i) {
     CHECK(v[i] == T{});
   }
+#else
+  vector<T, N> v;
+  for (auto i = 0; i < sz; ++i) {
+    v.unchecked_push_back(T{});
+  }
+#endif
   for (std::size_t i = 0; i < v.size(); ++i) { // contiguous
     CHECK(*(v.begin() + i) == *(std::addressof(*v.begin()) + i));
     CHECK(*(v.cbegin() + i) == *(std::addressof(*v.cbegin()) + i));
@@ -342,8 +351,10 @@ constexpr void test_constructor_input_iterators() {}
 #endif
 
 template <typename T, std::size_t N> constexpr bool test_all_() {
+#if !BEMAN_INPLACE_VECTOR_FREESTANDING_DELETED()
   test_il_constructor<T, N>();
   test_il_assignment<T, N>();
+#endif
   test_default_constructor<T, N>();
   for (size_t i = 0; i < N; ++i)
     test_default_constructor_bounds_and_contiguous_iterators<T, N>(i);
@@ -358,6 +369,19 @@ template <typename T, std::size_t N> void test_all() {
   test_all_<T, N>();
 }
 
+template <typename T>
+T construct_vec(std::initializer_list<typename T::value_type> il) {
+#if BEMAN_INPLACE_VECTOR_FREESTANDING_DELETED()
+  T vec;
+  for (auto &v : il) {
+    vec.unchecked_push_back(v);
+  }
+  return vec;
+#else
+  return T(il);
+#endif
+}
+
 int main() {
   { // storage
     using beman::details::inplace_vector::storage::non_trivial;
@@ -825,7 +849,7 @@ int main() {
 
   { // erase
     {
-      vector<int, 4> l1{1, 2, 3};
+      auto l1 = construct_vec<vector<int, 4>>({1, 2, 3});
       CHECK(l1.size() == 3);
       vector<int, 4>::const_iterator i = l1.begin();
       ++i;
@@ -850,37 +874,38 @@ int main() {
   { // erase iter iter
     using vec_t = vector<int, 5>;
     {
-      vec_t l1{1, 2, 3};
+      auto l1 = construct_vec<vec_t>({1, 2, 3});
       vec_t::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
       CHECK(l1.size() == 3);
       CHECK(std::distance(l1.cbegin(), l1.cend()) == 3);
       CHECK(i == l1.begin());
     }
     {
-      vec_t l1{1, 2, 3};
+      auto l1 = construct_vec<vec_t>({1, 2, 3});
       vec_t::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin()));
       CHECK(l1.size() == 2);
       CHECK(std::distance(l1.cbegin(), l1.cend()) == 2);
       CHECK(i == l1.begin());
-      CHECK(l1 == vec_t{2, 3});
+      CHECK(l1 == construct_vec<vec_t>({2, 3}));
     }
     {
-      vec_t l1{1, 2, 3};
+      auto l1 = construct_vec<vec_t>({1, 2, 3});
       vec_t::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 2));
       CHECK(l1.size() == 1);
       CHECK(std::distance(l1.cbegin(), l1.cend()) == 1);
       CHECK(i == l1.begin());
-      CHECK(l1 == vec_t{3});
+      CHECK(l1 == construct_vec<vec_t>({3}));
     }
     {
-      vec_t l1{1, 2, 3};
+      auto l1 = construct_vec<vec_t>({1, 2, 3});
       vec_t::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 3));
       CHECK(l1.empty());
       CHECK(std::distance(l1.cbegin(), l1.cend()) == 0);
       CHECK(i == l1.begin());
     }
     {
-      vector<vec_t, 3> outer{vec_t{1}, vec_t{1}};
+      auto outer = construct_vec<vector<vec_t, 3>>(
+          {construct_vec<vec_t>({1}), construct_vec<vec_t>({1})});
       outer.erase(outer.begin(), outer.begin());
       CHECK(outer.size() == 2);
       CHECK(outer[0].size() == 1);