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