Add no exceptions support for tests

20162026 · 20162026 · commit 4b951fcd2422 · 2025-05-20T00:01:18.000+03:00
diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml
@@ -55,6 +55,8 @@ jobs:
             args: "-DCMAKE_CXX_FLAGS=-fsanitize=thread"
           - description: "ASan"
             args: "-DCMAKE_CXX_FLAGS='-fsanitize=address -fsanitize=undefined'"
+          - description: "NoExcep"
+            args: "-DBEMAN_INPLACE_VECTOR_NO_EXCEPTIONS=on"
         include:
           - platform: ubuntu-24.04
             compiler:
diff --git a/tests/beman/inplace_vector/constructors.test.cpp b/tests/beman/inplace_vector/constructors.test.cpp
@@ -21,7 +21,7 @@ TYPED_TEST(Constructors, SizedDefault) {
 
   EXPECT_EQ(IV(0), IV{});
 
-  EXPECT_THROW(IV(IV::capacity() + 1), std::bad_alloc);
+  SAFE_EXPECT_THROW(IV(IV::capacity() + 1), std::bad_alloc);
 
   constexpr auto mid_size = std::midpoint(0ul, IV::capacity());
   IV mid(mid_size);
@@ -57,7 +57,7 @@ TYPED_TEST(Constructors, SizedValue) {
     IV device(0, value);
     EXPECT_EQ(device, IV{});
 
-    EXPECT_THROW(IV(IV::capacity() + 1, value), std::bad_alloc);
+    SAFE_EXPECT_THROW(IV(IV::capacity() + 1, value), std::bad_alloc);
   }
 
   if constexpr (IV::capacity() < 1u)
diff --git a/tests/beman/inplace_vector/container_requirements.test.cpp b/tests/beman/inplace_vector/container_requirements.test.cpp
@@ -626,7 +626,7 @@ TYPED_TEST(SequenceContainerRequirements, ConstructorInitializerList) {
   using T = TestFixture::T;
 
   if (IV::capacity() == 0) {
-    EXPECT_THROW(IV({T{20}}), std::bad_alloc);
+    SAFE_EXPECT_THROW(IV({T{20}}), std::bad_alloc);
     return;
   }
 
@@ -657,7 +657,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignInitializerList) {
 
   if (IV::capacity() == 0) {
     IV device;
-    EXPECT_THROW(device = {T{52}}, std::bad_alloc);
+    SAFE_EXPECT_THROW(device = {T{52}}, std::bad_alloc);
     return;
   }
 
@@ -787,7 +787,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignIterRange) {
     EXPECT_EQ(device, correct);
 
     std::array<T, IV::capacity() + 1> ref{};
-    EXPECT_THROW(device.assign(ref.begin(), ref.end()), std::bad_alloc);
+    SAFE_EXPECT_THROW(device.assign(ref.begin(), ref.end()), std::bad_alloc);
   }
 
   {
@@ -802,7 +802,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignIterRange) {
     // [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(
+    SAFE_EXPECT_THROW(
         device.assign(InputIterator{0}, InputIterator{IV::max_size() + 1}),
         std::bad_alloc);
   }
@@ -833,7 +833,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignRange) {
   std::array<T, IV::capacity() + 1> ref;
   std::copy(correct.begin(), correct.end(), ref.begin());
   ref.back() = T{5};
-  EXPECT_THROW(device.assign_range(ref), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.assign_range(ref), std::bad_alloc);
 }
 
 // a.assign(il)
@@ -846,7 +846,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignFuncInitializerList) {
   auto device = this->unique();
 
   if (device.capacity() == 0) {
-    EXPECT_THROW(device.assign({T{50}}), std::bad_alloc);
+    SAFE_EXPECT_THROW(device.assign({T{50}}), std::bad_alloc);
     return;
   }
 
@@ -916,7 +916,8 @@ TYPED_TEST(SequenceContainerRequirements, AssignMulti) {
   }
 
   device.clear();
-  EXPECT_THROW(device.assign(device.capacity() + 1, T{12}), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.assign(device.capacity() + 1, T{12}),
+                    std::bad_alloc);
 }
 
 // a.front()
@@ -1017,7 +1018,7 @@ TYPED_TEST(SequenceContainerRequirements, ElementAccessAt) {
     EXPECT_EQ(device.at(i), *(device.begin() + i));
   }
 
-  EXPECT_THROW(device.at(IV::capacity()), std::out_of_range);
+  SAFE_EXPECT_THROW(device.at(IV::capacity()), std::out_of_range);
 }
 
 }; // namespace
diff --git a/tests/beman/inplace_vector/gtest_setup.hpp b/tests/beman/inplace_vector/gtest_setup.hpp
@@ -392,3 +392,9 @@ template <typename Param> class IVBasicTest : public ::testing::Test {
 
 template <typename Param>
 std::size_t IVBasicTest<Param>::InputIterator::num_deref;
+
+#if BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS()
+#define SAFE_EXPECT_THROW(x, y) EXPECT_DEATH(x, ".*")
+#else
+#define SAFE_EXPECT_THROW(x, y) EXPECT_THROW(x, y)
+#endif
diff --git a/tests/beman/inplace_vector/inplace_vector.test.cpp b/tests/beman/inplace_vector/inplace_vector.test.cpp
@@ -65,6 +65,12 @@ template <typename T> constexpr void test() {
   assert(const_data == std::addressof(const_front));
 }
 
+#if BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS()
+int main() {
+  test<int>();
+  return 0;
+}
+#else
 void test_exceptions() {
   using vec = inplace_vector<int, 42>;
   {
@@ -86,8 +92,10 @@ void test_exceptions() {
     }
   }
 }
+
 int main() {
   test<int>();
   test_exceptions();
   return 0;
 }
+#endif
diff --git a/tests/beman/inplace_vector/modifiers.test.cpp b/tests/beman/inplace_vector/modifiers.test.cpp
@@ -42,10 +42,10 @@ TYPED_TEST(Modifiers, InsertSingleConstRef) {
   }
 
   T val{272};
-  EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);
   EXPECT_EQ(device, reference);
 
-  EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);
   EXPECT_EQ(device, reference);
 }
 
@@ -82,10 +82,10 @@ TYPED_TEST(Modifiers, InsertSingleRV) {
     }
   }
 
-  EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);
   EXPECT_EQ(device, reference);
 
-  EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);
   EXPECT_EQ(device, reference);
 }
 
@@ -121,10 +121,10 @@ TYPED_TEST(Modifiers, InsertEmplace) {
     }
   }
 
-  EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);
   EXPECT_EQ(device, reference);
 
-  EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);
   EXPECT_EQ(device, reference);
 }
 
@@ -161,7 +161,7 @@ TYPED_TEST(Modifiers, InsertMulti) {
   }
 
   EXPECT_NO_THROW(device.insert(device.begin(), 0, {2538}));
-  EXPECT_THROW(device.insert(device.begin(), 1, {2538}), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.insert(device.begin(), 1, {2538}), std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, InsertInitList) {
@@ -201,7 +201,7 @@ TYPED_TEST(Modifiers, InsertInitList) {
 
   auto full = this->unique();
   EXPECT_NO_THROW(full.insert(full.begin(), {}));
-  EXPECT_THROW(full.insert(full.begin(), {T{25}}), std::bad_alloc);
+  SAFE_EXPECT_THROW(full.insert(full.begin(), {T{25}}), std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, InsertRange) {
@@ -257,8 +257,9 @@ TYPED_TEST(Modifiers, InsertRange) {
   EXPECT_NO_THROW(device.insert_range(device.begin(), std::array<T, 0>{}));
   EXPECT_EQ(device, reference);
 
-  EXPECT_THROW(device.insert_range(device.begin(), std::array<T, 1>{T{25}}),
-               std::bad_alloc);
+  SAFE_EXPECT_THROW(
+      device.insert_range(device.begin(), std::array<T, 1>{T{25}}),
+      std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, InsertItrRange) {
@@ -315,7 +316,7 @@ TYPED_TEST(Modifiers, InsertItrRange) {
   EXPECT_EQ(device, reference);
 
   std::array<T, 1> single_array{T{25}};
-  EXPECT_THROW(
+  SAFE_EXPECT_THROW(
       device.insert(device.begin(), single_array.begin(), single_array.end()),
       std::bad_alloc);
 }
@@ -375,7 +376,7 @@ TYPED_TEST(Modifiers, PushBackConstRef) {
   }
 
   T val{0};
-  EXPECT_THROW(device.push_back(val), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.push_back(val), std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, PushBackRV) {
@@ -401,7 +402,7 @@ TYPED_TEST(Modifiers, PushBackRV) {
   }
 
   T val{0};
-  EXPECT_THROW(device.push_back(val), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.push_back(val), std::bad_alloc);
 }
 
 // TODO: Check if there's extra copies
@@ -427,7 +428,7 @@ TYPED_TEST(Modifiers, EmplaceBack) {
     EXPECT_EQ(device, IV(reference.begin(), reference.begin() + i + 1));
   }
 
-  EXPECT_THROW(device.emplace_back(0), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.emplace_back(0), std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, TryEmplaceBack) {
@@ -701,7 +702,7 @@ TYPED_TEST(Modifiers, ReserveNonEmpty) {
   device.reserve(device.capacity());
   EXPECT_EQ(device, reference);
 
-  EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, ReserveEmpty) {
@@ -723,7 +724,7 @@ TYPED_TEST(Modifiers, ReserveEmpty) {
   device.reserve(device.capacity());
   EXPECT_EQ(device, IV());
 
-  EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);
 }
 
 TYPED_TEST(Modifiers, ShrinkToFitNonEmpty) {
diff --git a/tests/beman/inplace_vector/ref_impl.test.cpp b/tests/beman/inplace_vector/ref_impl.test.cpp
@@ -42,6 +42,11 @@ static constexpr void __assert_failure(char const *__file, int __line,
           : ::__assert_failure(static_cast<const char *>(__FILE__), __LINE__,  \
                                "assertion failed: " #__VA_ARGS__))
 
+#if BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS()
+#define CHECK_THROWS(EXPR, EXCEPT)                                             \
+  do {                                                                         \
+  } while (0)
+#else
 #define CHECK_THROWS(EXPR, EXCEPT)                                             \
   if (auto e =                                                                 \
           [&] {                                                                \
@@ -58,6 +63,7 @@ static constexpr void __assert_failure(char const *__file, int __line,
     __assert_failure(static_cast<const char *>(__FILE__), __LINE__,            \
                      "expression failed to throw " #EXCEPT ": " #EXPR);        \
   }
+#endif
 
 template struct beman::details::inplace_vector::storage::zero_sized<int>;
 template struct beman::details::inplace_vector::storage::trivial<int, 10>;
diff --git a/tests/beman/inplace_vector/size_n_data.test.cpp b/tests/beman/inplace_vector/size_n_data.test.cpp
@@ -56,7 +56,7 @@ TYPED_TEST(SizeNCapacity, ResizeUp) {
 
   IV device;
 
-  EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);
   EXPECT_EQ(device, IV{});
 
   if (device.capacity() == 0)
@@ -86,7 +86,7 @@ TYPED_TEST(SizeNCapacity, ResizeUp) {
   }
 
   IV before_resize(device);
-  EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);
+  SAFE_EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);
   EXPECT_EQ(device, before_resize);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -626,7 +626,7 @@ TYPED_TEST(SequenceContainerRequirements, ConstructorInitializerList) {`
`626`	`626`	`using T = TestFixture::T;`
`627`	`627`
`628`	`628`	`if (IV::capacity() == 0) {`
`629`		`- EXPECT_THROW(IV({T{20}}), std::bad_alloc);`
	`629`	`+ SAFE_EXPECT_THROW(IV({T{20}}), std::bad_alloc);`
`630`	`630`	`return;`
`631`	`631`	`}`
`632`	`632`
`@@ -657,7 +657,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignInitializerList) {`
`657`	`657`
`658`	`658`	`if (IV::capacity() == 0) {`
`659`	`659`	`IV device;`
`660`		`- EXPECT_THROW(device = {T{52}}, std::bad_alloc);`
	`660`	`+ SAFE_EXPECT_THROW(device = {T{52}}, std::bad_alloc);`
`661`	`661`	`return;`
`662`	`662`	`}`
`663`	`663`
`@@ -787,7 +787,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignIterRange) {`
`787`	`787`	`EXPECT_EQ(device, correct);`
`788`	`788`
`789`	`789`	`std::array<T, IV::capacity() + 1> ref{};`
`790`		`- EXPECT_THROW(device.assign(ref.begin(), ref.end()), std::bad_alloc);`
	`790`	`+ SAFE_EXPECT_THROW(device.assign(ref.begin(), ref.end()), std::bad_alloc);`
`791`	`791`	`}`
`792`	`792`
`793`	`793`	`{`
`@@ -802,7 +802,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignIterRange) {`
`802`	`802`	`// [containers.sequences.inplace.vector.overview]`
`803`	`803`	`// 5. Any member function of inplace_vector<T, N> that would cause the size`
`804`	`804`	`// to exceed N throws an exception of type bad_alloc.`
`805`		`- EXPECT_THROW(`
	`805`	`+ SAFE_EXPECT_THROW(`
`806`	`806`	`device.assign(InputIterator{0}, InputIterator{IV::max_size() + 1}),`
`807`	`807`	`std::bad_alloc);`
`808`	`808`	`}`
`@@ -833,7 +833,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignRange) {`
`833`	`833`	`std::array<T, IV::capacity() + 1> ref;`
`834`	`834`	`std::copy(correct.begin(), correct.end(), ref.begin());`
`835`	`835`	`ref.back() = T{5};`
`836`		`- EXPECT_THROW(device.assign_range(ref), std::bad_alloc);`
	`836`	`+ SAFE_EXPECT_THROW(device.assign_range(ref), std::bad_alloc);`
`837`	`837`	`}`
`838`	`838`
`839`	`839`	`// a.assign(il)`
`@@ -846,7 +846,7 @@ TYPED_TEST(SequenceContainerRequirements, AssignFuncInitializerList) {`
`846`	`846`	`auto device = this->unique();`
`847`	`847`
`848`	`848`	`if (device.capacity() == 0) {`
`849`		`- EXPECT_THROW(device.assign({T{50}}), std::bad_alloc);`
	`849`	`+ SAFE_EXPECT_THROW(device.assign({T{50}}), std::bad_alloc);`
`850`	`850`	`return;`
`851`	`851`	`}`
`852`	`852`
`@@ -916,7 +916,8 @@ TYPED_TEST(SequenceContainerRequirements, AssignMulti) {`
`916`	`916`	`}`
`917`	`917`
`918`	`918`	`device.clear();`
`919`		`- EXPECT_THROW(device.assign(device.capacity() + 1, T{12}), std::bad_alloc);`
	`919`	`+ SAFE_EXPECT_THROW(device.assign(device.capacity() + 1, T{12}),`
	`920`	`+ std::bad_alloc);`
`920`	`921`	`}`
`921`	`922`
`922`	`923`	`// a.front()`
`@@ -1017,7 +1018,7 @@ TYPED_TEST(SequenceContainerRequirements, ElementAccessAt) {`
`1017`	`1018`	`EXPECT_EQ(device.at(i), *(device.begin() + i));`
`1018`	`1019`	`}`
`1019`	`1020`
`1020`		`- EXPECT_THROW(device.at(IV::capacity()), std::out_of_range);`
	`1021`	`+ SAFE_EXPECT_THROW(device.at(IV::capacity()), std::out_of_range);`
`1021`	`1022`	`}`
`1022`	`1023`
`1023`	`1024`	`}; // namespace`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,12 @@ template <typename T> constexpr void test() {`
`65`	`65`	`assert(const_data == std::addressof(const_front));`
`66`	`66`	`}`
`67`	`67`
	`68`	`+#if BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS()`
	`69`	`+int main() {`
	`70`	`+ test<int>();`
	`71`	`+ return 0;`
	`72`	`+}`
	`73`	`+#else`
`68`	`74`	`void test_exceptions() {`
`69`	`75`	`using vec = inplace_vector<int, 42>;`
`70`	`76`	`{`
`@@ -86,8 +92,10 @@ void test_exceptions() {`
`86`	`92`	`}`
`87`	`93`	`}`
`88`	`94`	`}`
	`95`	`+`
`89`	`96`	`int main() {`
`90`	`97`	`test<int>();`
`91`	`98`	`test_exceptions();`
`92`	`99`	`return 0;`
`93`	`100`	`}`
	`101`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -42,10 +42,10 @@ TYPED_TEST(Modifiers, InsertSingleConstRef) {`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`T val{272};`
`45`		`- EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);`
	`45`	`+ SAFE_EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);`
`46`	`46`	`EXPECT_EQ(device, reference);`
`47`	`47`
`48`		`- EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);`
	`48`	`+ SAFE_EXPECT_THROW(device.insert(device.begin(), val), std::bad_alloc);`
`49`	`49`	`EXPECT_EQ(device, reference);`
`50`	`50`	`}`
`51`	`51`
`@@ -82,10 +82,10 @@ TYPED_TEST(Modifiers, InsertSingleRV) {`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`- EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);`
	`85`	`+ SAFE_EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);`
`86`	`86`	`EXPECT_EQ(device, reference);`
`87`	`87`
`88`		`- EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);`
	`88`	`+ SAFE_EXPECT_THROW(device.insert(device.begin(), T{272}), std::bad_alloc);`
`89`	`89`	`EXPECT_EQ(device, reference);`
`90`	`90`	`}`
`91`	`91`
`@@ -121,10 +121,10 @@ TYPED_TEST(Modifiers, InsertEmplace) {`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`- EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);`
	`124`	`+ SAFE_EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);`
`125`	`125`	`EXPECT_EQ(device, reference);`
`126`	`126`
`127`		`- EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);`
	`127`	`+ SAFE_EXPECT_THROW(device.emplace(device.begin(), 272), std::bad_alloc);`
`128`	`128`	`EXPECT_EQ(device, reference);`
`129`	`129`	`}`
`130`	`130`
`@@ -161,7 +161,7 @@ TYPED_TEST(Modifiers, InsertMulti) {`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`EXPECT_NO_THROW(device.insert(device.begin(), 0, {2538}));`
`164`		`- EXPECT_THROW(device.insert(device.begin(), 1, {2538}), std::bad_alloc);`
	`164`	`+ SAFE_EXPECT_THROW(device.insert(device.begin(), 1, {2538}), std::bad_alloc);`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`TYPED_TEST(Modifiers, InsertInitList) {`
`@@ -201,7 +201,7 @@ TYPED_TEST(Modifiers, InsertInitList) {`
`201`	`201`
`202`	`202`	`auto full = this->unique();`
`203`	`203`	`EXPECT_NO_THROW(full.insert(full.begin(), {}));`
`204`		`- EXPECT_THROW(full.insert(full.begin(), {T{25}}), std::bad_alloc);`
	`204`	`+ SAFE_EXPECT_THROW(full.insert(full.begin(), {T{25}}), std::bad_alloc);`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`TYPED_TEST(Modifiers, InsertRange) {`
`@@ -257,8 +257,9 @@ TYPED_TEST(Modifiers, InsertRange) {`
`257`	`257`	`EXPECT_NO_THROW(device.insert_range(device.begin(), std::array<T, 0>{}));`
`258`	`258`	`EXPECT_EQ(device, reference);`
`259`	`259`
`260`		`- EXPECT_THROW(device.insert_range(device.begin(), std::array<T, 1>{T{25}}),`
`261`		`- std::bad_alloc);`
	`260`	`+ SAFE_EXPECT_THROW(`
	`261`	`+ device.insert_range(device.begin(), std::array<T, 1>{T{25}}),`
	`262`	`+ std::bad_alloc);`
`262`	`263`	`}`
`263`	`264`
`264`	`265`	`TYPED_TEST(Modifiers, InsertItrRange) {`
`@@ -315,7 +316,7 @@ TYPED_TEST(Modifiers, InsertItrRange) {`
`315`	`316`	`EXPECT_EQ(device, reference);`
`316`	`317`
`317`	`318`	`std::array<T, 1> single_array{T{25}};`
`318`		`- EXPECT_THROW(`
	`319`	`+ SAFE_EXPECT_THROW(`
`319`	`320`	`device.insert(device.begin(), single_array.begin(), single_array.end()),`
`320`	`321`	`std::bad_alloc);`
`321`	`322`	`}`
`@@ -375,7 +376,7 @@ TYPED_TEST(Modifiers, PushBackConstRef) {`
`375`	`376`	`}`
`376`	`377`
`377`	`378`	`T val{0};`
`378`		`- EXPECT_THROW(device.push_back(val), std::bad_alloc);`
	`379`	`+ SAFE_EXPECT_THROW(device.push_back(val), std::bad_alloc);`
`379`	`380`	`}`
`380`	`381`
`381`	`382`	`TYPED_TEST(Modifiers, PushBackRV) {`
`@@ -401,7 +402,7 @@ TYPED_TEST(Modifiers, PushBackRV) {`
`401`	`402`	`}`
`402`	`403`
`403`	`404`	`T val{0};`
`404`		`- EXPECT_THROW(device.push_back(val), std::bad_alloc);`
	`405`	`+ SAFE_EXPECT_THROW(device.push_back(val), std::bad_alloc);`
`405`	`406`	`}`
`406`	`407`
`407`	`408`	`// TODO: Check if there's extra copies`
`@@ -427,7 +428,7 @@ TYPED_TEST(Modifiers, EmplaceBack) {`
`427`	`428`	`EXPECT_EQ(device, IV(reference.begin(), reference.begin() + i + 1));`
`428`	`429`	`}`
`429`	`430`
`430`		`- EXPECT_THROW(device.emplace_back(0), std::bad_alloc);`
	`431`	`+ SAFE_EXPECT_THROW(device.emplace_back(0), std::bad_alloc);`
`431`	`432`	`}`
`432`	`433`
`433`	`434`	`TYPED_TEST(Modifiers, TryEmplaceBack) {`
`@@ -701,7 +702,7 @@ TYPED_TEST(Modifiers, ReserveNonEmpty) {`
`701`	`702`	`device.reserve(device.capacity());`
`702`	`703`	`EXPECT_EQ(device, reference);`
`703`	`704`
`704`		`- EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);`
	`705`	`+ SAFE_EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);`
`705`	`706`	`}`
`706`	`707`
`707`	`708`	`TYPED_TEST(Modifiers, ReserveEmpty) {`
`@@ -723,7 +724,7 @@ TYPED_TEST(Modifiers, ReserveEmpty) {`
`723`	`724`	`device.reserve(device.capacity());`
`724`	`725`	`EXPECT_EQ(device, IV());`
`725`	`726`
`726`		`- EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);`
	`727`	`+ SAFE_EXPECT_THROW(device.reserve(device.capacity() + 1), std::bad_alloc);`
`727`	`728`	`}`
`728`	`729`
`729`	`730`	`TYPED_TEST(Modifiers, ShrinkToFitNonEmpty) {`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ TYPED_TEST(SizeNCapacity, ResizeUp) {`
`56`	`56`
`57`	`57`	`IV device;`
`58`	`58`
`59`		`- EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);`
	`59`	`+ SAFE_EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);`
`60`	`60`	`EXPECT_EQ(device, IV{});`
`61`	`61`
`62`	`62`	`if (device.capacity() == 0)`
`@@ -86,7 +86,7 @@ TYPED_TEST(SizeNCapacity, ResizeUp) {`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`IV before_resize(device);`
`89`		`- EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);`
	`89`	`+ SAFE_EXPECT_THROW(device.resize(device.capacity() + 1), std::bad_alloc);`
`90`	`90`	`EXPECT_EQ(device, before_resize);`
`91`	`91`	`}`
`92`	`92`