Rewrite document meta store tests to gtest.

2 files changed, 492 insertions, 523 deletions

diff --git a/searchcore/src/tests/proton/documentmetastore/CMakeLists.txt b/searchcore/src/tests/proton/documentmetastore/CMakeLists.txt
index 626243459eb..f31d82240e0 100644
--- a/searchcore/src/tests/proton/documentmetastore/CMakeLists.txt
+++ b/searchcore/src/tests/proton/documentmetastore/CMakeLists.txt
@@ -9,6 +9,7 @@ vespa_add_executable(searchcore_documentmetastore_test_app TEST
     searchcore_attribute
     searchcore_feedoperation
     searchcore_fconfig
+    gtest
 )
 vespa_add_test(NAME searchcore_documentmetastore_test_app COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/documentmetastore_test.sh
                DEPENDS searchcore_documentmetastore_test_app)
diff --git a/searchcore/src/tests/proton/documentmetastore/documentmetastore_test.cpp b/searchcore/src/tests/proton/documentmetastore/documentmetastore_test.cpp
index 8fa66e65af3..4509f11af58 100644
--- a/searchcore/src/tests/proton/documentmetastore/documentmetastore_test.cpp
+++ b/searchcore/src/tests/proton/documentmetastore/documentmetastore_test.cpp
@@ -1,31 +1,34 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
+
 #include <vespa/document/base/documentid.h>
-#include <vespa/searchcore/proton/documentmetastore/documentmetastore.h>
-#include <vespa/searchcore/proton/flushengine/shrink_lid_space_flush_target.h>
 #include <vespa/searchcore/proton/bucketdb/bucketdbhandler.h>
 #include <vespa/searchcore/proton/bucketdb/checksumaggregators.h>
 #include <vespa/searchcore/proton/bucketdb/i_bucket_create_listener.h>
+#include <vespa/searchcore/proton/common/hw_info.h>
+#include <vespa/searchcore/proton/documentmetastore/documentmetastore.h>
+#include <vespa/searchcore/proton/flushengine/shrink_lid_space_flush_target.h>
+#include <vespa/searchcore/proton/server/itlssyncer.h>
 #include <vespa/searchlib/attribute/attributefilesavetarget.h>
-#include <vespa/searchlib/fef/matchdatalayout.h>
-#include <vespa/searchlib/queryeval/simpleresult.h>
 #include <vespa/searchlib/common/tunefileinfo.h>
+#include <vespa/searchlib/fef/matchdatalayout.h>
 #include <vespa/searchlib/index/dummyfileheadercontext.h>
-#include <vespa/vespalib/util/threadstackexecutor.h>
+#include <vespa/searchlib/query/queryterm.h>
+#include <vespa/searchlib/queryeval/simpleresult.h>
+#include <vespa/vespalib/gtest/gtest.h>
 #include <vespa/vespalib/io/fileutil.h>
-#include <vespa/vespalib/util/exceptions.h>
 #include <vespa/vespalib/test/insertion_operators.h>
-#include <vespa/searchcore/proton/server/itlssyncer.h>
-#include <vespa/searchcore/proton/common/hw_info.h>
-#include <vespa/searchlib/query/queryterm.h>
+#include <vespa/vespalib/util/exceptions.h>
+#include <vespa/vespalib/util/threadstackexecutor.h>
+#include <thread>
+
 #include <vespa/log/log.h>
 LOG_SETUP("documentmetastore_test");
 
 using namespace document;
 using proton::bucketdb::BucketState;
+using proton::bucketdb::IBucketCreateListener;
 using proton::bucketdb::LegacyChecksumAggregator;
 using proton::bucketdb::XXH64ChecksumAggregator;
-using proton::bucketdb::IBucketCreateListener;
 using search::AttributeFileSaveTarget;
 using search::AttributeGuard;
 using search::AttributeVector;
@@ -42,12 +45,12 @@ using search::index::DummyFileHeaderContext;
 using search::queryeval::Blueprint;
 using search::queryeval::SearchIterator;
 using search::queryeval::SimpleResult;
+using searchcorespi::IFlushTarget;
 using storage::spi::BucketChecksum;
 using storage::spi::BucketInfo;
 using storage::spi::Timestamp;
 using vespalib::GenerationHandler;
 using vespalib::GenerationHolder;
-using searchcorespi::IFlushTarget;
 using namespace std::literals;
 
 namespace proton {
@@ -59,17 +62,14 @@ static constexpr uint64_t timestampBias = UINT64_C(2000000000000);
 
 }
 
-
-class DummyTlsSyncer : public ITlsSyncer
-{
+class DummyTlsSyncer : public ITlsSyncer {
 public:
     virtual ~DummyTlsSyncer() = default;
 
     virtual void sync() override { }
 };
 
-class ReverseGidCompare : public DocumentMetaStore::IGidCompare
-{
+class ReverseGidCompare : public DocumentMetaStore::IGidCompare {
     GlobalId::BucketOrderCmp _comp;
 public:
     ReverseGidCompare()
@@ -78,9 +78,7 @@ public:
     {
     }
 
-    virtual bool
-    operator()(const GlobalId &lhs, const GlobalId &rhs) const override
-    {
+    virtual bool operator()(const GlobalId &lhs, const GlobalId &rhs) const override {
         return _comp(rhs, lhs);
     }
 };
@@ -103,8 +101,8 @@ struct BoolVector : public std::vector<bool> {
     }
 };
 
-typedef DocumentMetaStore::Result PutRes;
-typedef DocumentMetaStore::Result Result;
+using PutRes = DocumentMetaStore::Result;
+using Result = DocumentMetaStore::Result;
 
 BucketDBOwner::SP
 createBucketDB()
@@ -112,7 +110,7 @@ createBucketDB()
     return std::make_shared<BucketDBOwner>();
 }
 
-bool
+void
 assertPut(const BucketId &bucketId,
           const Timestamp &timestamp,
           uint32_t lid,
@@ -120,28 +118,28 @@ assertPut(const BucketId &bucketId,
           DocumentMetaStore &dms)
 {
     Result inspect = dms.inspect(gid);
-    PutRes putRes;
     uint32_t docSize = 1;
-    if (!EXPECT_TRUE((putRes = dms.put(gid, bucketId, timestamp, docSize, inspect.getLid())).
-            ok())) return false;
-    return EXPECT_EQUAL(lid, putRes.getLid());
+    PutRes putRes = dms.put(gid, bucketId, timestamp, docSize, inspect.getLid());
+    EXPECT_TRUE(putRes.ok());
+    EXPECT_EQ(lid, putRes.getLid());
 }
 
 bool
 compare(const GlobalId &lhs, const GlobalId &rhs)
 {
-    return EXPECT_EQUAL(lhs.toString(), rhs.toString());
+    EXPECT_EQ(lhs.toString(), rhs.toString());
+    return (lhs.toString() == rhs.toString());
 }
 
-bool
+void
 assertGid(const GlobalId &exp, uint32_t lid, const DocumentMetaStore &dms)
 {
     GlobalId act;
-    if (!EXPECT_TRUE(dms.getGid(lid, act))) return false;
-    return compare(exp, act);
+    EXPECT_TRUE(dms.getGid(lid, act));
+    EXPECT_TRUE(compare(exp, act));
 }
 
-bool
+void
 assertGid(const GlobalId &exp,
           uint32_t lid,
           const DocumentMetaStore &dms,
@@ -151,55 +149,46 @@ assertGid(const GlobalId &exp,
     GlobalId act;
     BucketId bucketId;
     Timestamp timestamp(1);
-    if (!EXPECT_TRUE(dms.getGid(lid, act)))
-        return false;
-    if (!compare(exp, act))
-        return false;
+    EXPECT_TRUE(dms.getGid(lid, act));
+    EXPECT_TRUE(compare(exp, act));
     DocumentMetaData meta = dms.getMetaData(act);
-    if (!EXPECT_TRUE(meta.valid()))
-        return false;
+    EXPECT_TRUE(meta.valid());
     bucketId = meta.bucketId;
     timestamp = meta.timestamp;
-    if (!EXPECT_EQUAL(expBucketId.getRawId(), bucketId.getRawId()))
-        return false;
-    if (!EXPECT_EQUAL(expBucketId.getId(), bucketId.getId()))
-        return false;
-    if (!EXPECT_EQUAL(expTimestamp, timestamp))
-        return false;
-    return true;
+    EXPECT_EQ(expBucketId.getRawId(), bucketId.getRawId());
+    EXPECT_EQ(expBucketId.getId(), bucketId.getId());
+    EXPECT_EQ(expTimestamp, timestamp);
 }
 
-bool
+void
 assertLid(uint32_t exp, const GlobalId &gid, const DocumentMetaStore &dms)
 {
     uint32_t act;
-    if (!EXPECT_TRUE(dms.getLid(gid, act))) return false;
-    return EXPECT_EQUAL(exp, act);
+    EXPECT_TRUE(dms.getLid(gid, act));
+    EXPECT_EQ(exp, act);
 }
 
-bool
+void
 assertMetaData(const DocumentMetaData &exp, const DocumentMetaData &act)
 {
-    if (!EXPECT_EQUAL(exp.lid, act.lid)) return false;
-    if (!EXPECT_EQUAL(exp.timestamp, act.timestamp)) return false;
-    if (!EXPECT_EQUAL(exp.bucketId, act.bucketId)) return false;
-    if (!EXPECT_EQUAL(exp.gid, act.gid)) return false;
-    if (!EXPECT_EQUAL(exp.removed, act.removed)) return false;
-    return true;
+    EXPECT_EQ(exp.lid, act.lid);
+    EXPECT_EQ(exp.timestamp, act.timestamp);
+    EXPECT_EQ(exp.bucketId, act.bucketId);
+    EXPECT_EQ(exp.gid, act.gid);
+    EXPECT_EQ(exp.removed, act.removed);
 }
 
-bool
+void
 assertActiveLids(const BoolVector &exp, const search::BitVector &act)
 {
     // lid 0 is reserved
-    if (!EXPECT_EQUAL(exp.size() + 1, act.size())) return false;
+    EXPECT_EQ(exp.size() + 1, act.size());
     for (size_t i = 0; i < exp.size(); ++i) {
-        if (!EXPECT_EQUAL(exp[i], act.testBit(i + 1))) return false;
+        EXPECT_EQ(exp[i], act.testBit(i + 1));
     }
-    return true;
 }
 
-bool
+void
 assertWhiteList(const SimpleResult &exp, Blueprint::UP whiteListBlueprint, bool strict, uint32_t docIdLimit)
 {
     MatchDataLayout mdl;
@@ -210,10 +199,10 @@ assertWhiteList(const SimpleResult &exp, Blueprint::UP whiteListBlueprint, bool
     SearchIterator::UP sb = whiteListBlueprint->createSearch(*md, strict);
     SimpleResult act;
     act.searchStrict(*sb, docIdLimit);
-    return EXPECT_EQUAL(exp, act);
+    EXPECT_EQ(exp, act);
 }
 
-bool
+void
 assertSearchResult(const SimpleResult &exp, const DocumentMetaStore &dms,
                    const vespalib::string &term, const QueryTermSimple::SearchTerm &termType,
                    bool strict, uint32_t docIdLimit = 100)
@@ -228,19 +217,16 @@ assertSearchResult(const SimpleResult &exp, const DocumentMetaStore &dms,
     } else {
         act.search(*sb, docIdLimit);
     }
-    return EXPECT_EQUAL(exp, act);
+    EXPECT_EQ(exp, act);
 }
 
-bool
+void
 assertBucketInfo(uint32_t expDocCount,
                  uint32_t expMetaCount,
                  const BucketInfo &act)
 {
-    if (!EXPECT_EQUAL(expDocCount, act.getDocumentCount()))
-        return false;
-    if (!EXPECT_EQUAL(expMetaCount, act.getEntryCount()))
-        return false;
-    return true;
+    EXPECT_EQ(expDocCount, act.getDocumentCount());
+    EXPECT_EQ(expMetaCount, act.getEntryCount());
 }
 
 GlobalId gid1("111111111111");
@@ -292,155 +278,155 @@ putGid(DocumentMetaStore &dms, const GlobalId &gid, uint32_t lid, Timestamp time
     EXPECT_TRUE(dms.put(gid, bid, timestamp, docSize, lid).ok());
 }
 
-TEST("require that removed documents are bucketized to bucket 0")
+TEST(DocumentMetaStoreTest, removed_documents_are_bucketized_to_bucket_0)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
-    EXPECT_EQUAL(1u, dms.getNumDocs());
-    EXPECT_EQUAL(0u, dms.getNumUsedLids());
+    EXPECT_EQ(1u, dms.getNumDocs());
+    EXPECT_EQ(0u, dms.getNumUsedLids());
 
     vespalib::GenerationHandler::Guard guard = dms.getGuard();
-    EXPECT_EQUAL(BucketId(), dms.getBucketOf(guard, 1));
-    EXPECT_TRUE(assertPut(bucketId1, time1, 1, gid1, dms));
-    EXPECT_EQUAL(bucketId1, dms.getBucketOf(guard, 1));
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2, gid2, dms));
-    EXPECT_EQUAL(bucketId2, dms.getBucketOf(guard, 2));
+    EXPECT_EQ(BucketId(), dms.getBucketOf(guard, 1));
+    assertPut(bucketId1, time1, 1, gid1, dms);
+    EXPECT_EQ(bucketId1, dms.getBucketOf(guard, 1));
+    assertPut(bucketId2, time2, 2, gid2, dms);
+    EXPECT_EQ(bucketId2, dms.getBucketOf(guard, 2));
     EXPECT_TRUE(dms.remove(1));
-    EXPECT_EQUAL(BucketId(), dms.getBucketOf(guard, 1));
-    EXPECT_EQUAL(bucketId2, dms.getBucketOf(guard, 2));
+    EXPECT_EQ(BucketId(), dms.getBucketOf(guard, 1));
+    EXPECT_EQ(bucketId2, dms.getBucketOf(guard, 2));
 }
 
-TEST("requireThatGidsCanBeInsertedAndRetrieved")
+TEST(DocumentMetaStoreTest, gids_can_be_inserted_and_retrieved)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
     // put()
-    EXPECT_EQUAL(1u, dms.getNumDocs());
-    EXPECT_EQUAL(0u, dms.getNumUsedLids());
-    EXPECT_TRUE(assertPut(bucketId1, time1, 1, gid1, dms));
-    EXPECT_EQUAL(2u, dms.getNumDocs());
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2, gid2, dms));
-    EXPECT_EQUAL(3u, dms.getNumDocs());
-    EXPECT_EQUAL(2u, dms.getNumUsedLids());
+    EXPECT_EQ(1u, dms.getNumDocs());
+    EXPECT_EQ(0u, dms.getNumUsedLids());
+    assertPut(bucketId1, time1, 1, gid1, dms);
+    EXPECT_EQ(2u, dms.getNumDocs());
+    EXPECT_EQ(1u, dms.getNumUsedLids());
+    assertPut(bucketId2, time2, 2, gid2, dms);
+    EXPECT_EQ(3u, dms.getNumDocs());
+    EXPECT_EQ(2u, dms.getNumUsedLids());
     // gid1 already inserted
-    EXPECT_TRUE(assertPut(bucketId1, time1, 1, gid1, dms));
+    assertPut(bucketId1, time1, 1, gid1, dms);
     // gid2 already inserted
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2, gid2, dms));
+    assertPut(bucketId2, time2, 2, gid2, dms);
 
 
     // getGid()
     GlobalId gid;
-    EXPECT_TRUE(assertGid(gid1, 1, dms));
-    EXPECT_TRUE(assertGid(gid2, 2, dms));
+    assertGid(gid1, 1, dms);
+    assertGid(gid2, 2, dms);
     EXPECT_TRUE(!dms.getGid(3, gid));
 
     // getLid()
     uint32_t lid = 0;
-    EXPECT_TRUE(assertLid(1, gid1, dms));
-    EXPECT_TRUE(assertLid(2, gid2, dms));
+    assertLid(1, gid1, dms);
+    assertLid(2, gid2, dms);
     EXPECT_TRUE(!dms.getLid(gid3, lid));
 }
 
-TEST("requireThatGidsCanBeCleared")
+TEST(DocumentMetaStore, gids_can_be_cleared)
 {
     DocumentMetaStore dms(createBucketDB());
     GlobalId gid;
     uint32_t lid = 0u;
     dms.constructFreeList();
     addGid(dms, gid1, bucketId1, time1);
-    EXPECT_TRUE(assertGid(gid1, 1, dms));
-    EXPECT_TRUE(assertLid(1, gid1, dms));
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
+    assertGid(gid1, 1, dms);
+    assertLid(1, gid1, dms);
+    EXPECT_EQ(1u, dms.getNumUsedLids());
     EXPECT_TRUE(dms.remove(1));
     dms.removeComplete(1);
-    EXPECT_EQUAL(0u, dms.getNumUsedLids());
+    EXPECT_EQ(0u, dms.getNumUsedLids());
     EXPECT_TRUE(!dms.getGid(1, gid));
     EXPECT_TRUE(!dms.getLid(gid1, lid));
     // reuse lid
     addGid(dms, gid2, bucketId2, time2);
-    EXPECT_TRUE(assertGid(gid2, 1, dms));
-    EXPECT_TRUE(assertLid(1, gid2, dms));
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
+    assertGid(gid2, 1, dms);
+    assertLid(1, gid2, dms);
+    EXPECT_EQ(1u, dms.getNumUsedLids());
     EXPECT_TRUE(dms.remove(1));
     dms.removeComplete(1);
-    EXPECT_EQUAL(0u, dms.getNumUsedLids());
+    EXPECT_EQ(0u, dms.getNumUsedLids());
     EXPECT_TRUE(!dms.getGid(1, gid));
     EXPECT_TRUE(!dms.getLid(gid2, lid));
     EXPECT_TRUE(!dms.remove(1)); // not used
     EXPECT_TRUE(!dms.remove(2)); // outside range
 }
 
-TEST("requireThatGenerationHandlingIsWorking")
+TEST(DocumentMetaStore, generation_handling_is_working)
 {
     AttributeVector::SP av(new DocumentMetaStore(createBucketDB()));
     DocumentMetaStore * dms = static_cast<DocumentMetaStore *>(av.get());
     dms->constructFreeList();
     const GenerationHandler & gh = dms->getGenerationHandler();
-    EXPECT_EQUAL(1u, gh.getCurrentGeneration());
+    EXPECT_EQ(1u, gh.getCurrentGeneration());
     addGid(*dms, gid1, bucketId1, time1);
-    EXPECT_EQUAL(2u, gh.getCurrentGeneration());
-    EXPECT_EQUAL(0u, gh.getGenerationRefCount());
+    EXPECT_EQ(2u, gh.getCurrentGeneration());
+    EXPECT_EQ(0u, gh.getGenerationRefCount());
     {
         AttributeGuard g1(av);
-        EXPECT_EQUAL(1u, gh.getGenerationRefCount());
+        EXPECT_EQ(1u, gh.getGenerationRefCount());
         {
             AttributeGuard g2(av);
-            EXPECT_EQUAL(2u, gh.getGenerationRefCount());
+            EXPECT_EQ(2u, gh.getGenerationRefCount());
         }
-        EXPECT_EQUAL(1u, gh.getGenerationRefCount());
+        EXPECT_EQ(1u, gh.getGenerationRefCount());
     }
-    EXPECT_EQUAL(0u, gh.getGenerationRefCount());
+    EXPECT_EQ(0u, gh.getGenerationRefCount());
     dms->remove(1);
     dms->removeComplete(1);
-    EXPECT_EQUAL(4u, gh.getCurrentGeneration());
+    EXPECT_EQ(4u, gh.getCurrentGeneration());
 }
 
-TEST("requireThatBasicFreeListIsWorking")
+TEST(DocumentMetaStoreTest, basic_free_list_is_working)
 {
     GenerationHolder genHold;
     LidStateVector freeLids(100, 100, genHold, true, false);
     LidHoldList list;
     EXPECT_TRUE(freeLids.empty());
-    EXPECT_EQUAL(0u, freeLids.count());
-    EXPECT_EQUAL(0u, list.size());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(0u, list.size());
 
     list.add(10, 10);
     EXPECT_TRUE(freeLids.empty());
-    EXPECT_EQUAL(0u, freeLids.count());
-    EXPECT_EQUAL(1u, list.size());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(1u, list.size());
 
     list.add(20, 20);
     list.add(30, 30);
     EXPECT_TRUE(freeLids.empty());
-    EXPECT_EQUAL(0u, freeLids.count());
-    EXPECT_EQUAL(3u, list.size());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(3u, list.size());
 
     list.trimHoldLists(20, freeLids);
     EXPECT_FALSE(freeLids.empty());
-    EXPECT_EQUAL(1u, freeLids.count());
+    EXPECT_EQ(1u, freeLids.count());
 
-    EXPECT_EQUAL(10u, freeLids.getLowest());
+    EXPECT_EQ(10u, freeLids.getLowest());
     freeLids.clearBit(10);
     EXPECT_TRUE(freeLids.empty());
-    EXPECT_EQUAL(0u, freeLids.count());
-    EXPECT_EQUAL(2u, list.size());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(2u, list.size());
 
     list.trimHoldLists(31, freeLids);
     EXPECT_FALSE(freeLids.empty());
-    EXPECT_EQUAL(2u, freeLids.count());
+    EXPECT_EQ(2u, freeLids.count());
 
-    EXPECT_EQUAL(20u, freeLids.getLowest());
+    EXPECT_EQ(20u, freeLids.getLowest());
     freeLids.clearBit(20);
     EXPECT_FALSE(freeLids.empty());
-    EXPECT_EQUAL(1u, freeLids.count());
-    EXPECT_EQUAL(0u, list.size());
+    EXPECT_EQ(1u, freeLids.count());
+    EXPECT_EQ(0u, list.size());
 
-    EXPECT_EQUAL(30u, freeLids.getLowest());
+    EXPECT_EQ(30u, freeLids.getLowest());
     freeLids.clearBit(30);
     EXPECT_TRUE(freeLids.empty());
-    EXPECT_EQUAL(0u, list.size());
-    EXPECT_EQUAL(0u, freeLids.count());
+    EXPECT_EQ(0u, list.size());
+    EXPECT_EQ(0u, freeLids.count());
 }
 
 void
@@ -448,24 +434,24 @@ assertLidStateVector(const std::vector<uint32_t> &expLids, uint32_t lowest, uint
                      const LidStateVector &actLids)
 {
     if (!expLids.empty()) {
-        EXPECT_EQUAL(expLids.size(), actLids.count());
+        EXPECT_EQ(expLids.size(), actLids.count());
         uint32_t trueBit = 0;
         for (auto i : expLids) {
             EXPECT_TRUE(actLids.testBit(i));
             trueBit = actLids.getNextTrueBit(trueBit);
-            EXPECT_EQUAL(i, trueBit);
+            EXPECT_EQ(i, trueBit);
             ++trueBit;
         }
         trueBit = actLids.getNextTrueBit(trueBit);
-        EXPECT_EQUAL(actLids.size(), trueBit);
-        EXPECT_EQUAL(lowest, actLids.getLowest());
-        EXPECT_EQUAL(highest, actLids.getHighest());
+        EXPECT_EQ(actLids.size(), trueBit);
+        EXPECT_EQ(lowest, actLids.getLowest());
+        EXPECT_EQ(highest, actLids.getHighest());
     } else {
         EXPECT_TRUE(actLids.empty());
     }
 }
 
-TEST("requireThatLidStateVectorResizingIsWorking")
+TEST(DocumentMetaStoreTest, lid_state_vector_resizing_is_working)
 {
     GenerationHolder genHold;
     LidStateVector lids(1000, 1000, genHold, true, true);
@@ -513,47 +499,47 @@ TEST("requireThatLidStateVectorResizingIsWorking")
     genHold.clearHoldLists();
 }
 
-TEST("requireThatLidAndGidSpaceIsReused")
+TEST(DocumentMetaStoreTest, lid_and_gid_space_is_reused)
 {
     AttributeVector::SP av(new DocumentMetaStore(createBucketDB()));
     DocumentMetaStore * dms = static_cast<DocumentMetaStore *>(av.get());
     dms->constructFreeList();
-    EXPECT_EQUAL(1u, dms->getNumDocs());
-    EXPECT_EQUAL(0u, dms->getNumUsedLids());
-    EXPECT_TRUE(assertPut(bucketId1, time1, 1, gid1, *dms)); // -> gen 1
-    EXPECT_EQUAL(2u, dms->getNumDocs());
-    EXPECT_EQUAL(1u, dms->getNumUsedLids());
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2, gid2, *dms)); // -> gen 2
-    EXPECT_EQUAL(3u, dms->getNumDocs());
-    EXPECT_EQUAL(2u, dms->getNumUsedLids());
+    EXPECT_EQ(1u, dms->getNumDocs());
+    EXPECT_EQ(0u, dms->getNumUsedLids());
+    assertPut(bucketId1, time1, 1, gid1, *dms); // -> gen 1
+    EXPECT_EQ(2u, dms->getNumDocs());
+    EXPECT_EQ(1u, dms->getNumUsedLids());
+    assertPut(bucketId2, time2, 2, gid2, *dms); // -> gen 2
+    EXPECT_EQ(3u, dms->getNumDocs());
+    EXPECT_EQ(2u, dms->getNumUsedLids());
     dms->remove(2); // -> gen 3
     dms->removeComplete(2); // -> gen 4
-    EXPECT_EQUAL(3u, dms->getNumDocs());
-    EXPECT_EQUAL(1u, dms->getNumUsedLids());
+    EXPECT_EQ(3u, dms->getNumDocs());
+    EXPECT_EQ(1u, dms->getNumUsedLids());
     // -> gen 5 (reuse of lid 2)
-    EXPECT_TRUE(assertPut(bucketId3, time3, 2, gid3, *dms));
-    EXPECT_EQUAL(3u, dms->getNumDocs());
-    EXPECT_EQUAL(2u, dms->getNumUsedLids()); // reuse
-    EXPECT_TRUE(assertGid(gid3, 2, *dms));
+    assertPut(bucketId3, time3, 2, gid3, *dms);
+    EXPECT_EQ(3u, dms->getNumDocs());
+    EXPECT_EQ(2u, dms->getNumUsedLids()); // reuse
+    assertGid(gid3, 2, *dms);
     {
         AttributeGuard g1(av); // guard on gen 5
         dms->remove(2);
         dms->removeComplete(2);
-        EXPECT_EQUAL(3u, dms->getNumDocs());
-        EXPECT_EQUAL(1u, dms->getNumUsedLids()); // lid 2 free but guarded
-        EXPECT_TRUE(assertPut(bucketId4, time4, 3, gid4, *dms));
-        EXPECT_EQUAL(4u, dms->getNumDocs()); // generation guarded, new lid
-        EXPECT_EQUAL(2u, dms->getNumUsedLids());
-        EXPECT_TRUE(assertGid(gid4, 3, *dms));
+        EXPECT_EQ(3u, dms->getNumDocs());
+        EXPECT_EQ(1u, dms->getNumUsedLids()); // lid 2 free but guarded
+        assertPut(bucketId4, time4, 3, gid4, *dms);
+        EXPECT_EQ(4u, dms->getNumDocs()); // generation guarded, new lid
+        EXPECT_EQ(2u, dms->getNumUsedLids());
+        assertGid(gid4, 3, *dms);
     }
-    EXPECT_TRUE(assertPut(bucketId5, time5, 4, gid5, *dms));
-    EXPECT_EQUAL(5u, dms->getNumDocs()); // reuse blocked by previous guard. released at end of put()
-    EXPECT_EQUAL(3u, dms->getNumUsedLids());
-    EXPECT_TRUE(assertGid(gid5, 4, *dms));
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2, gid2, *dms)); // reuse of lid 2
-    EXPECT_EQUAL(5u, dms->getNumDocs());
-    EXPECT_EQUAL(4u, dms->getNumUsedLids());
-    EXPECT_TRUE(assertGid(gid2, 2, *dms));
+    assertPut(bucketId5, time5, 4, gid5, *dms);
+    EXPECT_EQ(5u, dms->getNumDocs()); // reuse blocked by previous guard. released at end of put()
+    EXPECT_EQ(3u, dms->getNumUsedLids());
+    assertGid(gid5, 4, *dms);
+    assertPut(bucketId2, time2, 2, gid2, *dms); // reuse of lid 2
+    EXPECT_EQ(5u, dms->getNumDocs());
+    EXPECT_EQ(4u, dms->getNumUsedLids());
+    assertGid(gid2, 2, *dms);
 }
 
 GlobalId
@@ -570,7 +556,7 @@ createGid(uint32_t userId, uint32_t lid)
     return docId.getGlobalId();
 }
 
-TEST("requireThatWeCanStoreBucketIdAndTimestamp")
+TEST(DocumentMetaStoreTest, can_store_bucket_id_and_timestamp)
 {
     DocumentMetaStore dms(createBucketDB());
     uint32_t numLids = 1000;
@@ -581,19 +567,19 @@ TEST("requireThatWeCanStoreBucketIdAndTimestamp")
         BucketId bucketId(gid.convertToBucketId());
         bucketId.setUsedBits(numBucketBits);
         uint32_t addLid = addGid(dms, gid, bucketId, Timestamp(lid + timestampBias));
-        EXPECT_EQUAL(lid, addLid);
+        EXPECT_EQ(lid, addLid);
     }
     for (uint32_t lid = 1; lid <= numLids; ++lid) {
         GlobalId gid = createGid(lid);
         BucketId bucketId(gid.convertToBucketId());
         bucketId.setUsedBits(numBucketBits);
-        EXPECT_TRUE(assertGid(gid, lid, dms, bucketId,
-                              Timestamp(lid + timestampBias)));
-        EXPECT_TRUE(assertLid(lid, gid, dms));
+        assertGid(gid, lid, dms, bucketId,
+                  Timestamp(lid + timestampBias));
+        assertLid(lid, gid, dms);
     }
 }
 
-TEST("requireThatGidsCanBeSavedAndLoaded")
+TEST(DocumentMetaStoreTest, gids_can_be_saved_and_loaded)
 {
     DocumentMetaStore dms1(createBucketDB());
     uint32_t numLids = 1000;
@@ -608,7 +594,7 @@ TEST("requireThatGidsCanBeSavedAndLoaded")
         BucketId bucketId(gid.convertToBucketId());
         bucketId.setUsedBits(numBucketBits);
         uint32_t addLid = addGid(dms1, gid, bucketId, Timestamp(lid + timestampBias));
-        EXPECT_EQUAL(lid, addLid);
+        EXPECT_EQ(lid, addLid);
     }
     for (size_t i = 0; i < removeLids.size(); ++i) {
         dms1.remove(removeLids[i]);
@@ -616,7 +602,7 @@ TEST("requireThatGidsCanBeSavedAndLoaded")
     }
     uint64_t expSaveBytesSize = DocumentMetaStore::minHeaderLen +
                                 (1000 - 4) * DocumentMetaStore::entrySize;
-    EXPECT_EQUAL(expSaveBytesSize, dms1.getEstimatedSaveByteSize());
+    EXPECT_EQ(expSaveBytesSize, dms1.getEstimatedSaveByteSize());
     TuneFileAttributes tuneFileAttributes;
     DummyFileHeaderContext fileHeaderContext;
     AttributeFileSaveTarget saveTarget(tuneFileAttributes, fileHeaderContext);
@@ -625,16 +611,16 @@ TEST("requireThatGidsCanBeSavedAndLoaded")
     DocumentMetaStore dms2(createBucketDB(), "documentmetastore2");
     EXPECT_TRUE(dms2.load());
     dms2.constructFreeList();
-    EXPECT_EQUAL(numLids + 1, dms2.getNumDocs());
-    EXPECT_EQUAL(numLids - 4, dms2.getNumUsedLids()); // 4 removed
+    EXPECT_EQ(numLids + 1, dms2.getNumDocs());
+    EXPECT_EQ(numLids - 4, dms2.getNumUsedLids()); // 4 removed
     for (uint32_t lid = 1; lid <= numLids; ++lid) {
         GlobalId gid = createGid(lid);
         BucketId bucketId(gid.convertToBucketId());
         bucketId.setUsedBits(numBucketBits);
         if (std::count(removeLids.begin(), removeLids.end(), lid) == 0) {
-            EXPECT_TRUE(assertGid(gid, lid, dms2, bucketId,
-                                  Timestamp(lid + timestampBias)));
-            EXPECT_TRUE(assertLid(lid, gid, dms2));
+            assertGid(gid, lid, dms2, bucketId,
+                      Timestamp(lid + timestampBias));
+            assertLid(lid, gid, dms2);
         } else {
             LOG(info, "Lid %u was removed before saving", lid);
             uint32_t myLid;
@@ -651,43 +637,43 @@ TEST("requireThatGidsCanBeSavedAndLoaded")
                           gid.convertToBucketId().getRawId());
         // re-use removeLid[i]
         uint32_t addLid = addGid(dms2, gid, bucketId, Timestamp(43u + i));
-        EXPECT_EQUAL(removeLids[i], addLid);
-        EXPECT_EQUAL(numLids + 1, dms2.getNumDocs());
-        EXPECT_EQUAL(numLids - (3 - i), dms2.getNumUsedLids());
+        EXPECT_EQ(removeLids[i], addLid);
+        EXPECT_EQ(numLids + 1, dms2.getNumDocs());
+        EXPECT_EQ(numLids - (3 - i), dms2.getNumUsedLids());
     }
 }
 
-TEST("requireThatStatsAreUpdated")
+TEST(DocumentMetaStore, stats_are_updated)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
     size_t perGidUsed = sizeof(uint32_t) + GlobalId::LENGTH;
-    EXPECT_EQUAL(1u, dms.getStatus().getNumDocs());
-    EXPECT_EQUAL(1u, dms.getStatus().getNumValues());
+    EXPECT_EQ(1u, dms.getStatus().getNumDocs());
+    EXPECT_EQ(1u, dms.getStatus().getNumValues());
     uint64_t lastAllocated = dms.getStatus().getAllocated();
     uint64_t lastUsed = dms.getStatus().getUsed();
-    EXPECT_GREATER(lastAllocated, perGidUsed);
-    EXPECT_GREATER(lastUsed, perGidUsed);
+    EXPECT_GT(lastAllocated, perGidUsed);
+    EXPECT_GT(lastUsed, perGidUsed);
 
     std::this_thread::sleep_for(6000ms);
     addGid(dms, gid1, bucketId1, time1);
-    EXPECT_EQUAL(2u, dms.getStatus().getNumDocs());
-    EXPECT_EQUAL(2u, dms.getStatus().getNumValues());
-    EXPECT_GREATER_EQUAL(dms.getStatus().getAllocated(), lastAllocated);
-    EXPECT_GREATER_EQUAL(dms.getStatus().getAllocated(), lastUsed);
-    EXPECT_GREATER(dms.getStatus().getUsed(), lastUsed);
-    EXPECT_GREATER(dms.getStatus().getUsed(), 2 * perGidUsed);
+    EXPECT_EQ(2u, dms.getStatus().getNumDocs());
+    EXPECT_EQ(2u, dms.getStatus().getNumValues());
+    EXPECT_GE(dms.getStatus().getAllocated(), lastAllocated);
+    EXPECT_GE(dms.getStatus().getAllocated(), lastUsed);
+    EXPECT_GT(dms.getStatus().getUsed(), lastUsed);
+    EXPECT_GT(dms.getStatus().getUsed(), 2 * perGidUsed);
     lastAllocated = dms.getStatus().getAllocated();
     lastUsed = dms.getStatus().getUsed();
 
     addGid(dms, gid2, bucketId2, time2);
     dms.commit(true);
-    EXPECT_EQUAL(3u, dms.getStatus().getNumDocs());
-    EXPECT_EQUAL(3u, dms.getStatus().getNumValues());
-    EXPECT_GREATER_EQUAL(dms.getStatus().getAllocated(), lastAllocated);
-    EXPECT_GREATER_EQUAL(dms.getStatus().getAllocated(), lastUsed);
-    EXPECT_GREATER(dms.getStatus().getUsed(), lastUsed);
-    EXPECT_GREATER(dms.getStatus().getUsed(), 3 * perGidUsed);
+    EXPECT_EQ(3u, dms.getStatus().getNumDocs());
+    EXPECT_EQ(3u, dms.getStatus().getNumValues());
+    EXPECT_GE(dms.getStatus().getAllocated(), lastAllocated);
+    EXPECT_GE(dms.getStatus().getAllocated(), lastUsed);
+    EXPECT_GT(dms.getStatus().getUsed(), lastUsed);
+    EXPECT_GT(dms.getStatus().getUsed(), 3 * perGidUsed);
     LOG(info,
         "stats after 2 gids added: allocated %d, used is %d > %d (3 * %d)",
         static_cast<int>(dms.getStatus().getAllocated()),
@@ -696,49 +682,47 @@ TEST("requireThatStatsAreUpdated")
         static_cast<int>(perGidUsed));
 }
 
-TEST("requireThatWeCanPutAndRemoveBeforeFreeListConstruct")
+TEST(DocumentMetaStoreTest, can_put_and_remove_before_free_list_construct)
 {
     DocumentMetaStore dms(createBucketDB());
     EXPECT_TRUE(dms.put(gid4, bucketId4, time4, docSize4, 4).ok());
-    EXPECT_TRUE(assertLid(4, gid4, dms));
-    EXPECT_TRUE(assertGid(gid4, 4, dms));
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
-    EXPECT_EQUAL(5u, dms.getNumDocs());
+    assertLid(4, gid4, dms);
+    assertGid(gid4, 4, dms);
+    EXPECT_EQ(1u, dms.getNumUsedLids());
+    EXPECT_EQ(5u, dms.getNumDocs());
     EXPECT_TRUE(dms.put(gid1, bucketId1, time1, docSize1, 1).ok());
     // already there, nothing changes
     EXPECT_TRUE(dms.put(gid1, bucketId1, time1, docSize1, 1).ok());
-    EXPECT_TRUE(assertLid(1, gid1, dms));
-    EXPECT_TRUE(assertGid(gid1, 1, dms));
-    EXPECT_EQUAL(2u, dms.getNumUsedLids());
-    EXPECT_EQUAL(5u, dms.getNumDocs());
+    assertLid(1, gid1, dms);
+    assertGid(gid1, 1, dms);
+    EXPECT_EQ(2u, dms.getNumUsedLids());
+    EXPECT_EQ(5u, dms.getNumDocs());
     // gid1 already there with lid 1
-    EXPECT_EXCEPTION(dms.put(gid1, bucketId1, time1, docSize1, 2).ok(),
-                     vespalib::IllegalStateException,
-                     "gid found, but using another lid");
-    EXPECT_EXCEPTION(dms.put(gid5, bucketId5, time5, docSize5, 1).ok(),
-                     vespalib::IllegalStateException,
-                     "gid not found, but lid is used by another gid");
-    EXPECT_TRUE(assertLid(1, gid1, dms));
-    EXPECT_TRUE(assertGid(gid1, 1, dms));
-    EXPECT_EQUAL(2u, dms.getNumUsedLids());
-    EXPECT_EQUAL(5u, dms.getNumDocs());
+    EXPECT_THROW(dms.put(gid1, bucketId1, time1, docSize1, 2).ok(),
+                 vespalib::IllegalStateException);
+    EXPECT_THROW(dms.put(gid5, bucketId5, time5, docSize5, 1).ok(),
+                 vespalib::IllegalStateException);
+    assertLid(1, gid1, dms);
+    assertGid(gid1, 1, dms);
+    EXPECT_EQ(2u, dms.getNumUsedLids());
+    EXPECT_EQ(5u, dms.getNumDocs());
     EXPECT_TRUE(dms.remove(4)); // -> goes to free list. cleared and re-applied in constructFreeList().
     uint32_t lid;
     GlobalId gid;
     EXPECT_TRUE(!dms.getLid(gid4, lid));
     EXPECT_TRUE(!dms.getGid(4, gid));
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
-    EXPECT_EQUAL(5u, dms.getNumDocs());
+    EXPECT_EQ(1u, dms.getNumUsedLids());
+    EXPECT_EQ(5u, dms.getNumDocs());
     dms.constructFreeList();
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
-    EXPECT_EQUAL(5u, dms.getNumDocs());
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2, gid2, dms));
-    EXPECT_TRUE(assertPut(bucketId3, time3, 3, gid3, dms));
-    EXPECT_EQUAL(3u, dms.getNumUsedLids());
-    EXPECT_EQUAL(5u, dms.getNumDocs());
+    EXPECT_EQ(1u, dms.getNumUsedLids());
+    EXPECT_EQ(5u, dms.getNumDocs());
+    assertPut(bucketId2, time2, 2, gid2, dms);
+    assertPut(bucketId3, time3, 3, gid3, dms);
+    EXPECT_EQ(3u, dms.getNumUsedLids());
+    EXPECT_EQ(5u, dms.getNumDocs());
 }
 
-TEST("requireThatWeCanSortGids")
+TEST(DocumentMetaStoreTest, can_sort_gids)
 {
     DocumentMetaStore dms(createBucketDB());
     DocumentMetaStore rdms(createBucketDB(),
@@ -756,9 +740,9 @@ TEST("requireThatWeCanSortGids")
         BucketId bucketId(minNumBits,
                           gid.convertToBucketId().getRawId());
         uint32_t addLid = addGid(dms, gid, bucketId, Timestamp(0u));
-        EXPECT_EQUAL(lid, addLid);
+        EXPECT_EQ(lid, addLid);
         uint32_t addLid2 = addGid(rdms, gid, bucketId, Timestamp(0u));
-        EXPECT_EQUAL(lid, addLid2);
+        EXPECT_EQ(lid, addLid2);
     }
     std::vector<uint32_t> lids;
     std::vector<uint32_t> rlids;
@@ -767,10 +751,10 @@ TEST("requireThatWeCanSortGids")
     for (DocumentMetaStore::ConstIterator rit = rdms.beginFrozen();
          rit.valid(); ++rit)
         rlids.push_back(rit.getKey());
-    EXPECT_EQUAL(numLids, lids.size());
-    EXPECT_EQUAL(numLids, rlids.size());
+    EXPECT_EQ(numLids, lids.size());
+    EXPECT_EQ(numLids, rlids.size());
     for (uint32_t i = 0; i < numLids; ++i) {
-        EXPECT_EQUAL(lids[numLids - 1 - i], rlids[i]);
+        EXPECT_EQ(lids[numLids - 1 - i], rlids[i]);
     }
 }
 
@@ -791,7 +775,7 @@ requireThatBasicBucketInfoWorks()
         BucketId bucketId(minNumBits,
                           gid.convertToBucketId().getRawId());
         uint32_t addLid = addGid(dms, gid, bucketId, timestamp);
-        EXPECT_EQUAL(lid, addLid);
+        EXPECT_EQ(lid, addLid);
         m[std::make_pair(bucketId, gid)] = timestamp;
     }
     for (uint32_t lid = 2; lid <= numLids; lid += 7) {
@@ -801,7 +785,7 @@ requireThatBasicBucketInfoWorks()
         BucketId bucketId(minNumBits,
                           gid.convertToBucketId().getRawId());
         uint32_t addLid = addGid(dms, gid, bucketId, timestamp);
-        EXPECT_EQUAL(lid, addLid);
+        EXPECT_EQ(lid, addLid);
         m[std::make_pair(bucketId, gid)] = timestamp;
     }
     for (uint32_t lid = 3; lid <= numLids; lid += 5) {
@@ -824,8 +808,8 @@ requireThatBasicBucketInfoWorks()
             ++cnt;
         } else {
             BucketInfo bi = bucketDB->get(prevBucket);
-            EXPECT_EQUAL(cnt, bi.getDocumentCount());
-            EXPECT_EQUAL(cksum.getChecksum(), bi.getChecksum());
+            EXPECT_EQ(cnt, bi.getDocumentCount());
+            EXPECT_EQ(cksum.getChecksum(), bi.getChecksum());
             prevBucket = i->first.first;
             cksum = ChecksumType(BucketChecksum(0));
             cksum.addDoc(i->first.second, i->second);
@@ -835,12 +819,12 @@ requireThatBasicBucketInfoWorks()
     }
     maxcnt = std::max(maxcnt, cnt);
     BucketInfo bi = bucketDB->get(prevBucket);
-    EXPECT_EQUAL(cnt, bi.getDocumentCount());
-    EXPECT_EQUAL(cksum.getChecksum(), bi.getChecksum());
+    EXPECT_EQ(cnt, bi.getDocumentCount());
+    EXPECT_EQ(cksum.getChecksum(), bi.getChecksum());
     LOG(info, "Largest bucket: %u elements", maxcnt);
 }
 
-TEST("requireThatBasicBucketInfoWorks")
+TEST(DocumentMetaStoreTest, basic_bucket_info_works)
 {
     BucketState::setChecksumType(BucketState::ChecksumType::LEGACY);
     requireThatBasicBucketInfoWorks<LegacyChecksumAggregator>();
@@ -848,10 +832,10 @@ TEST("requireThatBasicBucketInfoWorks")
     requireThatBasicBucketInfoWorks<XXH64ChecksumAggregator>();
 }
 
-TEST("requireThatWeCanRetrieveListOfLidsFromBucketId")
+TEST(DocumentMetaStoreTest, can_retrieve_list_of_lids_from_bucket_id)
 {
-    typedef std::vector<uint32_t> LidVector;
-    typedef std::map<BucketId, LidVector> Map;
+    using LidVector = std::vector<uint32_t>;
+    using Map = std::map<BucketId, LidVector>;
     DocumentMetaStore dms(createBucketDB());
     const uint32_t bucketBits = 2; // -> 4 buckets
     uint32_t numLids = 1000;
@@ -864,12 +848,12 @@ TEST("requireThatWeCanRetrieveListOfLidsFromBucketId")
         BucketId bucketId(bucketBits,
                           gid.convertToBucketId().getRawId());
         uint32_t addLid = addGid(dms, gid, bucketId, Timestamp(0));
-        EXPECT_EQUAL(lid, addLid);
+        EXPECT_EQ(lid, addLid);
         m[bucketId].push_back(lid);
     }
 
     // Verify that bucket id x has y lids
-    EXPECT_EQUAL(4u, m.size());
+    EXPECT_EQ(4u, m.size());
     for (Map::const_iterator itr = m.begin(); itr != m.end(); ++itr) {
         const BucketId &bucketId = itr->first;
         const LidVector &expLids = itr->second;
@@ -877,7 +861,7 @@ TEST("requireThatWeCanRetrieveListOfLidsFromBucketId")
             bucketId.toString().c_str(), expLids.size());
         LidVector actLids;
         dms.getLids(bucketId, actLids);
-        EXPECT_EQUAL(expLids.size(), actLids.size());
+        EXPECT_EQ(expLids.size(), actLids.size());
         for (size_t i = 0; i < expLids.size(); ++i) {
             EXPECT_TRUE(std::find(actLids.begin(), actLids.end(), expLids[i]) != actLids.end());
         }
@@ -916,7 +900,7 @@ struct UserDocFixture {
     ~UserDocFixture();
     void addGlobalId(const GlobalId &gid, uint32_t expLid, uint32_t timestampConst = 100) {
         uint32_t actLid = addGid(dms, gid, Timestamp(expLid + timestampConst));
-        EXPECT_EQUAL(expLid, actLid);
+        EXPECT_EQ(expLid, actLid);
     }
     void putGlobalId(const GlobalId &gid, uint32_t lid, uint32_t timestampConst = 100) {
         putGid(dms, gid, lid, Timestamp(lid + timestampConst));
@@ -954,13 +938,13 @@ UserDocFixture::addGlobalIds(size_t numGids) {
     }
 }
 
-TEST("requireThatWeCanRetrieveListOfMetaDataFromBucketId")
+TEST(DocumentMetaStoreTest, can_retrieve_list_of_meta_data_from_bucket_id)
 {
     UserDocFixture f;
     { // empty bucket
         DocumentMetaData::Vector result;
         f.dms.getMetaData(f.bid1, result);
-        EXPECT_EQUAL(0u, result.size());
+        EXPECT_EQ(0u, result.size());
     }
     f.dms.constructFreeList();
     f.addGlobalIds();
@@ -968,137 +952,137 @@ TEST("requireThatWeCanRetrieveListOfMetaDataFromBucketId")
         DocumentMetaData::Vector result;
         f.dms.getMetaData(f.bid1, result);
         std::sort(result.begin(), result.end(), Comparator());
-        EXPECT_EQUAL(4u, result.size());
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(1, Timestamp(101), f.bid1,
-                                                    f.gids[0]), result[0]));
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(2, Timestamp(102), f.bid1,
-                                                    f.gids[1]), result[1]));
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(4, Timestamp(104), f.bid1,
-                                                    f.gids[3]), result[2]));
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(5, Timestamp(105), f.bid1,
-                                                    f.gids[4]), result[3]));
+        EXPECT_EQ(4u, result.size());
+        assertMetaData(DocumentMetaData(1, Timestamp(101), f.bid1,
+                                        f.gids[0]), result[0]);
+        assertMetaData(DocumentMetaData(2, Timestamp(102), f.bid1,
+                                        f.gids[1]), result[1]);
+        assertMetaData(DocumentMetaData(4, Timestamp(104), f.bid1,
+                                        f.gids[3]), result[2]);
+        assertMetaData(DocumentMetaData(5, Timestamp(105), f.bid1,
+                                        f.gids[4]), result[3]);
     }
     { // verify bucket 2
         DocumentMetaData::Vector result;
         f.dms.getMetaData(f.bid2, result);
         std::sort(result.begin(), result.end(), Comparator());
-        EXPECT_EQUAL(3u, result.size());
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(3, Timestamp(103), f.bid2,
-                                                    f.gids[2]), result[0]));
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(6, Timestamp(106), f.bid2,
-                                                    f.gids[5]), result[1]));
-        EXPECT_TRUE(assertMetaData(DocumentMetaData(7, Timestamp(107), f.bid2,
-                                                    f.gids[6]), result[2]));
+        EXPECT_EQ(3u, result.size());
+        assertMetaData(DocumentMetaData(3, Timestamp(103), f.bid2,
+                                        f.gids[2]), result[0]);
+        assertMetaData(DocumentMetaData(6, Timestamp(106), f.bid2,
+                                        f.gids[5]), result[1]);
+        assertMetaData(DocumentMetaData(7, Timestamp(107), f.bid2,
+                                        f.gids[6]), result[2]);
     }
 }
 
-TEST("requireThatBucketStateCanBeUpdated")
+TEST(DocumentMetaStoreTest, bucket_state_can_be_updated)
 {
     UserDocFixture f;
     f.dms.constructFreeList();
-    EXPECT_EQUAL(1u, f.dms.getActiveLids().size()); // lid 0 is reserved
+    EXPECT_EQ(1u, f.dms.getActiveLids().size()); // lid 0 is reserved
 
     f.addGlobalIds();
-    EXPECT_TRUE(assertActiveLids(BoolVector().F().F().F().F().F().F().F(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().F().F().F().F().F().F().F(), f.dms.getActiveLids());
+    EXPECT_EQ(0u, f.dms.getNumActiveLids());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid1).isActive());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid2).isActive());
 
     f.dms.setBucketState(f.bid1, true);
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().T().F().T().T().F().F(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(4u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().T().F().T().T().F().F(), f.dms.getActiveLids());
+    EXPECT_EQ(4u, f.dms.getNumActiveLids());
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->get(f.bid1).isActive());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid2).isActive());
 
     f.dms.setBucketState(f.bid2, true);
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().T().T().T().T().T().T(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(7u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().T().T().T().T().T().T(), f.dms.getActiveLids());
+    EXPECT_EQ(7u, f.dms.getNumActiveLids());
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->get(f.bid1).isActive());
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->get(f.bid2).isActive());
 
     f.addGlobalId(createGid(30, 8), 8);
     f.addGlobalId(createGid(10, 9), 9); // bid1 is active so added document should be active as well
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().T().T().T().T().T().T().F().T(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(8u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().T().T().T().T().T().T().F().T(), f.dms.getActiveLids());
+    EXPECT_EQ(8u, f.dms.getNumActiveLids());
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->get(f.bid1).isActive());
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->get(f.bid2).isActive());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid3).isActive());
 
     f.dms.setBucketState(f.bid1, false);
-    EXPECT_TRUE(assertActiveLids(BoolVector().F().F().T().F().F().T().T().F().F(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(3u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().F().F().T().F().F().T().T().F().F(), f.dms.getActiveLids());
+    EXPECT_EQ(3u, f.dms.getNumActiveLids());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid1).isActive());
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->get(f.bid2).isActive());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid3).isActive());
 
     f.dms.setBucketState(f.bid2, false);
-    EXPECT_TRUE(assertActiveLids(BoolVector().F().F().F().F().F().F().F().F().F(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().F().F().F().F().F().F().F().F().F(), f.dms.getActiveLids());
+    EXPECT_EQ(0u, f.dms.getNumActiveLids());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid1).isActive());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid2).isActive());
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->get(f.bid3).isActive());
 }
 
 
-TEST("requireThatRemovedLidsAreClearedAsActive")
+TEST(DocumentMetaStoreTest, removed_lids_are_cleared_as_active)
 {
     UserDocFixture f;
     f.dms.constructFreeList();
     f.addGlobalIds(2);
     f.dms.setBucketState(f.bid1, true);
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().T(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(2u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().T(), f.dms.getActiveLids());
+    EXPECT_EQ(2u, f.dms.getNumActiveLids());
     f.dms.remove(2);
     f.dms.removeComplete(2);
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().F(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(1u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().F(), f.dms.getActiveLids());
+    EXPECT_EQ(1u, f.dms.getNumActiveLids());
     f.addGlobalId(f.gids[2], 2); // from bid2
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().F(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(1u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().F(), f.dms.getActiveLids());
+    EXPECT_EQ(1u, f.dms.getNumActiveLids());
     f.dms.remove(2);
     f.dms.removeComplete(2);
     f.addGlobalId(f.gids[3], 2); // from bid1
-    EXPECT_TRUE(assertActiveLids(BoolVector().T().T(), f.dms.getActiveLids()));
-    EXPECT_EQUAL(2u, f.dms.getNumActiveLids());
+    assertActiveLids(BoolVector().T().T(), f.dms.getActiveLids());
+    EXPECT_EQ(2u, f.dms.getNumActiveLids());
 }
 
-TEST("require that whitelist blueprint is created")
+TEST(DocumentMetaStoreTest, whitelist_blueprint_is_created)
 {
     UserDocFixture f;
     f.dms.constructFreeList();
     f.addGlobalIds();
 
     f.dms.setBucketState(f.bid1, true);
-    EXPECT_TRUE(assertWhiteList(SimpleResult().addHit(1).addHit(2).addHit(4).addHit(5), f.dms.createWhiteListBlueprint(),
-                                true, f.dms.getCommittedDocIdLimit()));
+    assertWhiteList(SimpleResult().addHit(1).addHit(2).addHit(4).addHit(5), f.dms.createWhiteListBlueprint(),
+                    true, f.dms.getCommittedDocIdLimit());
 
     f.dms.setBucketState(f.bid2, true);
-    EXPECT_TRUE(assertWhiteList(SimpleResult().addHit(1).addHit(2).addHit(3).addHit(4).addHit(5).addHit(6).addHit(7), f.dms.createWhiteListBlueprint(),
-                                true,  f.dms.getCommittedDocIdLimit()));
+    assertWhiteList(SimpleResult().addHit(1).addHit(2).addHit(3).addHit(4).addHit(5).addHit(6).addHit(7), f.dms.createWhiteListBlueprint(),
+                    true,  f.dms.getCommittedDocIdLimit());
 }
 
-TEST("requireThatDocumentAndMetaEntryCountIsUpdated")
+TEST(DocumentMetaStoreTest, document_and_meta_entry_count_is_updated)
 {
     UserDocFixture f;
     f.dms.constructFreeList();
-    EXPECT_EQUAL(0u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getDocumentCount());
-    EXPECT_EQUAL(0u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
-    EXPECT_EQUAL(0u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getDocumentCount());
-    EXPECT_EQUAL(0u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
+    EXPECT_EQ(0u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getDocumentCount());
+    EXPECT_EQ(0u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
+    EXPECT_EQ(0u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getDocumentCount());
+    EXPECT_EQ(0u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
     f.addGlobalIds();
-    EXPECT_EQUAL(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getDocumentCount());
-    EXPECT_EQUAL(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
-    EXPECT_EQUAL(3u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getDocumentCount());
-    EXPECT_EQUAL(3u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
+    EXPECT_EQ(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getDocumentCount());
+    EXPECT_EQ(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
+    EXPECT_EQ(3u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getDocumentCount());
+    EXPECT_EQ(3u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
     f.dms.remove(3); // from bid2
     f.dms.removeComplete(3);
-    EXPECT_EQUAL(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getDocumentCount());
-    EXPECT_EQUAL(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
-    EXPECT_EQUAL(2u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getDocumentCount());
-    EXPECT_EQUAL(2u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
+    EXPECT_EQ(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getDocumentCount());
+    EXPECT_EQ(4u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
+    EXPECT_EQ(2u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getDocumentCount());
+    EXPECT_EQ(2u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
 }
 
-TEST("requireThatEmptyBucketsAreRemoved")
+TEST(DocumentMetaStoreTest, empty_buckets_are_removed)
 {
     UserDocFixture f;
     f.dms.constructFreeList();
@@ -1111,7 +1095,7 @@ TEST("requireThatEmptyBucketsAreRemoved")
     f.dms.removeComplete(3);
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->hasBucket(f.bid1));
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->hasBucket(f.bid2));
-    EXPECT_EQUAL(0u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
+    EXPECT_EQ(0u, f.dms.getBucketDB().takeGuard()->get(f.bid2).getEntryCount());
     f._bucketDBHandler.handleDeleteBucket(f.bid2);
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->hasBucket(f.bid2));
     f.dms.remove(1); // from bid1
@@ -1121,13 +1105,12 @@ TEST("requireThatEmptyBucketsAreRemoved")
     f.dms.remove(2); // from bid1
     f.dms.removeComplete(2);
     EXPECT_TRUE(f.dms.getBucketDB().takeGuard()->hasBucket(f.bid1));
-    EXPECT_EQUAL(0u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
+    EXPECT_EQ(0u, f.dms.getBucketDB().takeGuard()->get(f.bid1).getEntryCount());
     f._bucketDBHandler.handleDeleteBucket(f.bid1);
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->hasBucket(f.bid1));
     EXPECT_FALSE(f.dms.getBucketDB().takeGuard()->hasBucket(f.bid2));
 }
 
-
 struct GlobalIdEntry {
     uint32_t lid;
     GlobalId gid;
@@ -1143,10 +1126,9 @@ struct GlobalIdEntry {
     {}
 };
 
-typedef std::vector<GlobalIdEntry> GlobalIdVector;
+using GlobalIdVector = std::vector<GlobalIdEntry>;
 
-struct MyBucketCreateListener : public IBucketCreateListener
-{
+struct MyBucketCreateListener : public IBucketCreateListener {
     std::vector<document::BucketId> _buckets;
 
     MyBucketCreateListener();
@@ -1162,15 +1144,13 @@ MyBucketCreateListener::~MyBucketCreateListener()
 {
 }
 
-
 void
 MyBucketCreateListener::notifyCreateBucket(const document::BucketId &bucket)
 {
     _buckets.emplace_back(bucket);
 }
 
-struct SplitAndJoinEmptyFixture
-{
+struct SplitAndJoinEmptyFixture {
     DocumentMetaStore dms;
     BucketId          bid10;
     BucketId          bid11;
@@ -1193,7 +1173,7 @@ struct SplitAndJoinEmptyFixture
     }
 
     void assertNotifyCreateBuckets(std::vector<document::BucketId> expBuckets) {
-        EXPECT_EQUAL(expBuckets, _bucketCreateListener._buckets);
+        EXPECT_EQ(expBuckets, _bucketCreateListener._buckets);
     }
 };
 
@@ -1214,8 +1194,7 @@ SplitAndJoinEmptyFixture::~SplitAndJoinEmptyFixture()
 }
 
 
-struct SplitAndJoinFixture : public SplitAndJoinEmptyFixture
-{
+struct SplitAndJoinFixture : public SplitAndJoinEmptyFixture {
     typedef std::map<BucketId, GlobalIdVector> BucketMap;
     GlobalIdVector    gids;
     BucketMap         bid1s;
@@ -1282,9 +1261,9 @@ SplitAndJoinFixture::SplitAndJoinFixture()
         bid2s[gids.back().bid2].push_back(gids.back());
         bid3s[gids.back().bid3].push_back(gids.back());
     }
-    ASSERT_EQUAL(2u, bid1s.size());
-    ASSERT_EQUAL(4u, bid2s.size());
-    ASSERT_EQUAL(8u, bid3s.size());
+    assert(2u == bid1s.size());
+    assert(4u == bid2s.size());
+    assert(8u == bid3s.size());
     bid10Gids = &bid1s[bid10];
     bid11Gids = &bid1s[bid11];
     bid21Gids = &bid2s[bid21];
@@ -1300,7 +1279,7 @@ getBoolVector(const GlobalIdVector &gids, size_t sz)
     BoolVector retval(sz);
     for (size_t i = 0; i < gids.size(); ++i) {
         uint32_t lid(gids[i].lid);
-        ASSERT_TRUE(lid <= sz && lid > 0u);
+        assert(lid <= sz && lid > 0u);
         retval[lid - 1] = true;
     }
     return retval;
@@ -1315,15 +1294,16 @@ getBoolVectorFiltered(const GlobalIdVector &gids, size_t sz,
     for (size_t i = 0; i < gids.size(); ++i) {
         const GlobalIdEntry &g(gids[i]);
         uint32_t lid(g.lid);
-        ASSERT_TRUE(lid <= sz && lid > 0u);
-        if (g.bid3 == skip)
+        assert(lid <= sz && lid > 0u);
+        if (g.bid3 == skip) {
             continue;
+        }
         retval[lid - 1] = true;
     }
     return retval;
 }
 
-TEST("requireThatBucketInfoIsCorrectAfterSplit")
+TEST(DocumentMetaStoreTest, bucket_info_is_correct_after_split)
 {
     SplitAndJoinFixture f;
     f.insertGids1();
@@ -1331,10 +1311,10 @@ TEST("requireThatBucketInfoIsCorrectAfterSplit")
     BucketInfo bi11 = f.getInfo(f.bid11);
     LOG(info, "%s: %s", f.bid10.toString().c_str(), bi10.toString().c_str());
     LOG(info, "%s: %s", f.bid11.toString().c_str(), bi11.toString().c_str());
-    EXPECT_TRUE(assertBucketInfo(f.bid10Gids->size(), f.bid10Gids->size(), bi10));
-    EXPECT_TRUE(assertBucketInfo(f.bid11Gids->size(), f.bid11Gids->size(), bi11));
-    EXPECT_NOT_EQUAL(bi10.getEntryCount(), bi11.getEntryCount());
-    EXPECT_EQUAL(31u, bi10.getEntryCount() + bi11.getEntryCount());
+    assertBucketInfo(f.bid10Gids->size(), f.bid10Gids->size(), bi10);
+    assertBucketInfo(f.bid11Gids->size(), f.bid11Gids->size(), bi11);
+    EXPECT_NE(bi10.getEntryCount(), bi11.getEntryCount());
+    EXPECT_EQ(31u, bi10.getEntryCount() + bi11.getEntryCount());
 
     f._bucketDBHandler.handleSplit(10, f.bid11, f.bid21, f.bid23);
 
@@ -1346,25 +1326,24 @@ TEST("requireThatBucketInfoIsCorrectAfterSplit")
     LOG(info, "%s: %s", f.bid11.toString().c_str(), nbi11.toString().c_str());
     LOG(info, "%s: %s", f.bid21.toString().c_str(), bi21.toString().c_str());
     LOG(info, "%s: %s", f.bid23.toString().c_str(), bi23.toString().c_str());
-    EXPECT_TRUE(assertBucketInfo(f.bid10Gids->size(),
-                                 f.bid10Gids->size(),
-                                 nbi10));
-    EXPECT_TRUE(assertBucketInfo(0u, 0u, nbi11));
-    EXPECT_TRUE(assertBucketInfo(f.bid21Gids->size(),
-                                 f.bid21Gids->size(),
-                                 bi21));
-    EXPECT_TRUE(assertBucketInfo(f.bid23Gids->size(),
-                                 f.bid23Gids->size(),
-                                 bi23));
-    EXPECT_EQUAL(bi11.getEntryCount(),
-                 bi21.getEntryCount() + bi23.getEntryCount());
-    EXPECT_EQUAL(bi11.getDocumentCount(),
-                 bi21.getDocumentCount() +
-                 bi23.getDocumentCount());
+    assertBucketInfo(f.bid10Gids->size(),
+                     f.bid10Gids->size(),
+                     nbi10);
+    assertBucketInfo(0u, 0u, nbi11);
+    assertBucketInfo(f.bid21Gids->size(),
+                     f.bid21Gids->size(),
+                     bi21);
+    assertBucketInfo(f.bid23Gids->size(),
+                     f.bid23Gids->size(),
+                     bi23);
+    EXPECT_EQ(bi11.getEntryCount(),
+              bi21.getEntryCount() + bi23.getEntryCount());
+    EXPECT_EQ(bi11.getDocumentCount(),
+              bi21.getDocumentCount() + bi23.getDocumentCount());
     f.assertNotifyCreateBuckets({ f.bid21, f.bid23 });
 }
 
-TEST("requireThatActiveStateIsPreservedAfterSplit")
+TEST(DocumentMetaStoreTest, active_state_is_preserved_after_split)
 {
     { // non-active bucket
         SplitAndJoinFixture f;
@@ -1374,7 +1353,7 @@ TEST("requireThatActiveStateIsPreservedAfterSplit")
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         EXPECT_FALSE(f.getInfo(f.bid22).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
     }
     { // active bucket
         SplitAndJoinFixture f;
@@ -1386,7 +1365,7 @@ TEST("requireThatActiveStateIsPreservedAfterSplit")
         EXPECT_TRUE(f.getInfo(f.bid22).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
     { // non-active source, active overlapping target1
         SplitAndJoinFixture f;
@@ -1394,17 +1373,17 @@ TEST("requireThatActiveStateIsPreservedAfterSplit")
         EXPECT_FALSE(f.getInfo(f.bid10).isActive());
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
         f.dms.setBucketState(f.bid20, true);
         EXPECT_TRUE(f.getInfo(f.bid20).isActive());
         assertActiveLids(getBoolVector(*f.bid30Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid30Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid30Gids->size(), f.dms.getNumActiveLids());
         f._bucketDBHandler.handleSplit(10, f.bid10, f.bid20, f.bid22);
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         EXPECT_FALSE(f.getInfo(f.bid22).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
     }
     { // non-active source, active overlapping target2
         SplitAndJoinFixture f;
@@ -1412,17 +1391,17 @@ TEST("requireThatActiveStateIsPreservedAfterSplit")
         EXPECT_FALSE(f.getInfo(f.bid10).isActive());
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
         f.dms.setBucketState(f.bid22, true);
         EXPECT_TRUE(f.getInfo(f.bid22).isActive());
         assertActiveLids(getBoolVector(*f.bid32Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid32Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid32Gids->size(), f.dms.getNumActiveLids());
         f._bucketDBHandler.handleSplit(10, f.bid10, f.bid20, f.bid22);
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         EXPECT_FALSE(f.getInfo(f.bid22).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
     }
     { // active source, non-active overlapping target1
         SplitAndJoinFixture f;
@@ -1432,13 +1411,13 @@ TEST("requireThatActiveStateIsPreservedAfterSplit")
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         BoolVector filtered(getBoolVectorFiltered(*f.bid10Gids, 31, f.bid30));
         assertActiveLids(filtered, f.dms.getActiveLids());
-        EXPECT_EQUAL(filtered.countTrue(), f.dms.getNumActiveLids());
+        EXPECT_EQ(filtered.countTrue(), f.dms.getNumActiveLids());
         f._bucketDBHandler.handleSplit(10, f.bid10, f.bid20, f.bid22);
         EXPECT_TRUE(f.getInfo(f.bid20).isActive());
         EXPECT_TRUE(f.getInfo(f.bid22).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
     { // active source, non-active overlapping target2
         SplitAndJoinFixture f;
@@ -1448,17 +1427,17 @@ TEST("requireThatActiveStateIsPreservedAfterSplit")
         EXPECT_FALSE(f.getInfo(f.bid20).isActive());
         BoolVector filtered(getBoolVectorFiltered(*f.bid10Gids, 31, f.bid32));
         assertActiveLids(filtered, f.dms.getActiveLids());
-        EXPECT_EQUAL(filtered.countTrue(), f.dms.getNumActiveLids());
+        EXPECT_EQ(filtered.countTrue(), f.dms.getNumActiveLids());
         f._bucketDBHandler.handleSplit(10, f.bid10, f.bid20, f.bid22);
         EXPECT_TRUE(f.getInfo(f.bid20).isActive());
         EXPECT_TRUE(f.getInfo(f.bid22).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
 }
 
-TEST("requireThatActiveStateIsPreservedAfterEmptySplit")
+TEST(DocumentMetaStoreTest, active_state_is_preserved_after_empty_split)
 {
     { // non-active bucket
         SplitAndJoinEmptyFixture f;
@@ -1479,7 +1458,7 @@ TEST("requireThatActiveStateIsPreservedAfterEmptySplit")
     }
 }
 
-TEST("requireThatBucketInfoIsCorrectAfterJoin")
+TEST(DocumentMetaStoreTest, bucket_info_is_correct_after_join)
 {
     SplitAndJoinFixture f;
     f.insertGids2();
@@ -1487,10 +1466,10 @@ TEST("requireThatBucketInfoIsCorrectAfterJoin")
     BucketInfo bi23 = f.getInfo(f.bid23);
     LOG(info, "%s: %s", f.bid21.toString().c_str(), bi21.toString().c_str());
     LOG(info, "%s: %s", f.bid23.toString().c_str(), bi23.toString().c_str());
-    EXPECT_TRUE(assertBucketInfo(f.bid21Gids->size(), f.bid21Gids->size(), bi21));
-    EXPECT_TRUE(assertBucketInfo(f.bid23Gids->size(), f.bid23Gids->size(), bi23));
-    EXPECT_NOT_EQUAL(bi21.getEntryCount(), bi23.getEntryCount());
-    EXPECT_EQUAL(f.bid11Gids->size(), bi21.getEntryCount() + bi23.getEntryCount());
+    assertBucketInfo(f.bid21Gids->size(), f.bid21Gids->size(), bi21);
+    assertBucketInfo(f.bid23Gids->size(), f.bid23Gids->size(), bi23);
+    EXPECT_NE(bi21.getEntryCount(), bi23.getEntryCount());
+    EXPECT_EQ(f.bid11Gids->size(), bi21.getEntryCount() + bi23.getEntryCount());
 
     f._bucketDBHandler.handleJoin(10, f.bid21, f.bid23, f.bid11);
     BucketInfo bi11 = f.getInfo(f.bid11);
@@ -1499,19 +1478,19 @@ TEST("requireThatBucketInfoIsCorrectAfterJoin")
     LOG(info, "%s: %s", f.bid11.toString().c_str(), bi11.toString().c_str());
     LOG(info, "%s: %s", f.bid21.toString().c_str(), nbi21.toString().c_str());
     LOG(info, "%s: %s", f.bid23.toString().c_str(), nbi23.toString().c_str());
-    EXPECT_TRUE(assertBucketInfo(f.bid11Gids->size(),
-                                 f.bid11Gids->size(), bi11));
-    EXPECT_TRUE(assertBucketInfo(0u, 0u, nbi21));
-    EXPECT_TRUE(assertBucketInfo(0u, 0u, nbi23));
-    EXPECT_EQUAL(bi21.getEntryCount() + bi23.getEntryCount(),
-                 bi11.getEntryCount());
-    EXPECT_EQUAL(bi21.getDocumentCount() +
-                 bi23.getDocumentCount(),
-                 bi11.getDocumentCount());
+    assertBucketInfo(f.bid11Gids->size(),
+                     f.bid11Gids->size(), bi11);
+    assertBucketInfo(0u, 0u, nbi21);
+    assertBucketInfo(0u, 0u, nbi23);
+    EXPECT_EQ(bi21.getEntryCount() + bi23.getEntryCount(),
+              bi11.getEntryCount());
+    EXPECT_EQ(bi21.getDocumentCount() +
+              bi23.getDocumentCount(),
+              bi11.getDocumentCount());
     f.assertNotifyCreateBuckets({ f.bid11 });
 }
 
-TEST("requireThatActiveStateIsPreservedAfterJoin")
+TEST(DocumentMetaStoreTest, active_state_is_preserved_after_join)
 {
     { // non-active buckets
         SplitAndJoinFixture f;
@@ -1522,7 +1501,7 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         f._bucketDBHandler.handleJoin(10, f.bid20, f.bid22, f.bid10);
         EXPECT_FALSE(f.getInfo(f.bid10).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
     }
     { // active buckets
         SplitAndJoinFixture f;
@@ -1536,7 +1515,7 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_TRUE(f.getInfo(f.bid10).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
     { // 1 active bucket
         SplitAndJoinFixture f;
@@ -1549,7 +1528,7 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_TRUE(f.getInfo(f.bid10).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
     { // 1 active bucket
         SplitAndJoinFixture f;
@@ -1562,7 +1541,7 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_TRUE(f.getInfo(f.bid10).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
     { // non-active buckets, active target
         SplitAndJoinFixture f;
@@ -1573,12 +1552,12 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_FALSE(f.getInfo(f.bid22).isActive());
         assertActiveLids(getBoolVector(*f.bid30Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid30Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid30Gids->size(), f.dms.getNumActiveLids());
 
         f._bucketDBHandler.handleJoin(10, f.bid20, f.bid22, f.bid10);
         EXPECT_FALSE(f.getInfo(f.bid10).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
     }
     { // non-active buckets, active target
         SplitAndJoinFixture f;
@@ -1589,12 +1568,12 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_FALSE(f.getInfo(f.bid22).isActive());
         assertActiveLids(getBoolVector(*f.bid32Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid32Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid32Gids->size(), f.dms.getNumActiveLids());
 
         f._bucketDBHandler.handleJoin(10, f.bid20, f.bid22, f.bid10);
         EXPECT_FALSE(f.getInfo(f.bid10).isActive());
         assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-        EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+        EXPECT_EQ(0u, f.dms.getNumActiveLids());
     }
     { // active buckets, non-active target
         SplitAndJoinFixture f;
@@ -1606,13 +1585,13 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_TRUE(f.getInfo(f.bid22).isActive());
         BoolVector filtered(getBoolVectorFiltered(*f.bid10Gids, 31, f.bid30));
         assertActiveLids(filtered, f.dms.getActiveLids());
-        EXPECT_EQUAL(filtered.countTrue(), f.dms.getNumActiveLids());
+        EXPECT_EQ(filtered.countTrue(), f.dms.getNumActiveLids());
 
         f._bucketDBHandler.handleJoin(10, f.bid20, f.bid22, f.bid10);
         EXPECT_TRUE(f.getInfo(f.bid10).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
     { // active buckets, non-active target
         SplitAndJoinFixture f;
@@ -1624,17 +1603,17 @@ TEST("requireThatActiveStateIsPreservedAfterJoin")
         EXPECT_TRUE(f.getInfo(f.bid22).isActive());
         BoolVector filtered(getBoolVectorFiltered(*f.bid10Gids, 31, f.bid32));
         assertActiveLids(filtered, f.dms.getActiveLids());
-        EXPECT_EQUAL(filtered.countTrue(), f.dms.getNumActiveLids());
+        EXPECT_EQ(filtered.countTrue(), f.dms.getNumActiveLids());
 
         f._bucketDBHandler.handleJoin(10, f.bid20, f.bid22, f.bid10);
         EXPECT_TRUE(f.getInfo(f.bid10).isActive());
         assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                          f.dms.getActiveLids());
-        EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+        EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     }
 }
 
-TEST("requireThatActiveStateIsPreservedAfterEmptyJoin")
+TEST(DocumentMetaStoreTest, active_state_is_preserved_after_empty_join)
 {
     { // non-active buckets
         SplitAndJoinEmptyFixture f;
@@ -1671,31 +1650,30 @@ TEST("requireThatActiveStateIsPreservedAfterEmptyJoin")
     }
 }
 
-TEST("requireThatOverlappingBucketActiveStateWorks")
+TEST(DocumentMetaStoreTest, overlapping_bucket_active_state_works)
 {
     SplitAndJoinFixture f;
     f.insertGids1Mostly(f.bid30);
     assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-    EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+    EXPECT_EQ(0u, f.dms.getNumActiveLids());
     f.dms.setBucketState(f.bid10, true);
     BoolVector filtered(getBoolVectorFiltered(*f.bid10Gids, 31, f.bid30));
     assertActiveLids(filtered, f.dms.getActiveLids());
-    EXPECT_EQUAL(filtered.countTrue(), f.dms.getNumActiveLids());
+    EXPECT_EQ(filtered.countTrue(), f.dms.getNumActiveLids());
     f.dms.setBucketState(f.bid20, true);
     assertActiveLids(getBoolVector(*f.bid10Gids, 31),
                      f.dms.getActiveLids());
-    EXPECT_EQUAL(f.bid10Gids->size(), f.dms.getNumActiveLids());
+    EXPECT_EQ(f.bid10Gids->size(), f.dms.getNumActiveLids());
     f.dms.setBucketState(f.bid10, false);
     assertActiveLids(getBoolVector(*f.bid30Gids, 31),
                      f.dms.getActiveLids());
-    EXPECT_EQUAL(f.bid30Gids->size(), f.dms.getNumActiveLids());
+    EXPECT_EQ(f.bid30Gids->size(), f.dms.getNumActiveLids());
     f.dms.setBucketState(f.bid20, false);
     assertActiveLids(BoolVector(31), f.dms.getActiveLids());
-    EXPECT_EQUAL(0u, f.dms.getNumActiveLids());
+    EXPECT_EQ(0u, f.dms.getNumActiveLids());
 }
 
-struct RemovedFixture
-{
+struct RemovedFixture {
     std::shared_ptr<BucketDBOwner> _bucketDB;
     DocumentMetaStore dms;
     bucketdb::BucketDBHandler _bucketDBHandler;
@@ -1723,117 +1701,117 @@ RemovedFixture::RemovedFixture()
 }
 RemovedFixture::~RemovedFixture() {}
 
-TEST("requireThatRemoveChangedBucketWorks")
+TEST(DocumentMetaStoreTest, remove_changed_bucket_works)
 {
     RemovedFixture f;
     GlobalIdEntry g(1);
     f.dms.constructFreeList();
     f._bucketDBHandler.handleCreateBucket(g.bid1);
     uint32_t addLid1 = addGid(f.dms, g.gid, g.bid1, Timestamp(0));
-    EXPECT_EQUAL(1u, addLid1);
+    EXPECT_EQ(1u, addLid1);
     uint32_t addLid2 = addGid(f.dms, g.gid, g.bid2, Timestamp(0));
     EXPECT_TRUE(1u == addLid2);
     EXPECT_TRUE(f.dms.remove(1u));
     f.dms.removeComplete(1u);
 }
 
-TEST("requireThatGetLidUsageStatsWorks")
+TEST(DocumentMetaStoreTest, get_lid_usage_stats_works)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
 
     LidUsageStats s = dms.getLidUsageStats();
-    EXPECT_EQUAL(1u, s.getLidLimit());
-    EXPECT_EQUAL(0u, s.getUsedLids());
-    EXPECT_EQUAL(1u, s.getLowestFreeLid());
-    EXPECT_EQUAL(0u, s.getHighestUsedLid());
+    EXPECT_EQ(1u, s.getLidLimit());
+    EXPECT_EQ(0u, s.getUsedLids());
+    EXPECT_EQ(1u, s.getLowestFreeLid());
+    EXPECT_EQ(0u, s.getHighestUsedLid());
 
     putGid(dms, createGid(1), 1);
     
     s = dms.getLidUsageStats();
-    EXPECT_EQUAL(2u, s.getLidLimit());
-    EXPECT_EQUAL(1u, s.getUsedLids());
-    EXPECT_EQUAL(2u, s.getLowestFreeLid());
-    EXPECT_EQUAL(1u, s.getHighestUsedLid());
+    EXPECT_EQ(2u, s.getLidLimit());
+    EXPECT_EQ(1u, s.getUsedLids());
+    EXPECT_EQ(2u, s.getLowestFreeLid());
+    EXPECT_EQ(1u, s.getHighestUsedLid());
 
     putGid(dms, createGid(2), 2);
 
     s = dms.getLidUsageStats();
-    EXPECT_EQUAL(3u, s.getLidLimit());
-    EXPECT_EQUAL(2u, s.getUsedLids());
-    EXPECT_EQUAL(3u, s.getLowestFreeLid());
-    EXPECT_EQUAL(2u, s.getHighestUsedLid());
+    EXPECT_EQ(3u, s.getLidLimit());
+    EXPECT_EQ(2u, s.getUsedLids());
+    EXPECT_EQ(3u, s.getLowestFreeLid());
+    EXPECT_EQ(2u, s.getHighestUsedLid());
 
 
     putGid(dms, createGid(3), 3);
 
     s = dms.getLidUsageStats();
-    EXPECT_EQUAL(4u, s.getLidLimit());
-    EXPECT_EQUAL(3u, s.getUsedLids());
-    EXPECT_EQUAL(4u, s.getLowestFreeLid());
-    EXPECT_EQUAL(3u, s.getHighestUsedLid());
+    EXPECT_EQ(4u, s.getLidLimit());
+    EXPECT_EQ(3u, s.getUsedLids());
+    EXPECT_EQ(4u, s.getLowestFreeLid());
+    EXPECT_EQ(3u, s.getHighestUsedLid());
 
     dms.remove(1);
     dms.removeComplete(1);
     
     s = dms.getLidUsageStats();
-    EXPECT_EQUAL(4u, s.getLidLimit());
-    EXPECT_EQUAL(2u, s.getUsedLids());
-    EXPECT_EQUAL(1u, s.getLowestFreeLid());
-    EXPECT_EQUAL(3u, s.getHighestUsedLid());
+    EXPECT_EQ(4u, s.getLidLimit());
+    EXPECT_EQ(2u, s.getUsedLids());
+    EXPECT_EQ(1u, s.getLowestFreeLid());
+    EXPECT_EQ(3u, s.getHighestUsedLid());
 
     dms.remove(3);
     dms.removeComplete(3);
     
     s = dms.getLidUsageStats();
-    EXPECT_EQUAL(4u, s.getLidLimit());
-    EXPECT_EQUAL(1u, s.getUsedLids());
-    EXPECT_EQUAL(1u, s.getLowestFreeLid());
-    EXPECT_EQUAL(2u, s.getHighestUsedLid());
+    EXPECT_EQ(4u, s.getLidLimit());
+    EXPECT_EQ(1u, s.getUsedLids());
+    EXPECT_EQ(1u, s.getLowestFreeLid());
+    EXPECT_EQ(2u, s.getHighestUsedLid());
 
     dms.remove(2);
     dms.removeComplete(2);
     
     s = dms.getLidUsageStats();
-    EXPECT_EQUAL(4u, s.getLidLimit());
-    EXPECT_EQUAL(0u, s.getUsedLids());
-    EXPECT_EQUAL(1u, s.getLowestFreeLid());
-    EXPECT_EQUAL(0u, s.getHighestUsedLid());
+    EXPECT_EQ(4u, s.getLidLimit());
+    EXPECT_EQ(0u, s.getUsedLids());
+    EXPECT_EQ(1u, s.getLowestFreeLid());
+    EXPECT_EQ(0u, s.getHighestUsedLid());
 }
 
-bool
+void
 assertLidBloat(uint32_t expBloat, uint32_t lidLimit, uint32_t usedLids)
 {
     LidUsageStats stats(lidLimit, usedLids, 0, 0);
-    return  EXPECT_EQUAL(expBloat, stats.getLidBloat());
+    EXPECT_EQ(expBloat, stats.getLidBloat());
 }
 
-TEST("require that LidUsageStats::getLidBloat() works")
+TEST(LidUsageStatsTest, lid_bloat_is_calculated)
 {
     assertLidBloat(4, 10, 5);
     assertLidBloat(0, 1, 0);
     assertLidBloat(0, 1, 1);
 }
 
-TEST("requireThatMoveWorks")
+TEST(DocumentMetaStoreTest, move_works)
 {
     DocumentMetaStore dms(createBucketDB());
     GlobalId gid;
     uint32_t lid = 0u;
     dms.constructFreeList();
     
-    EXPECT_EQUAL(1u, dms.getNumDocs());
-    EXPECT_EQUAL(0u, dms.getNumUsedLids());
-    EXPECT_TRUE(assertPut(bucketId1, time1, 1u, gid1, dms));
-    EXPECT_EQUAL(2u, dms.getNumDocs());
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
-    EXPECT_TRUE(assertPut(bucketId2, time2, 2u, gid2, dms));
-    EXPECT_EQUAL(3u, dms.getNumDocs());
-    EXPECT_EQUAL(2u, dms.getNumUsedLids());
+    EXPECT_EQ(1u, dms.getNumDocs());
+    EXPECT_EQ(0u, dms.getNumUsedLids());
+    assertPut(bucketId1, time1, 1u, gid1, dms);
+    EXPECT_EQ(2u, dms.getNumDocs());
+    EXPECT_EQ(1u, dms.getNumUsedLids());
+    assertPut(bucketId2, time2, 2u, gid2, dms);
+    EXPECT_EQ(3u, dms.getNumDocs());
+    EXPECT_EQ(2u, dms.getNumUsedLids());
     EXPECT_TRUE(dms.getGid(1u, gid));
     EXPECT_TRUE(dms.getLid(gid2, lid));
-    EXPECT_EQUAL(gid1, gid);
-    EXPECT_EQUAL(2u, lid);
+    EXPECT_EQ(gid1, gid);
+    EXPECT_EQ(2u, lid);
     EXPECT_TRUE(dms.remove(1));
     EXPECT_FALSE(dms.getGid(1u, gid));
     EXPECT_FALSE(dms.getGidEvenIfMoved(1u, gid));
@@ -1842,7 +1820,7 @@ TEST("requireThatMoveWorks")
     EXPECT_FALSE(dms.getGid(1u, gid));
     EXPECT_FALSE(dms.getGidEvenIfMoved(1u, gid));
     EXPECT_TRUE(dms.getGid(2u, gid));
-    EXPECT_EQUAL(1u, dms.getNumUsedLids());
+    EXPECT_EQ(1u, dms.getNumUsedLids());
     dms.move(2u, 1u);
     EXPECT_TRUE(dms.getGid(1u, gid));
     EXPECT_FALSE(dms.getGid(2u, gid));
@@ -1852,11 +1830,11 @@ TEST("requireThatMoveWorks")
     EXPECT_FALSE(dms.getGid(2u, gid));
     EXPECT_TRUE(dms.getGidEvenIfMoved(2u, gid));
     EXPECT_TRUE(dms.getLid(gid2, lid));
-    EXPECT_EQUAL(gid2, gid);
-    EXPECT_EQUAL(1u, lid);
+    EXPECT_EQ(gid2, gid);
+    EXPECT_EQ(1u, lid);
 }
 
-bool
+void
 assertLidSpace(uint32_t numDocs,
                uint32_t committedDocIdLimit,
                uint32_t numUsedLids,
@@ -1864,12 +1842,11 @@ assertLidSpace(uint32_t numDocs,
                bool canShrinkLidSpace,
                const DocumentMetaStore &dms)
 {
-    if (!EXPECT_EQUAL(numDocs, dms.getNumDocs())) return false;
-    if (!EXPECT_EQUAL(committedDocIdLimit, dms.getCommittedDocIdLimit())) return false;
-    if (!EXPECT_EQUAL(numUsedLids, dms.getNumUsedLids())) return false;
-    if (!EXPECT_EQUAL(wantShrinkLidSpace, dms.wantShrinkLidSpace())) return false;
-    if (!EXPECT_EQUAL(canShrinkLidSpace, dms.canShrinkLidSpace())) return false;
-    return true;
+    EXPECT_EQ(numDocs, dms.getNumDocs());
+    EXPECT_EQ(committedDocIdLimit, dms.getCommittedDocIdLimit());
+    EXPECT_EQ(numUsedLids, dms.getNumUsedLids());
+    EXPECT_EQ(wantShrinkLidSpace, dms.wantShrinkLidSpace());
+    EXPECT_EQ(canShrinkLidSpace, dms.canShrinkLidSpace());
 }
 
 void
@@ -1879,7 +1856,7 @@ populate(uint32_t endLid, DocumentMetaStore &dms)
         GlobalId gid = createGid(lid);
         putGid(dms, gid, lid, Timestamp(10000 + lid));
     }
-    EXPECT_TRUE(assertLidSpace(endLid, endLid, endLid - 1, false, false, dms));
+    assertLidSpace(endLid, endLid, endLid - 1, false, false, dms);
 }
 
 void
@@ -1891,7 +1868,7 @@ remove(uint32_t startLid, uint32_t shrinkTarget, DocumentMetaStore &dms)
     }
 }
 
-TEST("requireThatShrinkWorks")
+TEST(DocumentMetaStoreTest, shrink_works)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
@@ -1900,20 +1877,19 @@ TEST("requireThatShrinkWorks")
 
     uint32_t shrinkTarget = 5;
     remove(9, shrinkTarget, dms);
-    EXPECT_TRUE(assertLidSpace(10, 10, shrinkTarget - 1, false, false, dms));
+    assertLidSpace(10, 10, shrinkTarget - 1, false, false, dms);
 
     dms.compactLidSpace(shrinkTarget);
-    EXPECT_TRUE(assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, false, dms));
+    assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, false, dms);
 
     dms.holdUnblockShrinkLidSpace();
-    EXPECT_TRUE(assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, true, dms));
+    assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, true, dms);
 
     dms.shrinkLidSpace();
-    EXPECT_TRUE(assertLidSpace(shrinkTarget, shrinkTarget, shrinkTarget - 1, false, false, dms));
+    assertLidSpace(shrinkTarget, shrinkTarget, shrinkTarget - 1, false, false, dms);
 }
 
-
-TEST("requireThatShrinkViaFlushTargetWorks")
+TEST(DocumentMetaStoreTest, shrink_via_flush_target_works)
 {
     DocumentMetaStore::SP dms(new DocumentMetaStore(createBucketDB()));
     dms->constructFreeList();
@@ -1931,24 +1907,24 @@ TEST("requireThatShrinkViaFlushTargetWorks")
 
     uint32_t shrinkTarget = 5;
     remove(9, shrinkTarget, *dms);
-    EXPECT_TRUE(assertLidSpace(10, 10, shrinkTarget - 1, false, false, *dms));
-    EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(),
-                 ft->getApproxMemoryGain().getAfter());
+    assertLidSpace(10, 10, shrinkTarget - 1, false, false, *dms);
+    EXPECT_EQ(ft->getApproxMemoryGain().getBefore(),
+              ft->getApproxMemoryGain().getAfter());
 
     dms->compactLidSpace(shrinkTarget);
-    EXPECT_TRUE(assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, false, *dms));
-    EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(),
-                 ft->getApproxMemoryGain().getAfter());
+    assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, false, *dms);
+    EXPECT_EQ(ft->getApproxMemoryGain().getBefore(),
+              ft->getApproxMemoryGain().getAfter());
     AttributeGuard::UP g(new AttributeGuard(dms));
 
     dms->holdUnblockShrinkLidSpace();
-    EXPECT_TRUE(assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, false, *dms));
-    EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(),
-                 ft->getApproxMemoryGain().getAfter());
+    assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, false, *dms);
+    EXPECT_EQ(ft->getApproxMemoryGain().getBefore(),
+              ft->getApproxMemoryGain().getAfter());
 
     g.reset();
     dms->removeAllOldGenerations();
-    EXPECT_TRUE(assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, true, *dms));
+    assertLidSpace(10, shrinkTarget, shrinkTarget - 1, true, true, *dms);
     EXPECT_TRUE(ft->getApproxMemoryGain().getBefore() >
                 ft->getApproxMemoryGain().getAfter());
 
@@ -1957,12 +1933,11 @@ TEST("requireThatShrinkViaFlushTargetWorks")
     exec.execute(std::move(task));
     exec.sync();
     exec.shutdown();
-    EXPECT_TRUE(assertLidSpace(shrinkTarget, shrinkTarget, shrinkTarget - 1, false, false, *dms));
-    EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(),
-                 ft->getApproxMemoryGain().getAfter());
+    assertLidSpace(shrinkTarget, shrinkTarget, shrinkTarget - 1, false, false, *dms);
+    EXPECT_EQ(ft->getApproxMemoryGain().getBefore(),
+              ft->getApproxMemoryGain().getAfter());
 }
 
-
 namespace {
 
 void
@@ -1972,7 +1947,7 @@ addLid(DocumentMetaStore &dms, uint32_t lid, uint32_t docSize = 1)
     BucketId bucketId(gid.convertToBucketId());
     bucketId.setUsedBits(numBucketBits);
     uint32_t addedLid = addGid(dms, gid, bucketId, Timestamp(lid + timestampBias), docSize);
-    EXPECT_EQUAL(lid, addedLid);
+    EXPECT_EQ(lid, addedLid);
 }
 
 void
@@ -1980,7 +1955,7 @@ assertSize(DocumentMetaStore &dms, uint32_t lid, uint32_t expSize)
 {
     EXPECT_TRUE(dms.validLid(lid));
     const auto &metaData = dms.getRawMetaData(lid);
-    EXPECT_EQUAL(expSize, metaData.getDocSize());
+    EXPECT_EQ(expSize, metaData.getDocSize());
 }
 
 void
@@ -1990,59 +1965,55 @@ removeLid(DocumentMetaStore &dms, uint32_t lid)
     dms.removeComplete(lid);
 }
 
-
 void
 assertCompact(DocumentMetaStore &dms, uint32_t docIdLimit,
               uint32_t committedDocIdLimit,
               uint32_t compactTarget, uint32_t numUsedLids)
 {
-    EXPECT_TRUE(assertLidSpace(docIdLimit, committedDocIdLimit, numUsedLids, false, false, dms));
+    assertLidSpace(docIdLimit, committedDocIdLimit, numUsedLids, false, false, dms);
     dms.compactLidSpace(compactTarget);
-    EXPECT_TRUE(assertLidSpace(docIdLimit, compactTarget, numUsedLids, true, false, dms));
+    assertLidSpace(docIdLimit, compactTarget, numUsedLids, true, false, dms);
     dms.holdUnblockShrinkLidSpace();
-    EXPECT_TRUE(assertLidSpace(docIdLimit, compactTarget, numUsedLids, true, true, dms));
+    assertLidSpace(docIdLimit, compactTarget, numUsedLids, true, true, dms);
 }
 
-
 void
-assertShrink(DocumentMetaStore &dms, uint32_t shrinkTarget,
-             uint32_t numUsedLids)
+assertShrink(DocumentMetaStore &dms, uint32_t shrinkTarget, uint32_t numUsedLids)
 {
     dms.shrinkLidSpace();
-    TEST_DO(EXPECT_TRUE(assertLidSpace(shrinkTarget, shrinkTarget, numUsedLids, false, false, dms)));
+    assertLidSpace(shrinkTarget, shrinkTarget, numUsedLids, false, false, dms);
 }
 
 }
 
-
-TEST("requireThatSecondShrinkWorksAfterCompactAndInactiveInsert")
+TEST(DocumentMetaStoreTest, second_shrink_works_after_compact_and_inactive_insert)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
-    TEST_DO(addLid(dms, 1));
-    TEST_DO(addLid(dms, 2));
-    TEST_DO(addLid(dms, 3));
+    addLid(dms, 1);
+    addLid(dms, 2);
+    addLid(dms, 3);
     removeLid(dms, 2);
     removeLid(dms, 3);
-    EXPECT_TRUE(assertLidSpace(4, 4, 1, false, false, dms));
-    TEST_DO(assertCompact(dms, 4, 4, 2, 1));
-    TEST_DO(addLid(dms, 2));
-    TEST_DO(assertShrink(dms, 3, 2));
+    assertLidSpace(4, 4, 1, false, false, dms);
+    assertCompact(dms, 4, 4, 2, 1);
+    addLid(dms, 2);
+    assertShrink(dms, 3, 2);
     removeLid(dms, 2);
-    TEST_DO(assertCompact(dms, 3, 3, 2, 1));
-    TEST_DO(assertShrink(dms, 2, 1));
+    assertCompact(dms, 3, 3, 2, 1);
+    assertShrink(dms, 2, 1);
 }
 
-TEST("require that document sizes are saved")
+TEST(DocumentMetaStoreTest, document_sizes_are_saved)
 {
     DocumentMetaStore dms1(createBucketDB());
     dms1.constructFreeList();
-    TEST_DO(addLid(dms1, 1, 100));
-    TEST_DO(addLid(dms1, 2, 10000));
-    TEST_DO(addLid(dms1, 3, 100000000));
-    TEST_DO(assertSize(dms1, 1, 100));
-    TEST_DO(assertSize(dms1, 2, 10000));
-    TEST_DO(assertSize(dms1, 3, (1u << 24) - 1));
+    addLid(dms1, 1, 100);
+    addLid(dms1, 2, 10000);
+    addLid(dms1, 3, 100000000);
+    assertSize(dms1, 1, 100);
+    assertSize(dms1, 2, 10000);
+    assertSize(dms1, 3, (1u << 24) - 1);
 
     TuneFileAttributes tuneFileAttributes;
     DummyFileHeaderContext fileHeaderContext;
@@ -2054,16 +2025,16 @@ TEST("require that document sizes are saved")
     DocumentMetaStore dms3(createBucketDB(), "documentmetastore3");
     EXPECT_TRUE(dms3.load());
     dms3.constructFreeList();
-    TEST_DO(assertSize(dms3, 1, 100));
-    TEST_DO(assertSize(dms3, 2, 10000));
-    TEST_DO(assertSize(dms3, 3, (1u << 24) - 1));
+    assertSize(dms3, 1, 100);
+    assertSize(dms3, 2, 10000);
+    assertSize(dms3, 3, (1u << 24) - 1);
 
     DocumentMetaStore dms4(createBucketDB(), "documentmetastore4");
     EXPECT_TRUE(dms4.load());
     dms4.constructFreeList();
-    TEST_DO(assertSize(dms4, 1, 1));
-    TEST_DO(assertSize(dms4, 2, 1));
-    TEST_DO(assertSize(dms4, 3, 1));
+    assertSize(dms4, 1, 1);
+    assertSize(dms4, 2, 1);
+    assertSize(dms4, 3, 1);
 }
 
 namespace {
@@ -2072,8 +2043,8 @@ void
 assertLidGidFound(uint32_t lid, DocumentMetaStore &dms)
 {
     GlobalId gid = createGid(lid);
-    EXPECT_TRUE(assertLid(lid, gid, dms));
-    EXPECT_TRUE(assertGid(gid, lid, dms));
+    assertLid(lid, gid, dms);
+    assertGid(gid, lid, dms);
     EXPECT_TRUE(dms.validLid(lid));
 }
 
@@ -2090,32 +2061,29 @@ assertLidGidNotFound(uint32_t lid, DocumentMetaStore &dms)
 
 }
 
-TEST("require that multiple lids can be removed with removeBatch()")
+TEST(DocumentMetaStoreTest, multiple_lids_can_be_removed_with_removeBatch)
 {
     DocumentMetaStore dms(createBucketDB());
     dms.constructFreeList();
-    TEST_DO(addLid(dms, 1));
-    TEST_DO(addLid(dms, 2));
-    TEST_DO(addLid(dms, 3));
-    TEST_DO(addLid(dms, 4));
+    addLid(dms, 1);
+    addLid(dms, 2);
+    addLid(dms, 3);
+    addLid(dms, 4);
 
-    TEST_DO(assertLidGidFound(1, dms));
-    TEST_DO(assertLidGidFound(2, dms));
-    TEST_DO(assertLidGidFound(3, dms));
-    TEST_DO(assertLidGidFound(4, dms));
+    assertLidGidFound(1, dms);
+    assertLidGidFound(2, dms);
+    assertLidGidFound(3, dms);
+    assertLidGidFound(4, dms);
 
     dms.removeBatch({1, 3}, 5);
     dms.removeBatchComplete({1, 3});
 
-    TEST_DO(assertLidGidNotFound(1, dms));
-    TEST_DO(assertLidGidFound(2, dms));
-    TEST_DO(assertLidGidNotFound(3, dms));
-    TEST_DO(assertLidGidFound(4, dms));
+    assertLidGidNotFound(1, dms);
+    assertLidGidFound(2, dms);
+    assertLidGidNotFound(3, dms);
+    assertLidGidFound(4, dms);
 }
 
 }
 
-TEST_MAIN()
-{
-    TEST_RUN_ALL();
-}
+GTEST_MAIN_RUN_ALL_TESTS()