[fbl][test] Convert fbl container tests to zxtest
Change-Id: I3cce939789feebf955b5a82d16b2c0019218f324
diff --git a/zircon/system/ulib/fbl/include/fbl/intrusive_wavl_tree_internal.h b/zircon/system/ulib/fbl/include/fbl/intrusive_wavl_tree_internal.h
index 8181ba8..ac8b7ff 100644
--- a/zircon/system/ulib/fbl/include/fbl/intrusive_wavl_tree_internal.h
+++ b/zircon/system/ulib/fbl/include/fbl/intrusive_wavl_tree_internal.h
@@ -39,14 +39,10 @@
static void RecordEraseDoubleRotation() {}
template <typename TreeType>
- static bool VerifyRankRule(const TreeType& tree, typename TreeType::RawPtrType node) {
- return true;
- }
+ static void VerifyRankRule(const TreeType& tree, typename TreeType::RawPtrType node) {}
template <typename TreeType>
- static bool VerifyBalance(const TreeType& tree, uint64_t depth) {
- return true;
- }
+ static void VerifyBalance(const TreeType& tree, uint64_t depth) {}
};
} // namespace intrusive_containers
diff --git a/zircon/system/ulib/fbl/test/BUILD.gn b/zircon/system/ulib/fbl/test/BUILD.gn
index f713ef9..13baec3 100644
--- a/zircon/system/ulib/fbl/test/BUILD.gn
+++ b/zircon/system/ulib/fbl/test/BUILD.gn
@@ -37,12 +37,16 @@
"unique_fd_tests.cc",
"vector_tests.cc",
]
+
deps = [
"$zx/system/ulib/fbl",
- "$zx/system/ulib/unittest", # TODO: convert to zxtest.
"$zx/system/ulib/zxtest",
]
+ if (!is_fuchsia) {
+ defines = [ "FBL_TEST_ENABLE_WAVL_TREE_BALANCE_TEST=1" ]
+ }
+
if (is_fuchsia) {
# These tests won't run on the host. There are two primary reasons for this.
#
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/associative_container_test_environment.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/associative_container_test_environment.h
index 64c8422..a21875c 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/associative_container_test_environment.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/associative_container_test_environment.h
@@ -2,11 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_ASSOCIATIVE_CONTAINER_TEST_ENVIRONMENT_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_ASSOCIATIVE_CONTAINER_TEST_ENVIRONMENT_H_
-#include <unittest/unittest.h>
#include <fbl/tests/intrusive_containers/base_test_environments.h>
#include <fbl/tests/lfsr.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -50,11 +51,9 @@
return SizeUtils<CType>::size(container);
}
- bool SetTestObjKeys(const PtrType& test_obj, PopulateMethod method) {
- BEGIN_TEST;
-
- ASSERT_NONNULL(test_obj, "");
- ASSERT_LT(test_obj->value(), OBJ_COUNT, "");
+ void SetTestObjKeys(const PtrType& test_obj, PopulateMethod method) {
+ ASSERT_NOT_NULL(test_obj);
+ ASSERT_LT(test_obj->value(), OBJ_COUNT);
// Assign a key to the object based on the chosen populate method.
KeyType key = 0;
@@ -88,18 +87,14 @@
// Set the primary key on the object. Offset the "other" key by OBJ_COUNT
test_obj->SetKey(key);
OtherContainerTraits::SetKey(*test_obj, other_key);
-
- END_TEST;
}
- bool Populate(ContainerType& container, PopulateMethod method,
+ void Populate(ContainerType& container, PopulateMethod method,
RefAction ref_action = RefAction::HoldSome) {
- BEGIN_TEST;
-
- EXPECT_EQ(0U, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0U, ObjType::live_obj_count());
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(i, Size(container), "");
+ EXPECT_EQ(i, Size(container));
// Unless explicitly told to do so, don't hold a reference in the
// test environment for every 4th object created. Note, this only
@@ -122,10 +117,10 @@
}
PtrType new_object = this->CreateTrackedObject(i, i, hold_ref);
- ASSERT_NONNULL(new_object, "");
- EXPECT_EQ(new_object->raw_ptr(), objects()[i], "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_EQ(new_object->raw_ptr(), objects()[i]);
- ASSERT_TRUE(SetTestObjKeys(new_object, method), "");
+ ASSERT_NO_FAILURES(SetTestObjKeys(new_object, method));
KeyType obj_key = KeyTraits::GetKey(*new_object);
max_key_ = !i ? obj_key : KeyTraits::LessThan(max_key_, obj_key) ? obj_key : max_key_;
@@ -142,52 +137,40 @@
#else
container.insert(TestEnvTraits::Transfer(new_object));
#endif
- EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object));
} else {
container.insert(std::move(new_object));
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
}
- EXPECT_EQ(OBJ_COUNT, Size(container), "");
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(container), "");
-
- END_TEST;
+ EXPECT_EQ(OBJ_COUNT, Size(container));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container));
}
- bool Populate(ContainerType& container, RefAction ref_action = RefAction::HoldSome) override {
+ void Populate(ContainerType& container, RefAction ref_action = RefAction::HoldSome) override {
return Populate(container, PopulateMethod::AscendingKey, ref_action);
}
- bool DoInsertByKey(PopulateMethod populate_method) {
- BEGIN_TEST;
-
- EXPECT_TRUE(Populate(container(), populate_method), "");
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
-
- END_TEST;
+ void DoInsertByKey(PopulateMethod populate_method) {
+ ASSERT_NO_FATAL_FAILURES(Populate(container(), populate_method));
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
}
- bool InsertByKey() {
- BEGIN_TEST;
+ void InsertByKey() {
+ ASSERT_NO_FATAL_FAILURES(DoInsertByKey(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
- EXPECT_TRUE(DoInsertByKey(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
+ ASSERT_NO_FATAL_FAILURES(DoInsertByKey(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT));
- EXPECT_TRUE(DoInsertByKey(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT));
-
- EXPECT_TRUE(DoInsertByKey(PopulateMethod::RandomKey), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(3 * OBJ_COUNT));
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(DoInsertByKey(PopulateMethod::RandomKey));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(3 * OBJ_COUNT));
}
- bool DoFindByKey(PopulateMethod populate_method) {
- BEGIN_TEST;
-
- EXPECT_TRUE(Populate(container(), populate_method), "");
+ void DoFindByKey(PopulateMethod populate_method) {
+ ASSERT_NO_FATAL_FAILURES(Populate(container(), populate_method));
// Lookup the various items which should be in the collection by key.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
@@ -196,43 +179,36 @@
auto iter = const_container().find(key);
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(key, iter->GetKey(), "");
- EXPECT_EQ(value, iter->value(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(key, iter->GetKey());
+ EXPECT_EQ(value, iter->value());
}
// Fail to look up something which should not be in the collection.
auto iter = const_container().find(kBannedKeyValue);
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
}
- bool FindByKey() {
- BEGIN_TEST;
+ void FindByKey() {
+ ASSERT_NO_FATAL_FAILURES(DoFindByKey(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
- EXPECT_TRUE(DoFindByKey(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
+ ASSERT_NO_FATAL_FAILURES(DoFindByKey(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT));
- EXPECT_TRUE(DoFindByKey(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT));
-
- EXPECT_TRUE(DoFindByKey(PopulateMethod::RandomKey), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(3 * OBJ_COUNT));
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(DoFindByKey(PopulateMethod::RandomKey));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(3 * OBJ_COUNT));
}
- bool DoEraseByKey(PopulateMethod populate_method, size_t already_erased) {
- BEGIN_TEST;
-
- EXPECT_TRUE(Populate(container(), populate_method), "");
+ void DoEraseByKey(PopulateMethod populate_method, size_t already_erased) {
+ ASSERT_NO_FATAL_FAILURES(Populate(container(), populate_method));
size_t remaining = OBJ_COUNT;
size_t erased = 0;
// Fail to erase a key which is not in the container.
- EXPECT_NULL(container().erase(kBannedKeyValue), "");
+ EXPECT_NULL(container().erase(kBannedKeyValue));
// Erase all of the even members of the collection by key.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
@@ -243,13 +219,15 @@
if (key & 1)
continue;
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(erased + already_erased));
- EXPECT_TRUE(TestEnvironment<TestEnvTraits>::DoErase(key, i, remaining), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(++erased + already_erased));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(erased + already_erased));
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::DoErase(key, i, remaining));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(++erased + already_erased));
--remaining;
}
- EXPECT_EQ(remaining, Size(container()), "");
+ EXPECT_EQ(remaining, Size(container()));
// Erase the remaining odd members.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
@@ -257,40 +235,35 @@
continue;
KeyType key = objects()[i]->GetKey();
- EXPECT_TRUE(key & 1, "");
+ EXPECT_TRUE(key & 1);
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(erased + already_erased));
- EXPECT_TRUE(TestEnvironment<TestEnvTraits>::DoErase(key, i, remaining), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(++erased + already_erased));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(erased + already_erased));
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::DoErase(key, i, remaining));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(++erased + already_erased));
--remaining;
}
- EXPECT_EQ(0u, Size(container()), "");
+ EXPECT_EQ(0u, Size(container()));
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
}
- bool EraseByKey() {
- BEGIN_TEST;
-
- EXPECT_TRUE(DoEraseByKey(PopulateMethod::AscendingKey, 0), "");
- EXPECT_TRUE(DoEraseByKey(PopulateMethod::DescendingKey, OBJ_COUNT), "");
- EXPECT_TRUE(DoEraseByKey(PopulateMethod::RandomKey, 2 * OBJ_COUNT), "");
-
- END_TEST;
+ void EraseByKey() {
+ ASSERT_NO_FATAL_FAILURES(DoEraseByKey(PopulateMethod::AscendingKey, 0));
+ ASSERT_NO_FATAL_FAILURES(DoEraseByKey(PopulateMethod::DescendingKey, OBJ_COUNT));
+ ASSERT_NO_FATAL_FAILURES(DoEraseByKey(PopulateMethod::RandomKey, 2 * OBJ_COUNT));
}
- bool DoInsertOrFind(PopulateMethod populate_method, size_t already_destroyed) {
- BEGIN_TEST;
-
+ void DoInsertOrFind(PopulateMethod populate_method, size_t already_destroyed) {
for (unsigned int pass_iterator = 0u; pass_iterator < 2u; ++pass_iterator) {
for (size_t i = 0u; i < OBJ_COUNT; ++i) {
// Create a new tracked object.
PtrType new_object = this->CreateTrackedObject(i, i, true);
- ASSERT_NONNULL(new_object, "");
- EXPECT_EQ(new_object->raw_ptr(), objects()[i], "");
- ASSERT_TRUE(SetTestObjKeys(new_object, populate_method), "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_EQ(new_object->raw_ptr(), objects()[i]);
+ ASSERT_NO_FAILURES(SetTestObjKeys(new_object, populate_method));
// Insert the object into the container using insert_or_find. There
// should be no collision. Exercise both the move and the copy
@@ -305,32 +278,34 @@
success = container().insert_or_find(TestEnvTraits::Transfer(new_object),
pass_iterator ? &iter : nullptr);
#endif
- EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object));
} else {
success =
container().insert_or_find(std::move(new_object), pass_iterator ? &iter : nullptr);
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
- EXPECT_TRUE(success, "");
+ EXPECT_TRUE(success);
// If we passed an iterator to the insert_or_find operation, it
// should point to the newly inserted object.
if (pass_iterator) {
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(objects()[i], iter->raw_ptr(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(objects()[i], iter->raw_ptr());
}
}
// If we have not tested passing a non-null iterator yet, reset the
// environment and do the test again.
- if (!pass_iterator)
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
+ if (!pass_iterator) {
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
+ }
}
// The objects from the first test pass should have been deleted.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + OBJ_COUNT));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + OBJ_COUNT));
// Now go over the (populated) container and attempt to insert new
// objects which have the same keys as existing objects. Each of these
@@ -338,13 +313,13 @@
// previously.
for (unsigned int pass_iterator = 0u; pass_iterator < 2u; ++pass_iterator) {
for (size_t i = 0u; i < OBJ_COUNT; ++i) {
- ASSERT_NONNULL(objects()[i], "");
+ ASSERT_NOT_NULL(objects()[i]);
// Create a new non-tracked object; assign it the same key as
// the existing object.
PtrType new_object = TestEnvTraits::CreateObject(i);
- ASSERT_NONNULL(new_object, "");
- EXPECT_NE(new_object->raw_ptr(), objects()[i], "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_NE(new_object->raw_ptr(), objects()[i]);
new_object->SetKey(KeyTraits::GetKey(*objects()[i]));
// Attempt (but fail) to insert the object into the container
@@ -369,68 +344,62 @@
// The object should not have been inserted. If an attempt was
// made to move the pointer into the collection, it should have
// failed and we should still own the pointer.
- EXPECT_FALSE(success, "");
- ASSERT_NONNULL(new_object, "");
+ EXPECT_FALSE(success);
+ ASSERT_NOT_NULL(new_object);
// If we passed an iterator to the insert_or_find operation, it
// should point to the object we collided with.
if (pass_iterator) {
- EXPECT_TRUE(iter.IsValid(), "");
- if (iter.IsValid(), "") {
- EXPECT_EQ(objects()[i], iter->raw_ptr(), "");
- EXPECT_NE(PtrTraits::GetRaw(new_object), iter->raw_ptr(), "");
+ EXPECT_TRUE(iter.IsValid());
+ if (iter.IsValid()) {
+ EXPECT_EQ(objects()[i], iter->raw_ptr());
+ EXPECT_NE(PtrTraits::GetRaw(new_object), iter->raw_ptr());
EXPECT_TRUE(
- KeyTraits::EqualTo(KeyTraits::GetKey(*iter), KeyTraits::GetKey(*new_object)), "");
+ KeyTraits::EqualTo(KeyTraits::GetKey(*iter), KeyTraits::GetKey(*new_object)));
}
}
// Release the object we failed to insert.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + OBJ_COUNT +
- (OBJ_COUNT * pass_iterator) + i));
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(
+ already_destroyed + OBJ_COUNT + (OBJ_COUNT * pass_iterator) + i));
TestEnvTraits::ReleaseObject(new_object);
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(
already_destroyed + OBJ_COUNT + (OBJ_COUNT * pass_iterator) + i + 1));
}
}
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + (4 * OBJ_COUNT)));
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + (4 * OBJ_COUNT)));
}
- bool InsertOrFind() {
- BEGIN_TEST;
-
+ void InsertOrFind() {
// Each time we run this test, we create and destroy 4 * OBJ_COUNT objects
- EXPECT_TRUE(DoInsertOrFind(PopulateMethod::AscendingKey, 0), "");
- EXPECT_TRUE(DoInsertOrFind(PopulateMethod::DescendingKey, 4 * OBJ_COUNT), "");
- EXPECT_TRUE(DoInsertOrFind(PopulateMethod::RandomKey, 8 * OBJ_COUNT), "");
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(DoInsertOrFind(PopulateMethod::AscendingKey, 0));
+ ASSERT_NO_FATAL_FAILURES(DoInsertOrFind(PopulateMethod::DescendingKey, 4 * OBJ_COUNT));
+ ASSERT_NO_FATAL_FAILURES(DoInsertOrFind(PopulateMethod::RandomKey, 8 * OBJ_COUNT));
}
template <typename CopyOrMoveUtil>
- bool DoInsertOrReplace(size_t extra_elements, size_t already_destroyed) {
- BEGIN_TEST;
-
- ASSERT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_TRUE(Populate(container(), PopulateMethod::AscendingKey), "");
+ void DoInsertOrReplace(size_t extra_elements, size_t already_destroyed) {
+ ASSERT_EQ(0u, ObjType::live_obj_count());
+ ASSERT_NO_FATAL_FAILURES(Populate(container(), PopulateMethod::AscendingKey));
// Attempt to replace every element in the container with one that has
// the same key. Then attempt to replace some which were not in the
// container to start with and verify that they were inserted instead.
for (size_t i = 0; i < OBJ_COUNT + extra_elements; ++i) {
PtrType new_obj = TestEnvTraits::CreateObject(i);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
new_obj->SetKey(i);
PtrType replaced = container().insert_or_replace(CopyOrMoveUtil::Op(new_obj));
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
if (i < OBJ_COUNT) {
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, container().size(), "");
- ASSERT_NONNULL(replaced, "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, container().size());
+ ASSERT_NOT_NULL(replaced);
ASSERT_LT(replaced->value(), OBJ_COUNT);
EXPECT_TRUE(KeyTraits::EqualTo(KeyTraits::GetKey(*replaced), i));
EXPECT_TRUE(KeyTraits::EqualTo(KeyTraits::GetKey(*replaced), replaced->value()));
@@ -438,49 +407,45 @@
ASSERT_EQ(objects()[i], PtrTraits::GetRaw(replaced));
ReleaseObject(i);
replaced = nullptr;
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, container().size(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, container().size());
// The replaced object should be gone now.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + i + 1));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + i + 1));
} else {
EXPECT_EQ(i + 1, ObjType::live_obj_count());
- EXPECT_EQ(i + 1, container().size(), "");
- EXPECT_NULL(replaced, "");
+ EXPECT_EQ(i + 1, container().size());
+ EXPECT_NULL(replaced);
// We should have succeeded in inserting this object, so the delete count should not
// have gone up.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + OBJ_COUNT));
+ ASSERT_NO_FATAL_FAILURES(
+ TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + OBJ_COUNT));
}
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
while (!container().is_empty()) {
PtrType ptr = container().erase(container().begin());
TestEnvTraits::ReleaseObject(ptr);
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(already_destroyed + (2 * OBJ_COUNT) +
- extra_elements));
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(TestEnvTraits::CheckCustomDeleteInvocations(
+ already_destroyed + (2 * OBJ_COUNT) + extra_elements));
}
- bool InsertOrReplace() {
- BEGIN_TEST;
-
+ void InsertOrReplace() {
// Each time we run each version of the tests, we create and destroy 2 *
// OBJ_COUNT + the number of extra elements we specify;
constexpr size_t EXTRA_ELEMENTS = 10;
constexpr size_t TOTAL_OBJS = (2 * OBJ_COUNT) + EXTRA_ELEMENTS;
- EXPECT_TRUE(DoInsertOrReplace<MoveUtil>(EXTRA_ELEMENTS, 0), "");
+ ASSERT_NO_FATAL_FAILURES(DoInsertOrReplace<MoveUtil>(EXTRA_ELEMENTS, 0));
if (CopyUtil<PtrTraits>::CanCopy) {
- EXPECT_TRUE(DoInsertOrReplace<CopyUtil<PtrTraits>>(EXTRA_ELEMENTS, TOTAL_OBJS), "");
+ ASSERT_NO_FATAL_FAILURES(DoInsertOrReplace<CopyUtil<PtrTraits>>(EXTRA_ELEMENTS, TOTAL_OBJS));
}
-
- END_TEST;
}
protected:
@@ -563,3 +528,5 @@
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_ASSOCIATIVE_CONTAINER_TEST_ENVIRONMENT_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/base_test_environments.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/base_test_environments.h
index 6fe62e8..d4385d9 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/base_test_environments.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/base_test_environments.h
@@ -2,16 +2,17 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_BASE_TEST_ENVIRONMENTS_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_BASE_TEST_ENVIRONMENTS_H_
-#include <unittest/unittest.h>
+#include <utility>
+
#include <fbl/ref_counted.h>
#include <fbl/ref_ptr.h>
#include <fbl/tests/intrusive_containers/objects.h>
#include <fbl/tests/intrusive_containers/test_environment_utils.h>
#include <fbl/unique_ptr.h>
-
-#include <utility>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -227,61 +228,52 @@
// containers will use an implementation of push_front while associative
// containers will assign a key to the objects which get created and then
// use an implementation of insert.
- virtual bool Populate(ContainerType& container, RefAction ref_action = RefAction::HoldSome) = 0;
+ virtual void Populate(ContainerType& container, RefAction ref_action = RefAction::HoldSome) = 0;
- bool Reset() {
- BEGIN_TEST;
-
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ void Reset() {
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
container().clear();
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
for (size_t i = 0; i < OBJ_COUNT; ++i)
ReleaseObject(i);
- EXPECT_EQ(0u, refs_held(), "");
+ EXPECT_EQ(0u, refs_held());
refs_held() = 0;
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
ObjType::ResetLiveObjCount();
-
- END_TEST;
}
- bool Clear() {
- BEGIN_TEST;
-
+ void Clear() {
// Start by making some objects.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
// Clear the container. Afterwards, the number of live objects we have
// should be equal to the number of references being held by the test
// environment.
container().clear();
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_EQ(refs_held(), ObjType::live_obj_count(), "");
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_EQ(refs_held(), ObjType::live_obj_count());
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_NONNULL(objects()[i], "");
+ EXPECT_NOT_NULL(objects()[i]);
// If our underlying object it still being kept alive by the test
// environment, make sure that its internal pointer state has been
// properly cleared out.
if (HoldingObject(i)) {
auto& ns = ContainerType::NodeTraits::node_state(*objects()[i]);
- EXPECT_FALSE(ns.InContainer(), "");
+ EXPECT_FALSE(ns.InContainer());
}
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
- bool ClearUnsafe() {
- BEGIN_TEST;
-
+ void ClearUnsafe() {
// Start by making some objects.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
// Perform an unsafe clear of the container. Afterwards, the number of
// live objects we have should be equal to the number of elements
@@ -294,215 +286,192 @@
// (by necessity) always hold references to all internally allocated
// unmanaged objects.
container().clear_unsafe();
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_NONNULL(objects()[i], "");
+ EXPECT_NOT_NULL(objects()[i]);
// Make sure that the internal pointer states of all of our objects
// do not know yet that they have been removed from the container.
// The clear_unsafe operation should not have updated any of the
// internal object states.
auto& ns = ContainerType::NodeTraits::node_state(*objects()[i]);
- EXPECT_TRUE(ns.InContainer(), "");
+ EXPECT_TRUE(ns.InContainer());
}
-
- END_TEST;
}
- bool IsEmpty() {
- BEGIN_TEST;
-
- EXPECT_TRUE(container().is_empty(), "");
- ASSERT_TRUE(Populate(container()), "");
- EXPECT_FALSE(container().is_empty(), "");
- EXPECT_TRUE(Reset(), "");
- EXPECT_TRUE(container().is_empty(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
-
- END_TEST;
+ void IsEmpty() {
+ EXPECT_TRUE(container().is_empty());
+ ASSERT_NO_FAILURES(Populate(container()));
+ EXPECT_FALSE(container().is_empty());
+ Reset();
+ EXPECT_TRUE(container().is_empty());
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
template <typename TargetType>
- bool DoErase(TargetType&& target, size_t ndx, size_t remaining, bool check_ndx = true) {
- BEGIN_TEST;
-
- ASSERT_TRUE(ndx < OBJ_COUNT, "");
- ASSERT_TRUE(remaining <= OBJ_COUNT, "");
- ASSERT_TRUE(!container().is_empty(), "");
- ASSERT_TRUE(ValidEraseTarget(target), "");
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining, Size(container()), "");
+ void DoErase(TargetType&& target, size_t ndx, size_t remaining, bool check_ndx = true) {
+ ASSERT_TRUE(ndx < OBJ_COUNT);
+ ASSERT_TRUE(remaining <= OBJ_COUNT);
+ ASSERT_TRUE(!container().is_empty());
+ ASSERT_TRUE(ValidEraseTarget(target));
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining, Size(container()));
size_t erased_ndx;
{
// Erase the item and sanity check it against our tracking.
PtrType tmp = container().erase(target);
- ASSERT_NONNULL(tmp, "");
+ ASSERT_NOT_NULL(tmp);
if (check_ndx) {
- EXPECT_EQ(tmp->value(), ndx, "");
- EXPECT_EQ(objects()[ndx], tmp->raw_ptr(), "");
+ EXPECT_EQ(tmp->value(), ndx);
+ EXPECT_EQ(objects()[ndx], tmp->raw_ptr());
}
erased_ndx = tmp->value();
// Make sure that the intrusive bookkeeping is up-to-date.
auto& ns = ContainerType::NodeTraits::node_state(*tmp);
- EXPECT_TRUE(ns.IsValid(), "");
- EXPECT_FALSE(ns.InContainer(), "");
+ EXPECT_TRUE(ns.IsValid());
+ EXPECT_FALSE(ns.InContainer());
// The container has shrunk, but the object should still be around.
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining - 1, Size(container()), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining - 1, Size(container()));
}
// If we were not holding onto the object using the test
// environment's tracking, the live object count should have
// dropped. Otherwise, it should remain the same.
if (!HoldingObject(erased_ndx))
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
else
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
// Let go of the object and verify that it has now gone away.
ReleaseObject(erased_ndx);
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
-
- END_TEST;
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
}
- bool IterErase() {
- BEGIN_TEST;
-
+ void IterErase() {
// Don't perform index sanity checks for the objects we erase unless
// this is a sequence container type.
bool check_ndx = ContainerType::IsSequenced;
size_t erased = 0;
// Remove all of the elements from the container by erasing from the front.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(erased));
- EXPECT_TRUE(DoErase(container().begin(), i, OBJ_COUNT - i, check_ndx), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(++erased));
+ TestEnvTraits::CheckCustomDeleteInvocations(erased);
+ DoErase(container().begin(), i, OBJ_COUNT - i, check_ndx);
+ TestEnvTraits::CheckCustomDeleteInvocations(++erased);
}
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
// Remove all but 2 of the elements from the container by erasing from the middle.
static_assert(2 < OBJ_COUNT, "OBJ_COUNT too small to run Erase test!");
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
auto iter = container().begin();
iter++;
for (size_t i = 1; i < OBJ_COUNT - 1; ++i) {
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(erased));
- EXPECT_TRUE(DoErase(iter++, i, OBJ_COUNT - i + 1, check_ndx), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(++erased));
+ TestEnvTraits::CheckCustomDeleteInvocations(erased);
+ DoErase(iter++, i, OBJ_COUNT - i + 1, check_ndx);
+ TestEnvTraits::CheckCustomDeleteInvocations(++erased);
}
// Attempting to erase end() from a container with more than one element in
// it should return nullptr.
- EXPECT_NULL(container().erase(container().end()), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(erased));
- EXPECT_TRUE(DoErase(container().begin(), 0, 2, check_ndx), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(++erased));
+ EXPECT_NULL(container().erase(container().end()));
+ TestEnvTraits::CheckCustomDeleteInvocations(erased);
+ DoErase(container().begin(), 0, 2, check_ndx);
+ TestEnvTraits::CheckCustomDeleteInvocations(++erased);
// Attempting to erase end() from a container with just one element in
// it should return nullptr.
- EXPECT_NULL(container().erase(container().end()), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(erased));
- EXPECT_TRUE(DoErase(container().begin(), OBJ_COUNT - 1, 1, check_ndx), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(++erased));
+ EXPECT_NULL(container().erase(container().end()));
+ TestEnvTraits::CheckCustomDeleteInvocations(erased);
+ DoErase(container().begin(), OBJ_COUNT - 1, 1, check_ndx);
+ TestEnvTraits::CheckCustomDeleteInvocations(++erased);
// Attempting to erase end() from an empty container should return nullptr.
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_NULL(container().erase(container().end()), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_NULL(container().erase(container().end()));
EXPECT_EQ(erased, OBJ_COUNT * 2);
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT * 2));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT * 2);
}
- bool ReverseIterErase() {
- BEGIN_TEST;
-
+ void ReverseIterErase() {
// Don't perform index sanity checks for the objects we erase unless
// this is a sequence container type.
bool check_ndx = ContainerType::IsSequenced;
// Remove all of the elements from the container by erasing from the back.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
auto iter = container().end();
iter--;
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_TRUE(DoErase(iter--, OBJ_COUNT - i - 1, OBJ_COUNT - i, check_ndx), "");
+ DoErase(iter--, OBJ_COUNT - i - 1, OBJ_COUNT - i, check_ndx);
}
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
-
- END_TEST;
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
}
- bool DirectErase() {
- BEGIN_TEST;
-
+ void DirectErase() {
// Remove all of the elements from the container by erasing using direct
// node pointers which should end up always being at the front of the
// container.
- ASSERT_TRUE(Populate(container(), RefAction::HoldAll), "");
+ ASSERT_NO_FAILURES(Populate(container(), RefAction::HoldAll));
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- ASSERT_NONNULL(objects()[i], "");
- EXPECT_TRUE(DoErase(*objects()[i], i, OBJ_COUNT - i), "");
+ ASSERT_NOT_NULL(objects()[i]);
+ DoErase(*objects()[i], i, OBJ_COUNT - i);
}
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
// Remove all of the elements from the container by erasing using direct
// node pointers which should end up always being at the back of the
// container.
- ASSERT_TRUE(Populate(container(), RefAction::HoldAll), "");
+ ASSERT_NO_FAILURES(Populate(container(), RefAction::HoldAll));
for (size_t i = 0; i < OBJ_COUNT; ++i) {
size_t ndx = OBJ_COUNT - i - 1;
- ASSERT_NONNULL(objects()[ndx], "");
- EXPECT_TRUE(DoErase(*objects()[ndx], ndx, ndx + 1), "");
+ ASSERT_NOT_NULL(objects()[ndx]);
+ DoErase(*objects()[ndx], ndx, ndx + 1);
}
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
// Remove all of the elements from the container by erasing using direct
// node pointers which should end up always being somewhere in the
// middle of the container.
static_assert(2 < OBJ_COUNT, "OBJ_COUNT too small to run Erase test!");
- ASSERT_TRUE(Populate(container(), RefAction::HoldAll), "");
+ ASSERT_NO_FAILURES(Populate(container(), RefAction::HoldAll));
for (size_t i = 1; i < OBJ_COUNT - 1; ++i) {
- ASSERT_NONNULL(objects()[i], "");
- EXPECT_TRUE(DoErase(*objects()[i], i, OBJ_COUNT - i + 1), "");
+ ASSERT_NOT_NULL(objects()[i]);
+ DoErase(*objects()[i], i, OBJ_COUNT - i + 1);
}
-
- END_TEST;
}
template <typename IterType>
- bool DoIterate(const IterType& begin, const IterType& end) {
- BEGIN_TEST;
+ void DoIterate(const IterType& begin, const IterType& end) {
IterType iter;
// Iterate using begin/end
size_t i = 0;
for (iter = begin; iter != end;) {
// Exercise both -> and * dereferencing
- ASSERT_TRUE(iter.IsValid(), "");
+ ASSERT_TRUE(iter.IsValid());
- EXPECT_EQ(0u, iter->visited_count(), "");
+ EXPECT_EQ(0u, iter->visited_count());
iter->Visit();
- EXPECT_EQ(1u, (*iter).visited_count(), "");
+ EXPECT_EQ(1u, (*iter).visited_count());
(*iter).Visit();
- EXPECT_EQ(2u, (*iter).visited_count(), "");
+ EXPECT_EQ(2u, (*iter).visited_count());
// Exercise both pre and postfix increment
if ((i++) & 1)
@@ -510,10 +479,10 @@
else
++iter;
}
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
for (i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(2u, objects()[i]->visited_count(), "");
+ EXPECT_EQ(2u, objects()[i]->visited_count());
objects()[i]->ResetVisitedCount();
}
@@ -521,8 +490,8 @@
// both pre and post-fix.
iter = end;
++iter;
- EXPECT_FALSE(iter.IsValid(), "");
- EXPECT_TRUE(iter == end, "");
+ EXPECT_FALSE(iter.IsValid());
+ EXPECT_TRUE(iter == end);
// We know that the iterator is already at the end of the container, but
// perform the explicit assignment in order to check that the assignment
@@ -530,127 +499,120 @@
// constructor or the explicit rvalue constructor, if supplied)
iter = end;
iter++;
- EXPECT_FALSE(iter.IsValid(), "");
- EXPECT_TRUE(iter == end, "");
-
- END_TEST;
+ EXPECT_FALSE(iter.IsValid());
+ EXPECT_TRUE(iter == end);
}
- bool Iterate() {
- BEGIN_TEST;
-
+ void Iterate() {
// Both begin and cbegin should both be invalid, and to end/cend
- ASSERT_EQ(0u, Size(container()), "");
- EXPECT_FALSE(container().begin().IsValid(), "");
- EXPECT_TRUE(container().begin() == container().end(), "");
+ ASSERT_EQ(0u, Size(container()));
+ EXPECT_FALSE(container().begin().IsValid());
+ EXPECT_TRUE(container().begin() == container().end());
- EXPECT_FALSE(container().cbegin().IsValid(), "");
- EXPECT_TRUE(container().cbegin() == container().cend(), "");
+ EXPECT_FALSE(container().cbegin().IsValid());
+ EXPECT_TRUE(container().cbegin() == container().cend());
// Attempting to increment begin() for an empty container should result
// in an invalid iterator which is still equal to end(). Check both
// prefix and postfix decrement operators.
auto iter = container().begin();
++iter;
- EXPECT_TRUE(container().end() == iter, "");
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_TRUE(container().end() == iter);
+ EXPECT_FALSE(iter.IsValid());
iter = container().begin();
iter++;
- EXPECT_TRUE(container().end() == iter, "");
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_TRUE(container().end() == iter);
+ EXPECT_FALSE(iter.IsValid());
// Check const_iterator as well.
auto const_iter = container().cbegin();
++const_iter;
- EXPECT_TRUE(container().cend() == const_iter, "");
- EXPECT_FALSE(const_iter.IsValid(), "");
+ EXPECT_TRUE(container().cend() == const_iter);
+ EXPECT_FALSE(const_iter.IsValid());
const_iter = container().cbegin();
const_iter++;
- EXPECT_TRUE(container().cend() == const_iter, "");
- EXPECT_FALSE(const_iter.IsValid(), "");
+ EXPECT_TRUE(container().cend() == const_iter);
+ EXPECT_FALSE(const_iter.IsValid());
// Make some objects.
- ASSERT_TRUE(Populate(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
// Both begin and cbegin should both be valid, and not equal to end/cend
- EXPECT_TRUE(container().begin().IsValid(), "");
- EXPECT_TRUE(container().begin() != container().end(), "");
+ EXPECT_TRUE(container().begin().IsValid());
+ EXPECT_TRUE(container().begin() != container().end());
- EXPECT_TRUE(container().cbegin().IsValid(), "");
- EXPECT_TRUE(container().cbegin() != container().cend(), "");
+ EXPECT_TRUE(container().cbegin().IsValid());
+ EXPECT_TRUE(container().cbegin() != container().cend());
- EXPECT_TRUE(DoIterate(container().begin(), container().end()), ""); // Test iterator
- EXPECT_TRUE(DoIterate(container().cbegin(), container().cend()), ""); // Test const_iterator
+ DoIterate(container().begin(), container().end()); // Test iterator
+ DoIterate(container().cbegin(), container().cend()); // Test const_iterator
// Iterate using the range-based for loop syntax
for (auto& obj : container()) {
- EXPECT_EQ(0u, obj.visited_count(), "");
+ EXPECT_EQ(0u, obj.visited_count());
obj.Visit();
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
}
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(1u, objects()[i]->visited_count(), "");
+ EXPECT_EQ(1u, objects()[i]->visited_count());
objects()[i]->ResetVisitedCount();
}
// Iterate using the range-based for loop syntax over const references.
for (const auto& obj : container()) {
- EXPECT_EQ(0u, obj.visited_count(), "");
+ EXPECT_EQ(0u, obj.visited_count());
obj.Visit();
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
}
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(1u, objects()[i]->visited_count(), "");
+ EXPECT_EQ(1u, objects()[i]->visited_count());
objects()[i]->ResetVisitedCount();
}
// None of the objects should have been destroyed during this test.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
template <typename IterType>
- bool DoReverseIterate(const IterType& begin, const IterType& end) {
- BEGIN_TEST;
+ void DoReverseIterate(const IterType& begin, const IterType& end) {
IterType iter;
// Backing up one from end() should give a valid iterator (either prefix
// or postfix).
iter = end;
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
iter--;
- EXPECT_TRUE(iter.IsValid(), "");
+ EXPECT_TRUE(iter.IsValid());
iter = end;
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
--iter;
- EXPECT_TRUE(iter.IsValid(), "");
+ EXPECT_TRUE(iter.IsValid());
// Make sure that backing up an iterator by one points always points
// to the previous object in the container.
iter = begin;
size_t prev_ndx = iter->value();
while (++iter != end) {
- ASSERT_LT(prev_ndx, OBJ_COUNT, "");
- ASSERT_NONNULL(objects()[prev_ndx], "");
+ ASSERT_LT(prev_ndx, OBJ_COUNT);
+ ASSERT_NOT_NULL(objects()[prev_ndx]);
auto prev_iter = iter;
--prev_iter;
- ASSERT_TRUE(prev_iter.IsValid(), "");
- EXPECT_FALSE(prev_iter == iter, "");
- EXPECT_TRUE(*prev_iter == *objects()[prev_ndx], "");
+ ASSERT_TRUE(prev_iter.IsValid());
+ EXPECT_FALSE(prev_iter == iter);
+ EXPECT_TRUE(*prev_iter == *objects()[prev_ndx]);
prev_iter = iter;
prev_iter--;
- ASSERT_TRUE(prev_iter.IsValid(), "");
- EXPECT_FALSE(prev_iter == iter, "");
- EXPECT_TRUE(*prev_iter == *objects()[prev_ndx], "");
+ ASSERT_TRUE(prev_iter.IsValid());
+ EXPECT_FALSE(prev_iter == iter);
+ EXPECT_TRUE(*prev_iter == *objects()[prev_ndx]);
prev_ndx = iter->value();
}
@@ -658,160 +620,148 @@
// Attempting to back up past the beginning should result in an
// invalid iterator.
iter = begin;
- ASSERT_TRUE(iter.IsValid(), "");
+ ASSERT_TRUE(iter.IsValid());
--iter;
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
iter = begin;
- ASSERT_TRUE(iter.IsValid(), "");
+ ASSERT_TRUE(iter.IsValid());
iter--;
- EXPECT_FALSE(iter.IsValid(), "");
-
- END_TEST;
+ EXPECT_FALSE(iter.IsValid());
}
- bool ReverseIterate() {
- BEGIN_TEST;
-
+ void ReverseIterate() {
// Make sure that backing up from end() for an empty container stays at
// end. Check both prefix and postfix decrement operators.
- ASSERT_EQ(0u, Size(container()), "");
+ ASSERT_EQ(0u, Size(container()));
auto iter = container().end();
--iter;
- EXPECT_TRUE(container().end() == iter, "");
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_TRUE(container().end() == iter);
+ EXPECT_FALSE(iter.IsValid());
iter = container().end();
iter--;
- EXPECT_TRUE(container().end() == iter, "");
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_TRUE(container().end() == iter);
+ EXPECT_FALSE(iter.IsValid());
// Check const_iterator as well.
auto const_iter = container().cend();
--const_iter;
- EXPECT_TRUE(container().cend() == const_iter, "");
- EXPECT_FALSE(const_iter.IsValid(), "");
+ EXPECT_TRUE(container().cend() == const_iter);
+ EXPECT_FALSE(const_iter.IsValid());
const_iter = container().cend();
const_iter--;
- EXPECT_TRUE(container().cend() == const_iter, "");
- EXPECT_FALSE(const_iter.IsValid(), "");
+ EXPECT_TRUE(container().cend() == const_iter);
+ EXPECT_FALSE(const_iter.IsValid());
// Making some objects.
- ASSERT_TRUE(Populate(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
// Test iterator
- EXPECT_TRUE(DoReverseIterate(container().begin(), container().end()), "");
+ ASSERT_NO_FATAL_FAILURES(DoReverseIterate(container().begin(), container().end()));
// Test const_iterator
- EXPECT_TRUE(DoReverseIterate(container().cbegin(), container().cend()), "");
+ ASSERT_NO_FATAL_FAILURES(DoReverseIterate(container().cbegin(), container().cend()));
// None of the objects should have been destroyed during this test.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool MakeIterator() {
- BEGIN_TEST;
-
+ void MakeIterator() {
// Populate the container. Hold internal refs to everything we add to
// the container.
- ASSERT_TRUE(Populate(container(), RefAction::HoldAll), "");
+ ASSERT_NO_FAILURES(Populate(container(), RefAction::HoldAll));
// For every member of the container, make an iterator using the
// internal reference we are holding. Verify that the iterator is in
// the position we expect it to be in.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- ASSERT_NONNULL(objects()[i], "");
+ ASSERT_NOT_NULL(objects()[i]);
auto iter = container().make_iterator(*objects()[i]);
- ASSERT_TRUE(iter != container().end(), "");
- EXPECT_EQ(objects()[i]->value(), iter->value(), "");
- EXPECT_EQ(objects()[i], iter->raw_ptr(), "");
+ ASSERT_TRUE(iter != container().end());
+ EXPECT_EQ(objects()[i]->value(), iter->value());
+ EXPECT_EQ(objects()[i], iter->raw_ptr());
if (ContainerType::IsSequenced) {
auto other_iter = container().begin();
for (size_t j = 0; j < i; ++j) {
- EXPECT_FALSE(other_iter == iter, "");
+ EXPECT_FALSE(other_iter == iter);
++other_iter;
}
- EXPECT_TRUE(other_iter == iter, "");
+ EXPECT_TRUE(other_iter == iter);
}
}
-
- END_TEST;
}
- bool Swap() {
- BEGIN_TEST;
-
+ void Swap() {
{
- ContainerType other_container; // Make an empty container.
- ASSERT_TRUE(Populate(container()), ""); // Fill the internal container with stuff.
+ ContainerType other_container; // Make an empty container.
+ ASSERT_NO_FAILURES(Populate(container())); // Fill the internal container with stuff.
// Sanity check, swap, then check again.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_FALSE(container().is_empty(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_TRUE(other_container.is_empty(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_FALSE(container().is_empty());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_TRUE(other_container.is_empty());
for (auto& obj : container()) {
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
obj.Visit();
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
container().swap(other_container);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_FALSE(other_container.is_empty(), "");
- EXPECT_EQ(OBJ_COUNT, Size(other_container), "");
- EXPECT_TRUE(container().is_empty(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_FALSE(other_container.is_empty());
+ EXPECT_EQ(OBJ_COUNT, Size(other_container));
+ EXPECT_TRUE(container().is_empty());
for (auto& obj : other_container) {
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
obj.Visit();
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
// Swap back to check the case where container() was empty, but other_container
// had elements.
container().swap(other_container);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_FALSE(container().is_empty(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_TRUE(other_container.is_empty(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_FALSE(container().is_empty());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_TRUE(other_container.is_empty());
for (const auto& obj : container())
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
// Nothing should have been deleted yet.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
// Reset;
- EXPECT_TRUE(Reset(), "");
+ Reset();
// Now all of the objects should be gone.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
// Make a new other_container, this time with some stuff in it.
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
{
- ContainerType other_container; // Make an empty container.
- ASSERT_TRUE(Populate(container()), ""); // Fill the internal container with stuff.
+ ContainerType other_container; // Make an empty container.
+ ASSERT_NO_FAILURES(Populate(container())); // Fill the internal container with stuff.
static constexpr size_t OTHER_COUNT = 5;
static constexpr size_t OTHER_START = 10000;
@@ -824,107 +774,103 @@
}
// Sanity check
- EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_EQ(OTHER_COUNT, Size(other_container), "");
+ EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_EQ(OTHER_COUNT, Size(other_container));
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
// Visit everything in container() once, and everything in
// other_container twice.
for (auto& obj : container()) {
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
obj.Visit();
}
for (const auto& obj : other_container) {
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
obj.Visit();
obj.Visit();
}
for (auto& obj : container())
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
for (auto& obj : other_container)
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
// Swap and sanity check again
container().swap(other_container);
- EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(other_container), "");
- EXPECT_EQ(OTHER_COUNT, Size(container()), "");
+ EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(other_container));
+ EXPECT_EQ(OTHER_COUNT, Size(container()));
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
// Everything in container() should have been visited twice so far,
// while everything in other_container should have been visited
// once.
for (auto& obj : container())
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
for (auto& obj : other_container)
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
// Swap back and sanity check again
container().swap(other_container);
- EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_EQ(OTHER_COUNT, Size(other_container), "");
+ EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_EQ(OTHER_COUNT, Size(other_container));
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
for (auto& obj : container())
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
for (auto& obj : other_container)
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
// No new objects should have been deleted.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
// If we are testing unmanaged pointers clean them up.
- EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count());
other_container.clear();
if (!PtrTraits::IsManaged) {
- EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + OTHER_COUNT, ObjType::live_obj_count());
for (size_t i = 0; i < OTHER_COUNT; ++i)
delete raw_ptrs[i];
}
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
// Now, we should have deleted an additional OTHER_COUNT objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT + OTHER_COUNT));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT + OTHER_COUNT);
// Reset the internal state
- EXPECT_TRUE(Reset(), "");
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
+ Reset();
+ EXPECT_EQ(0u, ObjType::live_obj_count());
// Now we should have filled and emptied the test environment twice, and
// created+destroyed an additional OTHER_COUNT objects..
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations((2 * OBJ_COUNT) + OTHER_COUNT));
+ TestEnvTraits::CheckCustomDeleteInvocations((2 * OBJ_COUNT) + OTHER_COUNT);
}
-
- END_TEST;
}
- bool RvalueOps() {
- BEGIN_TEST;
-
+ void RvalueOps() {
// Populate the internal container.
- ASSERT_TRUE(Populate(container()), "");
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
for (auto& obj : container()) {
- ASSERT_GT(OBJ_COUNT, obj.value(), "");
- EXPECT_EQ(0u, obj.visited_count(), "");
- EXPECT_EQ(objects()[obj.value()], &obj, "");
+ ASSERT_GT(OBJ_COUNT, obj.value());
+ EXPECT_EQ(0u, obj.visited_count());
+ EXPECT_EQ(objects()[obj.value()], &obj);
obj.Visit();
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
// Move its contents to a new container by explicitly invoking the Rvalue
// constructor.
@@ -933,18 +879,18 @@
#else
ContainerType other_container(std::move(container()));
#endif
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(other_container), "");
- EXPECT_TRUE(container().is_empty(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(other_container));
+ EXPECT_TRUE(container().is_empty());
for (const auto& obj : other_container) {
- ASSERT_GT(OBJ_COUNT, obj.value(), "");
- EXPECT_EQ(1u, obj.visited_count(), "");
- EXPECT_EQ(objects()[obj.value()], &obj, "");
+ ASSERT_GT(OBJ_COUNT, obj.value());
+ EXPECT_EQ(1u, obj.visited_count());
+ EXPECT_EQ(objects()[obj.value()], &obj);
obj.Visit();
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
// Move the contents again, this time using move-initialization which implicitly
// invokes the Rvalue constructor.
@@ -953,19 +899,19 @@
#else
ContainerType another_container = std::move(other_container);
#endif
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(another_container), "");
- EXPECT_TRUE(other_container.is_empty(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(another_container));
+ EXPECT_TRUE(other_container.is_empty());
for (const auto& obj : another_container) {
- ASSERT_GT(OBJ_COUNT, obj.value(), "");
- EXPECT_EQ(2u, obj.visited_count(), "");
- EXPECT_EQ(objects()[obj.value()], &obj, "");
+ ASSERT_GT(OBJ_COUNT, obj.value());
+ EXPECT_EQ(2u, obj.visited_count());
+ EXPECT_EQ(objects()[obj.value()], &obj);
obj.Visit();
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(another_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(another_container));
// Move the contents of the final container back to the internal container. If we
// are testing managed pointer types, put some objects into the internal
@@ -982,19 +928,19 @@
}
// Sanity checks before the assignment
- EXPECT_EQ(OBJ_COUNT + extras_added, ObjType::live_obj_count(), "");
- EXPECT_EQ(extras_added, Size(container()), "");
+ EXPECT_EQ(OBJ_COUNT + extras_added, ObjType::live_obj_count());
+ EXPECT_EQ(extras_added, Size(container()));
for (const auto& obj : container()) {
- ASSERT_GT(EXTRA_COUNT, obj.value(), "");
- EXPECT_EQ(0u, obj.visited_count(), "");
+ ASSERT_GT(EXTRA_COUNT, obj.value());
+ EXPECT_EQ(0u, obj.visited_count());
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(another_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(another_container));
// No objects should have been deleted yet.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
#if TEST_WILL_NOT_COMPILE || 0
container() = another_container;
#else
@@ -1002,35 +948,31 @@
#endif
// The extra objects we put into container() should have been released
// when we moved the contents of another_container into container()
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(extras_added));
+ TestEnvTraits::CheckCustomDeleteInvocations(extras_added);
// another_container should now be empty, and we should have returned to our
// starting, post-populated state.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_TRUE(another_container.is_empty(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_TRUE(another_container.is_empty());
for (const auto& obj : container()) {
- ASSERT_GT(OBJ_COUNT, obj.value(), "");
- EXPECT_EQ(3u, obj.visited_count(), "");
- EXPECT_EQ(objects()[obj.value()], &obj, "");
+ ASSERT_GT(OBJ_COUNT, obj.value());
+ EXPECT_EQ(3u, obj.visited_count());
+ EXPECT_EQ(objects()[obj.value()], &obj);
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(another_container), "");
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(another_container));
}
- bool Scope() {
- BEGIN_TEST;
-
+ void Scope() {
// Make sure that both unique_ptrs and RefPtrs handle being moved
// properly, and that containers of such pointers automatically clean up
// when the container goes out of scope and destructs. Note: Don't try
// this with an unmanaged pointer. Lists of unmanaged pointers will
// ZX_ASSERT if they destruct with elements still in them.
- EXPECT_EQ(0U, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0U, ObjType::live_obj_count());
{ // Begin scope for container
ContainerType container;
@@ -1038,24 +980,20 @@
// Put some stuff into the container. Don't hold any internal
// references to anything we add.
Populate(container, RefAction::HoldNone);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
} // Let the container go out of scope and clean itself up..
- EXPECT_EQ(0U, ObjType::live_obj_count(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
-
- END_TEST;
+ EXPECT_EQ(0U, ObjType::live_obj_count());
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
- bool TwoContainer() {
- BEGIN_TEST;
-
+ void TwoContainer() {
// Start by populating the internal container. We should end up with
// OBJ_COUNT objects, but we may not be holding internal references to
// all of them.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
// Create the other type of container that ObjType can exist on and populate
// it using the default operation for the container type.
@@ -1066,28 +1004,28 @@
// The two containers should be the same length, and nothing should have
// changed about the live object count.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(other_container), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(other_container));
// Make sure that none of the members of container() or other_container
// have been visited. Then visit every member of other_container, and
// make sure that all of the members of container() have been visited
// once.
for (auto& obj : container())
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
for (auto& obj : other_container)
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
for (auto& obj : other_container) {
obj.Visit();
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
}
for (auto& obj : container()) {
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
obj.Visit();
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
}
// If this is a sequenced container, then other_container should be in
@@ -1095,35 +1033,35 @@
if (OtherContainerType::IsSequenced) {
auto other_iter = other_container.begin();
for (const auto& obj : container()) {
- ASSERT_FALSE(other_iter == other_container.end(), "");
- EXPECT_EQ(OBJ_COUNT - obj.value() - 1, other_iter->value(), "");
+ ASSERT_FALSE(other_iter == other_container.end());
+ EXPECT_EQ(OBJ_COUNT - obj.value() - 1, other_iter->value());
++other_iter;
}
- EXPECT_TRUE(other_iter == other_container.end(), "");
+ EXPECT_TRUE(other_iter == other_container.end());
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(other_container), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(other_container));
// Clear the internal container. No objects should go away and the other
// container should be un-affected
container().clear();
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(other_container), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(other_container));
for (auto& obj : other_container)
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
if (OtherContainerType::IsSequenced) {
auto other_iter = other_container.begin();
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- ASSERT_FALSE(other_iter == other_container.end(), "");
- EXPECT_EQ(OBJ_COUNT - i - 1, other_iter->value(), "");
+ ASSERT_FALSE(other_iter == other_container.end());
+ EXPECT_EQ(OBJ_COUNT - i - 1, other_iter->value());
++other_iter;
}
- EXPECT_TRUE(other_iter == other_container.end(), "");
+ EXPECT_TRUE(other_iter == other_container.end());
}
// If we are testing a container of managed pointers, release our internal
@@ -1137,32 +1075,29 @@
for (size_t i = 0; i < OBJ_COUNT; ++i)
ReleaseObject(i);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, refs_held(), "");
- EXPECT_EQ(OBJ_COUNT, Size(other_container), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(0u, refs_held());
+ EXPECT_EQ(OBJ_COUNT, Size(other_container));
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
// Finally, clear() other_container and reset the internal state. At this
// point, all objects should have gone away.
other_container.clear();
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
- EXPECT_TRUE(Reset(), "");
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
+ Reset();
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, refs_held(), "");
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_EQ(0u, Size(other_container), "");
-
- END_TEST;
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, refs_held());
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_EQ(0u, Size(other_container));
}
- bool ThreeContainerHelper() {
- BEGIN_TEST;
+ void ThreeContainerHelper() {
// Start by populating the internal container. We should end up with
// OBJ_COUNT objects, but we may not be holding internal references to
// all of them.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
// Create the other types of containers that ObjType can exist on and populate
// them using the default operation for the container type.
@@ -1176,42 +1111,42 @@
}
for (auto& obj : tagged1) {
- EXPECT_TRUE(InContainer<typename ContainerTraits::Tag1>(obj), "");
- EXPECT_TRUE(InContainer<typename ContainerTraits::Tag2>(obj), "");
- EXPECT_TRUE(InContainer<typename ContainerTraits::Tag3>(obj), "");
+ EXPECT_TRUE(InContainer<typename ContainerTraits::Tag1>(obj));
+ EXPECT_TRUE(InContainer<typename ContainerTraits::Tag2>(obj));
+ EXPECT_TRUE(InContainer<typename ContainerTraits::Tag3>(obj));
}
// The three containers should be the same length, and nothing should have
// changed about the live object count.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged1), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged2), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged3), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(tagged1));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged2));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged3));
// Make sure that none of the members of container() or other_container
// have been visited. Then visit every member of the other containers,
// and make sure that all of the members of container() have been
// visited once.
for (auto& obj : tagged1)
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
for (auto& obj : tagged2)
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
for (auto& obj : tagged3)
- ASSERT_EQ(0u, obj.visited_count(), "");
+ ASSERT_EQ(0u, obj.visited_count());
for (auto& obj : tagged1) {
obj.Visit();
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
}
for (auto& obj : tagged2) {
obj.Visit();
- EXPECT_EQ(2u, obj.visited_count(), "");
+ EXPECT_EQ(2u, obj.visited_count());
}
for (auto& obj : tagged3) {
obj.Visit();
- EXPECT_EQ(3u, obj.visited_count(), "");
+ EXPECT_EQ(3u, obj.visited_count());
}
// If this is a sequenced container, then the other containers should be in
@@ -1221,51 +1156,51 @@
ContainerTraits::TaggedType3::IsSequenced) {
auto iter1 = tagged1.begin();
for (const auto& obj : container()) {
- ASSERT_FALSE(iter1 == tagged1.end(), "");
- EXPECT_EQ(OBJ_COUNT - obj.value() - 1, iter1->value(), "");
+ ASSERT_FALSE(iter1 == tagged1.end());
+ EXPECT_EQ(OBJ_COUNT - obj.value() - 1, iter1->value());
++iter1;
}
- EXPECT_TRUE(iter1 == tagged1.end(), "");
+ EXPECT_TRUE(iter1 == tagged1.end());
auto iter2 = tagged2.begin();
for (const auto& obj : container()) {
- ASSERT_FALSE(iter2 == tagged2.end(), "");
- EXPECT_EQ(OBJ_COUNT - obj.value() - 1, iter2->value(), "");
+ ASSERT_FALSE(iter2 == tagged2.end());
+ EXPECT_EQ(OBJ_COUNT - obj.value() - 1, iter2->value());
++iter2;
}
- EXPECT_TRUE(iter2 == tagged2.end(), "");
+ EXPECT_TRUE(iter2 == tagged2.end());
auto iter3 = tagged3.begin();
for (const auto& obj : container()) {
- ASSERT_FALSE(iter3 == tagged3.end(), "");
- EXPECT_EQ(OBJ_COUNT - obj.value() - 1, iter3->value(), "");
+ ASSERT_FALSE(iter3 == tagged3.end());
+ EXPECT_EQ(OBJ_COUNT - obj.value() - 1, iter3->value());
++iter3;
}
- EXPECT_TRUE(iter3 == tagged3.end(), "");
+ EXPECT_TRUE(iter3 == tagged3.end());
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(tagged1), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(tagged2), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(tagged3), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(tagged1));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(tagged2));
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(tagged3));
// Clear the internal container. No objects should go away and the other
// containers should be un-affected
container().clear();
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged1), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged2), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged3), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged1));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged2));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged3));
for (auto& obj : tagged1) {
- EXPECT_EQ(3u, obj.visited_count(), "");
+ EXPECT_EQ(3u, obj.visited_count());
}
for (auto& obj : tagged2) {
- EXPECT_EQ(3u, obj.visited_count(), "");
+ EXPECT_EQ(3u, obj.visited_count());
}
for (auto& obj : tagged3) {
- EXPECT_EQ(3u, obj.visited_count(), "");
+ EXPECT_EQ(3u, obj.visited_count());
}
if constexpr (ContainerTraits::TaggedType1::IsSequenced &&
@@ -1273,27 +1208,27 @@
ContainerTraits::TaggedType3::IsSequenced) {
auto iter1 = tagged1.begin();
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- ASSERT_FALSE(iter1 == tagged1.end(), "");
- EXPECT_EQ(OBJ_COUNT - i - 1, iter1->value(), "");
+ ASSERT_FALSE(iter1 == tagged1.end());
+ EXPECT_EQ(OBJ_COUNT - i - 1, iter1->value());
++iter1;
}
- EXPECT_TRUE(iter1 == tagged1.end(), "");
+ EXPECT_TRUE(iter1 == tagged1.end());
auto iter2 = tagged2.begin();
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- ASSERT_FALSE(iter2 == tagged2.end(), "");
- EXPECT_EQ(OBJ_COUNT - i - 1, iter2->value(), "");
+ ASSERT_FALSE(iter2 == tagged2.end());
+ EXPECT_EQ(OBJ_COUNT - i - 1, iter2->value());
++iter2;
}
- EXPECT_TRUE(iter2 == tagged2.end(), "");
+ EXPECT_TRUE(iter2 == tagged2.end());
auto iter3 = tagged3.begin();
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- ASSERT_FALSE(iter3 == tagged3.end(), "");
- EXPECT_EQ(OBJ_COUNT - i - 1, iter3->value(), "");
+ ASSERT_FALSE(iter3 == tagged3.end());
+ EXPECT_EQ(OBJ_COUNT - i - 1, iter3->value());
++iter3;
}
- EXPECT_TRUE(iter3 == tagged3.end(), "");
+ EXPECT_TRUE(iter3 == tagged3.end());
}
// If we are testing a container of managed pointers, release our internal
@@ -1307,61 +1242,58 @@
for (size_t i = 0; i < OBJ_COUNT; ++i)
ReleaseObject(i);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, refs_held(), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged1), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged2), "");
- EXPECT_EQ(OBJ_COUNT, Size(tagged3), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(0u, refs_held());
+ EXPECT_EQ(OBJ_COUNT, Size(tagged1));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged2));
+ EXPECT_EQ(OBJ_COUNT, Size(tagged3));
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
// Finally, clear() the other other_containers and reset the internal state. At this
// point, all objects should have gone away.
tagged1.clear();
tagged2.clear();
tagged3.clear();
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
- EXPECT_TRUE(Reset(), "");
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
+ Reset();
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0u, refs_held(), "");
- EXPECT_EQ(0u, Size(container()), "");
- EXPECT_EQ(0u, Size(tagged1), "");
- EXPECT_EQ(0u, Size(tagged2), "");
- EXPECT_EQ(0u, Size(tagged3), "");
-
- END_TEST;
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0u, refs_held());
+ EXPECT_EQ(0u, Size(container()));
+ EXPECT_EQ(0u, Size(tagged1));
+ EXPECT_EQ(0u, Size(tagged2));
+ EXPECT_EQ(0u, Size(tagged3));
}
- bool IterCopyPointer() {
- BEGIN_TEST;
+ void IterCopyPointer() {
PtrType ptr;
typename ContainerType::iterator iter;
// A default constructed iterator should give back nullptr when
// CopyPointer is called.
ptr = iter.CopyPointer();
- EXPECT_NULL(ptr, "");
+ EXPECT_NULL(ptr);
// The begining/end of an emptry container should also return nullptr.
ptr = container().begin().CopyPointer();
- EXPECT_NULL(ptr, "");
+ EXPECT_NULL(ptr);
ptr = container().end().CopyPointer();
- EXPECT_NULL(ptr, "");
+ EXPECT_NULL(ptr);
// Populate the container.
- ASSERT_TRUE(Populate(container(), RefAction::HoldAll), "");
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, refs_held(), "");
+ ASSERT_NO_FAILURES(Populate(container(), RefAction::HoldAll));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, refs_held());
// end().CopyPointer should still return nullptr.
ptr = container().end().CopyPointer();
- EXPECT_NULL(ptr, "");
+ EXPECT_NULL(ptr);
// begin().CopyPointer() should be non-null.
ptr = container().begin().CopyPointer();
- EXPECT_NONNULL(ptr, "");
+ EXPECT_NOT_NULL(ptr);
// clear the container and release all internally held references.
container().clear();
@@ -1370,25 +1302,21 @@
// We should not be holding any references, but we should still have a
// live object if we are testing a managed pointer type.
- EXPECT_EQ(0u, refs_held(), "");
+ EXPECT_EQ(0u, refs_held());
if (PtrTraits::IsManaged)
- EXPECT_EQ(1u, ObjType::live_obj_count(), "");
+ EXPECT_EQ(1u, ObjType::live_obj_count());
else
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
// null out our pointer. No matter what, our live_obj_count should now
// be zero.
ptr = nullptr;
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
-
- END_TEST;
+ EXPECT_EQ(0u, ObjType::live_obj_count());
}
- bool EraseIf() {
- BEGIN_TEST;
-
+ void EraseIf() {
// Populate our container.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
// Erase all of the even members
size_t even_erased = 0;
@@ -1399,11 +1327,11 @@
even_erased++;
}
- EXPECT_EQ(EVEN_OBJ_COUNT, even_erased, "");
- EXPECT_EQ(OBJ_COUNT, even_erased + Size(container()), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(even_erased));
+ EXPECT_EQ(EVEN_OBJ_COUNT, even_erased);
+ EXPECT_EQ(OBJ_COUNT, even_erased + Size(container()));
+ TestEnvTraits::CheckCustomDeleteInvocations(even_erased);
for (const auto& obj : container())
- EXPECT_TRUE(obj.value() & 1, "");
+ EXPECT_TRUE(obj.value() & 1);
// Erase all of the odd members
size_t odd_erased = 0;
@@ -1414,33 +1342,29 @@
odd_erased++;
}
- EXPECT_EQ(ODD_OBJ_COUNT, odd_erased, "");
- EXPECT_EQ(OBJ_COUNT, even_erased + odd_erased, "");
- EXPECT_TRUE(container().is_empty(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
-
- END_TEST;
+ EXPECT_EQ(ODD_OBJ_COUNT, odd_erased);
+ EXPECT_EQ(OBJ_COUNT, even_erased + odd_erased);
+ EXPECT_TRUE(container().is_empty());
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
- bool FindIf() {
- BEGIN_TEST;
-
+ void FindIf() {
// Populate our container.
- ASSERT_TRUE(Populate(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
// Find all of the members which should be in the container.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
auto iter =
const_container().find_if([i](const ObjType& obj) -> bool { return (obj.value() == i); });
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(0u, iter->visited_count(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(0u, iter->visited_count());
iter->Visit();
}
// Every member should have been visited once.
for (auto& obj : container()) {
- EXPECT_EQ(1u, obj.visited_count(), "");
+ EXPECT_EQ(1u, obj.visited_count());
obj.ResetVisitedCount();
}
@@ -1456,22 +1380,20 @@
++total_found;
iter->Visit();
}
- EXPECT_EQ(ODD_OBJ_COUNT, total_found, "");
+ EXPECT_EQ(ODD_OBJ_COUNT, total_found);
// All of the odd members should have been visited once, while all of
// the even members should not have been visited.
for (const auto& obj : container())
- EXPECT_EQ(obj.value() & 1, obj.visited_count(), "");
+ EXPECT_EQ(obj.value() & 1, obj.visited_count());
// Fail to find a member which should not be in the container.
auto iter = const_container().find_if(
[](const ObjType& obj) -> bool { return (obj.value() == OBJ_COUNT); });
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
// We should not have destroyed any objects in this test.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
static PtrType TakePtr(PtrType& ptr) {
@@ -1505,3 +1427,5 @@
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_BASE_TEST_ENVIRONMENTS_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_doubly_linked_list_checker.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_doubly_linked_list_checker.h
index 50d99ac..1425adc 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_doubly_linked_list_checker.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_doubly_linked_list_checker.h
@@ -2,10 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_DOUBLY_LINKED_LIST_CHECKER_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_DOUBLY_LINKED_LIST_CHECKER_H_
-#include <unittest/unittest.h>
#include <fbl/intrusive_hash_table.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -20,17 +21,15 @@
class DoublyLinkedListChecker {
public:
template <typename ContainerType>
- static bool SanityCheck(const ContainerType& container) {
+ static void SanityCheck(const ContainerType& container) {
using NodeTraits = typename ContainerType::NodeTraits;
using PtrTraits = typename ContainerType::PtrTraits;
- BEGIN_TEST;
-
typename PtrTraits::RawPtrType tmp = container.head_;
while (true) {
- ASSERT_NONNULL(tmp, "");
+ ASSERT_NOT_NULL(tmp);
if (is_sentinel_ptr(tmp)) {
- ASSERT_EQ(container.sentinel(), tmp, "");
+ ASSERT_EQ(container.sentinel(), tmp);
break;
}
@@ -39,15 +38,15 @@
tmp = container.tail();
if (!is_sentinel_ptr(container.head_)) {
- ASSERT_NONNULL(tmp, "");
+ ASSERT_NOT_NULL(tmp);
tmp = NodeTraits::node_state(*tmp).next_;
}
- ASSERT_EQ(container.sentinel(), tmp, "");
-
- END_TEST;
+ ASSERT_EQ(container.sentinel(), tmp);
}
};
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_DOUBLY_LINKED_LIST_CHECKER_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_hash_table_checker.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_hash_table_checker.h
index a429654..bdfacf8 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_hash_table_checker.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_hash_table_checker.h
@@ -2,13 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_HASH_TABLE_CHECKER_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_HASH_TABLE_CHECKER_H_
-#include <unittest/unittest.h>
#include <fbl/intrusive_hash_table.h>
#include <fbl/tests/intrusive_containers/intrusive_doubly_linked_list_checker.h>
#include <fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h>
#include <fbl/tests/intrusive_containers/test_environment_utils.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -19,35 +20,33 @@
class HashTableChecker {
public:
template <typename ContainerType>
- static bool SanityCheck(const ContainerType& container) {
+ static void SanityCheck(const ContainerType& container) {
using BucketType = typename ContainerType::BucketType;
using BucketChecker = typename BucketType::CheckerType;
using HashType = typename ContainerType::HashType;
using HashTraits = typename ContainerType::HashTraits;
using KeyTraits = typename ContainerType::KeyTraits;
- BEGIN_TEST;
-
// Demand that every bucket pass its sanity check. Keep a running total
// of the total size of the HashTable in the process.
size_t total_size = 0;
for (size_t i = 0; i < ContainerType::kNumBuckets; ++i) {
- ASSERT_TRUE(BucketChecker::SanityCheck(container.buckets_[i]), "");
+ ASSERT_NO_FATAL_FAILURES(BucketChecker::SanityCheck(container.buckets_[i]));
total_size += SizeUtils<BucketType>::size(container.buckets_[i]);
// For every element in the bucket, make sure that the bucket index
// matches the hash of the element.
for (const auto& obj : container.buckets_[i]) {
- ASSERT_EQ(HashTraits::GetHash(KeyTraits::GetKey(obj)), static_cast<HashType>(i), "");
+ ASSERT_EQ(HashTraits::GetHash(KeyTraits::GetKey(obj)), static_cast<HashType>(i));
}
}
- EXPECT_EQ(container.size(), total_size, "");
-
- END_TEST;
+ EXPECT_EQ(container.size(), total_size);
}
};
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_HASH_TABLE_CHECKER_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h
index c64f26c..68e3cca 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h
@@ -2,10 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_SINGLY_LINKED_LIST_CHECKER_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_SINGLY_LINKED_LIST_CHECKER_H_
-#include <unittest/unittest.h>
#include <fbl/intrusive_hash_table.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -20,27 +21,26 @@
class SinglyLinkedListChecker {
public:
template <typename ContainerType>
- static bool SanityCheck(const ContainerType& container) {
+ static void SanityCheck(const ContainerType& container) {
using NodeTraits = typename ContainerType::NodeTraits;
using PtrTraits = typename ContainerType::PtrTraits;
- BEGIN_TEST;
typename PtrTraits::RawPtrType tmp = container.head_;
while (true) {
- ASSERT_NONNULL(tmp, "");
+ ASSERT_NOT_NULL(tmp);
if (is_sentinel_ptr(tmp)) {
- ASSERT_EQ(container.sentinel(), tmp, "");
+ ASSERT_EQ(container.sentinel(), tmp);
break;
}
tmp = NodeTraits::node_state(*tmp).next_;
}
-
- END_TEST;
}
};
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_SINGLY_LINKED_LIST_CHECKER_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_wavl_tree_checker.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_wavl_tree_checker.h
index 90bd4df..2f1663b 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_wavl_tree_checker.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/intrusive_wavl_tree_checker.h
@@ -2,10 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_WAVL_TREE_CHECKER_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_WAVL_TREE_CHECKER_H_
-#include <unittest/unittest.h>
#include <fbl/intrusive_wavl_tree.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -17,11 +18,10 @@
class WAVLTreeChecker {
public:
template <typename TreeType>
- static bool VerifyParentBackLinks(const TreeType& tree, typename TreeType::RawPtrType node) {
- BEGIN_TEST;
+ static void VerifyParentBackLinks(const TreeType& tree, typename TreeType::RawPtrType node) {
using NodeTraits = typename TreeType::NodeTraits;
- ASSERT_TRUE(valid_sentinel_ptr(node), "");
+ ASSERT_TRUE(valid_sentinel_ptr(node));
const auto& ns = NodeTraits::node_state(*node);
if (valid_sentinel_ptr(ns.left_)) {
@@ -33,13 +33,10 @@
EXPECT_EQ(node, NodeTraits::node_state(*ns.right_).parent_,
"Corrupt right-side parent back-link!");
}
-
- END_TEST;
}
template <typename TreeType>
- static bool SanityCheck(const TreeType& tree) {
- BEGIN_TEST;
+ static void SanityCheck(const TreeType& tree) {
using NodeTraits = typename TreeType::NodeTraits;
using RawPtrType = typename TreeType::RawPtrType;
using Observer = typename TreeType::Observer;
@@ -48,26 +45,26 @@
if (tree.is_empty()) {
// If the tree is empty, then the root should be null, and the
// left/right-most members should be set to the sentinel value.
- ASSERT_NULL(tree.root_, "");
- ASSERT_EQ(tree.sentinel(), tree.left_most_, "");
- ASSERT_EQ(tree.sentinel(), tree.right_most_, "");
- EXPECT_EQ(0u, tree.size(), "");
+ ASSERT_NULL(tree.root_);
+ ASSERT_EQ(tree.sentinel(), tree.left_most_);
+ ASSERT_EQ(tree.sentinel(), tree.right_most_);
+ EXPECT_EQ(0u, tree.size());
} else {
// If the tree is non-empty, then the root, left-most and
// right-most pointers should all be valid. The LR-child of the
// LR-most element should be the sentinel value.
- ASSERT_NONNULL(tree.root_, "");
- ASSERT_FALSE(is_sentinel_ptr(tree.root_), "");
+ ASSERT_NOT_NULL(tree.root_);
+ ASSERT_FALSE(is_sentinel_ptr(tree.root_));
- ASSERT_NONNULL(tree.left_most_, "");
- ASSERT_FALSE(is_sentinel_ptr(tree.left_most_), "");
- ASSERT_EQ(tree.sentinel(), NodeTraits::node_state(*tree.left_most_).left_, "");
+ ASSERT_NOT_NULL(tree.left_most_);
+ ASSERT_FALSE(is_sentinel_ptr(tree.left_most_));
+ ASSERT_EQ(tree.sentinel(), NodeTraits::node_state(*tree.left_most_).left_);
- ASSERT_NONNULL(tree.right_most_, "");
- ASSERT_FALSE(is_sentinel_ptr(tree.right_most_), "");
- ASSERT_EQ(tree.sentinel(), NodeTraits::node_state(*tree.right_most_).right_, "");
+ ASSERT_NOT_NULL(tree.right_most_);
+ ASSERT_FALSE(is_sentinel_ptr(tree.right_most_));
+ ASSERT_EQ(tree.sentinel(), NodeTraits::node_state(*tree.right_most_).right_);
- EXPECT_LT(0u, tree.size(), "");
+ EXPECT_LT(0u, tree.size());
}
// Compute the size and depth of the tree, verifying the parent
@@ -83,7 +80,7 @@
// Start by going left until we have determined the depth of the
// left most node of the tree.
while (valid_sentinel_ptr(node)) {
- ASSERT_TRUE(VerifyParentBackLinks(tree, node), "");
+ ASSERT_NO_FAILURES(VerifyParentBackLinks(tree, node));
auto& ns = NodeTraits::node_state(*node);
++cur_depth;
@@ -111,22 +108,22 @@
depth = cur_depth;
++size;
- ASSERT_TRUE(VerifyParentBackLinks(tree, node), "");
+ ASSERT_NO_FAILURES(VerifyParentBackLinks(tree, node));
// Verify the rank rule using the tree's observer's implementation.
// If this sanity check is being run as part of the balance test, it
// will use the implementation above. For all other tests, only the
// rank parity is stored in the node, so we cannot rigorously verify
// the rule. The default VerifyRankRule implementation will be used
- // instead (which just returns true).
- ASSERT_TRUE(Observer::VerifyRankRule(tree, node), "");
+ // instead.
+ ASSERT_NO_FAILURES(Observer::VerifyRankRule(tree, node));
// #2: Can we go right?
const auto& ns = NodeTraits::node_state(*node);
if (valid_sentinel_ptr(ns.right_)) {
cur_depth++;
node = ns.right_;
- ASSERT_TRUE(VerifyParentBackLinks(tree, node), "");
+ ASSERT_NO_FAILURES(VerifyParentBackLinks(tree, node));
// Now go as far left as we can.
while (true) {
@@ -137,7 +134,7 @@
++cur_depth;
node = ns.left_;
- ASSERT_TRUE(VerifyParentBackLinks(tree, node), "");
+ ASSERT_NO_FAILURES(VerifyParentBackLinks(tree, node));
}
// Loop and visit the next node.
@@ -152,8 +149,8 @@
bool is_left = (parent_ns.left_ == node);
bool is_right = (parent_ns.right_ == node);
- ASSERT_TRUE(is_left != is_right, "");
- ASSERT_TRUE(is_left || is_right, "");
+ ASSERT_TRUE(is_left != is_right);
+ ASSERT_TRUE(is_left || is_right);
node = parent;
--cur_depth;
@@ -170,16 +167,16 @@
}
// We should have visited all of the nodes by now.
- ASSERT_EQ(tree.size(), size, "");
+ ASSERT_EQ(tree.size(), size);
// If this is being called from the balance tests, check the balance
// bounds, and computational complexity bounds.
- ASSERT_TRUE(Observer::VerifyBalance(tree, depth), "");
-
- END_TEST;
+ ASSERT_NO_FAILURES(Observer::VerifyBalance(tree, depth));
}
};
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_INTRUSIVE_WAVL_TREE_CHECKER_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/objects.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/objects.h
index 8bee00c..c2306bd 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/objects.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/objects.h
@@ -2,17 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_OBJECTS_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_OBJECTS_H_
+
+#include <atomic>
+#include <memory>
+#include <utility>
#include <fbl/alloc_checker.h>
#include <fbl/ref_counted.h>
#include <fbl/ref_ptr.h>
#include <fbl/unique_ptr.h>
-#include <unittest/unittest.h>
-
-#include <atomic>
-#include <memory>
-#include <utility>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -206,7 +207,7 @@
ptr = nullptr;
}
- static bool CheckCustomDeleteInvocations(size_t expected) { return true; }
+ static void CheckCustomDeleteInvocations(size_t expected) {}
static void ResetCustomDeleter() {}
// Unmanaged pointers never get cleared when being moved or transferred.
@@ -230,7 +231,7 @@
static void ReleaseObject(PtrType& ptr) { ptr = nullptr; }
- static bool CheckCustomDeleteInvocations(size_t expected) { return true; }
+ static void CheckCustomDeleteInvocations(size_t expected) {}
static void ResetCustomDeleter() {}
// Unique pointers always get cleared when being moved or transferred.
@@ -254,7 +255,7 @@
static void ReleaseObject(PtrType& ptr) { ptr = nullptr; }
- static bool CheckCustomDeleteInvocations(size_t expected) { return true; }
+ static void CheckCustomDeleteInvocations(size_t expected) {}
static void ResetCustomDeleter() {}
// Unique pointers always get cleared when being moved or transferred.
@@ -278,10 +279,8 @@
static void ReleaseObject(PtrType& ptr) { ptr = nullptr; }
- static bool CheckCustomDeleteInvocations(size_t expected) {
- BEGIN_HELPER;
+ static void CheckCustomDeleteInvocations(size_t expected) {
EXPECT_EQ(expected, TestCustomDeleter<_ObjType>::delete_count());
- END_HELPER;
}
static void ResetCustomDeleter() { TestCustomDeleter<_ObjType>::reset_delete_count(); }
@@ -307,7 +306,7 @@
static void ReleaseObject(PtrType& ptr) { ptr = nullptr; }
- static bool CheckCustomDeleteInvocations(size_t expected) { return true; }
+ static void CheckCustomDeleteInvocations(size_t expected) {}
static void ResetCustomDeleter() {}
// RefCounted pointers do not get cleared when being transferred, but do get
@@ -320,3 +319,5 @@
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_OBJECTS_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/ordered_associative_container_test_environment.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/ordered_associative_container_test_environment.h
index 240ec36..fcedb35c 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/ordered_associative_container_test_environment.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/ordered_associative_container_test_environment.h
@@ -2,11 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_ORDERED_ASSOCIATIVE_CONTAINER_TEST_ENVIRONMENT_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_ORDERED_ASSOCIATIVE_CONTAINER_TEST_ENVIRONMENT_H_
-#include <unittest/unittest.h>
#include <fbl/algorithm.h>
#include <fbl/tests/intrusive_containers/associative_container_test_environment.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -62,99 +63,83 @@
}
};
- bool DoOrderedIter(PopulateMethod populate_method) {
- BEGIN_TEST;
-
- ASSERT_TRUE(ACTE::Populate(container(), populate_method), "");
+ void DoOrderedIter(PopulateMethod populate_method) {
+ ASSERT_NO_FAILURES(ACTE::Populate(container(), populate_method));
auto iter = container().begin();
- EXPECT_TRUE(iter.IsValid(), "");
+ EXPECT_TRUE(iter.IsValid());
for (auto prev = iter++; iter.IsValid(); prev = iter++) {
// None of the associative containers currently support storing
// mutliple nodes with the same key, therefor the iteration ordering
// of the keys should be strictly monotonically increasing.
- ASSERT_TRUE(prev.IsValid(), "");
+ ASSERT_TRUE(prev.IsValid());
auto iter_key = KeyTraits::GetKey(*iter);
auto prev_key = KeyTraits::GetKey(*prev);
- EXPECT_TRUE(KeyTraits::LessThan(prev_key, iter_key), "");
- EXPECT_FALSE(KeyTraits::LessThan(iter_key, prev_key), "");
- EXPECT_FALSE(KeyTraits::EqualTo(prev_key, iter_key), "");
- EXPECT_FALSE(KeyTraits::EqualTo(iter_key, prev_key), "");
+ EXPECT_TRUE(KeyTraits::LessThan(prev_key, iter_key));
+ EXPECT_FALSE(KeyTraits::LessThan(iter_key, prev_key));
+ EXPECT_FALSE(KeyTraits::EqualTo(prev_key, iter_key));
+ EXPECT_FALSE(KeyTraits::EqualTo(iter_key, prev_key));
}
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
- END_TEST;
+ ASSERT_NO_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
}
- bool OrderedIter() {
- BEGIN_TEST;
-
- EXPECT_TRUE(DoOrderedIter(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(DoOrderedIter(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(DoOrderedIter(PopulateMethod::RandomKey), "");
-
- END_TEST;
+ void OrderedIter() {
+ ASSERT_NO_FATAL_FAILURES(DoOrderedIter(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoOrderedIter(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoOrderedIter(PopulateMethod::RandomKey));
}
- bool DoOrderedReverseIter(PopulateMethod populate_method) {
- BEGIN_TEST;
-
- ASSERT_TRUE(ACTE::Populate(container(), populate_method), "");
+ void DoOrderedReverseIter(PopulateMethod populate_method) {
+ ASSERT_NO_FAILURES(ACTE::Populate(container(), populate_method));
auto iter = container().end();
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
--iter;
- EXPECT_TRUE(iter.IsValid(), "");
+ EXPECT_TRUE(iter.IsValid());
for (auto prev = iter--; iter.IsValid(); prev = iter--) {
// None of the associative containers currently support storing
// mutliple nodes with the same key, therefor the reverse iteration
// ordering of the keys should be strictly monotonically decreasing.
- ASSERT_TRUE(prev.IsValid(), "");
+ ASSERT_TRUE(prev.IsValid());
auto iter_key = KeyTraits::GetKey(*iter);
auto prev_key = KeyTraits::GetKey(*prev);
- EXPECT_TRUE(KeyTraits::LessThan(iter_key, prev_key), "");
- EXPECT_FALSE(KeyTraits::LessThan(prev_key, iter_key), "");
- EXPECT_FALSE(KeyTraits::EqualTo(prev_key, iter_key), "");
- EXPECT_FALSE(KeyTraits::EqualTo(iter_key, prev_key), "");
+ EXPECT_TRUE(KeyTraits::LessThan(iter_key, prev_key));
+ EXPECT_FALSE(KeyTraits::LessThan(prev_key, iter_key));
+ EXPECT_FALSE(KeyTraits::EqualTo(prev_key, iter_key));
+ EXPECT_FALSE(KeyTraits::EqualTo(iter_key, prev_key));
}
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
- END_TEST;
+ ASSERT_NO_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
}
- bool OrderedReverseIter() {
- BEGIN_TEST;
-
- EXPECT_TRUE(DoOrderedReverseIter(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(DoOrderedReverseIter(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(DoOrderedReverseIter(PopulateMethod::RandomKey), "");
-
- END_TEST;
+ void OrderedReverseIter() {
+ ASSERT_NO_FATAL_FAILURES(DoOrderedReverseIter(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoOrderedReverseIter(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoOrderedReverseIter(PopulateMethod::RandomKey));
}
template <typename BoundTraits>
- bool DoBoundTest(PopulateMethod populate_method) {
- BEGIN_TEST;
-
+ void DoBoundTest(PopulateMethod populate_method) {
// Searching for a value while the tree is empty should always fail.
auto found = BoundTraits::Search(container(), 0u);
- EXPECT_FALSE(found.IsValid(), "");
+ EXPECT_FALSE(found.IsValid());
// Populate the container.
- ASSERT_TRUE(ACTE::Populate(container(), populate_method), "");
+ ASSERT_NO_FAILURES(ACTE::Populate(container(), populate_method));
// For every object we just put into the container compute the bound of
// obj.key, (obj.key - 1) and (obj.key + 1) using brute force as well as
// by using (upper|lower)_bound. Make sure that the result agree.
for (size_t i = 0; i < ACTE::OBJ_COUNT; ++i) {
auto ptr = ACTE::objects()[i];
- ASSERT_NONNULL(ptr, "");
+ ASSERT_NOT_NULL(ptr);
struct {
KeyType key;
@@ -170,7 +155,7 @@
// bound this/prev/next.
for (size_t j = 0; j < ACTE::OBJ_COUNT; ++j) {
auto tmp = ACTE::objects()[j];
- ASSERT_NONNULL(tmp, "");
+ ASSERT_NOT_NULL(tmp);
KeyType tmp_key = KeyTraits::GetKey(*tmp);
for (size_t k = 0; k < fbl::count_of(tests); ++k) {
@@ -192,48 +177,39 @@
// force. If we did find a bound, it should be the same bound
// we found using brute force.
if (test.bound != nullptr) {
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(test.bound, iter->raw_ptr(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(test.bound, iter->raw_ptr());
} else {
- EXPECT_FALSE(iter.IsValid(), "");
+ EXPECT_FALSE(iter.IsValid());
}
}
}
- ASSERT_TRUE(TestEnvironment<TestEnvTraits>::Reset(), "");
- END_TEST;
+ ASSERT_NO_FAILURES(TestEnvironment<TestEnvTraits>::Reset());
}
- bool UpperBound() {
- BEGIN_TEST;
-
+ void UpperBound() {
using NonConstBoundTraits = UpperBoundTraits<NonConstTraits>;
- EXPECT_TRUE(DoBoundTest<NonConstBoundTraits>(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(DoBoundTest<NonConstBoundTraits>(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(DoBoundTest<NonConstBoundTraits>(PopulateMethod::RandomKey), "");
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<NonConstBoundTraits>(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<NonConstBoundTraits>(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<NonConstBoundTraits>(PopulateMethod::RandomKey));
using ConstBoundTraits = UpperBoundTraits<ConstTraits>;
- EXPECT_TRUE(DoBoundTest<ConstBoundTraits>(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(DoBoundTest<ConstBoundTraits>(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(DoBoundTest<ConstBoundTraits>(PopulateMethod::RandomKey), "");
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<ConstBoundTraits>(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<ConstBoundTraits>(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<ConstBoundTraits>(PopulateMethod::RandomKey));
}
- bool LowerBound() {
- BEGIN_TEST;
-
+ void LowerBound() {
using NonConstBoundTraits = LowerBoundTraits<NonConstTraits>;
- EXPECT_TRUE(DoBoundTest<NonConstBoundTraits>(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(DoBoundTest<NonConstBoundTraits>(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(DoBoundTest<NonConstBoundTraits>(PopulateMethod::RandomKey), "");
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<NonConstBoundTraits>(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<NonConstBoundTraits>(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<NonConstBoundTraits>(PopulateMethod::RandomKey));
using ConstBoundTraits = LowerBoundTraits<ConstTraits>;
- EXPECT_TRUE(DoBoundTest<ConstBoundTraits>(PopulateMethod::AscendingKey), "");
- EXPECT_TRUE(DoBoundTest<ConstBoundTraits>(PopulateMethod::DescendingKey), "");
- EXPECT_TRUE(DoBoundTest<ConstBoundTraits>(PopulateMethod::RandomKey), "");
-
- END_TEST;
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<ConstBoundTraits>(PopulateMethod::AscendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<ConstBoundTraits>(PopulateMethod::DescendingKey));
+ ASSERT_NO_FATAL_FAILURES(DoBoundTest<ConstBoundTraits>(PopulateMethod::RandomKey));
}
private:
@@ -244,3 +220,5 @@
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_ORDERED_ASSOCIATIVE_CONTAINER_TEST_ENVIRONMENT_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/sequence_container_test_environment.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/sequence_container_test_environment.h
index c7ade58..e515199 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/sequence_container_test_environment.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/sequence_container_test_environment.h
@@ -2,14 +2,15 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
-
-#include <unittest/unittest.h>
-#include <fbl/algorithm.h>
-#include <fbl/tests/intrusive_containers/base_test_environments.h>
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_SEQUENCE_CONTAINER_TEST_ENVIRONMENT_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_SEQUENCE_CONTAINER_TEST_ENVIRONMENT_H_
#include <utility>
+#include <fbl/algorithm.h>
+#include <fbl/tests/intrusive_containers/base_test_environments.h>
+#include <zxtest/zxtest.h>
+
namespace fbl {
namespace tests {
namespace intrusive_containers {
@@ -39,14 +40,12 @@
return SizeUtils<CType>::size(container);
}
- bool Populate(ContainerType& container, RefAction ref_action = RefAction::HoldSome) override {
- BEGIN_TEST;
-
- EXPECT_EQ(0U, ObjType::live_obj_count(), "");
+ void Populate(ContainerType& container, RefAction ref_action = RefAction::HoldSome) override {
+ EXPECT_EQ(0U, ObjType::live_obj_count());
for (size_t i = 0; i < OBJ_COUNT; ++i) {
size_t ndx = OBJ_COUNT - i - 1;
- EXPECT_EQ(i, Size(container), "");
+ EXPECT_EQ(i, Size(container));
// Unless explicitly told to do so, don't hold a reference in the
// test environment for every 4th object created. Note, this only
@@ -69,8 +68,8 @@
}
PtrType new_object = this->CreateTrackedObject(ndx, ndx, hold_ref);
- ASSERT_NONNULL(new_object, "");
- EXPECT_EQ(new_object->raw_ptr(), objects()[ndx], "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_EQ(new_object->raw_ptr(), objects()[ndx]);
// Alternate whether or not we move the pointer, or "transfer" it.
// Transferring means different things for different pointer types.
@@ -84,38 +83,32 @@
#else
container.push_front(TestEnvTraits::Transfer(new_object));
#endif
- EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object));
} else {
container.push_front(std::move(new_object));
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
}
- EXPECT_EQ(OBJ_COUNT, Size(container), "");
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(container), "");
-
- END_TEST;
+ EXPECT_EQ(OBJ_COUNT, Size(container));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container));
}
- bool PushFront() {
- BEGIN_TEST;
- EXPECT_TRUE(Populate(container()), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
- END_TEST;
+ void PushFront() {
+ ASSERT_NO_FAILURES(Populate(container()));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool PushBack() {
- BEGIN_TEST;
-
- EXPECT_EQ(0U, ObjType::live_obj_count(), "");
+ void PushBack() {
+ EXPECT_EQ(0U, ObjType::live_obj_count());
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(i, Size(container()), "");
+ EXPECT_EQ(i, Size(container()));
PtrType new_object = this->CreateTrackedObject(i, i);
- ASSERT_NONNULL(new_object, "");
- EXPECT_EQ(new_object->raw_ptr(), objects()[i], "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_EQ(new_object->raw_ptr(), objects()[i]);
// Alternate whether or not we move the pointer, or "transfer" it.
if (i & 1) {
@@ -124,87 +117,79 @@
#else
container().push_back(TestEnvTraits::Transfer(new_object));
#endif
- EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object));
} else {
container().push_back(std::move(new_object));
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
}
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
size_t i = 0;
for (const auto& obj : container()) {
- ASSERT_LT(i, OBJ_COUNT, "");
- EXPECT_EQ(objects()[i]->value(), obj.value(), "");
- EXPECT_EQ(objects()[i], obj.raw_ptr(), "");
+ ASSERT_LT(i, OBJ_COUNT);
+ EXPECT_EQ(objects()[i]->value(), obj.value());
+ EXPECT_EQ(objects()[i], obj.raw_ptr());
i++;
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool PopFront() {
- BEGIN_TEST;
-
- ASSERT_TRUE(Populate(container()), "");
+ void PopFront() {
+ ASSERT_NO_FAILURES(Populate(container()));
// Remove elements using pop_front. List should shrink each time we
// remove an element, but the number of live objects should only shrink
// when we let the last reference go out of scope.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
size_t remaining = OBJ_COUNT - i;
- ASSERT_TRUE(!container().is_empty(), "");
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining, Size(container()), "");
+ ASSERT_TRUE(!container().is_empty());
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining, Size(container()));
{
// Pop the item and sanity check it against our tracking.
PtrType tmp = container().pop_front();
- EXPECT_NONNULL(tmp, "");
- EXPECT_EQ(tmp->value(), i, "");
- EXPECT_EQ(objects()[i], tmp->raw_ptr(), "");
+ EXPECT_NOT_NULL(tmp);
+ EXPECT_EQ(tmp->value(), i);
+ EXPECT_EQ(objects()[i], tmp->raw_ptr());
// Make sure that the intrusive bookkeeping is up-to-date.
auto& ns = ContainerType::NodeTraits::node_state(*tmp);
- EXPECT_NULL(ns.next_, "");
+ EXPECT_NULL(ns.next_);
// The container has shrunk, but the object should still be around.
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining - 1, Size(container()), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining - 1, Size(container()));
}
// If we were not holding onto the object using the test
// environment's tracking, the live object count should have
// dropped. Otherwise, it should remain the same.
if (!HoldingObject(i))
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
else
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
// Let go of the object and verify that it has now gone away.
ReleaseObject(i);
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(i + 1));
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
+ TestEnvTraits::CheckCustomDeleteInvocations(i + 1);
}
// List should be empty now. Popping anything else should result in a
// null pointer.
- EXPECT_TRUE(container().is_empty(), "");
+ EXPECT_TRUE(container().is_empty());
PtrType should_be_null = container().pop_front();
- EXPECT_NULL(should_be_null, "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
-
- END_TEST;
+ EXPECT_NULL(should_be_null);
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
- bool PopBack() {
- BEGIN_TEST;
-
- ASSERT_TRUE(Populate(container()), "");
+ void PopBack() {
+ ASSERT_NO_FAILURES(Populate(container()));
// Remove elements using pop_back. List should shrink each time we
// remove an element, but the number of live objects should only shrink
@@ -212,129 +197,122 @@
for (size_t i = 0; i < OBJ_COUNT; ++i) {
size_t remaining = OBJ_COUNT - i;
size_t obj_ndx = OBJ_COUNT - i - 1;
- ASSERT_TRUE(!container().is_empty(), "");
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining, Size(container()), "");
+ ASSERT_TRUE(!container().is_empty());
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining, Size(container()));
{
// Pop the item and sanity check it against our tracking.
PtrType tmp = container().pop_back();
- EXPECT_NONNULL(tmp, "");
- EXPECT_EQ(tmp->value(), obj_ndx, "");
- EXPECT_EQ(objects()[obj_ndx], tmp->raw_ptr(), "");
+ EXPECT_NOT_NULL(tmp);
+ EXPECT_EQ(tmp->value(), obj_ndx);
+ EXPECT_EQ(objects()[obj_ndx], tmp->raw_ptr());
// Make sure that the intrusive bookkeeping is up-to-date.
auto& ns = ContainerType::NodeTraits::node_state(*tmp);
- EXPECT_NULL(ns.next_, "");
+ EXPECT_NULL(ns.next_);
// The container has shrunk, but the object should still be around.
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining - 1, Size(container()), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining - 1, Size(container()));
}
// If we were not holding onto the object using the test
// environment's tracking, the live object count should have
// dropped. Otherwise, it should remain the same.
- if (!HoldingObject(obj_ndx))
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
- else
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
+ if (!HoldingObject(obj_ndx)) {
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
+ } else {
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ }
// Let go of the object and verify that it has now gone away.
ReleaseObject(obj_ndx);
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(i + 1));
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
+ TestEnvTraits::CheckCustomDeleteInvocations(i + 1);
}
// List should be empty now. Popping anything else should result in a
// null pointer.
- EXPECT_TRUE(container().is_empty(), "");
+ EXPECT_TRUE(container().is_empty());
PtrType should_be_null = container().pop_back();
- EXPECT_NULL(should_be_null, "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
-
- END_TEST;
+ EXPECT_NULL(should_be_null);
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
}
- bool EraseNext() {
- BEGIN_TEST;
-
- ASSERT_TRUE(Populate(container()), "");
+ void EraseNext() {
+ ASSERT_NO_FAILURES(Populate(container()));
// Remove as many elements as we can using erase_next.
auto iter = container().begin();
for (size_t i = 1; i < OBJ_COUNT; ++i) {
size_t remaining = OBJ_COUNT - i + 1;
- ASSERT_TRUE(!container().is_empty(), "");
- ASSERT_TRUE(iter != container().end(), "");
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining, Size(container()), "");
+ ASSERT_TRUE(!container().is_empty());
+ ASSERT_TRUE(iter != container().end());
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining, Size(container()));
{
// Erase the item and sanity check it against our tracking.
PtrType tmp = container().erase_next(iter);
- EXPECT_NONNULL(tmp, "");
- EXPECT_EQ(tmp->value(), i, "");
- EXPECT_EQ(objects()[i], tmp->raw_ptr(), "");
+ EXPECT_NOT_NULL(tmp);
+ EXPECT_EQ(tmp->value(), i);
+ EXPECT_EQ(objects()[i], tmp->raw_ptr());
// Make sure that the intrusive bookkeeping is up-to-date.
auto& ns = ContainerType::NodeTraits::node_state(*tmp);
- EXPECT_TRUE(ns.IsValid(), "");
- EXPECT_FALSE(ns.InContainer(), "");
+ EXPECT_TRUE(ns.IsValid());
+ EXPECT_FALSE(ns.InContainer());
// The container has shrunk, but the object should still be around.
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
- EXPECT_EQ(remaining - 1, Size(container()), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
+ EXPECT_EQ(remaining - 1, Size(container()));
}
// If we were not holding onto the object using the test
// environment's tracking, the live object count should have
// dropped. Otherwise, it should remain the same.
if (!HoldingObject(i))
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
else
- EXPECT_EQ(remaining, ObjType::live_obj_count(), "");
+ EXPECT_EQ(remaining, ObjType::live_obj_count());
// Let go of the object and verify that it has now gone away.
ReleaseObject(i);
- EXPECT_EQ(remaining - 1, ObjType::live_obj_count(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(i));
+ EXPECT_EQ(remaining - 1, ObjType::live_obj_count());
+ TestEnvTraits::CheckCustomDeleteInvocations(i);
}
// Iterator should now be one away from the end, and there should be one
// object left
- EXPECT_EQ(1u, ObjType::live_obj_count(), "");
- EXPECT_EQ(1u, Size(container()), "");
- EXPECT_TRUE(iter != container().end(), "");
+ EXPECT_EQ(1u, ObjType::live_obj_count());
+ EXPECT_EQ(1u, Size(container()));
+ EXPECT_TRUE(iter != container().end());
iter++;
- EXPECT_TRUE(iter == container().end(), "");
+ EXPECT_TRUE(iter == container().end());
// Attempt to erase the element after the final element. This should
// fail, and indicate that it has failed by returning null.
iter = container().begin();
PtrType tmp = container().erase_next(iter);
- EXPECT_NULL(tmp, "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT - 1));
-
- END_TEST;
+ EXPECT_NULL(tmp);
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT - 1);
}
template <typename IterType>
- bool DoInsertAfter(IterType&& iter, size_t pos) {
- BEGIN_TEST;
-
- EXPECT_EQ(ObjType::live_obj_count(), Size(container()), "");
- EXPECT_TRUE(iter != container().end(), "");
+ void DoInsertAfter(IterType&& iter, size_t pos) {
+ EXPECT_EQ(ObjType::live_obj_count(), Size(container()));
+ EXPECT_TRUE(iter != container().end());
size_t orig_container_len = ObjType::live_obj_count();
size_t orig_iter_pos = iter->value();
- ASSERT_LT(orig_iter_pos, OBJ_COUNT, "");
- EXPECT_EQ(objects()[orig_iter_pos], iter->raw_ptr(), "");
+ ASSERT_LT(orig_iter_pos, OBJ_COUNT);
+ EXPECT_EQ(objects()[orig_iter_pos], iter->raw_ptr());
PtrType new_object = this->CreateTrackedObject(pos, pos, true);
- ASSERT_NONNULL(new_object, "");
- EXPECT_EQ(new_object->raw_ptr(), objects()[pos], "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_EQ(new_object->raw_ptr(), objects()[pos]);
if (pos & 1) {
#if TEST_WILL_NOT_COMPILE || 0
@@ -342,35 +320,31 @@
#else
container().insert_after(iter, TestEnvTraits::Transfer(new_object));
#endif
- EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object));
} else {
container().insert_after(iter, std::move(new_object));
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
// List and number of live object should have grown.
- EXPECT_EQ(orig_container_len + 1, ObjType::live_obj_count(), "");
- EXPECT_EQ(orig_container_len + 1, Size(container()), "");
+ EXPECT_EQ(orig_container_len + 1, ObjType::live_obj_count());
+ EXPECT_EQ(orig_container_len + 1, Size(container()));
// The iterator should not have moved yet.
- EXPECT_TRUE(iter != container().end(), "");
- EXPECT_EQ(objects()[orig_iter_pos], iter->raw_ptr(), "");
- EXPECT_EQ(orig_iter_pos, iter->value(), "");
+ EXPECT_TRUE(iter != container().end());
+ EXPECT_EQ(objects()[orig_iter_pos], iter->raw_ptr());
+ EXPECT_EQ(orig_iter_pos, iter->value());
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool InsertAfter() {
- BEGIN_TEST;
-
+ void InsertAfter() {
// In order to insert_after, we need at least one object already in the
// container. Use push_front to make one.
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0U, Size(container()), "");
- EXPECT_TRUE(container().is_empty(), "");
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0U, Size(container()));
+ EXPECT_TRUE(container().is_empty());
container().push_front(std::move(this->CreateTrackedObject(0, 0, true)));
// Insert some elements after the last element container.
@@ -379,23 +353,23 @@
auto iter = container().begin();
for (size_t i = (OBJ_COUNT - END_INSERT_COUNT); i < OBJ_COUNT; ++i) {
- ASSERT_TRUE(DoInsertAfter(iter, i), "");
+ ASSERT_NO_FAILURES(DoInsertAfter(iter, i));
// Now that we have inserted after, we should be able to advance the
// iterator to what we just inserted.
iter++;
- ASSERT_TRUE(iter != container().end(), "");
- EXPECT_EQ(objects()[i], iter->raw_ptr(), "");
- EXPECT_EQ(objects()[i], (*iter).raw_ptr(), "");
- EXPECT_EQ(i, iter->value(), "");
- EXPECT_EQ(i, (*iter).value(), "");
+ ASSERT_TRUE(iter != container().end());
+ EXPECT_EQ(objects()[i], iter->raw_ptr());
+ EXPECT_EQ(objects()[i], (*iter).raw_ptr());
+ EXPECT_EQ(i, iter->value());
+ EXPECT_EQ(i, (*iter).value());
}
// Advancing iter at this point should bring it to the end.
- EXPECT_TRUE(iter != container().end(), "");
+ EXPECT_TRUE(iter != container().end());
iter++;
- EXPECT_TRUE(iter == container().end(), "");
+ EXPECT_TRUE(iter == container().end());
// Reset the iterator to the first element in the container, and test
// inserting between elements instead of at the end. To keep the
@@ -403,39 +377,35 @@
// advance the iterator in the process.
iter = container().begin();
for (size_t i = (OBJ_COUNT - END_INSERT_COUNT - 1); i > 0; --i) {
- ASSERT_TRUE(DoInsertAfter(iter, i), "");
+ ASSERT_NO_FAILURES(DoInsertAfter(iter, i));
}
- EXPECT_TRUE(iter != container().end(), "");
+ EXPECT_TRUE(iter != container().end());
// Check to make sure the container has the expected number of elements, and
// that they are in the proper order.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
size_t i = 0;
for (const auto& obj : container()) {
- EXPECT_EQ(objects()[i], &obj, "");
- EXPECT_EQ(objects()[i], obj.raw_ptr(), "");
- EXPECT_EQ(i, obj.value(), "");
+ EXPECT_EQ(objects()[i], &obj);
+ EXPECT_EQ(objects()[i], obj.raw_ptr());
+ EXPECT_EQ(i, obj.value());
i++;
}
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
template <typename TargetType>
- bool DoInsert(TargetType&& target, size_t pos) {
- BEGIN_TEST;
-
- EXPECT_EQ(ObjType::live_obj_count(), Size(container()), "");
+ void DoInsert(TargetType&& target, size_t pos) {
+ EXPECT_EQ(ObjType::live_obj_count(), Size(container()));
size_t orig_container_len = ObjType::live_obj_count();
PtrType new_object = this->CreateTrackedObject(pos, pos, true);
- ASSERT_NONNULL(new_object, "");
- EXPECT_EQ(new_object->raw_ptr(), objects()[pos], "");
+ ASSERT_NOT_NULL(new_object);
+ EXPECT_EQ(new_object->raw_ptr(), objects()[pos]);
if (pos & 1) {
#if TEST_WILL_NOT_COMPILE || 0
@@ -443,24 +413,20 @@
#else
container().insert(target, TestEnvTraits::Transfer(new_object));
#endif
- EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasTransferred(new_object));
} else {
container().insert(target, std::move(new_object));
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
// List and number of live object should have grown.
- EXPECT_EQ(orig_container_len + 1, ObjType::live_obj_count(), "");
- EXPECT_EQ(orig_container_len + 1, Size(container()), "");
-
- END_TEST;
+ EXPECT_EQ(orig_container_len + 1, ObjType::live_obj_count());
+ EXPECT_EQ(orig_container_len + 1, Size(container()));
}
- bool Insert() {
- BEGIN_TEST;
-
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0U, Size(container()), "");
+ void Insert() {
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0U, Size(container()));
static constexpr size_t END_INSERT_COUNT = 3;
static constexpr size_t START_INSERT_COUNT = 3;
@@ -473,13 +439,13 @@
// Insert some elements at the end of an initially empty container using the
// end() iterator accessor.
for (size_t i = (OBJ_COUNT - END_INSERT_COUNT); i < OBJ_COUNT; ++i)
- ASSERT_TRUE(DoInsert(container().end(), i), "");
+ ASSERT_NO_FAILURES(DoInsert(container().end(), i));
// Insert some elements at the start of a non-empty container using the
// begin() iterator accessor.
for (size_t i = 0; i < START_INSERT_COUNT; ++i) {
size_t ndx = START_INSERT_COUNT - i - 1;
- ASSERT_TRUE(DoInsert(container().begin(), ndx), "");
+ ASSERT_NO_FAILURES(DoInsert(container().begin(), ndx));
}
// Insert some elements in the middle non-empty container using an iterator
@@ -490,42 +456,38 @@
for (size_t i = 0; i < MID_INSERT_COUNT; ++i) {
size_t ndx = START_INSERT_COUNT + i;
- ASSERT_TRUE(DoInsert(iter, ndx), "");
+ ASSERT_NO_FAILURES(DoInsert(iter, ndx));
}
// iter should be END_INSERT_COUNT from the end of the
// container.
for (size_t i = 0; i < END_INSERT_COUNT; ++i) {
- EXPECT_TRUE(iter != container().end(), "");
+ EXPECT_TRUE(iter != container().end());
++iter;
}
- EXPECT_TRUE(++iter == container().end(), "");
+ EXPECT_TRUE(++iter == container().end());
// Check to make sure the container has the expected number of elements, and
// that they are in the proper order.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
size_t i = 0;
for (const auto& obj : container()) {
- ASSERT_LT(i, OBJ_COUNT, "");
- EXPECT_EQ(objects()[i], &obj, "");
- EXPECT_EQ(objects()[i], obj.raw_ptr(), "");
- EXPECT_EQ(i, obj.value(), "");
+ ASSERT_LT(i, OBJ_COUNT);
+ EXPECT_EQ(objects()[i], &obj);
+ EXPECT_EQ(objects()[i], obj.raw_ptr());
+ EXPECT_EQ(i, obj.value());
i++;
}
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool DirectInsert() {
- BEGIN_TEST;
-
- EXPECT_EQ(0u, ObjType::live_obj_count(), "");
- EXPECT_EQ(0U, Size(container()), "");
+ void DirectInsert() {
+ EXPECT_EQ(0u, ObjType::live_obj_count());
+ EXPECT_EQ(0U, Size(container()));
static constexpr size_t END_INSERT_COUNT = 3;
static constexpr size_t START_INSERT_COUNT = 3;
@@ -537,16 +499,17 @@
// Insert some elements at the end of an initially empty container using
// the end() iterator as the target.
- for (size_t i = (OBJ_COUNT - END_INSERT_COUNT); i < OBJ_COUNT; ++i)
- ASSERT_TRUE(DoInsert(container().end(), i), "");
+ for (size_t i = (OBJ_COUNT - END_INSERT_COUNT); i < OBJ_COUNT; ++i) {
+ ASSERT_NO_FAILURES(DoInsert(container().end(), i));
+ }
// Insert some elements at the start of a non-empty container node
// pointers which are always at the start of the container.
size_t insert_before_ndx = (OBJ_COUNT - END_INSERT_COUNT);
for (size_t i = 0; i < START_INSERT_COUNT; ++i) {
size_t ndx = START_INSERT_COUNT - i - 1;
- ASSERT_NONNULL(objects()[insert_before_ndx], "");
- ASSERT_TRUE(DoInsert(*objects()[insert_before_ndx], ndx), "");
+ ASSERT_NOT_NULL(objects()[insert_before_ndx]);
+ ASSERT_NO_FAILURES(DoInsert(*objects()[insert_before_ndx], ndx));
insert_before_ndx = ndx;
}
@@ -554,57 +517,49 @@
insert_before_ndx = (OBJ_COUNT - END_INSERT_COUNT);
for (size_t i = 0; i < MID_INSERT_COUNT; ++i) {
size_t ndx = START_INSERT_COUNT + i;
- ASSERT_NONNULL(objects()[insert_before_ndx], "");
- ASSERT_TRUE(DoInsert(*objects()[insert_before_ndx], ndx), "");
+ ASSERT_NOT_NULL(objects()[insert_before_ndx]);
+ ASSERT_NO_FAILURES(DoInsert(*objects()[insert_before_ndx], ndx));
}
// Check to make sure the container has the expected number of elements,
// and that they are in the proper order.
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
size_t i = 0;
for (const auto& obj : container()) {
- ASSERT_LT(i, OBJ_COUNT, "");
- EXPECT_EQ(objects()[i], &obj, "");
- EXPECT_EQ(objects()[i], obj.raw_ptr(), "");
- EXPECT_EQ(i, obj.value(), "");
+ ASSERT_LT(i, OBJ_COUNT);
+ EXPECT_EQ(objects()[i], &obj);
+ EXPECT_EQ(objects()[i], obj.raw_ptr());
+ EXPECT_EQ(i, obj.value());
i++;
}
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool FillN(size_t begin, size_t end) {
- BEGIN_TEST;
-
+ void FillN(size_t begin, size_t end) {
for (size_t i = begin; i < end; ++i) {
PtrType new_object = this->CreateTrackedObject(i, i);
- ASSERT_NONNULL(new_object, "");
+ ASSERT_NOT_NULL(new_object);
container().push_back(std::move(new_object));
- EXPECT_TRUE(TestEnvTraits::WasMoved(new_object), "");
+ EXPECT_TRUE(TestEnvTraits::WasMoved(new_object));
}
-
- END_TEST;
}
- bool BidirectionalEquals(const ContainerType& sequence, const size_t* values, size_t size) {
- BEGIN_TEST;
-
+ void BidirectionalEquals(const ContainerType& sequence, const size_t* values, size_t size) {
// We use SupportsConstantOrderErase as a way to discriminate a singly-
// linked list from a doubly-linked list.
static_assert(ContainerType::IsSequenced && ContainerType::SupportsConstantOrderErase,
"BidirectionalEquals must be used with a bi-directional sequence");
- ASSERT_EQ(size, Size(sequence), "");
+ ASSERT_EQ(size, Size(sequence));
// Iterate forwards and verify values.
const size_t* val_iter = values;
for (const auto& node : sequence) {
- EXPECT_EQ(node.value(), *val_iter, "");
+ EXPECT_EQ(node.value(), *val_iter);
++val_iter;
}
@@ -612,107 +567,100 @@
for (auto begin = sequence.begin(), end = sequence.end(); begin != end;) {
--val_iter;
--end;
- EXPECT_EQ(end->value(), *val_iter, "");
+ EXPECT_EQ(end->value(), *val_iter);
}
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool Splice() {
- BEGIN_TEST;
-
+ void Splice() {
constexpr size_t LIST_COUNT = 2;
static_assert(LIST_COUNT * 4 < OBJ_COUNT, "OBJ_COUNT too small to run Splice test!");
- EXPECT_EQ(0U, Size(container()), "");
+ EXPECT_EQ(0U, Size(container()));
ContainerType target;
- EXPECT_EQ(0U, Size(target), "");
+ EXPECT_EQ(0U, Size(target));
// Splice empty source into end of empty target list.
target.splice(target.end(), container());
- EXPECT_EQ(0U, Size(target), "");
- EXPECT_EQ(0u, Size(container()), "");
+ EXPECT_EQ(0U, Size(target));
+ EXPECT_EQ(0u, Size(container()));
// Populate the source list.
- ASSERT_TRUE(FillN(0, LIST_COUNT), "");
- EXPECT_EQ(LIST_COUNT, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(FillN(0, LIST_COUNT));
+ EXPECT_EQ(LIST_COUNT, Size(container()));
// Splice into end of empty target list.
target.splice(target.end(), container());
static const size_t expected_1[] = {0, 1};
- EXPECT_TRUE(BidirectionalEquals(target, expected_1, fbl::count_of(expected_1)), "");
- EXPECT_EQ(0u, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(BidirectionalEquals(target, expected_1, fbl::count_of(expected_1)));
+ EXPECT_EQ(0u, Size(container()));
// Populate the source list again.
- ASSERT_TRUE(FillN(LIST_COUNT, LIST_COUNT * 2), "");
- EXPECT_EQ(LIST_COUNT, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(FillN(LIST_COUNT, LIST_COUNT * 2));
+ EXPECT_EQ(LIST_COUNT, Size(container()));
// Splice into end of non-empty target list.
target.splice(target.end(), container());
static const size_t expected_2[] = {0, 1, 2, 3};
- EXPECT_TRUE(BidirectionalEquals(target, expected_2, fbl::count_of(expected_2)), "");
- EXPECT_EQ(0u, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(BidirectionalEquals(target, expected_2, fbl::count_of(expected_2)));
+ EXPECT_EQ(0u, Size(container()));
// Populate the source list again.
- ASSERT_TRUE(FillN(LIST_COUNT * 2, LIST_COUNT * 3), "");
- EXPECT_EQ(LIST_COUNT, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(FillN(LIST_COUNT * 2, LIST_COUNT * 3));
+ EXPECT_EQ(LIST_COUNT, Size(container()));
// Splice into start of non-empty target list.
target.splice(target.begin(), container());
static const size_t expected_3[] = {4, 5, 0, 1, 2, 3};
- EXPECT_TRUE(BidirectionalEquals(target, expected_3, fbl::count_of(expected_3)), "");
- EXPECT_EQ(0u, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(BidirectionalEquals(target, expected_3, fbl::count_of(expected_3)));
+ EXPECT_EQ(0u, Size(container()));
// Populate the source list again.
- ASSERT_TRUE(FillN(LIST_COUNT * 3, LIST_COUNT * 4), "");
- EXPECT_EQ(LIST_COUNT, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(FillN(LIST_COUNT * 3, LIST_COUNT * 4));
+ EXPECT_EQ(LIST_COUNT, Size(container()));
// Splice into second element of non-empty target list.
target.splice(++target.begin(), container());
static const size_t expected_4[] = {4, 6, 7, 5, 0, 1, 2, 3};
- EXPECT_TRUE(BidirectionalEquals(target, expected_4, fbl::count_of(expected_4)), "");
- EXPECT_EQ(0u, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(BidirectionalEquals(target, expected_4, fbl::count_of(expected_4)));
+ EXPECT_EQ(0u, Size(container()));
// Splice empty source into end of non-empty target list.
target.splice(target.end(), container());
- EXPECT_TRUE(BidirectionalEquals(target, expected_4, fbl::count_of(expected_4)), "");
- EXPECT_EQ(0u, Size(container()), "");
+ ASSERT_NO_FATAL_FAILURES(BidirectionalEquals(target, expected_4, fbl::count_of(expected_4)));
+ EXPECT_EQ(0u, Size(container()));
// No objects should have been deleted yet.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
// Finally clear the target.
target.clear();
- EXPECT_EQ(0u, Size(target), "");
+ EXPECT_EQ(0u, Size(target));
// By now, we should have created LIST_COUNT * 4 objects. They should all be gone now.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(LIST_COUNT * 4));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(LIST_COUNT * 4);
}
template <typename IterType>
- bool DoSeqIterate(const IterType& begin, const IterType& end) {
- BEGIN_TEST;
+ void DoSeqIterate(const IterType& begin, const IterType& end) {
IterType iter;
// begin() should point to the front of the sequence.
iter = begin;
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_TRUE(container().front() == *iter, "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_TRUE(container().front() == *iter);
// Iterate using begin/end
size_t i = 0;
for (iter = begin; iter != end;) {
// Exercise both -> and * dereferencing
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(objects()[i], iter->raw_ptr(), "");
- EXPECT_EQ(objects()[i], (*iter).raw_ptr(), "");
- EXPECT_EQ(i, iter->value(), "");
- EXPECT_EQ(i, (*iter).value(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(objects()[i], iter->raw_ptr());
+ EXPECT_EQ(objects()[i], (*iter).raw_ptr());
+ EXPECT_EQ(i, iter->value());
+ EXPECT_EQ(i, (*iter).value());
// Exercise both pre and postfix increment
if ((i++) & 1)
@@ -720,258 +668,239 @@
else
++iter;
}
- EXPECT_FALSE(iter.IsValid(), "");
-
- END_TEST;
+ EXPECT_FALSE(iter.IsValid());
}
- bool SeqIterate() {
- BEGIN_TEST;
-
+ void SeqIterate() {
// Start by making some objects.
- ASSERT_TRUE(Populate(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
// Test iterator
- EXPECT_TRUE(DoSeqIterate(container().begin(), container().end()), "");
+ ASSERT_NO_FATAL_FAILURES(DoSeqIterate(container().begin(), container().end()));
// Test const_iterator
- EXPECT_TRUE(DoSeqIterate(container().cbegin(), container().cend()), "");
+ ASSERT_NO_FATAL_FAILURES(DoSeqIterate(container().cbegin(), container().cend()));
// Iterate using the range-based for loop syntax
size_t i = 0;
for (auto& obj : container()) {
- EXPECT_EQ(objects()[i], &obj, "");
- EXPECT_EQ(objects()[i], obj.raw_ptr(), "");
- EXPECT_EQ(i, obj.value(), "");
+ EXPECT_EQ(objects()[i], &obj);
+ EXPECT_EQ(objects()[i], obj.raw_ptr());
+ EXPECT_EQ(i, obj.value());
i++;
}
// Iterate using the range-based for loop syntax over const references.
i = 0;
for (const auto& obj : container()) {
- EXPECT_EQ(objects()[i], &obj, "");
- EXPECT_EQ(objects()[i], obj.raw_ptr(), "");
- EXPECT_EQ(i, obj.value(), "");
+ EXPECT_EQ(objects()[i], &obj);
+ EXPECT_EQ(objects()[i], obj.raw_ptr());
+ EXPECT_EQ(i, obj.value());
i++;
}
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
template <typename IterType>
- bool DoSeqReverseIterate(const IterType& begin, const IterType& end) {
- BEGIN_TEST;
+ void DoSeqReverseIterate(const IterType& begin, const IterType& end) {
IterType iter;
// Backing up one from end() should give us back(). Check both pre
// and post-fix behavior.
iter = end;
--iter;
- ASSERT_TRUE(iter.IsValid(), "");
- ASSERT_TRUE(iter != end, "");
- EXPECT_TRUE(container().back() == *iter, "");
+ ASSERT_TRUE(iter.IsValid());
+ ASSERT_TRUE(iter != end);
+ EXPECT_TRUE(container().back() == *iter);
iter = end;
iter--;
- ASSERT_TRUE(iter.IsValid(), "");
- ASSERT_TRUE(iter != end, "");
- EXPECT_TRUE(container().back() == *iter, "");
+ ASSERT_TRUE(iter.IsValid());
+ ASSERT_TRUE(iter != end);
+ EXPECT_TRUE(container().back() == *iter);
// Make sure that backing up an iterator by one points always points
// to the previous object in the container.
iter = begin;
while (++iter != end) {
size_t prev_ndx = iter->value() - 1;
- ASSERT_LT(prev_ndx, OBJ_COUNT, "");
- ASSERT_NONNULL(objects()[prev_ndx], "");
+ ASSERT_LT(prev_ndx, OBJ_COUNT);
+ ASSERT_NOT_NULL(objects()[prev_ndx]);
auto prev_iter = iter;
--prev_iter;
- ASSERT_TRUE(prev_iter.IsValid(), "");
- EXPECT_FALSE(prev_iter == iter, "");
- EXPECT_TRUE(*prev_iter == *objects()[prev_ndx], "");
+ ASSERT_TRUE(prev_iter.IsValid());
+ EXPECT_FALSE(prev_iter == iter);
+ EXPECT_TRUE(*prev_iter == *objects()[prev_ndx]);
prev_iter = iter;
prev_iter--;
- ASSERT_TRUE(prev_iter.IsValid(), "");
- EXPECT_FALSE(prev_iter == iter, "");
- EXPECT_TRUE(*prev_iter == *objects()[prev_ndx], "");
+ ASSERT_TRUE(prev_iter.IsValid());
+ EXPECT_FALSE(prev_iter == iter);
+ EXPECT_TRUE(*prev_iter == *objects()[prev_ndx]);
}
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool SeqReverseIterate() {
- BEGIN_TEST;
-
+ void SeqReverseIterate() {
// Start by making some objects.
- ASSERT_TRUE(Populate(container()), "");
- EXPECT_EQ(OBJ_COUNT, Size(container()), "");
+ ASSERT_NO_FAILURES(Populate(container()));
+ EXPECT_EQ(OBJ_COUNT, Size(container()));
// Test iterator
- EXPECT_TRUE(DoSeqReverseIterate(container().begin(), container().end()), "");
+ ASSERT_NO_FATAL_FAILURES(DoSeqReverseIterate(container().begin(), container().end()));
// Test const_iterator
- EXPECT_TRUE(DoSeqReverseIterate(container().cbegin(), container().cend()), "");
+ ASSERT_NO_FATAL_FAILURES(DoSeqReverseIterate(container().cbegin(), container().cend()));
// This test should delete no objects
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(0));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations(0);
}
- bool ReplaceIfCopy() {
- BEGIN_TEST;
-
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ void ReplaceIfCopy() {
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
// Try (and fail) to replace an element in an empty container.
{
PtrType new_obj = TestEnvTraits::CreateObject(0);
auto raw_obj = PtrTraits::GetRaw(new_obj);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
EXPECT_EQ(0, Size(container()));
- EXPECT_EQ(1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(1, ObjType::live_obj_count());
PtrType replaced =
container().replace_if([](const ObjType& obj) -> bool { return true; }, new_obj);
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- ASSERT_NONNULL(new_obj, "");
- EXPECT_NULL(replaced, "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NOT_NULL(new_obj);
+ EXPECT_NULL(replaced);
EXPECT_EQ(raw_obj, PtrTraits::GetRaw(new_obj));
EXPECT_EQ(0, Size(container()));
- EXPECT_EQ(1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(new_obj);
EXPECT_EQ(0, Size(container()));
- EXPECT_EQ(0, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0, ObjType::live_obj_count());
}
// The object which we create in an attempt to replace an object in an
// empty container should be gone now.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(1));
+ TestEnvTraits::CheckCustomDeleteInvocations(1);
// Populate our container.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(i, ObjType::live_obj_count(), "");
+ EXPECT_EQ(i, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT - i - 1);
- ASSERT_NONNULL(new_obj, "");
- EXPECT_EQ(i + 1, ObjType::live_obj_count(), "");
+ ASSERT_NOT_NULL(new_obj);
+ EXPECT_EQ(i + 1, ObjType::live_obj_count());
container().push_front(std::move(new_obj));
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
// Replace all of the members of the contianer with new members which
// have a value never created during the populate phase.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT + i);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
PtrType replaced = container().replace_if(
[i](const ObjType& obj) -> bool { return (obj.value() == i); }, new_obj);
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- ASSERT_NONNULL(replaced, "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NOT_NULL(replaced);
EXPECT_TRUE(new_obj->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_FALSE(replaced->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_EQ(i, replaced->value());
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(replaced);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
}
// All of the replaced objects should have gone away now too.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT + 1));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT + 1);
// Try again, but this time fail each time (since all of the original
// element values have already been replaced).
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT + (2 * i));
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
PtrType replaced = container().replace_if(
[i](const ObjType& obj) -> bool { return (obj.value() == i); }, new_obj);
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
- ASSERT_NULL(replaced, "");
+ ASSERT_NULL(replaced);
EXPECT_FALSE(new_obj->ContainerTraits::ContainableBaseClass::InContainer());
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(new_obj);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
}
// The new objects we created (but failed to replace in the container) should now be gone.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations((2 * OBJ_COUNT) + 1));
+ TestEnvTraits::CheckCustomDeleteInvocations((2 * OBJ_COUNT) + 1);
// Make sure that the object are in order and have the values we expect.
size_t i = 0;
while (!container().is_empty()) {
PtrType ptr = container().pop_front();
- EXPECT_EQ(OBJ_COUNT + i, ptr->value(), "");
+ EXPECT_EQ(OBJ_COUNT + i, ptr->value());
TestEnvTraits::ReleaseObject(ptr);
++i;
}
- EXPECT_EQ(0, ObjType::live_obj_count(), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ EXPECT_EQ(0, ObjType::live_obj_count());
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
// Now all of the objects we created during the test should be gone.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations((3 * OBJ_COUNT) + 1));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations((3 * OBJ_COUNT) + 1);
}
- bool ReplaceIfMove() {
- BEGIN_TEST;
-
+ void ReplaceIfMove() {
// Try (and fail) to replace an element in an empty container.
{
PtrType new_obj = TestEnvTraits::CreateObject(0);
auto raw_obj = PtrTraits::GetRaw(new_obj);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
EXPECT_EQ(0, Size(container()));
- EXPECT_EQ(1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(1, ObjType::live_obj_count());
PtrType replaced =
container().replace_if([](const ObjType& obj) -> bool { return true; }, TakePtr(new_obj));
- EXPECT_NULL(new_obj, "");
- ASSERT_NONNULL(replaced, "");
+ EXPECT_NULL(new_obj);
+ ASSERT_NOT_NULL(replaced);
EXPECT_EQ(raw_obj, PtrTraits::GetRaw(replaced));
EXPECT_EQ(0, Size(container()));
- EXPECT_EQ(1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(replaced);
EXPECT_EQ(0, Size(container()));
- EXPECT_EQ(0, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0, ObjType::live_obj_count());
}
// The object which we create in an attempt to replace an object in an
// empty container should be gone now.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(1));
+ TestEnvTraits::CheckCustomDeleteInvocations(1);
// Populate our container.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(i, ObjType::live_obj_count(), "");
+ EXPECT_EQ(i, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT - i - 1);
- ASSERT_NONNULL(new_obj, "");
- EXPECT_EQ(i + 1, ObjType::live_obj_count(), "");
+ ASSERT_NOT_NULL(new_obj);
+ EXPECT_EQ(i + 1, ObjType::live_obj_count());
container().push_front(std::move(new_obj));
}
@@ -979,140 +908,132 @@
// Replace all of the members of the contianer with new members which
// have a value never created during Populate().
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT + i);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
PtrType replaced = container().replace_if(
[i](const ObjType& obj) -> bool { return (obj.value() == i); }, TakePtr(new_obj));
- EXPECT_NULL(new_obj, "");
- ASSERT_NONNULL(replaced, "");
+ EXPECT_NULL(new_obj);
+ ASSERT_NOT_NULL(replaced);
EXPECT_FALSE(replaced->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_EQ(i, replaced->value());
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(replaced);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
}
// All of the replaced objects should have gone away now too.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT + 1));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT + 1);
// Try again, but this time fail each time (since all of the original
// element values have already been replaced).
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT + (2 * i));
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
auto orig_raw = PtrTraits::GetRaw(new_obj);
PtrType replaced = container().replace_if(
[i](const ObjType& obj) -> bool { return (obj.value() == i); }, TakePtr(new_obj));
- EXPECT_NULL(new_obj, "");
- ASSERT_NONNULL(replaced, "");
- EXPECT_EQ(PtrTraits::GetRaw(replaced), orig_raw, "");
+ EXPECT_NULL(new_obj);
+ ASSERT_NOT_NULL(replaced);
+ EXPECT_EQ(PtrTraits::GetRaw(replaced), orig_raw);
EXPECT_FALSE(replaced->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_EQ(OBJ_COUNT + (2 * i), replaced->value());
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(replaced);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
}
// The new objects we created (but failed to replace in the container) should now be gone.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations((2 * OBJ_COUNT) + 1));
+ TestEnvTraits::CheckCustomDeleteInvocations((2 * OBJ_COUNT) + 1);
// Make sure that the object are in order and have the values we expect.
size_t i = 0;
while (!container().is_empty()) {
PtrType ptr = container().pop_front();
- EXPECT_EQ(OBJ_COUNT + i, ptr->value(), "");
+ EXPECT_EQ(OBJ_COUNT + i, ptr->value());
TestEnvTraits::ReleaseObject(ptr);
++i;
}
- EXPECT_EQ(0, ObjType::live_obj_count(), "");
+ EXPECT_EQ(0, ObjType::live_obj_count());
// Now all of the objects we created during the test should be gone.
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations((3 * OBJ_COUNT) + 1));
-
- END_TEST;
+ TestEnvTraits::CheckCustomDeleteInvocations((3 * OBJ_COUNT) + 1);
}
- bool ReplaceCopy() {
- BEGIN_TEST;
-
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ void ReplaceCopy() {
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
// Populate our container.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(i, ObjType::live_obj_count(), "");
+ EXPECT_EQ(i, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT - i - 1);
- ASSERT_NONNULL(new_obj, "");
- EXPECT_EQ(i + 1, ObjType::live_obj_count(), "");
+ ASSERT_NOT_NULL(new_obj);
+ EXPECT_EQ(i + 1, ObjType::live_obj_count());
container().push_front(std::move(new_obj));
}
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
// Replace all of the members of the contianer with new members which
// have a value never created during the populate phase.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT + i);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
auto iter =
container().find_if([i](const ObjType& obj) -> bool { return (obj.value() == i); });
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(i, iter->value(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(i, iter->value());
PtrType replaced = container().replace(*iter, new_obj);
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- ASSERT_NONNULL(replaced, "");
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ ASSERT_NOT_NULL(replaced);
EXPECT_TRUE(new_obj->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_FALSE(replaced->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_EQ(i, replaced->value());
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(replaced);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
// Make sure that the object are in order and have the values we expect.
size_t i = 0;
while (!container().is_empty()) {
PtrType ptr = container().pop_front();
- EXPECT_EQ(OBJ_COUNT + i, ptr->value(), "");
+ EXPECT_EQ(OBJ_COUNT + i, ptr->value());
TestEnvTraits::ReleaseObject(ptr);
++i;
}
- EXPECT_EQ(0, ObjType::live_obj_count(), "");
- EXPECT_TRUE(ContainerChecker::SanityCheck(container()), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT));
-
- END_TEST;
+ EXPECT_EQ(0, ObjType::live_obj_count());
+ ASSERT_NO_FATAL_FAILURES(ContainerChecker::SanityCheck(container()));
+ TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT);
}
- bool ReplaceMove() {
- BEGIN_TEST;
-
+ void ReplaceMove() {
// Populate our container.
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(i, ObjType::live_obj_count(), "");
+ EXPECT_EQ(i, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT - i - 1);
- ASSERT_NONNULL(new_obj, "");
- EXPECT_EQ(i + 1, ObjType::live_obj_count(), "");
+ ASSERT_NOT_NULL(new_obj);
+ EXPECT_EQ(i + 1, ObjType::live_obj_count());
container().push_front(std::move(new_obj));
}
@@ -1120,42 +1041,40 @@
// Replace all of the members of the contianer with new members which
// have a value never created during Populate().
for (size_t i = 0; i < OBJ_COUNT; ++i) {
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
PtrType new_obj = TestEnvTraits::CreateObject(OBJ_COUNT + i);
- ASSERT_NONNULL(new_obj, "");
+ ASSERT_NOT_NULL(new_obj);
auto iter =
container().find_if([i](const ObjType& obj) -> bool { return (obj.value() == i); });
- ASSERT_TRUE(iter.IsValid(), "");
- EXPECT_EQ(i, iter->value(), "");
+ ASSERT_TRUE(iter.IsValid());
+ EXPECT_EQ(i, iter->value());
PtrType replaced = container().replace(*iter, TakePtr(new_obj));
- EXPECT_NULL(new_obj, "");
- ASSERT_NONNULL(replaced, "");
+ EXPECT_NULL(new_obj);
+ ASSERT_NOT_NULL(replaced);
EXPECT_FALSE(replaced->ContainerTraits::ContainableBaseClass::InContainer());
EXPECT_EQ(i, replaced->value());
- EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT + 1, ObjType::live_obj_count());
TestEnvTraits::ReleaseObject(replaced);
- EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count(), "");
+ EXPECT_EQ(OBJ_COUNT, ObjType::live_obj_count());
}
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT));
+ TestEnvTraits::CheckCustomDeleteInvocations(OBJ_COUNT);
// Make sure that the object are in order and have the values we expect.
size_t i = 0;
while (!container().is_empty()) {
PtrType ptr = container().pop_front();
- EXPECT_EQ(OBJ_COUNT + i, ptr->value(), "");
+ EXPECT_EQ(OBJ_COUNT + i, ptr->value());
TestEnvTraits::ReleaseObject(ptr);
++i;
}
- EXPECT_EQ(0, ObjType::live_obj_count(), "");
- EXPECT_TRUE(TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT));
-
- END_TEST;
+ EXPECT_EQ(0, ObjType::live_obj_count());
+ TestEnvTraits::CheckCustomDeleteInvocations(2 * OBJ_COUNT);
}
private:
@@ -1177,3 +1096,5 @@
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_SEQUENCE_CONTAINER_TEST_ENVIRONMENT_H_
diff --git a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/test_thunks.h b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/test_thunks.h
index e6792ab..4588300 100644
--- a/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/test_thunks.h
+++ b/zircon/system/ulib/fbl/test/include/fbl/tests/intrusive_containers/test_thunks.h
@@ -2,19 +2,20 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#pragma once
+#ifndef FBL_TESTS_INTRUSIVE_CONTAINERS_TEST_THUNKS_H_
+#define FBL_TESTS_INTRUSIVE_CONTAINERS_TEST_THUNKS_H_
+
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
namespace intrusive_containers {
-#define MAKE_TEST_THUNK(_test_name) \
- static bool _test_name##Test() { \
- TestEnvironmentClass env; \
- BEGIN_TEST; \
- EXPECT_TRUE(env._test_name(), ""); \
- EXPECT_TRUE(env.Reset(), ""); \
- END_TEST; \
+#define MAKE_TEST_THUNK(_test_name) \
+ static void _test_name() { \
+ TestEnvironmentClass env; \
+ ASSERT_NO_FAILURES(env._test_name(), ""); \
+ ASSERT_NO_FAILURES(env.Reset(), ""); \
}
// A utility class used to generate static test thunks for the various
@@ -106,6 +107,14 @@
#define DEFINE_TEST_THUNK(_env_type, _container_type, _ptr_type) \
TestThunks<_env_type##ContainerTestEnvironment<_ptr_type##_container_type##TestTraits>>
+#define RUN_ZXTEST(_group, _flavor, _test) \
+ TEST(_group, _test##_##_flavor) { \
+ auto fn = _flavor ::_test; \
+ ASSERT_NO_FAILURES(fn()); \
+ }
+
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
+
+#endif // FBL_TESTS_INTRUSIVE_CONTAINERS_TEST_THUNKS_H_
diff --git a/zircon/system/ulib/fbl/test/intrusive_container_tests.cc b/zircon/system/ulib/fbl/test/intrusive_container_tests.cc
index 7824359..b0d1826 100644
--- a/zircon/system/ulib/fbl/test/intrusive_container_tests.cc
+++ b/zircon/system/ulib/fbl/test/intrusive_container_tests.cc
@@ -4,7 +4,7 @@
#include <fbl/intrusive_container_utils.h>
#include <fbl/tests/intrusive_containers/objects.h>
-#include <unittest/unittest.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -13,9 +13,7 @@
size_t TestObjBase::live_obj_count_ = 0;
template <typename T>
-bool swap_test(const T initial_a, const T initial_b) {
- BEGIN_HELPER;
-
+void swap_test(const T initial_a, const T initial_b) {
// Starting A and B need to be different in order for us to know that swap
// worked.
EXPECT_NE(::memcmp(&initial_a, &initial_b, sizeof(T)), 0);
@@ -26,13 +24,9 @@
EXPECT_EQ(::memcmp(&a, &initial_b, sizeof(T)), 0);
EXPECT_EQ(::memcmp(&b, &initial_a, sizeof(T)), 0);
-
- END_HELPER;
}
-bool swap_test() {
- BEGIN_TEST;
-
+TEST(IntrusiveContainerUtilsTest, Swap) {
struct SimpleSmallStruct {
uint8_t a, b;
};
@@ -43,35 +37,29 @@
uint64_t a, b;
};
- EXPECT_TRUE(swap_test<char>('a', 'b'));
- EXPECT_TRUE(swap_test<int8_t>(-5, 10));
- EXPECT_TRUE(swap_test<uint8_t>(5, 10));
- EXPECT_TRUE(swap_test<int16_t>(-12345, 12345));
- EXPECT_TRUE(swap_test<uint16_t>(12345, 54321));
- EXPECT_TRUE(swap_test<int32_t>(-1234567890, 123456789));
- EXPECT_TRUE(swap_test<uint32_t>(1234567890, 987654321));
- EXPECT_TRUE(swap_test<int64_t>(-12345678901234567, 12345678901234567));
- EXPECT_TRUE(swap_test<uint64_t>(12345678901234567, 98765432109876543));
- EXPECT_TRUE(swap_test<float>(-0.1234567f, 0.7654321f));
- EXPECT_TRUE(swap_test<double>(-0.12345678901234567890, 0.98765432109876543210));
- EXPECT_TRUE(swap_test<SimpleSmallStruct>({5, 4}, {2, 9}));
- EXPECT_TRUE(swap_test<SimpleBigStruct>({5, 4}, {2, 9}));
+ swap_test<char>('a', 'b');
+ swap_test<int8_t>(-5, 10);
+ swap_test<uint8_t>(5, 10);
+ swap_test<int16_t>(-12345, 12345);
+ swap_test<uint16_t>(12345, 54321);
+ swap_test<int32_t>(-1234567890, 123456789);
+ swap_test<uint32_t>(1234567890, 987654321);
+ swap_test<int64_t>(-12345678901234567, 12345678901234567);
+ swap_test<uint64_t>(12345678901234567, 98765432109876543);
+ swap_test<float>(-0.1234567f, 0.7654321f);
+ swap_test<double>(-0.12345678901234567890, 0.98765432109876543210);
+ swap_test<SimpleSmallStruct>({5, 4}, {2, 9});
+ swap_test<SimpleBigStruct>({5, 4}, {2, 9});
#if TEST_WILL_NOT_COMPILE || 0
- EXPECT_TRUE(swap_test<SimpleHugeStruct>({5, 4}, {2, 9}));
+ swap_test<SimpleHugeStruct>({5, 4}, {2, 9});
#endif
SimpleBigStruct a = {};
SimpleBigStruct b = {};
- EXPECT_TRUE(swap_test<void*>(&a, &b));
- EXPECT_TRUE(swap_test<SimpleBigStruct*>(&a, &b));
-
- END_TEST;
+ swap_test<void*>(&a, &b);
+ swap_test<SimpleBigStruct*>(&a, &b);
}
-BEGIN_TEST_CASE(container_utils_tests)
-RUN_NAMED_TEST("swap test", swap_test)
-END_TEST_CASE(container_utils_tests)
-
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
diff --git a/zircon/system/ulib/fbl/test/intrusive_doubly_linked_list_tests.cc b/zircon/system/ulib/fbl/test/intrusive_doubly_linked_list_tests.cc
index c06e546..f0d86ab 100644
--- a/zircon/system/ulib/fbl/test/intrusive_doubly_linked_list_tests.cc
+++ b/zircon/system/ulib/fbl/test/intrusive_doubly_linked_list_tests.cc
@@ -2,11 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <unittest/unittest.h>
#include <fbl/intrusive_double_list.h>
#include <fbl/tests/intrusive_containers/intrusive_doubly_linked_list_checker.h>
#include <fbl/tests/intrusive_containers/sequence_container_test_environment.h>
#include <fbl/tests/intrusive_containers/test_thunks.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -64,219 +64,214 @@
using SUPCDTE = DEFINE_TEST_THUNK(Sequence, DLL, StdUniquePtrCustomDeleter);
using RPTE = DEFINE_TEST_THUNK(Sequence, DLL, RefPtr);
-BEGIN_TEST_CASE(double_linked_list_tests)
//////////////////////////////////////////
// General container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("Clear (unmanaged)", UMTE::ClearTest)
-RUN_NAMED_TEST("Clear (unique)", UPTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr)", SUPDDTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr<Del>)", SUPCDTE::ClearTest)
-RUN_NAMED_TEST("Clear (RefPtr)", RPTE::ClearTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, Clear)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, Clear)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, Clear)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, Clear)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, Clear)
-RUN_NAMED_TEST("ClearUnsafe (unmanaged)", UMTE::ClearUnsafeTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ClearUnsafe)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ClearUnsafe (unique)", UPTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr)", SUPDDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)", SUPCDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (RefPtr)", RPTE::ClearUnsafeTest)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ClearUnsafe)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ClearUnsafe)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ClearUnsafe)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ClearUnsafe)
#endif
-RUN_NAMED_TEST("IsEmpty (unmanaged)", UMTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (unique)", UPTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr)", SUPDDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)", SUPCDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (RefPtr)", RPTE::IsEmptyTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, IsEmpty)
-RUN_NAMED_TEST("Iterate (unmanaged)", UMTE::IterateTest)
-RUN_NAMED_TEST("Iterate (unique)", UPTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr)", SUPDDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr<Del>)", SUPCDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (RefPtr)", RPTE::IterateTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, Iterate)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, Iterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, Iterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, Iterate)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, Iterate)
-RUN_NAMED_TEST("IterErase (unmanaged)", UMTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (unique)", UPTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr)", SUPDDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr<Del>)", SUPCDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (RefPtr)", RPTE::IterEraseTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, IterErase)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, IterErase)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, IterErase)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, IterErase)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, IterErase)
-RUN_NAMED_TEST("DirectErase (unmanaged)", UMTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (unique)", UPTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr)", SUPDDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr<Del>)", SUPCDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (RefPtr)", RPTE::DirectEraseTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, DirectErase)
-RUN_NAMED_TEST("MakeIterator (unmanaged)", UMTE::MakeIteratorTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, MakeIterator)
+
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ReverseIterErase)
+
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ReverseIterate)
+
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, Swap)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, Swap)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, Swap)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, Swap)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, Swap)
+
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, RvalueOps)
+
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, Scope)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, Scope)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, Scope)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, Scope)
+
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, TwoContainer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("MakeIterator (unique)", UPTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr)", SUPDDTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)", SUPCDTE::MakeIteratorTest)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, TwoContainer)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, TwoContainer)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, TwoContainer)
#endif
-RUN_NAMED_TEST("MakeIterator (RefPtr)", RPTE::MakeIteratorTest)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, TwoContainer)
-RUN_NAMED_TEST("ReverseIterErase (unmanaged)", UMTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (unique)", UPTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr)", SUPDDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)", SUPCDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (RefPtr)", RPTE::ReverseIterEraseTest)
-
-RUN_NAMED_TEST("ReverseIterate (unmanaged)", UMTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (unique)", UPTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr)", SUPDDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)", SUPCDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (RefPtr)", RPTE::ReverseIterateTest)
-
-RUN_NAMED_TEST("Swap (unmanaged)", UMTE::SwapTest)
-RUN_NAMED_TEST("Swap (unique)", UPTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr)", SUPDDTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr<Del>)", SUPCDTE::SwapTest)
-RUN_NAMED_TEST("Swap (RefPtr)", RPTE::SwapTest)
-
-RUN_NAMED_TEST("Rvalue Ops (unmanaged)", UMTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (unique)", UPTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr)", SUPDDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)", SUPCDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (RefPtr)", RPTE::RvalueOpsTest)
-
-RUN_NAMED_TEST("Scope (unique)", UPTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr)", SUPDDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr<Del>)", SUPCDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (RefPtr)", RPTE::ScopeTest)
-
-RUN_NAMED_TEST("TwoContainer (unmanaged)", UMTE::TwoContainerTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ThreeContainerHelper)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("TwoContainer (unique)", UPTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr)", SUPDDTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)", SUPCDTE::TwoContainerTest)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ThreeContainerHelper)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ThreeContainerHelper)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ThreeContainerHelper)
#endif
-RUN_NAMED_TEST("TwoContainer (RefPtr)", RPTE::TwoContainerTest)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ThreeContainerHelper)
-RUN_NAMED_TEST("ThreeContainerHelper (unmanaged)", UMTE::ThreeContainerHelperTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, IterCopyPointer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ThreeContainerHelper (unique)", UPTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr)", SUPDDTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr<Del>)", SUPCDTE::ThreeContainerHelperTest)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, IterCopyPointer)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, IterCopyPointer)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, IterCopyPointer)
#endif
-RUN_NAMED_TEST("ThreeContainerHelper (RefPtr)", RPTE::ThreeContainerHelperTest)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, IterCopyPointer)
-RUN_NAMED_TEST("IterCopyPointer (unmanaged)", UMTE::IterCopyPointerTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("IterCopyPointer (unique)", UPTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr)", SUPDDTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)", SUPCDTE::IterCopyPointerTest)
-#endif
-RUN_NAMED_TEST("IterCopyPointer (RefPtr)", RPTE::IterCopyPointerTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, EraseIf)
-RUN_NAMED_TEST("EraseIf (unmanaged)", UMTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (unique)", UPTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr)", SUPDDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr<Del>)", SUPCDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (RefPtr)", RPTE::EraseIfTest)
-
-RUN_NAMED_TEST("FindIf (unmanaged)", UMTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (unique)", UPTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr)", SUPDDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr<Del>)", SUPCDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (RefPtr)", RPTE::FindIfTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, FindIf)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, FindIf)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, FindIf)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, FindIf)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, FindIf)
//////////////////////////////////////////
// Sequence container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("PushFront (unmanaged)", UMTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (unique)", UPTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (std::uptr)", SUPDDTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (std::uptr<Del>)", SUPCDTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (RefPtr)", RPTE::PushFrontTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, PushFront)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, PushFront)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, PushFront)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, PushFront)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, PushFront)
-RUN_NAMED_TEST("PopFront (unmanaged)", UMTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (unique)", UPTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (std::uptr)", SUPDDTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (std::uptr<Del>)", SUPCDTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (RefPtr)", RPTE::PopFrontTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, PopFront)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, PopFront)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, PopFront)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, PopFront)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, PopFront)
-RUN_NAMED_TEST("PushBack (unmanaged)", UMTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (unique)", UPTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (std::uptr)", SUPDDTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (std::uptr<Del>)", SUPCDTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (RefPtr)", RPTE::PushBackTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, PushBack)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, PushBack)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, PushBack)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, PushBack)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, PushBack)
-RUN_NAMED_TEST("PopBack (unmanaged)", UMTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (unique)", UPTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (std::uptr)", SUPDDTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (std::uptr<Del>)", SUPCDTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (RefPtr)", RPTE::PopBackTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, PopBack)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, PopBack)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, PopBack)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, PopBack)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, PopBack)
-RUN_NAMED_TEST("SeqIterate (unmanaged)", UMTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (unique)", UPTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (std::uptr)", SUPDDTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (std::uptr<Del>)", SUPCDTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (RefPtr)", RPTE::SeqIterateTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, SeqIterate)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, SeqIterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, SeqIterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, SeqIterate)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, SeqIterate)
-RUN_NAMED_TEST("SeqReverseIterate (unmanaged)", UMTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (unique)", UPTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (std::uptr)", SUPDDTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (std::uptr<Del>)",SUPCDTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (RefPtr)", RPTE::SeqReverseIterateTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, SeqReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, SeqReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, SeqReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, SeqReverseIterate)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, SeqReverseIterate)
-RUN_NAMED_TEST("EraseNext (unmanaged)", UMTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (unique)", UPTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (std::uptr)", SUPDDTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (std::uptr<Del>)", SUPCDTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (RefPtr)", RPTE::EraseNextTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, EraseNext)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, EraseNext)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, EraseNext)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, EraseNext)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, EraseNext)
-RUN_NAMED_TEST("InsertAfter (unmanaged)", UMTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (unique)", UPTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (std::uptr)", SUPDDTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (std::uptr<Del>)", SUPCDTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (RefPtr)", RPTE::InsertAfterTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, InsertAfter)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, InsertAfter)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, InsertAfter)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, InsertAfter)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, InsertAfter)
-RUN_NAMED_TEST("Insert (unmanaged)", UMTE::InsertTest)
-RUN_NAMED_TEST("Insert (unique)", UPTE::InsertTest)
-RUN_NAMED_TEST("Insert (std::uptr)", SUPDDTE::InsertTest)
-RUN_NAMED_TEST("Insert (std::uptr<Del>)", SUPCDTE::InsertTest)
-RUN_NAMED_TEST("Insert (RefPtr)", RPTE::InsertTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, Insert)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, Insert)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, Insert)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, Insert)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, Insert)
-RUN_NAMED_TEST("DirectInsert (unmanaged)", UMTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (unique)", UPTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (std::uptr)", SUPDDTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (std::uptr<Del>)", SUPCDTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (RefPtr)", RPTE::DirectInsertTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, DirectInsert)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, DirectInsert)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, DirectInsert)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, DirectInsert)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, DirectInsert)
-RUN_NAMED_TEST("Splice (unmanaged)", UMTE::SpliceTest)
-RUN_NAMED_TEST("Splice (unique)", UPTE::SpliceTest)
-RUN_NAMED_TEST("Splice (std::uptr)", SUPDDTE::SpliceTest)
-RUN_NAMED_TEST("Splice (std::uptr<Del>)", SUPCDTE::SpliceTest)
-RUN_NAMED_TEST("Splice (RefPtr)", RPTE::SpliceTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, Splice)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, Splice)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, Splice)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, Splice)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, Splice)
-RUN_NAMED_TEST("ReplaceIfCopy (unmanaged)", UMTE::ReplaceIfCopyTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ReplaceIfCopy)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ReplaceIfCopy (unique)", UPTE::ReplaceIfCopyTest)
-RUN_NAMED_TEST("ReplaceIfCopy (std::uptr)", SUPDDTE::ReplaceIfCopyTest)
-RUN_NAMED_TEST("ReplaceIfCopy (std::uptr<Del>)", SUPCDTE::ReplaceIfCopyTest)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ReplaceIfCopy)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ReplaceIfCopy)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ReplaceIfCopy)
#endif
-RUN_NAMED_TEST("ReplaceIfCopy (RefPtr)", RPTE::ReplaceIfCopyTest)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ReplaceIfCopy)
-RUN_NAMED_TEST("ReplaceIfMove (unmanaged)", UMTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (unique)", UPTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (std::uptr)", SUPDDTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (std::uptr<Del>)", SUPCDTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (RefPtr)", RPTE::ReplaceIfMoveTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ReplaceIfMove)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ReplaceIfMove)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ReplaceIfMove)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ReplaceIfMove)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ReplaceIfMove)
-RUN_NAMED_TEST("ReplaceCopy (unmanaged)", UMTE::ReplaceCopyTest)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ReplaceCopy)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ReplaceCopy (unique)", UPTE::ReplaceCopyTest)
-RUN_NAMED_TEST("ReplaceCopy (std::uptr)", SUPDDTE::ReplaceCopyTest)
-RUN_NAMED_TEST("ReplaceCopy (std::uptr<Del>)", SUPCDTE::ReplaceCopyTest)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ReplaceCopy)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ReplaceCopy)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ReplaceCopy)
#endif
-RUN_NAMED_TEST("ReplaceCopy (RefPtr)", RPTE::ReplaceCopyTest)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ReplaceCopy)
-RUN_NAMED_TEST("ReplaceMove (unmanaged)", UMTE::ReplaceMoveTest)
-RUN_NAMED_TEST("ReplaceMove (unique)", UPTE::ReplaceMoveTest)
-RUN_NAMED_TEST("ReplaceMove (std::uptr)", SUPDDTE::ReplaceMoveTest)
-RUN_NAMED_TEST("ReplaceMove (std::uptr<Del>)", SUPCDTE::ReplaceMoveTest)
-RUN_NAMED_TEST("ReplaceMove (RefPtr)", RPTE::ReplaceMoveTest)
-
-END_TEST_CASE(double_linked_list_tests)
+RUN_ZXTEST(DoublyLinkedListTest, UMTE, ReplaceMove)
+RUN_ZXTEST(DoublyLinkedListTest, UPTE, ReplaceMove)
+RUN_ZXTEST(DoublyLinkedListTest, SUPDDTE, ReplaceMove)
+RUN_ZXTEST(DoublyLinkedListTest, SUPCDTE, ReplaceMove)
+RUN_ZXTEST(DoublyLinkedListTest, RPTE, ReplaceMove)
// clang-format on
} // namespace intrusive_containers
diff --git a/zircon/system/ulib/fbl/test/intrusive_hash_table_dll_tests.cc b/zircon/system/ulib/fbl/test/intrusive_hash_table_dll_tests.cc
index 727c88d..682bc6e 100644
--- a/zircon/system/ulib/fbl/test/intrusive_hash_table_dll_tests.cc
+++ b/zircon/system/ulib/fbl/test/intrusive_hash_table_dll_tests.cc
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <unittest/unittest.h>
#include <fbl/intrusive_double_list.h>
#include <fbl/intrusive_hash_table.h>
#include <fbl/tests/intrusive_containers/associative_container_test_environment.h>
#include <fbl/tests/intrusive_containers/intrusive_hash_table_checker.h>
#include <fbl/tests/intrusive_containers/test_thunks.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -102,161 +102,155 @@
using SUPCDTE = DEFINE_TEST_THUNK(Associative, HTDLL, StdUniquePtrCustomDeleter);
using RPTE = DEFINE_TEST_THUNK(Associative, HTDLL, RefPtr);
-BEGIN_TEST_CASE(hashtable_dll_tests)
//////////////////////////////////////////
// General container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("Clear (unmanaged)", UMTE::ClearTest)
-RUN_NAMED_TEST("Clear (unique)", UPTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr)", SUPDDTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr<Del>)", SUPCDTE::ClearTest)
-RUN_NAMED_TEST("Clear (RefPtr)", RPTE::ClearTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, Clear)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, Clear)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, Clear)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, Clear)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, Clear)
-RUN_NAMED_TEST("ClearUnsafe (unmanaged)", UMTE::ClearUnsafeTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, ClearUnsafe)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ClearUnsafe (unique)", UPTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr)", SUPDDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)", SUPCDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (RefPtr)", RPTE::ClearUnsafeTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, ClearUnsafe)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, ClearUnsafe)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, ClearUnsafe)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, ClearUnsafe)
#endif
-RUN_NAMED_TEST("IsEmpty (unmanaged)", UMTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (unique)", UPTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr)", SUPDDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)", SUPCDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (RefPtr)", RPTE::IsEmptyTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, IsEmpty)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, IsEmpty)
-RUN_NAMED_TEST("Iterate (unmanaged)", UMTE::IterateTest)
-RUN_NAMED_TEST("Iterate (unique)", UPTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr)", SUPDDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr<Del>)", SUPCDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (RefPtr)", RPTE::IterateTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, Iterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, Iterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, Iterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, Iterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, Iterate)
-RUN_NAMED_TEST("IterErase (unmanaged)", UMTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (unique)", UPTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr)", SUPDDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr<Del>)", SUPCDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (RefPtr)", RPTE::IterEraseTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, IterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, IterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, IterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, IterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, IterErase)
-RUN_NAMED_TEST("DirectErase (unmanaged)", UMTE::DirectEraseTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("DirectErase (unique)", UPTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr)", SUPDDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr<Del>)", SUPCDTE::DirectEraseTest)
-#endif
-RUN_NAMED_TEST("DirectErase (RefPtr)", RPTE::DirectEraseTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, DirectErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, DirectErase)
-RUN_NAMED_TEST("MakeIterator (unmanaged)", UMTE::MakeIteratorTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("MakeIterator (unique)", UPTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr)", SUPDDTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)", SUPCDTE::MakeIteratorTest)
-#endif
-RUN_NAMED_TEST("MakeIterator (RefPtr)", RPTE::MakeIteratorTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, MakeIterator)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, MakeIterator)
-RUN_NAMED_TEST("ReverseIterErase (unmanaged)", UMTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (unique)", UPTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr)", SUPDDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)", SUPCDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (RefPtr)", RPTE::ReverseIterEraseTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, ReverseIterErase)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, ReverseIterErase)
-RUN_NAMED_TEST("ReverseIterate (unmanaged)", UMTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (unique)", UPTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr)", SUPDDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)", SUPCDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (RefPtr)", RPTE::ReverseIterateTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, ReverseIterate)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, ReverseIterate)
// Hash tables do not support swapping or Rvalue operations (Assignment or
// construction) as doing so would be an O(n) operation (With 'n' == to the
// number of buckets in the hashtable)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("Swap (unmanaged)", UMTE::SwapTest)
-RUN_NAMED_TEST("Swap (unique)", UPTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr)", SUPDDTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr<Del>)", SUPCDTE::SwapTest)
-RUN_NAMED_TEST("Swap (RefPtr)", RPTE::SwapTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, Swap)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, Swap)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, Swap)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, Swap)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, Swap)
-RUN_NAMED_TEST("Rvalue Ops (unmanaged)", UMTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (unique)", UPTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr)", SUPDDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)", SUPCDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (RefPtr)", RPTE::RvalueOpsTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, RvalueOps)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, RvalueOps)
#endif
-RUN_NAMED_TEST("Scope (unique)", UPTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr)", SUPDDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr<Del>)", SUPCDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (RefPtr)", RPTE::ScopeTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, Scope)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, Scope)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, Scope)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, Scope)
-RUN_NAMED_TEST("TwoContainer (unmanaged)", UMTE::TwoContainerTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, TwoContainer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("TwoContainer (unique)", UPTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr)", SUPDDTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)", SUPCDTE::TwoContainerTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, TwoContainer)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, TwoContainer)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, TwoContainer)
#endif
-RUN_NAMED_TEST("TwoContainer (RefPtr)", RPTE::TwoContainerTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, TwoContainer)
-RUN_NAMED_TEST("ThreeContainerHelper (unmanaged)", UMTE::ThreeContainerHelperTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, ThreeContainerHelper)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ThreeContainerHelper (unique)", UPTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr)", SUPDDTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr<Del>)", SUPCDTE::ThreeContainerHelperTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, ThreeContainerHelper)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, ThreeContainerHelper)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, ThreeContainerHelper)
#endif
-RUN_NAMED_TEST("ThreeContainerHelper (RefPtr)", RPTE::ThreeContainerHelperTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, ThreeContainerHelper)
-RUN_NAMED_TEST("IterCopyPointer (unmanaged)", UMTE::IterCopyPointerTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, IterCopyPointer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("IterCopyPointer (unique)", UPTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr)", SUPDDTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)", SUPCDTE::IterCopyPointerTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, IterCopyPointer)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, IterCopyPointer)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, IterCopyPointer)
#endif
-RUN_NAMED_TEST("IterCopyPointer (RefPtr)", RPTE::IterCopyPointerTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, IterCopyPointer)
-RUN_NAMED_TEST("EraseIf (unmanaged)", UMTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (unique)", UPTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr)", SUPDDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr<Del>)", SUPCDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (RefPtr)", RPTE::EraseIfTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, EraseIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, EraseIf)
-RUN_NAMED_TEST("FindIf (unmanaged)", UMTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (unique)", UPTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr)", SUPDDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr<Del>)", SUPCDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (RefPtr)", RPTE::FindIfTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, FindIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, FindIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, FindIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, FindIf)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, FindIf)
//////////////////////////////////////////
// Associative container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("InsertByKey (unmanaged)", UMTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (unique)", UPTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (std::uptr)", SUPDDTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (std::uptr<Del>)", SUPCDTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (RefPtr)", RPTE::InsertByKeyTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, InsertByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, InsertByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, InsertByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, InsertByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, InsertByKey)
-RUN_NAMED_TEST("FindByKey (unmanaged)", UMTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (unique)", UPTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (std::uptr)", SUPDDTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (std::uptr<Del>)", SUPCDTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (RefPtr)", RPTE::FindByKeyTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, FindByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, FindByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, FindByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, FindByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, FindByKey)
-RUN_NAMED_TEST("EraseByKey (unmanaged)", UMTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (unique)", UPTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (std::uptr)", SUPDDTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (std::uptr<Del>)", SUPCDTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (RefPtr)", RPTE::EraseByKeyTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, EraseByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, EraseByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, EraseByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, EraseByKey)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, EraseByKey)
-RUN_NAMED_TEST("InsertOrFind (unmanaged)", UMTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (unique)", UPTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (std::uptr)", SUPDDTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (std::uptr<Del>)", SUPCDTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (RefPtr)", RPTE::InsertOrFindTest)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, InsertOrFind)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, InsertOrFind)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, InsertOrFind)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, InsertOrFind)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, InsertOrFind)
-RUN_NAMED_TEST("InsertOrReplace (unmanaged)", UMTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (unique)", UPTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (std::uptr)", SUPDDTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (std::uptr<Del>)", SUPCDTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (RefPtr)", RPTE::InsertOrReplaceTest)
-END_TEST_CASE(hashtable_dll_tests)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UMTE, InsertOrReplace)
+RUN_ZXTEST(DoublyLinkedHashTableTest, UPTE, InsertOrReplace)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPDDTE, InsertOrReplace)
+RUN_ZXTEST(DoublyLinkedHashTableTest, SUPCDTE, InsertOrReplace)
+RUN_ZXTEST(DoublyLinkedHashTableTest, RPTE, InsertOrReplace)
// clang-format on
} // namespace intrusive_containers
diff --git a/zircon/system/ulib/fbl/test/intrusive_hash_table_sll_tests.cc b/zircon/system/ulib/fbl/test/intrusive_hash_table_sll_tests.cc
index f67942b..3444242 100644
--- a/zircon/system/ulib/fbl/test/intrusive_hash_table_sll_tests.cc
+++ b/zircon/system/ulib/fbl/test/intrusive_hash_table_sll_tests.cc
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <unittest/unittest.h>
-#include <fbl/intrusive_single_list.h>
#include <fbl/intrusive_hash_table.h>
+#include <fbl/intrusive_single_list.h>
#include <fbl/tests/intrusive_containers/associative_container_test_environment.h>
#include <fbl/tests/intrusive_containers/intrusive_hash_table_checker.h>
#include <fbl/tests/intrusive_containers/test_thunks.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -102,165 +102,161 @@
using SUPCDTE = DEFINE_TEST_THUNK(Associative, HTSLL, StdUniquePtrCustomDeleter);
using RPTE = DEFINE_TEST_THUNK(Associative, HTSLL, RefPtr);
-BEGIN_TEST_CASE(hashtable_sll_tests)
//////////////////////////////////////////
// General container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("Clear (unmanaged)", UMTE::ClearTest)
-RUN_NAMED_TEST("Clear (unique)", UPTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr)", SUPDDTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr<Del>)", SUPCDTE::ClearTest)
-RUN_NAMED_TEST("Clear (RefPtr)", RPTE::ClearTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, Clear)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, Clear)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, Clear)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, Clear)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, Clear)
-RUN_NAMED_TEST("ClearUnsafe (unmanaged)", UMTE::ClearUnsafeTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, ClearUnsafe)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ClearUnsafe (unique)", UPTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr)", SUPDDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)", SUPCDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (RefPtr)", RPTE::ClearUnsafeTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, ClearUnsafe)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, ClearUnsafe)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, ClearUnsafe)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, ClearUnsafe)
#endif
-RUN_NAMED_TEST("IsEmpty (unmanaged)", UMTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (unique)", UPTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr)", SUPDDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)", SUPCDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (RefPtr)", RPTE::IsEmptyTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, IsEmpty)
-RUN_NAMED_TEST("Iterate (unmanaged)", UMTE::IterateTest)
-RUN_NAMED_TEST("Iterate (unique)", UPTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr)", SUPDDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr<Del>)", SUPCDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (RefPtr)", RPTE::IterateTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, Iterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, Iterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, Iterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, Iterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, Iterate)
// Hashtables with singly linked list bucket can perform direct
// iterator/reference erase operations, but the operations will be O(n)
-RUN_NAMED_TEST("IterErase (unmanaged)", UMTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (unique)", UPTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr)", SUPDDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr<Del>)", SUPCDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (RefPtr)", RPTE::IterEraseTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, IterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, IterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, IterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, IterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, IterErase)
-RUN_NAMED_TEST("DirectErase (unmanaged)", UMTE::DirectEraseTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("DirectErase (unique)", UPTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr)", SUPDDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr<Del>)", SUPCDTE::DirectEraseTest)
-#endif
-RUN_NAMED_TEST("DirectErase (RefPtr)", RPTE::DirectEraseTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, DirectErase)
-RUN_NAMED_TEST("MakeIterator (unmanaged)", UMTE::MakeIteratorTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("MakeIterator (unique)", UPTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr)", SUPDDTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)", SUPCDTE::MakeIteratorTest)
-#endif
-RUN_NAMED_TEST("MakeIterator (RefPtr)", RPTE::MakeIteratorTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, MakeIterator)
// HashTables with SinglyLinkedList buckets cannot iterate backwards (because
// their buckets cannot iterate backwards)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ReverseIterErase (unmanaged)", UMTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (unique)", UPTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr)", SUPDDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)", SUPCDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (RefPtr)", RPTE::ReverseIterEraseTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, ReverseIterErase)
-RUN_NAMED_TEST("ReverseIterate (unmanaged)", UMTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (unique)", UPTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr)", SUPDDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)", SUPCDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (RefPtr)", RPTE::ReverseIterateTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, ReverseIterate)
#endif
// Hash tables do not support swapping or Rvalue operations (Assignment or
// construction) as doing so would be an O(n) operation (With 'n' == to the
// number of buckets in the hashtable)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("Swap (unmanaged)", UMTE::SwapTest)
-RUN_NAMED_TEST("Swap (unique)", UPTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr)", SUPDDTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr<Del>)", SUPCDTE::SwapTest)
-RUN_NAMED_TEST("Swap (RefPtr)", RPTE::SwapTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, Swap)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, Swap)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, Swap)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, Swap)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, Swap)
-RUN_NAMED_TEST("Rvalue Ops (unmanaged)", UMTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (unique)", UPTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr)", SUPDDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)", SUPCDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (RefPtr)", RPTE::RvalueOpsTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, RvalueOps)
#endif
-RUN_NAMED_TEST("Scope (unique)", UPTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr)", SUPDDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr<Del>)", SUPCDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (RefPtr)", RPTE::ScopeTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, Scope)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, Scope)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, Scope)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, Scope)
-RUN_NAMED_TEST("TwoContainer (unmanaged)", UMTE::TwoContainerTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, TwoContainer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("TwoContainer (unique)", UPTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr)", SUPDDTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)", SUPCDTE::TwoContainerTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, TwoContainer)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, TwoContainer)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, TwoContainer)
#endif
-RUN_NAMED_TEST("TwoContainer (RefPtr)", RPTE::TwoContainerTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, TwoContainer)
-RUN_NAMED_TEST("ThreeContainerHelper (unmanaged)", UMTE::ThreeContainerHelperTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, ThreeContainerHelper)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ThreeContainerHelper (unique)", UPTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr)", SUPDDTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr<Del>)", SUPCDTE::ThreeContainerHelperTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, ThreeContainerHelper)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, ThreeContainerHelper)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, ThreeContainerHelper)
#endif
-RUN_NAMED_TEST("ThreeContainerHelper (RefPtr)", RPTE::ThreeContainerHelperTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, ThreeContainerHelper)
-RUN_NAMED_TEST("IterCopyPointer (unmanaged)", UMTE::IterCopyPointerTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, IterCopyPointer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("IterCopyPointer (unique)", UPTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr)", SUPDDTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)", DDTE::IterCopyPointerTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, IterCopyPointer)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, IterCopyPointer)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, IterCopyPointer)
#endif
-RUN_NAMED_TEST("IterCopyPointer (RefPtr)", RPTE::IterCopyPointerTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, IterCopyPointer)
-RUN_NAMED_TEST("EraseIf (unmanaged)", UMTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (unique)", UPTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr)", SUPCDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (RefPtr)", RPTE::EraseIfTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, EraseIf)
-RUN_NAMED_TEST("FindIf (unmanaged)", UMTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (unique)", UPTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr)", SUPDDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr<Del>)", SUPCDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (RefPtr)", RPTE::FindIfTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, FindIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, FindIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, FindIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, FindIf)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, FindIf)
//////////////////////////////////////////
// Associative container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("InsertByKey (unmanaged)", UMTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (unique)", UPTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (std::uptr)", SUPDDTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (std::uptr<Del>)", SUPCDTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (RefPtr)", RPTE::InsertByKeyTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, InsertByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, InsertByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, InsertByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, InsertByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, InsertByKey)
-RUN_NAMED_TEST("FindByKey (unmanaged)", UMTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (unique)", UPTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (std::uptr)", SUPDDTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (std::uptr<Del>)", SUPCDTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (RefPtr)", RPTE::FindByKeyTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, FindByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, FindByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, FindByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, FindByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, FindByKey)
-RUN_NAMED_TEST("EraseByKey (unmanaged)", UMTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (unique)", UPTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (std::uptr)", SUPDDTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (std::uptr<Del>)", SUPCDTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (RefPtr)", RPTE::EraseByKeyTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, EraseByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, EraseByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, EraseByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, EraseByKey)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, EraseByKey)
-RUN_NAMED_TEST("InsertOrFind (unmanaged)", UMTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (unique)", UPTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (std::uptr)", SUPDDTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (RefPtr)", RPTE::InsertOrFindTest)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, InsertOrFind)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, InsertOrFind)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, InsertOrFind)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, InsertOrFind)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, InsertOrFind)
-RUN_NAMED_TEST("InsertOrReplace (unmanaged)", UMTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (unique)", UPTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (std::uptr)", SUPDDTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (std::uptr<Del>)", SUPCDTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (RefPtr)", RPTE::InsertOrReplaceTest)
-END_TEST_CASE(hashtable_sll_tests)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UMTE, InsertOrReplace)
+RUN_ZXTEST(SinglyLinkedHashTableTest, UPTE, InsertOrReplace)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPDDTE, InsertOrReplace)
+RUN_ZXTEST(SinglyLinkedHashTableTest, SUPCDTE, InsertOrReplace)
+RUN_ZXTEST(SinglyLinkedHashTableTest, RPTE, InsertOrReplace)
// clang-format on
} // namespace intrusive_containers
diff --git a/zircon/system/ulib/fbl/test/intrusive_singly_linked_list_tests.cc b/zircon/system/ulib/fbl/test/intrusive_singly_linked_list_tests.cc
index 08820a9..bab204f 100644
--- a/zircon/system/ulib/fbl/test/intrusive_singly_linked_list_tests.cc
+++ b/zircon/system/ulib/fbl/test/intrusive_singly_linked_list_tests.cc
@@ -2,11 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <unittest/unittest.h>
#include <fbl/intrusive_single_list.h>
#include <fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h>
#include <fbl/tests/intrusive_containers/sequence_container_test_environment.h>
#include <fbl/tests/intrusive_containers/test_thunks.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -56,233 +56,228 @@
std::tuple<typename SLLTraits<int*>::Tag1, typename SLLTraits<int*>::Tag2,
typename SLLTraits<int*>::Tag3>>);
+// clang-format off
DEFINE_TEST_OBJECTS(SLL);
-using UMTE = DEFINE_TEST_THUNK(Sequence, SLL, Unmanaged);
-using UPTE = DEFINE_TEST_THUNK(Sequence, SLL, UniquePtr);
+using UMTE = DEFINE_TEST_THUNK(Sequence, SLL, Unmanaged);
+using UPTE = DEFINE_TEST_THUNK(Sequence, SLL, UniquePtr);
using SUPDDTE = DEFINE_TEST_THUNK(Sequence, SLL, StdUniquePtrDefaultDeleter);
using SUPCDTE = DEFINE_TEST_THUNK(Sequence, SLL, StdUniquePtrCustomDeleter);
-using RPTE = DEFINE_TEST_THUNK(Sequence, SLL, RefPtr);
+using RPTE = DEFINE_TEST_THUNK(Sequence, SLL, RefPtr);
-// clang-format off
-BEGIN_TEST_CASE(single_linked_list_tests)
//////////////////////////////////////////
// General container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("Clear (unmanaged)", UMTE::ClearTest)
-RUN_NAMED_TEST("Clear (unique)", UPTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr)", SUPDDTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr<Del>)", SUPCDTE::ClearTest)
-RUN_NAMED_TEST("Clear (RefPtr)", RPTE::ClearTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, Clear)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, Clear)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, Clear)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, Clear)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, Clear)
-RUN_NAMED_TEST("ClearUnsafe (unmanaged)", UMTE::ClearUnsafeTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, ClearUnsafe)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ClearUnsafe (unique)", UPTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr)", SUPDDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)", SUPCDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (RefPtr)", RPTE::ClearUnsafeTest)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, ClearUnsafe)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, ClearUnsafe)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, ClearUnsafe)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, ClearUnsafe)
#endif
-RUN_NAMED_TEST("IsEmpty (unmanaged)", UMTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (unique)", UPTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr)", SUPDDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)", SUPCDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (RefPtr)", RPTE::IsEmptyTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, IsEmpty)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, IsEmpty)
-RUN_NAMED_TEST("Iterate (unmanaged)", UMTE::IterateTest)
-RUN_NAMED_TEST("Iterate (unique)", UPTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr)", SUPDDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr<Del>)", SUPCDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (RefPtr)", RPTE::IterateTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, Iterate)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, Iterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, Iterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, Iterate)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, Iterate)
// SinglyLinkedLists cannot perform direct erase operations, nor can they erase
// using an iterator.
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("IterErase (unmanaged)", UMTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (unique)", UPTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr)", SUPDDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr<Del>)", SUPCDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (RefPtr)", RPTE::IterEraseTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, IterErase)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, IterErase)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, IterErase)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, IterErase)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, IterErase)
-RUN_NAMED_TEST("DirectErase (unmanaged)", UMTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (unique)", UPTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr)", SUPDDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr<Del>)", SUPCDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (RefPtr)", RPTE::DirectEraseTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, DirectErase)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, DirectErase)
#endif
-RUN_NAMED_TEST("MakeIterator (unmanaged)", UMTE::MakeIteratorTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("MakeIterator (unique)", UPTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr)", SUPDDTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)", SUPCDTE::MakeIteratorTest)
-#endif
-RUN_NAMED_TEST("MakeIterator (RefPtr)", RPTE::MakeIteratorTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, MakeIterator)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, MakeIterator)
// SinglyLinkedLists cannot iterate backwards.
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ReverseIterErase (unmanaged)", UMTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (unique)", UPTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr)", SUPDDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)", SUPCDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (RefPtr)", RPTE::ReverseIterEraseTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, ReverseIterErase)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, ReverseIterErase)
-RUN_NAMED_TEST("ReverseIterate (unmanaged)", UMTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (unique)", UPTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr)", SUPDDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)", SUPCDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (RefPtr)", RPTE::ReverseIterateTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, ReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, ReverseIterate)
#endif
-RUN_NAMED_TEST("Swap (unmanaged)", UMTE::SwapTest)
-RUN_NAMED_TEST("Swap (unique)", UPTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr)", SUPDDTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr<Del>)", SUPCDTE::SwapTest)
-RUN_NAMED_TEST("Swap (RefPtr)", RPTE::SwapTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, Swap)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, Swap)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, Swap)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, Swap)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, Swap)
-RUN_NAMED_TEST("Rvalue Ops (unmanaged)", UMTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (unique)", UPTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr)", SUPDDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)", SUPCDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (RefPtr)", RPTE::RvalueOpsTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, RvalueOps)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, RvalueOps)
-RUN_NAMED_TEST("Scope (unique)", UPTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr)", SUPDDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr<Del>)", SUPCDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (RefPtr)", RPTE::ScopeTest)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, Scope)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, Scope)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, Scope)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, Scope)
-RUN_NAMED_TEST("TwoContainer (unmanaged)", UMTE::TwoContainerTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, TwoContainer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("TwoContainer (unique)", UPTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr)", SUPDDTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)", SUPCDTE::TwoContainerTest)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, TwoContainer)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, TwoContainer)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, TwoContainer)
#endif
-RUN_NAMED_TEST("TwoContainer (RefPtr)", RPTE::TwoContainerTest)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, TwoContainer)
-RUN_NAMED_TEST("ThreeContainerHelper (unmanaged)", UMTE::ThreeContainerHelperTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, ThreeContainerHelper)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ThreeContainerHelper (unique)", UPTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr)", SUPDDTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr<Del>)", SUPCDTE::ThreeContainerHelperTest)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, ThreeContainerHelper)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, ThreeContainerHelper)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, ThreeContainerHelper)
#endif
-RUN_NAMED_TEST("ThreeContainerHelper (RefPtr)", RPTE::ThreeContainerHelperTest)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, ThreeContainerHelper)
-RUN_NAMED_TEST("IterCopyPointer (unmanaged)", UMTE::IterCopyPointerTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, IterCopyPointer)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("IterCopyPointer (unique)", UPTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr)", SUPDDTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)", SUPCDTE::IterCopyPointerTest)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, IterCopyPointer)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, IterCopyPointer)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, IterCopyPointer)
#endif
-RUN_NAMED_TEST("IterCopyPointer (RefPtr)", RPTE::IterCopyPointerTest)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, IterCopyPointer)
-RUN_NAMED_TEST("EraseIf (unmanaged)", UMTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (unique)", UPTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr)", SUPDDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr<Del>)", SUPCDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (RefPtr)", RPTE::EraseIfTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, EraseIf)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, EraseIf)
-RUN_NAMED_TEST("FindIf (unmanaged)", UMTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (unique)", UPTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr)", SUPDDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr<Del>)", SUPCDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (RefPtr)", RPTE::FindIfTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, FindIf)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, FindIf)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, FindIf)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, FindIf)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, FindIf)
//////////////////////////////////////////
// Sequence container specific tests.
//////////////////////////////////////////
-RUN_NAMED_TEST("PushFront (unmanaged)", UMTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (unique)", UPTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (std::uptr)", SUPDDTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (std::uptr<Del>)", SUPCDTE::PushFrontTest)
-RUN_NAMED_TEST("PushFront (RefPtr)", RPTE::PushFrontTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, PushFront)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, PushFront)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, PushFront)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, PushFront)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, PushFront)
-RUN_NAMED_TEST("PopFront (unmanaged)", UMTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (unique)", UPTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (std::uptr)", SUPDDTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (std::uptr<Del>)", SUPCDTE::PopFrontTest)
-RUN_NAMED_TEST("PopFront (RefPtr)", RPTE::PopFrontTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, PopFront)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, PopFront)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, PopFront)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, PopFront)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, PopFront)
// Singly linked lists cannot push/pop to/from the back
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("PushBack (unmanaged)", UMTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (unique)", UPTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (std::uptr)", SUPDDTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (std::uptr<Del>)", SUPCDTE::PushBackTest)
-RUN_NAMED_TEST("PushBack (RefPtr)", RPTE::PushBackTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, PushBack)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, PushBack)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, PushBack)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, PushBack)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, PushBack)
-RUN_NAMED_TEST("PopBack (unmanaged)", UMTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (unique)", UPTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (std::uptr)", SUPDDTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (std::uptr<Del>)", SUPCDTE::PopBackTest)
-RUN_NAMED_TEST("PopBack (RefPtr)", RPTE::PopBackTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, PopBack)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, PopBack)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, PopBack)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, PopBack)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, PopBack)
#endif
-RUN_NAMED_TEST("SeqIterate (unmanaged)", UMTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (unique)", UPTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (std::uptr)", SUPDDTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (std::uptr<Del>)", SUPCDTE::SeqIterateTest)
-RUN_NAMED_TEST("SeqIterate (RefPtr)", RPTE::SeqIterateTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, SeqIterate)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, SeqIterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, SeqIterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, SeqIterate)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, SeqIterate)
// SinglyLinkedLists cannot iterate backwards.
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("SeqReverseIterate (unmanaged)", UMTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (unique)", UPTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (std::uptr)", SUPDDTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (std::uptr<Del>)", SUPCDTE::SeqReverseIterateTest)
-RUN_NAMED_TEST("SeqReverseIterate (RefPtr)", RPTE::SeqReverseIterateTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, SeqReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, SeqReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, SeqReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, SeqReverseIterate)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, SeqReverseIterate)
#endif
-RUN_NAMED_TEST("EraseNext (unmanaged)", UMTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (unique)", UPTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (std::uptr)", SUPDDTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (std::uptr<Del>)", SUPCDTE::EraseNextTest)
-RUN_NAMED_TEST("EraseNext (RefPtr)", RPTE::EraseNextTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, EraseNext)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, EraseNext)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, EraseNext)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, EraseNext)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, EraseNext)
-RUN_NAMED_TEST("InsertAfter (unmanaged)", UMTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (unique)", UPTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (std::uptr)", SUPDDTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (std::uptr<Del>)", SUPCDTE::InsertAfterTest)
-RUN_NAMED_TEST("InsertAfter (RefPtr)", RPTE::InsertAfterTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, InsertAfter)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, InsertAfter)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, InsertAfter)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, InsertAfter)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, InsertAfter)
-// SinglyLinkedLists cannot perform inserts-bef ore operations, either with an
+// SinglyLinkedLists cannot perform inserts-before operations, either with an
// iterator or with a direct object reference.
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("Insert (unmanaged)", UMTE::InsertTest)
-RUN_NAMED_TEST("Insert (unique)", UPTE::InsertTest)
-RUN_NAMED_TEST("Insert (std::uptr)", SUPDDTE::InsertTest)
-RUN_NAMED_TEST("Insert (std::uptr<Del>)", SUPCDTE::InsertTest)
-RUN_NAMED_TEST("Insert (RefPtr)", RPTE::InsertTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, Insert)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, Insert)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, Insert)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, Insert)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, Insert)
-RUN_NAMED_TEST("DirectInsert (unmanaged)", UMTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (unique)", UPTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (std::uptr)", SUPDDTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (std::uptr<Del>)", SUPCDTE::DirectInsertTest)
-RUN_NAMED_TEST("DirectInsert (RefPtr)", RPTE::DirectInsertTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, DirectInsert)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, DirectInsert)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, DirectInsert)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, DirectInsert)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, DirectInsert)
#endif
-// SinglyLinkedLists cannot perform splice oper ations.
+// SinglyLinkedLists cannot perform splice operations.
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("Splice (unmanaged)", UMTE::SpliceTest)
-RUN_NAMED_TEST("Splice (unique)", UPTE::SpliceTest)
-RUN_NAMED_TEST("Splice (std::uptr)", SUPDDTE::SpliceTest)
-RUN_NAMED_TEST("Splice (std::uptr<Del>)", SUPCDTE::SpliceTest)
-RUN_NAMED_TEST("Splice (RefPtr)", RPTE::SpliceTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, Splice)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, Splice)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, Splice)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, Splice)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, Splice)
#endif
-RUN_NAMED_TEST("ReplaceIfCopy (unmanaged)", UMTE::ReplaceIfCopyTest)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, ReplaceIfCopy)
#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ReplaceIfCopy (unique)", UPTE::ReplaceIfCopyTest)
-RUN_NAMED_TEST("ReplaceIfCopy (std::uptr)", SUPDDTE::ReplaceIfCopyTest)
-RUN_NAMED_TEST("ReplaceIfCopy (std::uptr<Del>)", SUPCDTE::ReplaceIfCopyTest)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, ReplaceIfCopy)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, ReplaceIfCopy)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, ReplaceIfCopy)
#endif
-RUN_NAMED_TEST("ReplaceIfCopy (RefPtr)", RPTE::ReplaceIfCopyTest)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, ReplaceIfCopy)
-RUN_NAMED_TEST("ReplaceIfMove (unmanaged)", UMTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (unique)", UPTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (std::uptr)", SUPDDTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (std::uptr<Del>)", SUPCDTE::ReplaceIfMoveTest)
-RUN_NAMED_TEST("ReplaceIfMove (RefPtr)", RPTE::ReplaceIfMoveTest)
-
-END_TEST_CASE(single_linked_list_tests)
+RUN_ZXTEST(SinglyLinkedListTest, UMTE, ReplaceIfMove)
+RUN_ZXTEST(SinglyLinkedListTest, UPTE, ReplaceIfMove)
+RUN_ZXTEST(SinglyLinkedListTest, SUPDDTE, ReplaceIfMove)
+RUN_ZXTEST(SinglyLinkedListTest, SUPCDTE, ReplaceIfMove)
+RUN_ZXTEST(SinglyLinkedListTest, RPTE, ReplaceIfMove)
// clang-format on
} // namespace intrusive_containers
diff --git a/zircon/system/ulib/fbl/test/intrusive_wavl_tree_tests.cc b/zircon/system/ulib/fbl/test/intrusive_wavl_tree_tests.cc
index 6b7ada2..b76c953 100644
--- a/zircon/system/ulib/fbl/test/intrusive_wavl_tree_tests.cc
+++ b/zircon/system/ulib/fbl/test/intrusive_wavl_tree_tests.cc
@@ -3,12 +3,13 @@
// found in the LICENSE file.
#include <math.h>
+
+#include <fbl/intrusive_pointer_traits.h>
#include <fbl/intrusive_wavl_tree.h>
#include <fbl/tests/intrusive_containers/intrusive_wavl_tree_checker.h>
#include <fbl/tests/intrusive_containers/ordered_associative_container_test_environment.h>
#include <fbl/tests/intrusive_containers/test_thunks.h>
-#include <fbl/intrusive_pointer_traits.h>
-#include <unittest/unittest.h>
+#include <zxtest/zxtest.h>
namespace fbl {
namespace tests {
@@ -167,8 +168,7 @@
static void RecordEraseDoubleRotation() { ++op_counts_.erase_double_rotations_; }
template <typename TreeType>
- static bool VerifyRankRule(const TreeType& tree, typename TreeType::RawPtrType node) {
- BEGIN_TEST;
+ static void VerifyRankRule(const TreeType& tree, typename TreeType::RawPtrType node) {
using NodeTraits = typename TreeType::NodeTraits;
// Check the rank rule. The rules for a WAVL tree are...
@@ -195,14 +195,10 @@
ASSERT_GE(2, delta, "Right hand rank difference not on range [1, 2]");
}
}
-
- END_TEST;
}
template <typename TreeType>
- static bool VerifyBalance(const TreeType& tree, uint64_t depth) {
- BEGIN_TEST;
-
+ static void VerifyBalance(const TreeType& tree, uint64_t depth) {
// Compute the maximum expected depth.
uint64_t max_depth = 0;
if (tree.size()) {
@@ -238,8 +234,6 @@
EXPECT_LE(total_erase_rotations, op_counts_.erase_ops_, "#erase_rotations must be <= #erases");
EXPECT_GE(max_depth, depth);
-
- END_TEST;
}
private:
@@ -297,26 +291,20 @@
static constexpr size_t kBalanceTestSize = 2048;
-static bool DoBalanceTestInsert(BalanceTestTree& tree, BalanceTestObj* ptr) {
- BEGIN_TEST;
-
+static void DoBalanceTestInsert(BalanceTestTree& tree, BalanceTestObj* ptr) {
// The selected object should not be in the tree.
- ASSERT_NONNULL(ptr);
+ ASSERT_NOT_NULL(ptr);
ASSERT_FALSE(ptr->InContainer());
// Put the object into the tree. Assert that it succeeds, then
// sanity check the tree.
ASSERT_TRUE(tree.insert_or_find(BalanceTestObjPtr(ptr)));
- ASSERT_TRUE(WAVLTreeChecker::SanityCheck(tree));
-
- END_TEST;
+ ASSERT_NO_FAILURES(WAVLTreeChecker::SanityCheck(tree));
}
-static bool DoBalanceTestErase(BalanceTestTree& tree, BalanceTestObj* ptr) {
- BEGIN_TEST;
-
+static void DoBalanceTestErase(BalanceTestTree& tree, BalanceTestObj* ptr) {
// The selected object should still be in the tree.
- ASSERT_NONNULL(ptr);
+ ASSERT_NOT_NULL(ptr);
ASSERT_TRUE(ptr->InContainer());
// Erase should find the object and transfer its pointer back to us.
@@ -327,9 +315,7 @@
// Run a full sanity check on the tree. Its depth should be
// consistent with a tree which has seen both inserts and erases.
- ASSERT_TRUE(WAVLTreeChecker::SanityCheck(tree));
-
- END_TEST;
+ ASSERT_NO_FAILURES(WAVLTreeChecker::SanityCheck(tree));
}
static void ShuffleEraseDeck(const unique_ptr<BalanceTestObj[]>& objects,
@@ -343,9 +329,182 @@
}
}
-static bool WAVLBalanceTest() {
- BEGIN_TEST;
+// clang-format off
+//////////////////////////////////////////
+// General container specific tests.
+//////////////////////////////////////////
+RUN_ZXTEST(WavlTreeTest, UMTE, Clear)
+RUN_ZXTEST(WavlTreeTest, UPTE, Clear)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, Clear)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, Clear)
+RUN_ZXTEST(WavlTreeTest, RPTE, Clear)
+RUN_ZXTEST(WavlTreeTest, UMTE, ClearUnsafe)
+#if TEST_WILL_NOT_COMPILE || 0
+RUN_ZXTEST(WavlTreeTest, UPTE, ClearUnsafe)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, ClearUnsafe)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, ClearUnsafe)
+RUN_ZXTEST(WavlTreeTest, RPTE, ClearUnsafe)
+#endif
+
+RUN_ZXTEST(WavlTreeTest, UMTE, IsEmpty)
+RUN_ZXTEST(WavlTreeTest, UPTE, IsEmpty)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, IsEmpty)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, IsEmpty)
+RUN_ZXTEST(WavlTreeTest, RPTE, IsEmpty)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, Iterate)
+RUN_ZXTEST(WavlTreeTest, UPTE, Iterate)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, Iterate)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, Iterate)
+RUN_ZXTEST(WavlTreeTest, RPTE, Iterate)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, IterErase)
+RUN_ZXTEST(WavlTreeTest, UPTE, IterErase)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, IterErase)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, IterErase)
+RUN_ZXTEST(WavlTreeTest, RPTE, IterErase)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, DirectErase)
+RUN_ZXTEST(WavlTreeTest, UPTE, DirectErase)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, DirectErase)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, DirectErase)
+RUN_ZXTEST(WavlTreeTest, RPTE, DirectErase)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, MakeIterator)
+RUN_ZXTEST(WavlTreeTest, UPTE, MakeIterator)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, MakeIterator)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, MakeIterator)
+RUN_ZXTEST(WavlTreeTest, RPTE, MakeIterator)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, ReverseIterErase)
+RUN_ZXTEST(WavlTreeTest, UPTE, ReverseIterErase)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, ReverseIterErase)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, ReverseIterErase)
+RUN_ZXTEST(WavlTreeTest, RPTE, ReverseIterErase)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, ReverseIterate)
+RUN_ZXTEST(WavlTreeTest, UPTE, ReverseIterate)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, ReverseIterate)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, ReverseIterate)
+RUN_ZXTEST(WavlTreeTest, RPTE, ReverseIterate)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, Swap)
+RUN_ZXTEST(WavlTreeTest, UPTE, Swap)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, Swap)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, Swap)
+RUN_ZXTEST(WavlTreeTest, RPTE, Swap)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, RvalueOps)
+RUN_ZXTEST(WavlTreeTest, UPTE, RvalueOps)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, RvalueOps)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, RvalueOps)
+RUN_ZXTEST(WavlTreeTest, RPTE, RvalueOps)
+
+RUN_ZXTEST(WavlTreeTest, UPTE, Scope)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, Scope)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, Scope)
+RUN_ZXTEST(WavlTreeTest, RPTE, Scope)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, TwoContainer)
+#if TEST_WILL_NOT_COMPILE || 0
+RUN_ZXTEST(WavlTreeTest, UPTE, TwoContainer)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, TwoContainer)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, TwoContainer)
+#endif
+RUN_ZXTEST(WavlTreeTest, RPTE, TwoContainer)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, ThreeContainerHelper)
+#if TEST_WILL_NOT_COMPILE || 0
+RUN_ZXTEST(WavlTreeTest, UPTE, ThreeContainerHelper)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, ThreeContainerHelper)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, ThreeContainerHelper)
+#endif
+RUN_ZXTEST(WavlTreeTest, RPTE, ThreeContainerHelper)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, IterCopyPointer)
+#if TEST_WILL_NOT_COMPILE || 0
+RUN_ZXTEST(WavlTreeTest, UPTE, IterCopyPointer)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, IterCopyPointer)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, IterCopyPointer)
+#endif
+RUN_ZXTEST(WavlTreeTest, RPTE, IterCopyPointer)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, EraseIf)
+RUN_ZXTEST(WavlTreeTest, UPTE, EraseIf)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, EraseIf)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, EraseIf)
+RUN_ZXTEST(WavlTreeTest, RPTE, EraseIf)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, FindIf)
+RUN_ZXTEST(WavlTreeTest, UPTE, FindIf)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, FindIf)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, FindIf)
+RUN_ZXTEST(WavlTreeTest, RPTE, FindIf)
+
+//////////////////////////////////////////
+// Associative container specific tests.
+//////////////////////////////////////////
+RUN_ZXTEST(WavlTreeTest, UMTE, InsertByKey)
+RUN_ZXTEST(WavlTreeTest, UPTE, InsertByKey)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, InsertByKey)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, InsertByKey)
+RUN_ZXTEST(WavlTreeTest, RPTE, InsertByKey)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, FindByKey)
+RUN_ZXTEST(WavlTreeTest, UPTE, FindByKey)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, FindByKey)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, FindByKey)
+RUN_ZXTEST(WavlTreeTest, RPTE, FindByKey)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, EraseByKey)
+RUN_ZXTEST(WavlTreeTest, UPTE, EraseByKey)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, EraseByKey)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, EraseByKey)
+RUN_ZXTEST(WavlTreeTest, RPTE, EraseByKey)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, InsertOrFind)
+RUN_ZXTEST(WavlTreeTest, UPTE, InsertOrFind)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, InsertOrFind)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, InsertOrFind)
+RUN_ZXTEST(WavlTreeTest, RPTE, InsertOrFind)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, InsertOrReplace)
+RUN_ZXTEST(WavlTreeTest, UPTE, InsertOrReplace)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, InsertOrReplace)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, InsertOrReplace)
+RUN_ZXTEST(WavlTreeTest, RPTE, InsertOrReplace)
+
+////////////////////////////////////////////////
+// OrderedAssociative container specific tests.
+////////////////////////////////////////////////
+RUN_ZXTEST(WavlTreeTest, UMTE, OrderedIter)
+RUN_ZXTEST(WavlTreeTest, UPTE, OrderedIter)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, OrderedIter)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, OrderedIter)
+RUN_ZXTEST(WavlTreeTest, RPTE, OrderedIter)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, OrderedReverseIter)
+RUN_ZXTEST(WavlTreeTest, UPTE, OrderedReverseIter)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, OrderedReverseIter)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, OrderedReverseIter)
+RUN_ZXTEST(WavlTreeTest, RPTE, OrderedReverseIter)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, UpperBound)
+RUN_ZXTEST(WavlTreeTest, UPTE, UpperBound)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, UpperBound)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, UpperBound)
+RUN_ZXTEST(WavlTreeTest, RPTE, UpperBound)
+
+RUN_ZXTEST(WavlTreeTest, UMTE, LowerBound)
+RUN_ZXTEST(WavlTreeTest, UPTE, LowerBound)
+RUN_ZXTEST(WavlTreeTest, SUPDDTE, LowerBound)
+RUN_ZXTEST(WavlTreeTest, SUPCDTE, LowerBound)
+RUN_ZXTEST(WavlTreeTest, RPTE, LowerBound)
+
+// The balance test is a pretty heavy test. Only enable it when asked to do so.
+#if FBL_TEST_ENABLE_WAVL_TREE_BALANCE_TEST
+TEST(WavlTreeTest, Balance) {
WAVLBalanceTestObserver::OpCounts op_counts;
// Declare these in a specific order (object pointer first) so that the tree
@@ -399,27 +558,31 @@
// Place each object into the tree, then perform a full sanity check on
// the tree. If anything goes wrong, just abort the test. If we keep
// going, we are just going to get an unmanageable amt of errors.
- for (size_t i = 0; i < kBalanceTestSize; ++i)
- ASSERT_TRUE(DoBalanceTestInsert(tree, &objects[i]));
+ for (size_t i = 0; i < kBalanceTestSize; ++i) {
+ ASSERT_NO_FAILURES(DoBalanceTestInsert(tree, &objects[i]));
+ }
// Shuffle the erase deck.
ShuffleEraseDeck(objects, rng);
// Erase half of the elements in the tree.
- for (size_t i = 0; i < (kBalanceTestSize >> 1); ++i)
- ASSERT_TRUE(DoBalanceTestErase(tree, objects[i].EraseDeckPtr()));
+ for (size_t i = 0; i < (kBalanceTestSize >> 1); ++i) {
+ ASSERT_NO_FAILURES(DoBalanceTestErase(tree, objects[i].EraseDeckPtr()));
+ }
// Put the elements back so that we have inserted some elements into a
// non-empty tree which has seen erase operations.
- for (size_t i = 0; i < (kBalanceTestSize >> 1); ++i)
- ASSERT_TRUE(DoBalanceTestInsert(tree, objects[i].EraseDeckPtr()));
+ for (size_t i = 0; i < (kBalanceTestSize >> 1); ++i) {
+ ASSERT_NO_FAILURES(DoBalanceTestInsert(tree, objects[i].EraseDeckPtr()));
+ }
// Shuffle the erase deck again.
ShuffleEraseDeck(objects, rng);
// Now erase every element from the tree.
- for (size_t i = 0; i < kBalanceTestSize; ++i)
- ASSERT_TRUE(DoBalanceTestErase(tree, objects[i].EraseDeckPtr()));
+ for (size_t i = 0; i < kBalanceTestSize; ++i) {
+ ASSERT_NO_FAILURES(DoBalanceTestErase(tree, objects[i].EraseDeckPtr()));
+ }
ASSERT_EQ(0u, tree.size());
@@ -436,197 +599,9 @@
EXPECT_LT(0u, op_counts.erase_demotes_, "Insufficient test coverage!");
EXPECT_LT(0u, op_counts.erase_rotations_, "Insufficient test coverage!");
EXPECT_LT(0u, op_counts.erase_double_rotations_, "Insufficient test coverage!");
-
- END_TEST;
}
-
-// clang-format off
-BEGIN_TEST_CASE(wavl_tree_tests)
-//////////////////////////////////////////
-// General container specific tests.
-//////////////////////////////////////////
-RUN_NAMED_TEST("Clear (unmanaged)", UMTE::ClearTest)
-RUN_NAMED_TEST("Clear (unique)", UPTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr)", SUPDDTE::ClearTest)
-RUN_NAMED_TEST("Clear (std::uptr<Del>)", SUPCDTE::ClearTest)
-RUN_NAMED_TEST("Clear (RefPtr)", RPTE::ClearTest)
-
-RUN_NAMED_TEST("ClearUnsafe (unmanaged)", UMTE::ClearUnsafeTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ClearUnsafe (unique)", UPTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr)", SUPDDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)", SUPCDTE::ClearUnsafeTest)
-RUN_NAMED_TEST("ClearUnsafe (RefPtr)", RPTE::ClearUnsafeTest)
#endif
-RUN_NAMED_TEST("IsEmpty (unmanaged)", UMTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (unique)", UPTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr)", SUPDDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)", SUPCDTE::IsEmptyTest)
-RUN_NAMED_TEST("IsEmpty (RefPtr)", RPTE::IsEmptyTest)
-
-RUN_NAMED_TEST("Iterate (unmanaged)", UMTE::IterateTest)
-RUN_NAMED_TEST("Iterate (unique)", UPTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr)", SUPDDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (std::uptr<Del>)", SUPCDTE::IterateTest)
-RUN_NAMED_TEST("Iterate (RefPtr)", RPTE::IterateTest)
-
-RUN_NAMED_TEST("IterErase (unmanaged)", UMTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (unique)", UPTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr)", SUPDDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (std::uptr<Del>)", SUPCDTE::IterEraseTest)
-RUN_NAMED_TEST("IterErase (RefPtr)", RPTE::IterEraseTest)
-
-RUN_NAMED_TEST("DirectErase (unmanaged)", UMTE::DirectEraseTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("DirectErase (unique)", UPTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr)", SUPDDTE::DirectEraseTest)
-RUN_NAMED_TEST("DirectErase (std::uptr<Del>)", SUPCDTE::DirectEraseTest)
-#endif
-RUN_NAMED_TEST("DirectErase (RefPtr)", RPTE::DirectEraseTest)
-
-RUN_NAMED_TEST("MakeIterator (unmanaged)", UMTE::MakeIteratorTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("MakeIterator (unique)", UPTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr)", SUPDDTE::MakeIteratorTest)
-RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)", SUPCDTE::MakeIteratorTest)
-#endif
-RUN_NAMED_TEST("MakeIterator (RefPtr)", RPTE::MakeIteratorTest)
-
-RUN_NAMED_TEST("ReverseIterErase (unmanaged)", UMTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (unique)", UPTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr)", SUPDDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)", SUPCDTE::ReverseIterEraseTest)
-RUN_NAMED_TEST("ReverseIterErase (RefPtr)", RPTE::ReverseIterEraseTest)
-
-RUN_NAMED_TEST("ReverseIterate (unmanaged)", UMTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (unique)", UPTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr)", SUPDDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)", SUPCDTE::ReverseIterateTest)
-RUN_NAMED_TEST("ReverseIterate (RefPtr)", RPTE::ReverseIterateTest)
-
-RUN_NAMED_TEST("Swap (unmanaged)", UMTE::SwapTest)
-RUN_NAMED_TEST("Swap (unique)", UPTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr)", SUPDDTE::SwapTest)
-RUN_NAMED_TEST("Swap (std::uptr<Del>)", SUPCDTE::SwapTest)
-RUN_NAMED_TEST("Swap (RefPtr)", RPTE::SwapTest)
-
-RUN_NAMED_TEST("Rvalue Ops (unmanaged)", UMTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (unique)", UPTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr)", SUPDDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)", SUPCDTE::RvalueOpsTest)
-RUN_NAMED_TEST("Rvalue Ops (RefPtr)", RPTE::RvalueOpsTest)
-
-RUN_NAMED_TEST("Scope (unique)", UPTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr)", SUPDDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (std::uptr<Del>)", SUPCDTE::ScopeTest)
-RUN_NAMED_TEST("Scope (RefPtr)", RPTE::ScopeTest)
-
-RUN_NAMED_TEST("TwoContainer (unmanaged)", UMTE::TwoContainerTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("TwoContainer (unique)", UPTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr)", SUPDDTE::TwoContainerTest)
-RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)", SUPCDTE::TwoContainerTest)
-#endif
-RUN_NAMED_TEST("TwoContainer (RefPtr)", RPTE::TwoContainerTest)
-
-RUN_NAMED_TEST("ThreeContainerHelper (unmanaged)", UMTE::ThreeContainerHelperTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("ThreeContainerHelper (unique)", UPTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr)", SUPDDTE::ThreeContainerHelperTest)
-RUN_NAMED_TEST("ThreeContainerHelper (std::uptr<Del>)", SUPCDTE::ThreeContainerHelperTest)
-#endif
-RUN_NAMED_TEST("ThreeContainerHelper (RefPtr)", RPTE::ThreeContainerHelperTest)
-
-RUN_NAMED_TEST("IterCopyPointer (unmanaged)", UMTE::IterCopyPointerTest)
-#if TEST_WILL_NOT_COMPILE || 0
-RUN_NAMED_TEST("IterCopyPointer (unique)", UPTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr)", SUPDDTE::IterCopyPointerTest)
-RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)", SUPCDTE::IterCopyPointerTest)
-#endif
-RUN_NAMED_TEST("IterCopyPointer (RefPtr)", RPTE::IterCopyPointerTest)
-
-RUN_NAMED_TEST("EraseIf (unmanaged)", UMTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (unique)", UPTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr)", SUPDDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (std::uptr<Del>)", SUPCDTE::EraseIfTest)
-RUN_NAMED_TEST("EraseIf (RefPtr)", RPTE::EraseIfTest)
-
-RUN_NAMED_TEST("FindIf (unmanaged)", UMTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (unique)", UPTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr)", SUPDDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (std::uptr<Del>)", SUPCDTE::FindIfTest)
-RUN_NAMED_TEST("FindIf (RefPtr)", RPTE::FindIfTest)
-
-//////////////////////////////////////////
-// Associative container specific tests.
-//////////////////////////////////////////
-RUN_NAMED_TEST("InsertByKey (unmanaged)", UMTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (unique)", UPTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (std::uptr)", SUPDDTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (std::uptr<Del>)", SUPCDTE::InsertByKeyTest)
-RUN_NAMED_TEST("InsertByKey (RefPtr)", RPTE::InsertByKeyTest)
-
-RUN_NAMED_TEST("FindByKey (unmanaged)", UMTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (unique)", UPTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (std::uptr)", SUPDDTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (std::uptr<Del>)", SUPCDTE::FindByKeyTest)
-RUN_NAMED_TEST("FindByKey (RefPtr)", RPTE::FindByKeyTest)
-
-RUN_NAMED_TEST("EraseByKey (unmanaged)", UMTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (unique)", UPTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (std::uptr)", SUPDDTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (std::uptr<Del>)", SUPCDTE::EraseByKeyTest)
-RUN_NAMED_TEST("EraseByKey (RefPtr)", RPTE::EraseByKeyTest)
-
-RUN_NAMED_TEST("InsertOrFind (unmanaged)", UMTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (unique)", UPTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (std::uptr)", SUPDDTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (std::uptr<Del>)", SUPCDTE::InsertOrFindTest)
-RUN_NAMED_TEST("InsertOrFind (RefPtr)", RPTE::InsertOrFindTest)
-
-RUN_NAMED_TEST("InsertOrReplace (unmanaged)", UMTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (unique)", UPTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (std::uptr)", SUPDDTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (std::uptr<Del>)", SUPCDTE::InsertOrReplaceTest)
-RUN_NAMED_TEST("InsertOrReplace (RefPtr)", RPTE::InsertOrReplaceTest)
-
-////////////////////////////////////////////////
-// OrderedAssociative container specific tests.
-////////////////////////////////////////////////
-RUN_NAMED_TEST("OrderedIter (unmanaged)", UMTE::OrderedIterTest)
-RUN_NAMED_TEST("OrderedIter (unique)", UPTE::OrderedIterTest)
-RUN_NAMED_TEST("OrderedIter (std::uptr)", SUPDDTE::OrderedIterTest)
-RUN_NAMED_TEST("OrderedIter (std::uptr<Del>)", SUPCDTE::OrderedIterTest)
-RUN_NAMED_TEST("OrderedIter (RefPtr)", RPTE::OrderedIterTest)
-
-RUN_NAMED_TEST("OrderedReverseIter (unmanaged)", UMTE::OrderedReverseIterTest)
-RUN_NAMED_TEST("OrderedReverseIter (unique)", UPTE::OrderedReverseIterTest)
-RUN_NAMED_TEST("OrderedReverseIter (std::uptr)", SUPDDTE::OrderedReverseIterTest)
-RUN_NAMED_TEST("OrderedReverseIter (std::uptr<Del>)", SUPCDTE::OrderedReverseIterTest)
-RUN_NAMED_TEST("OrderedReverseIter (RefPtr)", RPTE::OrderedReverseIterTest)
-
-RUN_NAMED_TEST("UpperBound (unmanaged)", UMTE::UpperBoundTest)
-RUN_NAMED_TEST("UpperBound (unique)", UPTE::UpperBoundTest)
-RUN_NAMED_TEST("UpperBound (std::uptr)", SUPDDTE::UpperBoundTest)
-RUN_NAMED_TEST("UpperBound (std::uptr<Del>)", SUPCDTE::UpperBoundTest)
-RUN_NAMED_TEST("UpperBound (RefPtr)", RPTE::UpperBoundTest)
-
-RUN_NAMED_TEST("LowerBound (unmanaged)", UMTE::LowerBoundTest)
-RUN_NAMED_TEST("LowerBound (unique)", UPTE::LowerBoundTest)
-RUN_NAMED_TEST("LowerBound (std::uptr)", SUPDDTE::LowerBoundTest)
-RUN_NAMED_TEST("LowerBound (std::uptr<Del>)", SUPCDTE::LowerBoundTest)
-RUN_NAMED_TEST("LowerBound (RefPtr)", RPTE::LowerBoundTest)
-
-////////////////////////////
-// WAVLTree specific tests.
-////////////////////////////
-// ZX-2230: This can take more than 20 seconds in CI, so mark it medium.
-RUN_NAMED_TEST_MEDIUM("BalanceTest", WAVLBalanceTest)
-
-END_TEST_CASE(wavl_tree_tests)
-// clang-format on
-
} // namespace intrusive_containers
} // namespace tests
} // namespace fbl
