From 3b9a4b7cfe494070876e8eb9b3c12171396ab6bd Mon Sep 17 00:00:00 2001 From: Arthur O'Dwyer Date: Wed, 18 Oct 2023 13:12:47 -0400 Subject: [PATCH] [test] Further GTest-ize the whole test suite. Use `EXPECT_EQ` in place of `assert`, so that the test suite can be built (and actually test anything) even in release mode. No change in test coverage intended. --- test/flat_map_test.cpp | 300 ++++++++++++++++----------------- test/flat_set_test.cpp | 92 +++++----- test/hive_test.cpp | 2 +- test/inplace_function_test.cpp | 68 ++++---- test/ring_span_test.cpp | 38 ++--- test/slot_map_test.cpp | 150 ++++++++--------- test/uninitialized_test.cpp | 8 +- 7 files changed, 329 insertions(+), 329 deletions(-) diff --git a/test/flat_map_test.cpp b/test/flat_map_test.cpp index 92a2e0c..64ab069 100644 --- a/test/flat_map_test.cpp +++ b/test/flat_map_test.cpp @@ -59,13 +59,13 @@ TEST(flat_map, AmbiguousErase) fs.emplace("a", 1); fs.emplace("b", 2); fs.emplace("c", 3); - assert(fs.size() == 3); + EXPECT_TRUE(fs.size() == 3); fs.erase(AmbiguousEraseWidget("a")); // calls erase(const Key&) - assert(fs.size() == 2); + EXPECT_TRUE(fs.size() == 2); fs.erase(fs.begin()); // calls erase(iterator) - assert(fs.size() == 1); + EXPECT_TRUE(fs.size() == 1); fs.erase(fs.cbegin()); // calls erase(const_iterator) - assert(fs.size() == 0); + EXPECT_TRUE(fs.size() == 0); } TEST(flat_map, ExtractDoesntSwap) @@ -77,8 +77,8 @@ TEST(flat_map, ExtractDoesntSwap) std::pmr::polymorphic_allocator a(&mr); sg14::flat_map, std::pmr::vector, std::pmr::vector> fs({{1, 10}, {2, 20}}, a); auto ctrs = std::move(fs).extract(); - assert(ctrs.keys.get_allocator() == a); - assert(ctrs.values.get_allocator() == a); + EXPECT_TRUE(ctrs.keys.get_allocator() == a); + EXPECT_TRUE(ctrs.values.get_allocator() == a); } #endif @@ -87,8 +87,8 @@ TEST(flat_map, ExtractDoesntSwap) std::allocator a; sg14::flat_map, std::vector, std::vector> fs({{1, 10}, {2, 20}}, a); auto ctrs = std::move(fs).extract(); - assert(ctrs.keys.get_allocator() == a); - assert(ctrs.values.get_allocator() == a); + EXPECT_TRUE(ctrs.keys.get_allocator() == a); + EXPECT_TRUE(ctrs.values.get_allocator() == a); } } @@ -128,34 +128,34 @@ TEST(flat_map, MoveOperationsPilferOwnership) InstrumentedWidget::copy_ctors = 0; FS fs; fs.insert(std::make_pair(InstrumentedWidget("abc"), 1)); - assert(InstrumentedWidget::move_ctors == 3); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 3); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); fs.emplace(InstrumentedWidget("def"), 1); fs.erase("def"); // poor man's reserve() InstrumentedWidget::copy_ctors = 0; InstrumentedWidget::move_ctors = 0; fs.emplace("def", 1); // is still not directly emplaced; a temporary is created to find() - assert(InstrumentedWidget::move_ctors == 1); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 1); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); InstrumentedWidget::move_ctors = 0; FS fs2 = std::move(fs); // should just transfer buffer ownership - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); fs = std::move(fs2); // should just transfer buffer ownership - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); FS fs3(fs, std::allocator()); - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 2); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 2); InstrumentedWidget::copy_ctors = 0; FS fs4(std::move(fs), std::allocator()); // should just transfer buffer ownership - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); } TEST(flat_map, SortedUniqueConstruction) @@ -171,7 +171,7 @@ TEST(flat_map, SortedUniqueConstruction) bool test(sg14::sorted_unique_t) { return false; } }; explicitness_tester tester; - assert(tester.test({}) == true); + EXPECT_TRUE(tester.test({}) == true); #endif } @@ -183,53 +183,53 @@ TEST(flat_map, TryEmplace) // try_emplace for a non-existent key does move-from. InstrumentedWidget w("abc"); pair = fm.try_emplace(1, std::move(w)); - assert(w.is_moved_from); - assert(pair.second); + EXPECT_TRUE(w.is_moved_from); + EXPECT_TRUE(pair.second); } if (true) { // try_emplace over an existing key is a no-op. InstrumentedWidget w("def"); pair = fm.try_emplace(1, std::move(w)); - assert(!w.is_moved_from); - assert(!pair.second); - assert(pair.first->first == 1); - assert(pair.first->second.str() == "abc"); + EXPECT_TRUE(!w.is_moved_from); + EXPECT_TRUE(!pair.second); + EXPECT_TRUE(pair.first->first == 1); + EXPECT_TRUE(pair.first->second.str() == "abc"); } if (true) { // emplace for a non-existent key does move-from. InstrumentedWidget w("abc"); pair = fm.emplace(2, std::move(w)); - assert(w.is_moved_from); - assert(pair.second); - assert(pair.first->first == 2); - assert(pair.first->second.str() == "abc"); + EXPECT_TRUE(w.is_moved_from); + EXPECT_TRUE(pair.second); + EXPECT_TRUE(pair.first->first == 2); + EXPECT_TRUE(pair.first->second.str() == "abc"); } if (true) { // emplace over an existing key is a no-op, but does move-from in order to construct the pair. InstrumentedWidget w("def"); pair = fm.emplace(2, std::move(w)); - assert(w.is_moved_from); - assert(!pair.second); - assert(pair.first->first == 2); - assert(pair.first->second.str() == "abc"); + EXPECT_TRUE(w.is_moved_from); + EXPECT_TRUE(!pair.second); + EXPECT_TRUE(pair.first->first == 2); + EXPECT_TRUE(pair.first->second.str() == "abc"); } if (true) { // insert-or-assign for a non-existent key does move-construct. InstrumentedWidget w("abc"); pair = fm.insert_or_assign(3, std::move(w)); - assert(w.is_moved_from); - assert(pair.second); - assert(pair.first->first == 3); - assert(pair.first->second.str() == "abc"); + EXPECT_TRUE(w.is_moved_from); + EXPECT_TRUE(pair.second); + EXPECT_TRUE(pair.first->first == 3); + EXPECT_TRUE(pair.first->second.str() == "abc"); } if (true) { // insert-or-assign over an existing key does a move-assign. InstrumentedWidget w("def"); pair = fm.insert_or_assign(3, std::move(w)); - assert(w.is_moved_from); - assert(!pair.second); - assert(pair.first->first == 3); - assert(pair.first->second.str() == "def"); + EXPECT_TRUE(w.is_moved_from); + EXPECT_TRUE(!pair.second); + EXPECT_TRUE(pair.first->first == 3); + EXPECT_TRUE(pair.first->second.str() == "def"); } } @@ -238,34 +238,34 @@ TEST(flat_map, VectorBool) using FM = sg14::flat_map; FM fm; auto it_inserted = fm.emplace(true, false); - assert(it_inserted.second); + EXPECT_TRUE(it_inserted.second); auto it = it_inserted.first; - assert(it == fm.begin()); - assert(it->first == true); assert(it->first); - assert(it->second == false); assert(!it->second); + EXPECT_TRUE(it == fm.begin()); + EXPECT_TRUE(it->first == true); EXPECT_TRUE(it->first); + EXPECT_TRUE(it->second == false); EXPECT_TRUE(!it->second); it->second = false; - assert(fm.size() == 1); + EXPECT_TRUE(fm.size() == 1); it = fm.emplace_hint(it, false, true); - assert(it == fm.begin()); - assert(it->first == false); assert(!it->first); - assert(it->second == true); assert(it->second); + EXPECT_TRUE(it == fm.begin()); + EXPECT_TRUE(it->first == false); EXPECT_TRUE(!it->first); + EXPECT_TRUE(it->second == true); EXPECT_TRUE(it->second); it->second = true; - assert(fm.size() == 2); + EXPECT_TRUE(fm.size() == 2); auto count = fm.erase(false); - assert(count == 1); - assert(fm.size() == 1); + EXPECT_EQ(count, 1u); + EXPECT_EQ(fm.size(), 1u); it = fm.erase(fm.begin()); - assert(fm.empty()); - assert(it == fm.begin()); - assert(it == fm.end()); + EXPECT_TRUE(fm.empty()); + EXPECT_EQ(it, fm.begin()); + EXPECT_EQ(it, fm.end()); - assert(fm.find(true) == fm.end()); + EXPECT_EQ(fm.find(true), fm.end()); fm.try_emplace(true, true); - assert(fm.find(true) != fm.end()); - assert(fm[true] == true); + EXPECT_NE(fm.find(true), fm.end()); + EXPECT_EQ(fm[true], true); fm[true] = false; - assert(fm.find(true) != fm.end()); - assert(fm[true] == false); + EXPECT_NE(fm.find(true), fm.end()); + EXPECT_EQ(fm[true], false); fm.clear(); } @@ -312,8 +312,8 @@ TEST(flat_map, DeductionGuides) std::initializer_list> il = {{1,"c"}, {5,"b"}, {3,"a"}}; flat_map fm5(il); static_assert(std::is_same_v>); - assert(fm5.size() == 3); - assert(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}) )); + EXPECT_EQ(fm5.size(), 3); + EXPECT_EQ(fm5, decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}})); } if (true) { // flat_map(KeyContainer, MappedContainer) @@ -321,10 +321,10 @@ TEST(flat_map, DeductionGuides) std::vector vs {"a","b"}; flat_map fm1(vi, vs); static_assert(std::is_same_v>); - assert(( fm1 == flat_map(sg14::sorted_unique, {{1,"b"}, {2,"a"}}) )); + EXPECT_EQ(fm1, (flat_map(sg14::sorted_unique, {{1,"b"}, {2,"a"}}))); flat_map fm2(std::move(vs), std::move(vi)); static_assert(std::is_same_v>); - assert(( fm2 == flat_map(sg14::sorted_unique, {{"a",2}, {"b",1}}) )); + EXPECT_EQ(fm2, (flat_map(sg14::sorted_unique, {{"a",2}, {"b",1}}))); } if (true) { // flat_map(Container, Allocator) @@ -344,13 +344,13 @@ TEST(flat_map, DeductionGuides) std::vector vs {"a","b"}; flat_map fm1(vi, vs, std::allocator()); static_assert(std::is_same_v>); - assert(( fm1 == decltype(fm1)(sg14::sorted_unique, {{1,"b"}, {2,"a"}}) )); + EXPECT_EQ(fm1, (decltype(fm1)(sg14::sorted_unique, {{1,"b"}, {2,"a"}}))); #if __cpp_lib_memory_resource >= 201603 std::pmr::vector pvi {2,1}; std::pmr::vector pvs {"a","b"}; flat_map fm2(pvi, pvs, std::pmr::polymorphic_allocator()); static_assert(std::is_same_v, std::pmr::vector, std::pmr::vector>>); - assert(( fm2 == decltype(fm2)(sg14::sorted_unique, {{1,"b"}, {2,"a"}}) )); + EXPECT_EQ(fm2, (decltype(fm2)(sg14::sorted_unique, {{1,"b"}, {2,"a"}}))); #endif } if (true) { @@ -371,7 +371,7 @@ TEST(flat_map, DeductionGuides) std::initializer_list> il = {{1,"c"}, {3,"b"}, {5,"a"}}; flat_map fm5(sg14::sorted_unique, il); static_assert(std::is_same_v>); - assert(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"b"}, {5,"a"}}) )); + EXPECT_EQ(fm5, (decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"b"}, {5,"a"}}))); } if (true) { // flat_map(sorted_unique_t, KeyContainer, MappedContainer) @@ -379,10 +379,10 @@ TEST(flat_map, DeductionGuides) std::vector vs {"a","b"}; flat_map fm1(sg14::sorted_unique, vi, vs); static_assert(std::is_same_v>); - assert(( fm1 == decltype(fm1)(sg14::sorted_unique, {{1,"a"}, {2,"b"}}) )); + EXPECT_EQ(fm1, decltype(fm1)(sg14::sorted_unique, {{1,"a"}, {2,"b"}})); flat_map fm2(sg14::sorted_unique, std::move(vs), std::move(vi)); static_assert(std::is_same_v>); - assert(( fm2 == decltype(fm2)(sg14::sorted_unique, {{"a",1}, {"b",2}}) )); + EXPECT_EQ(fm2, decltype(fm2)(sg14::sorted_unique, {{"a",1}, {"b",2}})); } if (true) { // flat_map(sorted_unique_t, Container, Allocator) @@ -402,13 +402,13 @@ TEST(flat_map, DeductionGuides) std::vector vs {"a","b"}; flat_map fm1(sg14::sorted_unique, vs, vi, std::allocator()); static_assert(std::is_same_v>); - assert(( fm1 == decltype(fm1)(sg14::sorted_unique, {{"a",2}, {"b",1}}) )); + EXPECT_EQ(fm1, decltype(fm1)(sg14::sorted_unique, {{"a",2}, {"b",1}})); #if __cpp_lib_memory_resource >= 201603 std::pmr::vector pvi {1, 2}; std::pmr::vector pvs {"b","a"}; flat_map fm2(sg14::sorted_unique, pvi, pvs, std::pmr::polymorphic_allocator()); static_assert(std::is_same_v, std::pmr::vector, std::pmr::vector>>); - assert(( fm2 == decltype(fm2)(sg14::sorted_unique, {{1,"b"}, {2,"a"}}) )); + EXPECT_EQ(fm2, decltype(fm2)(sg14::sorted_unique, {{1,"b"}, {2,"a"}})); #endif } if (true) { @@ -427,7 +427,7 @@ TEST(flat_map, DeductionGuides) std::initializer_list> il = {{1,"c"}, {5,"b"}, {3,"a"}}; flat_map fm5(il.begin(), il.end()); static_assert(std::is_same_v>); - assert(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}) )); + EXPECT_EQ(fm5, decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}})); } if (true) { // flat_map(InputIterator, InputIterator, Compare = Compare()) @@ -437,11 +437,11 @@ TEST(flat_map, DeductionGuides) int x = 3; std::pair arr[] = {{1,2}, {2,3}, {3,4}, {4,5}}; flat_map fm2(arr, arr + 4, [&x](int a, int b){ return (a % x) < (b % x); }); - assert(fm2.key_comp()(2, 4) == false); + EXPECT_FALSE(fm2.key_comp()(2, 4)); x = 10; - assert(fm2.key_comp()(2, 4) == true); + EXPECT_TRUE(fm2.key_comp()(2, 4)); x = 3; - assert(fm2.begin()[0].first == 3); + EXPECT_EQ(fm2.begin()[0].first, 3); std::list> lst; flat_map fm3(lst.begin(), lst.end(), std::greater<>()); static_assert(std::is_same_v>>); @@ -453,12 +453,12 @@ TEST(flat_map, DeductionGuides) std::initializer_list> il = {{1,"c"}, {5,"b"}, {3,"a"}}; flat_map fm5(il.begin(), il.end(), std::less()); static_assert(std::is_same_v>); - assert(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}) )); + EXPECT_EQ(fm5, decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}})); flat_map fm6(arr, arr + 4, free_function_less); static_assert(std::is_same_v>); - assert(fm6.key_comp() == free_function_less); - assert(( fm6 == decltype(fm6)(sg14::sorted_unique, {{1,2}, {2,3}, {3,4}, {4,5}}, free_function_less) )); + EXPECT_EQ(fm6.key_comp(), free_function_less); + EXPECT_EQ(fm6, decltype(fm6)(sg14::sorted_unique, {{1,2}, {2,3}, {3,4}, {4,5}}, free_function_less)); } if (true) { // flat_map(InputIterator, InputIterator, Compare, Allocator) @@ -468,11 +468,11 @@ TEST(flat_map, DeductionGuides) int x = 3; std::pair arr[] = {{1,2}, {2,3}, {3,4}, {4,5}}; flat_map fm2(arr, arr + 4, [&x](int a, int b){ return (a % x) < (b % x); }, std::allocator()); - assert(fm2.key_comp()(2, 4) == false); + EXPECT_FALSE(fm2.key_comp()(2, 4)); x = 10; - assert(fm2.key_comp()(2, 4) == true); + EXPECT_TRUE(fm2.key_comp()(2, 4)); x = 3; - assert(fm2.begin()[0].first == 3); + EXPECT_EQ(fm2.begin()[0].first, 3); std::list> lst; flat_map fm3(lst.begin(), lst.end(), std::greater<>(), std::allocator()); static_assert(std::is_same_v>>); @@ -480,17 +480,17 @@ TEST(flat_map, DeductionGuides) std::pmr::vector> pv; flat_map fm4(pv.begin(), pv.end(), std::greater<>(), std::allocator()); static_assert(std::is_same_v>>); - assert(!flatmap_is_ctadable_from(0, pv.begin(), pv.end(), std::greater(), std::pmr::polymorphic_allocator())); + EXPECT_TRUE(!flatmap_is_ctadable_from(0, pv.begin(), pv.end(), std::greater(), std::pmr::polymorphic_allocator())); #endif std::initializer_list> il = {{1,"c"}, {5,"b"}, {3,"a"}}; flat_map fm5(il.begin(), il.end(), std::less(), std::allocator()); static_assert(std::is_same_v>); - assert(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}) )); + EXPECT_TRUE(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}) )); flat_map fm6(arr, arr + 4, free_function_less, std::allocator()); static_assert(std::is_same_v>); - assert(fm6.key_comp() == free_function_less); - assert(( fm6 == decltype(fm6)(sg14::sorted_unique, {{1,2}, {2,3}, {3,4}, {4,5}}, free_function_less) )); + EXPECT_TRUE(fm6.key_comp() == free_function_less); + EXPECT_TRUE(( fm6 == decltype(fm6)(sg14::sorted_unique, {{1,2}, {2,3}, {3,4}, {4,5}}, free_function_less) )); } if (true) { // flat_map(InputIterator, InputIterator, Allocator) @@ -548,11 +548,11 @@ TYPED_TEST(flat_mapt, Construction) {3, "c"}, {5, "b"}, }; - assert(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp())); - assert(std::is_sorted(fs.begin(), fs.end(), fs.value_comp())); - assert(fs[1] == Str("a")); - assert(fs[3] == Str("c")); - assert(fs[5] == Str("b")); + EXPECT_TRUE(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp())); + EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), fs.value_comp())); + EXPECT_TRUE(fs[1] == Str("a")); + EXPECT_TRUE(fs[3] == Str("c")); + EXPECT_TRUE(fs[5] == Str("b")); } for (auto&& fs : { FS({{1, "a"}, {3, "c"}, {5, "b"}}), @@ -563,18 +563,18 @@ TYPED_TEST(flat_mapt, Construction) FS(pairs.begin(), pairs.end(), Compare()), FS(pairs.rbegin(), pairs.rend(), Compare()), }) { - assert(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp())); - assert(std::is_sorted(fs.begin(), fs.end(), fs.value_comp())); - assert(fs.find(0) == fs.end()); - assert(fs.find(1) != fs.end()); - assert(fs.find(2) == fs.end()); - assert(fs.find(3) != fs.end()); - assert(fs.find(4) == fs.end()); - assert(fs.find(5) != fs.end()); - assert(fs.find(6) == fs.end()); - assert(fs.at(1) == Str("a")); - assert(fs.at(3) == Str("c")); - assert(fs.find(5)->second == Str("b")); + EXPECT_TRUE(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp())); + EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), fs.value_comp())); + EXPECT_TRUE(fs.find(0) == fs.end()); + EXPECT_TRUE(fs.find(1) != fs.end()); + EXPECT_TRUE(fs.find(2) == fs.end()); + EXPECT_TRUE(fs.find(3) != fs.end()); + EXPECT_TRUE(fs.find(4) == fs.end()); + EXPECT_TRUE(fs.find(5) != fs.end()); + EXPECT_TRUE(fs.find(6) == fs.end()); + EXPECT_TRUE(fs.at(1) == Str("a")); + EXPECT_TRUE(fs.at(3) == Str("c")); + EXPECT_TRUE(fs.find(5)->second == Str("b")); } if (std::is_sorted(keys.begin(), keys.end(), Compare())) { for (auto&& fs : { @@ -585,11 +585,11 @@ TYPED_TEST(flat_mapt, Construction) FS(sg14::sorted_unique, pairs.begin(), pairs.end(), Compare()), FS(sg14::sorted_unique, {{1, "a"}, {3, "c"}, {5, "b"}}, Compare()), }) { - assert(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp())); - assert(std::is_sorted(fs.begin(), fs.end(), fs.value_comp())); - assert(fs.at(1) == Str("a")); - assert(fs.at(3) == Str("c")); - assert(fs.find(5)->second == Str("b")); + EXPECT_TRUE(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp())); + EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), fs.value_comp())); + EXPECT_TRUE(fs.at(1) == Str("a")); + EXPECT_TRUE(fs.at(3) == Str("c")); + EXPECT_TRUE(fs.find(5)->second == Str("b")); } } } @@ -604,31 +604,31 @@ TYPED_TEST(flat_mapt, InsertOrAssign) using Str = std::conditional_t::value, std::string, Mapped>; fm.insert_or_assign(1, str); - assert(fm.at(1) == Str("a")); - assert(fm[1] == Str("a")); + EXPECT_TRUE(fm.at(1) == Str("a")); + EXPECT_TRUE(fm[1] == Str("a")); fm.insert_or_assign(2, std::move(str)); - assert(fm.at(2) == Str("a")); - assert(fm[2] == Str("a")); + EXPECT_TRUE(fm.at(2) == Str("a")); + EXPECT_TRUE(fm[2] == Str("a")); fm.insert_or_assign(2, "b"); - assert(fm.at(2) == Str("b")); - assert(fm[2] == Str("b")); + EXPECT_TRUE(fm.at(2) == Str("b")); + EXPECT_TRUE(fm[2] == Str("b")); fm.insert_or_assign(3, "c"); - assert(fm.at(3) == Str("c")); - assert(fm[3] == Str("c")); + EXPECT_TRUE(fm.at(3) == Str("c")); + EXPECT_TRUE(fm[3] == Str("c")); // With hints. fm.insert_or_assign(fm.begin(), 1, str); - assert(fm.at(1) == Str("a")); - assert(fm[1] == Str("a")); + EXPECT_TRUE(fm.at(1) == Str("a")); + EXPECT_TRUE(fm[1] == Str("a")); fm.insert_or_assign(fm.begin()+2, 2, std::move(str)); - assert(fm.at(2) == Str("a")); - assert(fm[2] == Str("a")); + EXPECT_TRUE(fm.at(2) == Str("a")); + EXPECT_TRUE(fm[2] == Str("a")); fm.insert_or_assign(fm.end(), 2, "c"); - assert(fm.at(2) == Str("c")); - assert(fm[2] == Str("c")); + EXPECT_TRUE(fm.at(2) == Str("c")); + EXPECT_TRUE(fm[2] == Str("c")); fm.insert_or_assign(fm.end() - 1, 3, "b"); - assert(fm.at(3) == Str("b")); - assert(fm[3] == Str("b")); + EXPECT_TRUE(fm.at(3) == Str("b")); + EXPECT_TRUE(fm[3] == Str("b")); } TYPED_TEST(flat_mapt, SpecialMembers) @@ -662,31 +662,31 @@ TYPED_TEST(flat_mapt, ComparisonOperators) {1, abc[2]}, {2, abc[3]}, }; // {1b, 2c} is equal to {1b, 2c}. - assert(fm1 == fm2); - assert(!(fm1 != fm2)); - assert(!(fm1 < fm2)); - assert(!(fm1 > fm2)); - assert(fm1 <= fm2); - assert(fm1 >= fm2); + EXPECT_TRUE(fm1 == fm2); + EXPECT_TRUE(!(fm1 != fm2)); + EXPECT_TRUE(!(fm1 < fm2)); + EXPECT_TRUE(!(fm1 > fm2)); + EXPECT_TRUE(fm1 <= fm2); + EXPECT_TRUE(fm1 >= fm2); fm2[2] = abc[1]; // {1b, 2c} is greater than {1b, 2a}. - assert(!(fm1 == fm2)); - assert(fm1 != fm2); - assert(!(fm1 < fm2)); - assert(fm1 > fm2); - assert(!(fm1 <= fm2)); - assert(fm1 >= fm2); + EXPECT_TRUE(!(fm1 == fm2)); + EXPECT_TRUE(fm1 != fm2); + EXPECT_TRUE(!(fm1 < fm2)); + EXPECT_TRUE(fm1 > fm2); + EXPECT_TRUE(!(fm1 <= fm2)); + EXPECT_TRUE(fm1 >= fm2); fm2.erase(2); fm2.insert({0, abc[3]}); // {1b, 2c} is greater than {0c, 1b}. - assert(!(fm1 == fm2)); - assert(fm1 != fm2); - assert(!(fm1 < fm2)); - assert(fm1 > fm2); - assert(!(fm1 <= fm2)); - assert(fm1 >= fm2); + EXPECT_TRUE(!(fm1 == fm2)); + EXPECT_TRUE(fm1 != fm2); + EXPECT_TRUE(!(fm1 < fm2)); + EXPECT_TRUE(fm1 > fm2); + EXPECT_TRUE(!(fm1 <= fm2)); + EXPECT_TRUE(fm1 >= fm2); } TYPED_TEST(flat_mapt, Search) @@ -696,19 +696,19 @@ TYPED_TEST(flat_mapt, Search) FM fm{{1, "a"}, {2, "b"}, {3, "c"}}; auto it = fm.lower_bound(2); auto cit = const_cast(fm).lower_bound(2); - assert(it == fm.begin() + 1); - assert(cit == it); + EXPECT_TRUE(it == fm.begin() + 1); + EXPECT_TRUE(cit == it); it = fm.upper_bound(2); cit = const_cast(fm).upper_bound(2); - assert(it == fm.begin() + 2); - assert(cit == it); + EXPECT_TRUE(it == fm.begin() + 2); + EXPECT_TRUE(cit == it); auto itpair = fm.equal_range(2); auto citpair = const_cast(fm).equal_range(2); - assert(itpair.first == fm.begin() + 1); - assert(itpair.second == fm.begin() + 2); - assert(citpair == decltype(citpair)(itpair)); + EXPECT_TRUE(itpair.first == fm.begin() + 1); + EXPECT_TRUE(itpair.second == fm.begin() + 2); + EXPECT_TRUE(citpair == decltype(citpair)(itpair)); static_assert(std::is_same::value, ""); static_assert(std::is_same::value, ""); diff --git a/test/flat_set_test.cpp b/test/flat_set_test.cpp index 553fee2..d102a8b 100644 --- a/test/flat_set_test.cpp +++ b/test/flat_set_test.cpp @@ -58,14 +58,14 @@ TEST(flat_set, AmbiguousErase) fs.emplace("a"); fs.emplace("b"); fs.emplace("c"); - assert(fs.size() == 3); + EXPECT_TRUE(fs.size() == 3); fs.erase(AmbiguousEraseWidget("a")); // calls erase(const Key&) - assert(fs.size() == 2); + EXPECT_TRUE(fs.size() == 2); fs.erase(fs.cbegin()); // calls erase(const_iterator) - assert(fs.size() == 1); + EXPECT_TRUE(fs.size() == 1); #if __cplusplus >= 201703L fs.erase(fs.begin()); // calls erase(iterator) - assert(fs.size() == 0); + EXPECT_TRUE(fs.size() == 0); #endif } @@ -78,8 +78,8 @@ TEST(flat_set, ExtractDoesntSwap) std::pmr::polymorphic_allocator a(&mr); sg14::flat_set, std::pmr::vector> fs({1, 2}, a); std::pmr::vector v = std::move(fs).extract(); - assert(v.get_allocator() == a); - assert(fs.empty()); + EXPECT_TRUE(v.get_allocator() == a); + EXPECT_TRUE(fs.empty()); } #endif @@ -88,8 +88,8 @@ TEST(flat_set, ExtractDoesntSwap) std::allocator a; sg14::flat_set, std::vector> fs({1, 2}, a); std::vector v = std::move(fs).extract(); - assert(v.get_allocator() == a); - assert(fs.empty()); + EXPECT_TRUE(v.get_allocator() == a); + EXPECT_TRUE(fs.empty()); } } @@ -127,10 +127,10 @@ TEST(flat_set, ThrowingSwapDoesntBreakInvariants) fsy.insert(8); std::vector expected_fsx = {7, 6, 5, 4}; std::vector expected_fsy = {1, 2, 3, 8}; - assert(expected_fsx.size() == fsx.size()); - assert(std::equal(expected_fsx.begin(), expected_fsx.end(), fsx.begin())); - assert(expected_fsy.size() == fsy.size()); - assert(std::equal(expected_fsy.begin(), expected_fsy.end(), fsy.begin())); + EXPECT_TRUE(expected_fsx.size() == fsx.size()); + EXPECT_TRUE(std::equal(expected_fsx.begin(), expected_fsx.end(), fsx.begin())); + EXPECT_TRUE(expected_fsy.size() == fsy.size()); + EXPECT_TRUE(std::equal(expected_fsy.begin(), expected_fsy.end(), fsy.begin())); } // However, if ComparatorWithThrowingSwap::please_throw were @@ -143,20 +143,20 @@ TEST(flat_set, VectorBool) using FS = sg14::flat_set; FS fs; auto it_inserted = fs.emplace(true); - assert(it_inserted.second); + EXPECT_TRUE(it_inserted.second); auto it = it_inserted.first; - assert(it == fs.begin()); - assert(fs.size() == 1); + EXPECT_TRUE(it == fs.begin()); + EXPECT_TRUE(fs.size() == 1); it = fs.emplace_hint(it, false); - assert(it == fs.begin()); - assert(fs.size() == 2); + EXPECT_TRUE(it == fs.begin()); + EXPECT_TRUE(fs.size() == 2); auto count = fs.erase(false); - assert(count == 1); - assert(fs.size() == 1); + EXPECT_TRUE(count == 1); + EXPECT_TRUE(fs.size() == 1); it = fs.erase(fs.begin()); - assert(fs.empty()); - assert(it == fs.begin()); - assert(it == fs.end()); + EXPECT_TRUE(fs.empty()); + EXPECT_TRUE(it == fs.begin()); + EXPECT_TRUE(it == fs.end()); #endif } @@ -217,34 +217,34 @@ TEST(flat_set, MoveOperationsPilferOwnership) InstrumentedWidget::copy_ctors = 0; FS fs; fs.insert(InstrumentedWidget("abc")); - assert(InstrumentedWidget::move_ctors == 1); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 1); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); fs.emplace(InstrumentedWidget("def")); fs.erase("def"); // poor man's reserve() InstrumentedWidget::copy_ctors = 0; InstrumentedWidget::move_ctors = 0; fs.emplace("def"); // is still not directly emplaced; a temporary is created to find() - assert(InstrumentedWidget::move_ctors == 1); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 1); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); InstrumentedWidget::move_ctors = 0; FS fs2 = std::move(fs); // should just transfer buffer ownership - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); fs = std::move(fs2); // should just transfer buffer ownership - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); FS fs3(fs, std::allocator()); - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 2); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 2); InstrumentedWidget::copy_ctors = 0; FS fs4(std::move(fs), std::allocator()); // should just transfer buffer ownership - assert(InstrumentedWidget::move_ctors == 0); - assert(InstrumentedWidget::copy_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::move_ctors == 0); + EXPECT_TRUE(InstrumentedWidget::copy_ctors == 0); } TYPED_TEST(flat_sett, Construction) @@ -258,14 +258,14 @@ TYPED_TEST(flat_sett, Construction) if (true) { FS fs; // default constructor fs = {1, 3, 5}; // assignment operator - assert(std::is_sorted(fs.begin(), fs.end(), fs.key_comp())); + EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), fs.key_comp())); } if (true) { FS fs {1, 3, 1, 5, 3}; - assert(fs.size() == 3); // assert that uniqueing takes place + EXPECT_TRUE(fs.size() == 3); // assert that uniqueing takes place std::vector vec2 = {1, 3, 1, 5, 3}; FS fs2(vec2); - assert(fs2.size() == 3); // assert that uniqueing takes place + EXPECT_TRUE(fs2.size() == 3); // assert that uniqueing takes place } for (auto&& fs : { FS(vec), @@ -278,14 +278,14 @@ TYPED_TEST(flat_sett, Construction) FS(vec.rbegin(), vec.rend(), Compare()), }) { auto cmp = fs.key_comp(); - assert(std::is_sorted(fs.begin(), fs.end(), cmp)); - assert(fs.find(0) == fs.end()); - assert(fs.find(1) != fs.end()); - assert(fs.find(2) == fs.end()); - assert(fs.find(3) != fs.end()); - assert(fs.find(4) == fs.end()); - assert(fs.find(5) != fs.end()); - assert(fs.find(6) == fs.end()); + EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), cmp)); + EXPECT_TRUE(fs.find(0) == fs.end()); + EXPECT_TRUE(fs.find(1) != fs.end()); + EXPECT_TRUE(fs.find(2) == fs.end()); + EXPECT_TRUE(fs.find(3) != fs.end()); + EXPECT_TRUE(fs.find(4) == fs.end()); + EXPECT_TRUE(fs.find(5) != fs.end()); + EXPECT_TRUE(fs.find(6) == fs.end()); } if (std::is_sorted(vec.begin(), vec.end(), Compare())) { for (auto&& fs : { @@ -297,7 +297,7 @@ TYPED_TEST(flat_sett, Construction) FS(sg14::sorted_unique, {1, 3, 5}, Compare()), }) { auto cmp = fs.key_comp(); - assert(std::is_sorted(fs.begin(), fs.end(), cmp)); + EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), cmp)); } } } diff --git a/test/hive_test.cpp b/test/hive_test.cpp index b0fff79..52b9c92 100644 --- a/test/hive_test.cpp +++ b/test/hive_test.cpp @@ -1681,7 +1681,7 @@ TEST(hive, RegressionTestIssue8) h.erase(h.begin()); h.erase(h.begin()); h.insert(6); - assert(h.size() == 4); // {6,3,4,5} + EXPECT_EQ(h.size(), 4u); // {6,3,4,5} EXPECT_INVARIANTS(h); auto it = h.begin(); diff --git a/test/inplace_function_test.cpp b/test/inplace_function_test.cpp index cf3134e..a70fe77 100644 --- a/test/inplace_function_test.cpp +++ b/test/inplace_function_test.cpp @@ -17,19 +17,19 @@ struct Functor { Functor() {} Functor(const Functor&) { copied += 1; } Functor(Functor&&) noexcept { moved += 1; } - void operator()(int i) { assert(i == expected); called_with = i; } + void operator()(int i) { EXPECT_TRUE(i == expected); called_with = i; } }; struct ConstFunctor { ConstFunctor() {} ConstFunctor(const ConstFunctor&) { copied += 1; } ConstFunctor(ConstFunctor&&) noexcept { moved += 1; } - void operator()(int i) const { assert(i == expected); called_with = i; } + void operator()(int i) const { EXPECT_TRUE(i == expected); called_with = i; } }; void Foo(int i) { - assert(i == expected); + EXPECT_TRUE(i == expected); called_with = i; } @@ -380,23 +380,23 @@ TEST(inplace_function, ConvertibleFromNullptr) auto nil = nullptr; const auto cnil = nullptr; - IPF f; assert(! bool(f)); - f = nullptr; assert(! bool(f)); - f = IPF(nullptr); assert(! bool(f)); - f = IPF(); assert(! bool(f)); - f = IPF{}; assert(! bool(f)); - f = {}; assert(! bool(f)); - f = nil; assert(! bool(f)); - f = IPF(nil); assert(! bool(f)); - f = IPF(std::move(nil)); assert(! bool(f)); - f = cnil; assert(! bool(f)); - f = IPF(cnil); assert(! bool(f)); - f = IPF(std::move(cnil)); assert(! bool(f)); - - assert(!f); - assert(f == nullptr); - assert(!(f != nullptr)); - expected = 0; try { f(42); } catch (const std::bad_function_call&) { expected = 1; } assert(expected == 1); + IPF f; EXPECT_TRUE(! bool(f)); + f = nullptr; EXPECT_TRUE(! bool(f)); + f = IPF(nullptr); EXPECT_TRUE(! bool(f)); + f = IPF(); EXPECT_TRUE(! bool(f)); + f = IPF{}; EXPECT_TRUE(! bool(f)); + f = {}; EXPECT_TRUE(! bool(f)); + f = nil; EXPECT_TRUE(! bool(f)); + f = IPF(nil); EXPECT_TRUE(! bool(f)); + f = IPF(std::move(nil)); EXPECT_TRUE(! bool(f)); + f = cnil; EXPECT_TRUE(! bool(f)); + f = IPF(cnil); EXPECT_TRUE(! bool(f)); + f = IPF(std::move(cnil)); EXPECT_TRUE(! bool(f)); + + EXPECT_TRUE(!f); + EXPECT_TRUE(f == nullptr); + EXPECT_TRUE(!(f != nullptr)); + expected = 0; try { f(42); } catch (const std::bad_function_call&) { expected = 1; } EXPECT_TRUE(expected == 1); } namespace { @@ -570,15 +570,15 @@ TEST(inplace_function, ReturnByMove) InstrumentedCopyConstructor::copies = 0; InstrumentedCopyConstructor::moves = 0; IPF20 f = [cc]() { }; - assert(InstrumentedCopyConstructor::copies == 1); - assert(InstrumentedCopyConstructor::moves == 1); + EXPECT_TRUE(InstrumentedCopyConstructor::copies == 1); + EXPECT_TRUE(InstrumentedCopyConstructor::moves == 1); InstrumentedCopyConstructor::copies = 0; InstrumentedCopyConstructor::moves = 0; return f; }; IPF40 f = foo(); - assert(InstrumentedCopyConstructor::copies == 0); - assert(InstrumentedCopyConstructor::moves == 1); + EXPECT_TRUE(InstrumentedCopyConstructor::copies == 0); + EXPECT_TRUE(InstrumentedCopyConstructor::moves == 1); } TEST(inplace_function, IsInvocableTrait) @@ -679,11 +679,11 @@ TEST(inplace_function, DefaultConstructor) using IPF = sg14::inplace_function; IPF func; - assert(!func); - assert(!bool(func)); - assert(func == nullptr); - assert(!(func != nullptr)); - expected = 0; try { func(42); } catch (std::bad_function_call&) { expected = 1; } assert(expected == 1); + EXPECT_TRUE(!func); + EXPECT_TRUE(!bool(func)); + EXPECT_TRUE(func == nullptr); + EXPECT_TRUE(!(func != nullptr)); + expected = 0; try { func(42); } catch (std::bad_function_call&) { expected = 1; } EXPECT_TRUE(expected == 1); } TEST(inplace_function, Assignment) @@ -693,9 +693,9 @@ TEST(inplace_function, Assignment) IPF func; func = Foo; - assert(!!func); - assert(func); - assert(!(func == nullptr)); - assert(func != nullptr); - called_with = 0; expected = 42; func(42); assert(called_with == 42); + EXPECT_TRUE(!!func); + EXPECT_TRUE(func); + EXPECT_TRUE(!(func == nullptr)); + EXPECT_TRUE(func != nullptr); + called_with = 0; expected = 42; func(42); EXPECT_TRUE(called_with == 42); } diff --git a/test/ring_span_test.cpp b/test/ring_span_test.cpp index c152828..40f9bbc 100644 --- a/test/ring_span_test.cpp +++ b/test/ring_span_test.cpp @@ -76,13 +76,13 @@ TEST(ring_span, IteratorRegression) r.push_back(1.0); decltype(r)::iterator it = r.end(); decltype(r)::const_iterator cit = r.end(); // test conversion from non-const to const - assert(it == cit); // test comparison of const and non-const - assert(it + 0 == it); - assert(it - 1 == r.begin()); - assert(cit + 0 == cit); - assert(cit - 1 == r.cbegin()); - assert(it - cit == 0); - assert(cit - r.begin() == 1); + EXPECT_TRUE(it == cit); // test comparison of const and non-const + EXPECT_TRUE(it + 0 == it); + EXPECT_TRUE(it - 1 == r.begin()); + EXPECT_TRUE(cit + 0 == cit); + EXPECT_TRUE(cit - 1 == r.cbegin()); + EXPECT_TRUE(it - cit == 0); + EXPECT_TRUE(cit - r.begin() == 1); std::array B; sg14::ring_span r2(B.begin(), B.end()); @@ -90,12 +90,12 @@ TEST(ring_span, IteratorRegression) // Set up the ring for the TEST_OP tests below. r = sg14::ring_span(A.begin(), A.end(), A.begin(), 2); - assert(r.size() == 2); + EXPECT_TRUE(r.size() == 2); #define TEST_OP(op, a, b, c) \ - assert(a(r.begin() op r.end())); \ - assert(b(r.end() op r.begin())); \ - assert(c(r.begin() op r.begin())) + EXPECT_TRUE(a(r.begin() op r.end())); \ + EXPECT_TRUE(b(r.end() op r.begin())); \ + EXPECT_TRUE(c(r.begin() op r.begin())) #define _ TEST_OP(==, !, !, _); TEST_OP(!=, _, _, !); @@ -112,12 +112,12 @@ TEST(ring_span, CopyPopper) std::vector v { "quick", "brown", "fox" }; sg14::ring_span> r(v.begin(), v.end(), {"popped"}); r.emplace_back("slow"); - assert((v == std::vector{"slow", "brown", "fox"})); + EXPECT_TRUE((v == std::vector{"slow", "brown", "fox"})); r.emplace_back("red"); - assert((v == std::vector{"slow", "red", "fox"})); + EXPECT_TRUE((v == std::vector{"slow", "red", "fox"})); std::string result = r.pop_front(); - assert((v == std::vector{"popped", "red", "fox"})); - assert(result == "slow"); + EXPECT_TRUE((v == std::vector{"popped", "red", "fox"})); + EXPECT_TRUE(result == "slow"); } TEST(ring_span, ReverseIterator) @@ -133,16 +133,16 @@ TEST(ring_span, ReverseIterator) std::vector v(3); std::copy(r.begin(), r.end(), v.begin()); - assert((v == std::vector{2,3,4})); + EXPECT_TRUE((v == std::vector{2,3,4})); std::copy(r.cbegin(), r.cend(), v.begin()); - assert((v == std::vector{2,3,4})); + EXPECT_TRUE((v == std::vector{2,3,4})); std::copy(r.rbegin(), r.rend(), v.begin()); - assert((v == std::vector{4,3,2})); + EXPECT_TRUE((v == std::vector{4,3,2})); std::copy(r.crbegin(), r.crend(), v.begin()); - assert((v == std::vector{4,3,2})); + EXPECT_TRUE((v == std::vector{4,3,2})); static_assert(std::is_same::value, ""); static_assert(std::is_same::value, ""); diff --git a/test/slot_map_test.cpp b/test/slot_map_test.cpp index e27bf20..9ecf329 100644 --- a/test/slot_map_test.cpp +++ b/test/slot_map_test.cpp @@ -125,7 +125,7 @@ static void print_slot_map(const sg14::slot_map& sm) for (auto&& value : sm) { printf(" %d", (int)value); } - assert(sm.reverse_map_.size() == sm.size()); + EXPECT_EQ(sm.reverse_map_.size(), sm.size()); printf("\n%d reverse_map:", (int)sm.reverse_map_.size()); for (auto&& idx : sm.reverse_map_) { printf(" %d", (int)idx); @@ -140,36 +140,36 @@ template static void BasicTests(T t1, T t2) { SM sm; - assert(sm.empty()); - assert(sm.size() == 0); + EXPECT_TRUE(sm.empty()); + EXPECT_EQ(sm.size(), 0u); SM sm2 = move_if_necessary(sm); - assert(sm2.empty()); - assert(sm2.size() == 0); + EXPECT_TRUE(sm2.empty()); + EXPECT_EQ(sm2.size(), 0u); auto k1 = sm.insert(std::move(t1)); auto k2 = sm.insert(move_if_necessary(t2)); - assert(!sm.empty()); - assert(sm.size() == 2); - assert(std::next(sm.begin(), 2) == sm.end()); - assert(sm.find(k1) == sm.begin()); - assert(sm.find(k2) == std::next(sm.begin())); - assert(sm2.empty()); - assert(sm2.size() == 0); + EXPECT_FALSE(sm.empty()); + EXPECT_EQ(sm.size(), 2u); + EXPECT_EQ(std::next(sm.begin(), 2), sm.end()); + EXPECT_EQ(sm.find(k1), sm.begin()); + EXPECT_EQ(sm.find(k2), std::next(sm.begin())); + EXPECT_TRUE(sm2.empty()); + EXPECT_EQ(sm2.size(), 0u); auto num_removed = sm.erase(k1); - assert(num_removed == 1); - assert(sm.size() == 1); - assert(sm.find(k1) == sm.end()); // find an expired key - try { (void)sm.at(k1); assert(false); } catch (const std::out_of_range&) {} - assert(sm.find(k2) == sm.begin()); // find a non-expired key - assert(sm.at(k2) == *sm.begin()); - assert(sm.find_unchecked(k2) == sm.begin()); - assert(sm[k2] == *sm.begin()); - assert(sm.erase(k1) == 0); // erase an expired key + EXPECT_EQ(num_removed, 1u); + EXPECT_EQ(sm.size(), 1u); + EXPECT_EQ(sm.find(k1), sm.end()); // find an expired key + ASSERT_THROW(sm.at(k1), std::out_of_range); + EXPECT_EQ(sm.find(k2), sm.begin()); // find a non-expired key + EXPECT_EQ(sm.at(k2), *sm.begin()); + EXPECT_EQ(sm.find_unchecked(k2), sm.begin()); + EXPECT_EQ(sm[k2], *sm.begin()); + EXPECT_EQ(sm.erase(k1), 0u); // erase an expired key sm.swap(sm2); - assert(sm.empty()); - assert(sm2.size() == 1); - assert(sm2.find(k1) == sm2.end()); // find an expired key - assert(sm2.find(k2) == sm2.begin()); // find a non-expired key - assert(sm2.erase(k1) == 0); // erase an expired key + EXPECT_TRUE(sm.empty()); + EXPECT_EQ(sm2.size(), 1u); + EXPECT_EQ(sm2.find(k1), sm2.end()); // find an expired key + EXPECT_EQ(sm2.find(k2), sm2.begin()); // find a non-expired key + EXPECT_EQ(sm2.erase(k1), 0u); // erase an expired key } template @@ -182,20 +182,20 @@ static void FullContainerStressTest(TGen t) auto k = sm.insert(t()); keys.push_back(k); } - assert(sm.size() == total); + EXPECT_TRUE(sm.size() == total); std::mt19937 g; std::shuffle(keys.begin(), keys.end(), g); for (int i = 0; i < total; ++i) { - assert(sm.size() == static_cast(total - i)); - assert(sm.find(keys[i]) != sm.end()); - assert(sm.find_unchecked(keys[i]) != sm.end()); + EXPECT_TRUE(sm.size() == static_cast(total - i)); + EXPECT_TRUE(sm.find(keys[i]) != sm.end()); + EXPECT_TRUE(sm.find_unchecked(keys[i]) != sm.end()); for (int j = 0; j < i; ++j) { - assert(sm.find(keys[j]) == sm.end()); + EXPECT_TRUE(sm.find(keys[j]) == sm.end()); } auto erased = sm.erase(keys[i]); - assert(erased == 1); + EXPECT_TRUE(erased == 1); } - assert(sm.empty()); + EXPECT_TRUE(sm.empty()); } template @@ -216,10 +216,10 @@ static void InsertEraseStressTest(TGen t) auto k = valid_keys.back(); valid_keys.pop_back(); auto erased = sm.erase(k); - assert(erased == 1); + EXPECT_TRUE(erased == 1); expired_keys.push_back(k); for (auto&& ek : expired_keys) { - assert(sm.find(ek) == sm.end()); + EXPECT_TRUE(sm.find(ek) == sm.end()); } } else { auto k = sm.insert(t()); @@ -245,12 +245,12 @@ static void EraseInLoopTest() ++it; } } - assert(total == 4950); + EXPECT_TRUE(total == 4950); int total2 = 0; for (auto&& elt : sm) { total2 += Monad::value_of(elt); } - assert(total2 == 1275); + EXPECT_TRUE(total2 == 1275); } template @@ -275,16 +275,16 @@ static void EraseRangeTest() } return (actual_total == expected_total); }; - assert(test(10, 8, 8)); - assert(test(10, 3, 7)); - assert(test(10, 0, 10)); - assert(test(10, 1, 10)); - assert(test(10, 0, 9)); - assert(test(10, 1, 9)); + EXPECT_TRUE(test(10, 8, 8)); + EXPECT_TRUE(test(10, 3, 7)); + EXPECT_TRUE(test(10, 0, 10)); + EXPECT_TRUE(test(10, 1, 10)); + EXPECT_TRUE(test(10, 0, 9)); + EXPECT_TRUE(test(10, 1, 9)); for (int N : { 2, 10, 100 }) { for (int i=0; i < N; ++i) { for (int j=i; j < N; ++j) { - assert(test(N, i, j)); + EXPECT_TRUE(test(N, i, j)); } } } @@ -308,19 +308,19 @@ static void PartitionTest() }); for (auto it = sm.begin(); it != pivot; ++it) { - assert(Monad::value_of(*it) >= 5); + EXPECT_TRUE(Monad::value_of(*it) >= 5); } for (auto it = pivot; it != sm.end(); ++it) { - assert(Monad::value_of(*it) < 5); + EXPECT_TRUE(Monad::value_of(*it) < 5); } - assert(Monad::value_of(*sm.find(key3)) == 3); - assert(Monad::value_of(*sm.find(key1)) == 1); - assert(Monad::value_of(*sm.find(key4)) == 4); - assert(Monad::value_of(*sm.find(key5)) == 5); - assert(Monad::value_of(*sm.find(key9)) == 9); - assert(Monad::value_of(*sm.find(key2)) == 2); - assert(Monad::value_of(*sm.find(key6)) == 6); + EXPECT_TRUE(Monad::value_of(*sm.find(key3)) == 3); + EXPECT_TRUE(Monad::value_of(*sm.find(key1)) == 1); + EXPECT_TRUE(Monad::value_of(*sm.find(key4)) == 4); + EXPECT_TRUE(Monad::value_of(*sm.find(key5)) == 5); + EXPECT_TRUE(Monad::value_of(*sm.find(key9)) == 9); + EXPECT_TRUE(Monad::value_of(*sm.find(key2)) == 2); + EXPECT_TRUE(Monad::value_of(*sm.find(key6)) == 6); } template @@ -330,42 +330,42 @@ static void ReserveTest() SM sm; auto k = sm.emplace(Monad::from_value(1)); (void)k; - assert(sm.size() == 1); + EXPECT_TRUE(sm.size() == 1); auto original_cap = sm.slot_count(); static_assert(std::is_same::value, ""); - assert(original_cap >= 1); + EXPECT_TRUE(original_cap >= 1); sm.reserve_slots(original_cap + 3); - assert(sm.slot_count() >= original_cap + 3); - assert(sm.size() == 1); + EXPECT_TRUE(sm.slot_count() >= original_cap + 3); + EXPECT_TRUE(sm.size() == 1); sm.emplace(Monad::from_value(2)); sm.emplace(Monad::from_value(3)); sm.emplace(Monad::from_value(4)); - assert(sm.size() == 4); + EXPECT_TRUE(sm.size() == 4); } template().capacity())> static void VerifyCapacityExists(bool expected) { - assert(expected); + EXPECT_TRUE(expected); SM sm; auto n = sm.capacity(); static_assert(std::is_same::value, ""); - assert(n == 0); + EXPECT_TRUE(n == 0); sm.reserve(100); - assert(sm.capacity() >= 100); - assert(sm.slot_count() >= 100); + EXPECT_TRUE(sm.capacity() >= 100); + EXPECT_TRUE(sm.slot_count() >= 100); } template void VerifyCapacityExists(Bool expected) { - assert(!expected); + EXPECT_TRUE(!expected); SM sm; sm.reserve(100); - assert(sm.slot_count() >= 100); + EXPECT_TRUE(sm.slot_count() >= 100); } TEST(slot_map, MemberTypedefs) @@ -476,10 +476,10 @@ void BoundsCheckingTest() sm.clear(); typename SM::iterator it = sm.find(k); - assert(it == sm.end()); + EXPECT_TRUE(it == sm.end()); typename SM::const_iterator cit = csm.find(k); - assert(cit == sm.end()); + EXPECT_TRUE(cit == sm.end()); } template @@ -492,20 +492,20 @@ static void GenerationsDontSkipTest() for (int i=1; i < original_cap; ++i) { sm.emplace(Monad::from_value(i)); } - assert(sm.size() == sm.slot_count()); + EXPECT_TRUE(sm.size() == sm.slot_count()); sm.erase(k1); auto k2 = sm.emplace(Monad::from_value(2)); #if __cplusplus < 201703L using std::get; - assert(get<0>(k2) == get<0>(k1)); - assert(get<1>(k2) == get<1>(k1) + 1); + EXPECT_TRUE(get<0>(k2) == get<0>(k1)); + EXPECT_TRUE(get<1>(k2) == get<1>(k1) + 1); #else auto [idx1, gen1] = k1; auto [idx2, gen2] = k2; - assert(idx2 == idx1); - assert(gen2 == gen1 + 1); + EXPECT_TRUE(idx2 == idx1); + EXPECT_TRUE(gen2 == gen1 + 1); #endif } @@ -520,11 +520,11 @@ static void IndexesAreUsedEvenlyTest() for (int i=2; i < original_cap; ++i) { sm.emplace(Monad::from_value(i)); } - assert(sm.size() == sm.slot_count()); + EXPECT_TRUE(sm.size() == sm.slot_count()); sm.erase(k1); sm.erase(k2); - assert(sm.size() == sm.slot_count() - 2); + EXPECT_TRUE(sm.size() == sm.slot_count() - 2); // There are now two slots available. // So consecutive insertions should prefer to @@ -537,11 +537,11 @@ static void IndexesAreUsedEvenlyTest() #if __cplusplus < 201703L using std::get; - assert(get<0>(k2) != get<0>(k1)); + EXPECT_TRUE(get<0>(k2) != get<0>(k1)); #else auto [idx1, gen1] = k1; auto [idx2, gen2] = k2; - assert(idx2 != idx1); + EXPECT_TRUE(idx2 != idx1); #endif } diff --git a/test/uninitialized_test.cpp b/test/uninitialized_test.cpp index 62e9f62..4b55f0b 100644 --- a/test/uninitialized_test.cpp +++ b/test/uninitialized_test.cpp @@ -30,9 +30,9 @@ namespace { move = 0; } static void test(uint64_t inconstruct, uint64_t indestruct, uint64_t inmove) { - assert(construct == inconstruct); - assert(destruct == indestruct); - assert(move == inmove); + EXPECT_TRUE(construct == inconstruct); + EXPECT_TRUE(destruct == indestruct); + EXPECT_TRUE(move == inmove); } }; uint64_t lifetest::construct = 0; @@ -61,7 +61,7 @@ TEST(uninitialized_value_construct, Basic) auto m = (int*)malloc(sizeof(int) * 5); sg14::uninitialized_value_construct(m, m + 5); - assert(std::all_of(m, m + 5, [](int x) { return x == 0; })); + EXPECT_TRUE(std::all_of(m, m + 5, [](int x) { return x == 0; })); free(m); }