diff --git a/tests/daemon/table/name-tree.cpp b/tests/daemon/table/name-tree.cpp
index ebb8550..9790596 100644
--- a/tests/daemon/table/name-tree.cpp
+++ b/tests/daemon/table/name-tree.cpp
@@ -24,6 +24,8 @@
  */
 
 #include "table/name-tree.hpp"
+#include <unordered_set>
+
 #include "tests/test-common.hpp"
 
 namespace nfd {
@@ -239,382 +241,215 @@
   BOOST_CHECK_EQUAL(nt.size(), 8);
 }
 
-BOOST_AUTO_TEST_CASE(IteratorFullEnumerate)
+/** \brief verify a NameTree enumeration contains expected entries
+ *
+ *  Example:
+ *  \code{.cpp}
+ *  auto& enumerable = ...;
+ *  EnumerationVerifier(enumerable)
+ *    .expect("/A")
+ *    .expect("/B")
+ *    .end();
+ *  // enumerable must have /A /B and nothing else to pass the test.
+ *  \endcode
+ */
+class EnumerationVerifier : noncopyable
 {
-  size_t nBuckets = 1024;
-  NameTree nt(nBuckets);
+public:
+  template<typename Enumerable>
+  EnumerationVerifier(Enumerable&& enumerable)
+  {
+    for (const name_tree::Entry& entry : enumerable) {
+      const Name& name = entry.getPrefix();
+      BOOST_CHECK_MESSAGE(m_names.insert(name).second, "duplicate Name " << name);
+    }
+  }
 
-  BOOST_CHECK_EQUAL(nt.size(), 0);
-  BOOST_CHECK_EQUAL(nt.getNBuckets(), nBuckets);
+  EnumerationVerifier&
+  expect(const Name& name)
+  {
+    BOOST_CHECK_MESSAGE(m_names.erase(name) == 1, "missing Name " << name);
+    return *this;
+  }
 
-  Name nameABC("ndn:/a/b/c");
-  shared_ptr<name_tree::Entry> npeABC = nt.lookup(nameABC);
+  void
+  end()
+  {
+    BOOST_CHECK_MESSAGE(m_names.empty(), "excess Names including " << *m_names.begin());
+  }
+
+private:
+  std::unordered_set<Name> m_names;
+};
+
+class EnumerationFixture : public BaseFixture
+{
+protected:
+  EnumerationFixture()
+    : nt(N_BUCKETS)
+  {
+    BOOST_CHECK_EQUAL(nt.size(), 0);
+    BOOST_CHECK_EQUAL(nt.getNBuckets(), N_BUCKETS);
+  }
+
+  void
+  insertAbAc()
+  {
+    nt.lookup("/a/b");
+    nt.lookup("/a/c");
+    BOOST_CHECK_EQUAL(nt.size(), 4);
+    // /, /a, /a/b, /a/c
+  }
+
+  void
+  insertAb1Ab2Ac1Ac2()
+  {
+    nt.lookup("/a/b/1");
+    nt.lookup("/a/b/2");
+    nt.lookup("/a/c/1");
+    nt.lookup("/a/c/2");
+    BOOST_CHECK_EQUAL(nt.size(), 8);
+    // /, /a, /a/b, /a/b/1, /a/b/2, /a/c, /a/c/1, /a/c/2
+  }
+
+protected:
+  static const size_t N_BUCKETS = 16;
+  NameTree nt;
+};
+const size_t EnumerationFixture::N_BUCKETS;
+
+BOOST_FIXTURE_TEST_CASE(IteratorFullEnumerate, EnumerationFixture)
+{
+  nt.lookup("/a/b/c");
   BOOST_CHECK_EQUAL(nt.size(), 4);
 
-  Name nameABD("/a/b/d");
-  shared_ptr<name_tree::Entry> npeABD = nt.lookup(nameABD);
+  nt.lookup("/a/b/d");
   BOOST_CHECK_EQUAL(nt.size(), 5);
 
-  Name nameAE("/a/e/");
-  shared_ptr<name_tree::Entry> npeAE = nt.lookup(nameAE);
+  nt.lookup("/a/e");
   BOOST_CHECK_EQUAL(nt.size(), 6);
 
-  Name nameF("/f");
-  shared_ptr<name_tree::Entry> npeF = nt.lookup(nameF);
+  nt.lookup("/f");
   BOOST_CHECK_EQUAL(nt.size(), 7);
 
-  Name nameRoot("/");
-  shared_ptr<name_tree::Entry> npeRoot = nt.lookup(nameRoot);
+  nt.lookup("/");
   BOOST_CHECK_EQUAL(nt.size(), 7);
 
-  Name nameA("/a");
-  Name nameAB("/a/b");
-
-  bool hasRoot  = false;
-  bool hasA     = false;
-  bool hasAB    = false;
-  bool hasABC   = false;
-  bool hasABD   = false;
-  bool hasAE    = false;
-  bool hasF     = false;
-
-  int counter = 0;
-  NameTree::const_iterator it = nt.fullEnumerate();
-
-  for(; it != nt.end(); it++)
-  {
-    counter++;
-
-    if (it->getPrefix() == nameRoot)
-      hasRoot = true;
-    if (it->getPrefix() == nameA)
-      hasA    = true;
-    if (it->getPrefix() == nameAB)
-      hasAB   = true;
-    if (it->getPrefix() == nameABC)
-      hasABC  = true;
-    if (it->getPrefix() == nameABD)
-      hasABD  = true;
-    if (it->getPrefix() == nameAE)
-      hasAE   = true;
-    if (it->getPrefix() == nameF)
-      hasF    = true;
-  }
-
-  BOOST_CHECK_EQUAL(hasRoot , true);
-  BOOST_CHECK_EQUAL(hasA    , true);
-  BOOST_CHECK_EQUAL(hasAB   , true);
-  BOOST_CHECK_EQUAL(hasABC  , true);
-  BOOST_CHECK_EQUAL(hasABD  , true);
-  BOOST_CHECK_EQUAL(hasAE   , true);
-  BOOST_CHECK_EQUAL(hasF    , true);
-
-  BOOST_CHECK_EQUAL(counter , 7);
+  auto&& enumerable = nt.fullEnumerate();
+  EnumerationVerifier(enumerable)
+    .expect("/")
+    .expect("/a")
+    .expect("/a/b")
+    .expect("/a/b/c")
+    .expect("/a/b/d")
+    .expect("/a/e")
+    .expect("/f")
+    .end();
 }
 
-// Predicates for testing the partial enumerate function
+BOOST_FIXTURE_TEST_SUITE(IteratorPartialEnumerate, EnumerationFixture)
 
-static inline std::pair<bool, bool>
-predicate_NameTreeEntry_NameA_Only(const name_tree::Entry& entry)
+BOOST_AUTO_TEST_CASE(Empty)
 {
-  Name nameA("/a");
-  bool first = nameA.equals(entry.getPrefix());
-  return std::make_pair(first, true);
+  auto&& enumerable = nt.partialEnumerate("/a");
+
+  EnumerationVerifier(enumerable)
+    .end();
 }
 
-static inline std::pair<bool, bool>
-predicate_NameTreeEntry_Except_NameA(const name_tree::Entry& entry)
+BOOST_AUTO_TEST_CASE(NotIn)
 {
-  Name nameA("/a");
-  bool first = !(nameA.equals(entry.getPrefix()));
-  return std::make_pair(first, true);
-}
-
-static inline std::pair<bool, bool>
-predicate_NameTreeEntry_NoSubNameA(const name_tree::Entry& entry)
-{
-  Name nameA("/a");
-  bool second = !(nameA.equals(entry.getPrefix()));
-  return std::make_pair(true, second);
-}
-
-static inline std::pair<bool, bool>
-predicate_NameTreeEntry_NoNameA_NoSubNameAB(const name_tree::Entry& entry)
-{
-  Name nameA("/a");
-  Name nameAB("/a/b");
-  bool first = !(nameA.equals(entry.getPrefix()));
-  bool second = !(nameAB.equals(entry.getPrefix()));
-  return std::make_pair(first, second);
-}
-
-static inline std::pair<bool, bool>
-predicate_NameTreeEntry_NoNameA_NoSubNameAC(const name_tree::Entry& entry)
-{
-  Name nameA("/a");
-  Name nameAC("/a/c");
-  bool first = !(nameA.equals(entry.getPrefix()));
-  bool second = !(nameAC.equals(entry.getPrefix()));
-  return std::make_pair(first, second);
-}
-
-static inline std::pair<bool, bool>
-predicate_NameTreeEntry_Example(const name_tree::Entry& entry)
-{
-  Name nameRoot("/");
-  Name nameA("/a");
-  Name nameAB("/a/b");
-  Name nameABC("/a/b/c");
-  Name nameAD("/a/d");
-  Name nameE("/e");
-  Name nameF("/f");
-
-  bool first = false;
-  bool second = false;
-
-  Name name = entry.getPrefix();
-
-  if (name == nameRoot || name == nameAB || name == nameABC || name == nameAD)
-  {
-    first = true;
-  }
-
-  if(name == nameRoot || name == nameA || name == nameF)
-  {
-    second = true;
-  }
-
-  return std::make_pair(first, second);
-}
-
-BOOST_AUTO_TEST_CASE(IteratorPartialEnumerate)
-{
-  typedef NameTree::const_iterator const_iterator;
-
-  size_t nBuckets = 16;
-  NameTree nameTree(nBuckets);
-  int counter = 0;
-
-  // empty nameTree, should return end();
-  Name nameA("/a");
-  bool hasA = false;
-  const_iterator itA = nameTree.partialEnumerate(nameA);
-  BOOST_CHECK(itA == nameTree.end());
-
-  // We have "/", "/a", "/a/b", "a/c" now.
-  Name nameAB("/a/b");
-  bool hasAB = false;
-  nameTree.lookup(nameAB);
-
-  Name nameAC("/a/c");
-  bool hasAC = false;
-  nameTree.lookup(nameAC);
-  BOOST_CHECK_EQUAL(nameTree.size(), 4);
+  this->insertAbAc();
 
   // Enumerate on some name that is not in nameTree
-  Name name0="/0";
-  const_iterator it0 = nameTree.partialEnumerate(name0);
-  BOOST_CHECK(it0 == nameTree.end());
+  Name name0("/0");
+  auto&& enumerable = nt.partialEnumerate("/0");
+
+  EnumerationVerifier(enumerable)
+    .end();
+}
+
+BOOST_AUTO_TEST_CASE(OnlyA)
+{
+  this->insertAbAc();
 
   // Accept "root" nameA only
-  const_iterator itAOnly = nameTree.partialEnumerate(nameA, &predicate_NameTreeEntry_NameA_Only);
-  BOOST_CHECK_EQUAL(itAOnly->getPrefix(), nameA);
-  BOOST_CHECK(++itAOnly == nameTree.end());
+  auto&& enumerable = nt.partialEnumerate("/a", [] (const name_tree::Entry& entry) {
+    return std::make_pair(entry.getPrefix() == "/a", true);
+  });
+
+  EnumerationVerifier(enumerable)
+    .expect("/a")
+    .end();
+}
+
+BOOST_AUTO_TEST_CASE(ExceptA)
+{
+  this->insertAbAc();
 
   // Accept anything except "root" nameA
-  const_iterator itExceptA = nameTree.partialEnumerate(nameA, &predicate_NameTreeEntry_Except_NameA);
-  hasA = false;
-  hasAB = false;
-  hasAC = false;
+  auto&& enumerable = nt.partialEnumerate("/a", [] (const name_tree::Entry& entry) {
+    return std::make_pair(entry.getPrefix() != "/a", true);
+  });
 
-  counter = 0;
-  for (; itExceptA != nameTree.end(); itExceptA++)
-  {
-    counter++;
+  EnumerationVerifier(enumerable)
+    .expect("/a/b")
+    .expect("/a/c")
+    .end();
+}
 
-    if (itExceptA->getPrefix() == nameA)
-      hasA  = true;
-
-    if (itExceptA->getPrefix() == nameAB)
-      hasAB = true;
-
-    if (itExceptA->getPrefix() == nameAC)
-      hasAC = true;
-  }
-  BOOST_CHECK_EQUAL(hasA,  false);
-  BOOST_CHECK_EQUAL(hasAB, true);
-  BOOST_CHECK_EQUAL(hasAC, true);
-
-  BOOST_CHECK_EQUAL(counter, 2);
-
-  Name nameAB1("a/b/1");
-  bool hasAB1 = false;
-  nameTree.lookup(nameAB1);
-
-  Name nameAB2("a/b/2");
-  bool hasAB2 = false;
-  nameTree.lookup(nameAB2);
-
-  Name nameAC1("a/c/1");
-  bool hasAC1 = false;
-  nameTree.lookup(nameAC1);
-
-  Name nameAC2("a/c/2");
-  bool hasAC2 = false;
-  nameTree.lookup(nameAC2);
-
-  BOOST_CHECK_EQUAL(nameTree.size(), 8);
+BOOST_AUTO_TEST_CASE(NoNameANoSubTreeAB)
+{
+  this->insertAb1Ab2Ac1Ac2();
 
   // No NameA
   // No SubTree from NameAB
-  const_iterator itNoNameANoSubNameAB = nameTree.partialEnumerate(nameA,
-    &predicate_NameTreeEntry_NoNameA_NoSubNameAB);
-  hasA   = false;
-  hasAB  = false;
-  hasAB1 = false;
-  hasAB2 = false;
-  hasAC  = false;
-  hasAC1 = false;
-  hasAC2 = false;
+  auto&& enumerable = nt.partialEnumerate("/a", [] (const name_tree::Entry& entry) {
+      return std::make_pair(entry.getPrefix() != "/a", entry.getPrefix() != "/a/b");
+    });
 
-  counter = 0;
+  EnumerationVerifier(enumerable)
+    .expect("/a/b")
+    .expect("/a/c")
+    .expect("/a/c/1")
+    .expect("/a/c/2")
+    .end();
+}
 
-  for (; itNoNameANoSubNameAB != nameTree.end(); itNoNameANoSubNameAB++)
-  {
-    counter++;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameA)
-      hasA   = true;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameAB)
-      hasAB  = true;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameAB1)
-      hasAB1 = true;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameAB2)
-      hasAB2 = true;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameAC)
-      hasAC  = true;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameAC1)
-      hasAC1 = true;
-
-    if (itNoNameANoSubNameAB->getPrefix() == nameAC2)
-      hasAC2 = true;
-  }
-
-  BOOST_CHECK_EQUAL(hasA,   false);
-  BOOST_CHECK_EQUAL(hasAB,  true);
-  BOOST_CHECK_EQUAL(hasAB1, false);
-  BOOST_CHECK_EQUAL(hasAB2, false);
-  BOOST_CHECK_EQUAL(hasAC,  true);
-  BOOST_CHECK_EQUAL(hasAC1, true);
-  BOOST_CHECK_EQUAL(hasAC2, true);
-
-  BOOST_CHECK_EQUAL(counter, 4);
+BOOST_AUTO_TEST_CASE(NoNameANoSubTreeAC)
+{
+  this->insertAb1Ab2Ac1Ac2();
 
   // No NameA
   // No SubTree from NameAC
-  const_iterator itNoNameANoSubNameAC = nameTree.partialEnumerate(nameA,
-    &predicate_NameTreeEntry_NoNameA_NoSubNameAC);
-  hasA   = false;
-  hasAB  = false;
-  hasAB1 = false;
-  hasAB2 = false;
-  hasAC  = false;
-  hasAC1 = false;
-  hasAC2 = false;
+  auto&& enumerable = nt.partialEnumerate("/a", [] (const name_tree::Entry& entry) {
+      return std::make_pair(entry.getPrefix() != "/a", entry.getPrefix() != "/a/c");
+    });
 
-  counter = 0;
+  EnumerationVerifier(enumerable)
+    .expect("/a/b")
+    .expect("/a/b/1")
+    .expect("/a/b/2")
+    .expect("/a/c")
+    .end();
+}
 
-  for (; itNoNameANoSubNameAC != nameTree.end(); itNoNameANoSubNameAC++)
-  {
-    counter++;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameA)
-      hasA   = true;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameAB)
-      hasAB  = true;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameAB1)
-      hasAB1 = true;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameAB2)
-      hasAB2 = true;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameAC)
-      hasAC  = true;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameAC1)
-      hasAC1 = true;
-
-    if (itNoNameANoSubNameAC->getPrefix() == nameAC2)
-      hasAC2 = true;
-  }
-
-  BOOST_CHECK_EQUAL(hasA,   false);
-  BOOST_CHECK_EQUAL(hasAB,  true);
-  BOOST_CHECK_EQUAL(hasAB1, true);
-  BOOST_CHECK_EQUAL(hasAB2, true);
-  BOOST_CHECK_EQUAL(hasAC,  true);
-  BOOST_CHECK_EQUAL(hasAC1, false);
-  BOOST_CHECK_EQUAL(hasAC2, false);
-
-  BOOST_CHECK_EQUAL(counter, 4);
+BOOST_AUTO_TEST_CASE(NoSubTreeA)
+{
+  this->insertAb1Ab2Ac1Ac2();
 
   // No Subtree from NameA
-  const_iterator itNoANoSubNameA = nameTree.partialEnumerate(nameA,
-    &predicate_NameTreeEntry_NoSubNameA);
+  auto&& enumerable = nt.partialEnumerate("/a", [] (const name_tree::Entry& entry) {
+      return std::make_pair(true, entry.getPrefix() != "/a");
+    });
 
-  hasA   = false;
-  hasAB  = false;
-  hasAB1 = false;
-  hasAB2 = false;
-  hasAC  = false;
-  hasAC1 = false;
-  hasAC2 = false;
+  EnumerationVerifier(enumerable)
+    .expect("/a")
+    .end();
+}
 
-  counter = 0;
-
-  for (; itNoANoSubNameA != nameTree.end(); itNoANoSubNameA++)
-  {
-    counter++;
-
-    if (itNoANoSubNameA->getPrefix() == nameA)
-      hasA   = true;
-
-    if (itNoANoSubNameA->getPrefix() == nameAB)
-      hasAB  = true;
-
-    if (itNoANoSubNameA->getPrefix() == nameAB1)
-      hasAB1 = true;
-
-    if (itNoANoSubNameA->getPrefix() == nameAB2)
-      hasAB2 = true;
-
-    if (itNoANoSubNameA->getPrefix() == nameAC)
-      hasAC  = true;
-
-    if (itNoANoSubNameA->getPrefix() == nameAC1)
-      hasAC1 = true;
-
-    if (itNoANoSubNameA->getPrefix() == nameAC2)
-      hasAC2 = true;
-  }
-
-  BOOST_CHECK_EQUAL(hasA,   true);
-  BOOST_CHECK_EQUAL(hasAB,  false);
-  BOOST_CHECK_EQUAL(hasAB1, false);
-  BOOST_CHECK_EQUAL(hasAB2, false);
-  BOOST_CHECK_EQUAL(hasAC,  false);
-  BOOST_CHECK_EQUAL(hasAC1, false);
-  BOOST_CHECK_EQUAL(hasAC2, false);
-
-  BOOST_CHECK_EQUAL(counter, 1);
-
+BOOST_AUTO_TEST_CASE(Example)
+{
   // Example
   // /
   // /A
@@ -624,163 +459,57 @@
   // /E
   // /F
 
-  NameTree nameTreeExample(nBuckets);
+  nt.lookup("/A");
+  nt.lookup("/A/B");
+  nt.lookup("/A/B/C");
+  nt.lookup("/A/D");
+  nt.lookup("/E");
+  nt.lookup("/F");
 
-  Name nameRoot("/");
-  bool hasRoot = false;
+  auto&& enumerable = nt.partialEnumerate("/A",
+    [] (const name_tree::Entry& entry) -> std::pair<bool, bool> {
+      bool visitEntry = false;
+      bool visitChildren = false;
 
-  nameTreeExample.lookup(nameA);
-  hasA = false;
-  nameTreeExample.lookup(nameAB);
-  hasAB = false;
+      Name name = entry.getPrefix();
 
-  Name nameABC("a/b/c");
-  bool hasABC = false;
-  nameTreeExample.lookup(nameABC);
+      if (name == "/" || name == "/A/B" || name == "/A/B/C" || name == "/A/D") {
+        visitEntry = true;
+      }
 
-  Name nameAD("/a/d");
-  nameTreeExample.lookup(nameAD);
-  bool hasAD = false;
+      if (name == "/" || name == "/A" || name == "/F") {
+        visitChildren = true;
+      }
 
-  Name nameE("/e");
-  nameTreeExample.lookup(nameE);
-  bool hasE = false;
+      return {visitEntry, visitChildren};
+    });
 
-  Name nameF("/f");
-  nameTreeExample.lookup(nameF);
-  bool hasF = false;
-
-  counter = 0;
-  const_iterator itExample = nameTreeExample.partialEnumerate(nameA,
-    &predicate_NameTreeEntry_Example);
-
-  for (; itExample != nameTreeExample.end(); itExample++)
-  {
-    counter++;
-
-    if (itExample->getPrefix() == nameRoot)
-      hasRoot = true;
-
-    if (itExample->getPrefix() == nameA)
-     hasA     = true;
-
-    if (itExample->getPrefix() == nameAB)
-     hasAB    = true;
-
-    if (itExample->getPrefix() == nameABC)
-     hasABC   = true;
-
-    if (itExample->getPrefix() == nameAD)
-     hasAD    = true;
-
-    if (itExample->getPrefix() == nameE)
-     hasE     = true;
-
-    if (itExample->getPrefix() == nameF)
-      hasF    = true;
-  }
-
-  BOOST_CHECK_EQUAL(hasRoot, false);
-  BOOST_CHECK_EQUAL(hasA,    false);
-  BOOST_CHECK_EQUAL(hasAB,   true);
-  BOOST_CHECK_EQUAL(hasABC,  false);
-  BOOST_CHECK_EQUAL(hasAD,   true);
-  BOOST_CHECK_EQUAL(hasE,    false);
-  BOOST_CHECK_EQUAL(hasF,    false);
-
-  BOOST_CHECK_EQUAL(counter, 2);
+  EnumerationVerifier(enumerable)
+    .expect("/A/B")
+    .expect("/A/D")
+    .end();
 }
 
+BOOST_AUTO_TEST_SUITE_END()
 
-BOOST_AUTO_TEST_CASE(IteratorFindAllMatches)
+BOOST_FIXTURE_TEST_CASE(IteratorFindAllMatches, EnumerationFixture)
 {
-  size_t nBuckets = 16;
-  NameTree nt(nBuckets);
-  int counter = 0;
-
-  Name nameABCDEF("a/b/c/d/e/f");
-  shared_ptr<name_tree::Entry> npeABCDEF = nt.lookup(nameABCDEF);
-
-  Name nameAAC("a/a/c");
-  shared_ptr<name_tree::Entry> npeAAC = nt.lookup(nameAAC);
-
-  Name nameAAD1("a/a/d/1");
-  shared_ptr<name_tree::Entry> npeAAD1 = nt.lookup(nameAAD1);
-
-  Name nameAAD2("a/a/d/2");
-  shared_ptr<name_tree::Entry> npeAAD2 = nt.lookup(nameAAD2);
-
-
+  nt.lookup("/a/b/c/d/e/f");
+  nt.lookup("/a/a/c");
+  nt.lookup("/a/a/d/1");
+  nt.lookup("/a/a/d/2");
   BOOST_CHECK_EQUAL(nt.size(), 12);
 
-  Name nameRoot ("/");
-  Name nameA    ("/a");
-  Name nameAB   ("/a/b");
-  Name nameABC  ("/a/b/c");
-  Name nameABCD ("/a/b/c/d");
-  Name nameABCDE("/a/b/c/d/e");
-  Name nameAA   ("/a/a");
-  Name nameAAD  ("/a/a/d");
+  auto&& allMatches = nt.findAllMatches("/a/b/c/d/e");
 
-  bool hasRoot    = false;
-  bool hasA       = false;
-  bool hasAB      = false;
-  bool hasABC     = false;
-  bool hasABCD    = false;
-  bool hasABCDE   = false;
-  bool hasABCDEF  = false;
-  bool hasAA      = false;
-  bool hasAAC     = false;
-  bool hasAAD     = false;
-  bool hasAAD1    = false;
-  bool hasAAD2    = false;
-
-  counter = 0;
-
-  auto&& allMatches = nt.findAllMatches(nameABCDEF);
-  for (const name_tree::Entry& entry : allMatches) {
-    counter++;
-
-    if (entry.getPrefix() == nameRoot)
-      hasRoot   = true;
-    if (entry.getPrefix() == nameA)
-      hasA      = true;
-    if (entry.getPrefix() == nameAB)
-      hasAB     = true;
-    if (entry.getPrefix() == nameABC)
-      hasABC    = true;
-    if (entry.getPrefix() == nameABCD)
-      hasABCD   = true;
-    if (entry.getPrefix() == nameABCDE)
-      hasABCDE  = true;
-    if (entry.getPrefix() == nameABCDEF)
-      hasABCDEF = true;
-    if (entry.getPrefix() == nameAA)
-      hasAA     = true;
-    if (entry.getPrefix() == nameAAC)
-      hasAAC    = true;
-    if (entry.getPrefix() == nameAAD)
-      hasAAD    = true;
-    if (entry.getPrefix() == nameAAD1)
-      hasAAD1   = true;
-    if (entry.getPrefix() == nameAAD2)
-      hasAAD2   = true;
-  }
-
-  BOOST_CHECK_EQUAL(hasRoot   , true);
-  BOOST_CHECK_EQUAL(hasA      , true);
-  BOOST_CHECK_EQUAL(hasAB     , true);
-  BOOST_CHECK_EQUAL(hasABC    , true);
-  BOOST_CHECK_EQUAL(hasABCD   , true);
-  BOOST_CHECK_EQUAL(hasABCDE  , true);
-  BOOST_CHECK_EQUAL(hasABCDEF , true);
-  BOOST_CHECK_EQUAL(hasAA     , false);
-  BOOST_CHECK_EQUAL(hasAAC    , false);
-  BOOST_CHECK_EQUAL(hasAAD    , false);
-  BOOST_CHECK_EQUAL(hasAAD1   , false);
-  BOOST_CHECK_EQUAL(hasAAD2   , false);
-
-  BOOST_CHECK_EQUAL(counter, 7);
+  EnumerationVerifier(allMatches)
+    .expect("/")
+    .expect("/a")
+    .expect("/a/b")
+    .expect("/a/b/c")
+    .expect("/a/b/c/d")
+    .expect("/a/b/c/d/e")
+    .end();
 }
 
 BOOST_AUTO_TEST_CASE(HashTableResizeShrink)