1 files changed, 79 insertions, 134 deletions

diff --git a/storage/src/tests/storageserver/documentapiconvertertest.cpp b/storage/src/tests/storageserver/documentapiconvertertest.cpp
index 7f8b1b8f34a..c879f7d2779 100644
--- a/storage/src/tests/storageserver/documentapiconvertertest.cpp
+++ b/storage/src/tests/storageserver/documentapiconvertertest.cpp
@@ -1,6 +1,5 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <cppunit/extensions/HelperMacros.h>
 #include <vespa/config/subscription/configuri.h>
 #include <vespa/document/base/testdocrepo.h>
 #include <vespa/document/bucket/bucketidfactory.h>
@@ -17,7 +16,7 @@
 #include <vespa/storageapi/message/persistence.h>
 #include <vespa/storageapi/message/removelocation.h>
 #include <vespa/storageapi/message/stat.h>
-#include <vespa/vespalib/testkit/test_kit.h>
+#include <vespa/vespalib/gtest/gtest.h>
 
 using document::Bucket;
 using document::BucketId;
@@ -29,6 +28,7 @@ using document::DocumentId;
 using document::DocumentTypeRepo;
 using document::readDocumenttypesConfig;
 using document::test::makeDocumentBucket;
+using namespace ::testing;
 
 namespace storage {
 
@@ -58,8 +58,7 @@ struct MockBucketResolver : public BucketResolver {
     }
 };
 
-struct DocumentApiConverterTest : public CppUnit::TestFixture
-{
+struct DocumentApiConverterTest : Test {
     std::shared_ptr<MockBucketResolver> _bucketResolver;
     std::unique_ptr<DocumentApiConverter> _converter;
     const std::shared_ptr<const DocumentTypeRepo> _repo;
@@ -67,20 +66,19 @@ struct DocumentApiConverterTest : public CppUnit::TestFixture
 
     DocumentApiConverterTest()
         : _bucketResolver(std::make_shared<MockBucketResolver>()),
-          _repo(std::make_shared<DocumentTypeRepo>(readDocumenttypesConfig(
-                    TEST_PATH("config-doctypes.cfg")))),
+          _repo(std::make_shared<DocumentTypeRepo>(readDocumenttypesConfig("../config-doctypes.cfg"))),
           _html_type(*_repo->getDocumentType("text/html"))
     {
     }
 
-    void setUp() override {
-        _converter.reset(new DocumentApiConverter("raw:", _bucketResolver));
+    void SetUp() override {
+        _converter = std::make_unique<DocumentApiConverter>("raw:", _bucketResolver);
     };
 
     template <typename DerivedT, typename BaseT>
     std::unique_ptr<DerivedT> dynamic_unique_ptr_cast(std::unique_ptr<BaseT> base) {
         auto derived = dynamic_cast<DerivedT*>(base.get());
-        CPPUNIT_ASSERT(derived);
+        assert(derived);
         base.release();
         return std::unique_ptr<DerivedT>(derived);
     }
@@ -103,162 +101,119 @@ struct DocumentApiConverterTest : public CppUnit::TestFixture
         auto result = _converter->toDocumentAPI(cmd);
         return dynamic_unique_ptr_cast<T>(std::move(result));
     }
-
-    void testPut();
-    void testForwardedPut();
-    void testUpdate();
-    void testRemove();
-    void testGet();
-    void testCreateVisitor();
-    void testCreateVisitorHighTimeout();
-    void testCreateVisitorReplyNotReady();
-    void testCreateVisitorReplyLastBucket();
-    void testDestroyVisitor();
-    void testVisitorInfo();
-    void testStatBucket();
-    void testGetBucketList();
-    void testRemoveLocation();
-    void can_replace_bucket_resolver_after_construction();
-
-    CPPUNIT_TEST_SUITE(DocumentApiConverterTest);
-    CPPUNIT_TEST(testPut);
-    CPPUNIT_TEST(testForwardedPut);
-    CPPUNIT_TEST(testUpdate);
-    CPPUNIT_TEST(testRemove);
-    CPPUNIT_TEST(testGet);
-    CPPUNIT_TEST(testCreateVisitor);
-    CPPUNIT_TEST(testCreateVisitorHighTimeout);
-    CPPUNIT_TEST(testCreateVisitorReplyNotReady);
-    CPPUNIT_TEST(testCreateVisitorReplyLastBucket);
-    CPPUNIT_TEST(testDestroyVisitor);
-    CPPUNIT_TEST(testVisitorInfo);
-    CPPUNIT_TEST(testStatBucket);
-    CPPUNIT_TEST(testGetBucketList);
-    CPPUNIT_TEST(testRemoveLocation);
-    CPPUNIT_TEST(can_replace_bucket_resolver_after_construction);
-    CPPUNIT_TEST_SUITE_END();
 };
 
-CPPUNIT_TEST_SUITE_REGISTRATION(DocumentApiConverterTest);
-
-void DocumentApiConverterTest::testPut()
-{
+TEST_F(DocumentApiConverterTest, put) {
     auto doc = std::make_shared<Document>(_html_type, defaultDocId);
 
     documentapi::PutDocumentMessage putmsg(doc);
     putmsg.setTimestamp(1234);
 
     auto cmd = toStorageAPI<api::PutCommand>(putmsg);
-    CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
-    CPPUNIT_ASSERT(cmd->getDocument().get() == doc.get());
+    EXPECT_EQ(defaultBucket, cmd->getBucket());
+    ASSERT_EQ(cmd->getDocument().get(), doc.get());
 
     std::unique_ptr<mbus::Reply> reply = putmsg.createReply();
-    CPPUNIT_ASSERT(reply.get());
+    ASSERT_TRUE(reply.get());
 
     toStorageAPI<api::PutReply>(*reply, *cmd);
 
     auto mbusPut = toDocumentAPI<documentapi::PutDocumentMessage>(*cmd);
-    CPPUNIT_ASSERT(mbusPut->getDocumentSP().get() == doc.get());
-    CPPUNIT_ASSERT(mbusPut->getTimestamp() == 1234);
+    ASSERT_EQ(mbusPut->getDocumentSP().get(), doc.get());
+    EXPECT_EQ(mbusPut->getTimestamp(), 1234);
 }
 
-void DocumentApiConverterTest::testForwardedPut()
-{
+TEST_F(DocumentApiConverterTest, forwarded_put) {
     auto doc = std::make_shared<Document>(_html_type, DocumentId(DocIdString("test", "test")));
 
-    documentapi::PutDocumentMessage* putmsg = new documentapi::PutDocumentMessage(doc);
-    std::unique_ptr<mbus::Reply> reply(((documentapi::DocumentMessage*)putmsg)->createReply());
-    reply->setMessage(std::unique_ptr<mbus::Message>(putmsg));
+    auto putmsg = std::make_unique<documentapi::PutDocumentMessage>(doc);
+    auto* putmsg_raw = putmsg.get();
+    std::unique_ptr<mbus::Reply> reply(putmsg->createReply());
+    reply->setMessage(std::unique_ptr<mbus::Message>(putmsg.release()));
 
-    auto cmd = toStorageAPI<api::PutCommand>(*putmsg);
+    auto cmd = toStorageAPI<api::PutCommand>(*putmsg_raw);
     cmd->setTimestamp(1234);
 
     auto rep = dynamic_unique_ptr_cast<api::PutReply>(cmd->makeReply());
     _converter->transferReplyState(*rep, *reply);
 }
 
-void DocumentApiConverterTest::testUpdate()
-{
+TEST_F(DocumentApiConverterTest, update) {
     auto update = std::make_shared<document::DocumentUpdate>(*_repo, _html_type, defaultDocId);
     documentapi::UpdateDocumentMessage updateMsg(update);
     updateMsg.setOldTimestamp(1234);
     updateMsg.setNewTimestamp(5678);
 
     auto updateCmd = toStorageAPI<api::UpdateCommand>(updateMsg);
-    CPPUNIT_ASSERT_EQUAL(defaultBucket, updateCmd->getBucket());
-    CPPUNIT_ASSERT_EQUAL(update.get(), updateCmd->getUpdate().get());
-    CPPUNIT_ASSERT_EQUAL(api::Timestamp(1234), updateCmd->getOldTimestamp());
-    CPPUNIT_ASSERT_EQUAL(api::Timestamp(5678), updateCmd->getTimestamp());
+    EXPECT_EQ(defaultBucket, updateCmd->getBucket());
+    ASSERT_EQ(update.get(), updateCmd->getUpdate().get());
+    EXPECT_EQ(api::Timestamp(1234), updateCmd->getOldTimestamp());
+    EXPECT_EQ(api::Timestamp(5678), updateCmd->getTimestamp());
 
     auto mbusReply = updateMsg.createReply();
-    CPPUNIT_ASSERT(mbusReply.get());
+    ASSERT_TRUE(mbusReply.get());
     toStorageAPI<api::UpdateReply>(*mbusReply, *updateCmd);
 
     auto mbusUpdate = toDocumentAPI<documentapi::UpdateDocumentMessage>(*updateCmd);
-    CPPUNIT_ASSERT((&mbusUpdate->getDocumentUpdate()) == update.get());
-    CPPUNIT_ASSERT_EQUAL(api::Timestamp(1234), mbusUpdate->getOldTimestamp());
-    CPPUNIT_ASSERT_EQUAL(api::Timestamp(5678), mbusUpdate->getNewTimestamp());
+    ASSERT_EQ((&mbusUpdate->getDocumentUpdate()), update.get());
+    EXPECT_EQ(api::Timestamp(1234), mbusUpdate->getOldTimestamp());
+    EXPECT_EQ(api::Timestamp(5678), mbusUpdate->getNewTimestamp());
 }
 
-void DocumentApiConverterTest::testRemove()
-{
+TEST_F(DocumentApiConverterTest, remove) {
     documentapi::RemoveDocumentMessage removemsg(defaultDocId);
     auto cmd = toStorageAPI<api::RemoveCommand>(removemsg);
-    CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
-    CPPUNIT_ASSERT_EQUAL(defaultDocId, cmd->getDocumentId());
+    EXPECT_EQ(defaultBucket, cmd->getBucket());
+    EXPECT_EQ(defaultDocId, cmd->getDocumentId());
 
     std::unique_ptr<mbus::Reply> reply = removemsg.createReply();
-    CPPUNIT_ASSERT(reply.get());
+    ASSERT_TRUE(reply.get());
 
     toStorageAPI<api::RemoveReply>(*reply, *cmd);
 
     auto mbusRemove = toDocumentAPI<documentapi::RemoveDocumentMessage>(*cmd);
-    CPPUNIT_ASSERT_EQUAL(defaultDocId, mbusRemove->getDocumentId());
+    EXPECT_EQ(defaultDocId, mbusRemove->getDocumentId());
 }
 
-void DocumentApiConverterTest::testGet()
-{
+TEST_F(DocumentApiConverterTest, get) {
     documentapi::GetDocumentMessage getmsg(defaultDocId, "foo bar");
 
     auto cmd = toStorageAPI<api::GetCommand>(getmsg);
-    CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
-    CPPUNIT_ASSERT_EQUAL(defaultDocId, cmd->getDocumentId());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("foo bar"), cmd->getFieldSet());
+    EXPECT_EQ(defaultBucket, cmd->getBucket());
+    EXPECT_EQ(defaultDocId, cmd->getDocumentId());
+    EXPECT_EQ("foo bar", cmd->getFieldSet());
 }
 
-void DocumentApiConverterTest::testCreateVisitor()
-{
+TEST_F(DocumentApiConverterTest, create_visitor) {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
     cv.setBucketSpace(defaultSpaceName);
     cv.setTimeRemaining(123456);
 
     auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
-    CPPUNIT_ASSERT_EQUAL(defaultBucketSpace, cmd->getBucket().getBucketSpace());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("mylib"), cmd->getLibraryName());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), cmd->getInstanceId());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("control-dest"), cmd->getControlDestination());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("data-dest"), cmd->getDataDestination());
-    CPPUNIT_ASSERT_EQUAL(123456u, cmd->getTimeout());
+    EXPECT_EQ(defaultBucketSpace, cmd->getBucket().getBucketSpace());
+    EXPECT_EQ("mylib", cmd->getLibraryName());
+    EXPECT_EQ("myinstance", cmd->getInstanceId());
+    EXPECT_EQ("control-dest", cmd->getControlDestination());
+    EXPECT_EQ("data-dest", cmd->getDataDestination());
+    EXPECT_EQ(123456u, cmd->getTimeout());
 
     auto msg = toDocumentAPI<documentapi::CreateVisitorMessage>(*cmd);
-    CPPUNIT_ASSERT_EQUAL(defaultSpaceName, msg->getBucketSpace());
+    EXPECT_EQ(defaultSpaceName, msg->getBucketSpace());
 }
 
-void DocumentApiConverterTest::testCreateVisitorHighTimeout()
-{
+TEST_F(DocumentApiConverterTest, create_visitor_high_timeout) {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
     cv.setTimeRemaining((uint64_t)std::numeric_limits<uint32_t>::max() + 1); // Will be INT_MAX
 
     auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("mylib"), cmd->getLibraryName());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), cmd->getInstanceId());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("control-dest"), cmd->getControlDestination());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("data-dest"), cmd->getDataDestination());
-    CPPUNIT_ASSERT_EQUAL((uint32_t) std::numeric_limits<int32_t>::max(), cmd->getTimeout());
+    EXPECT_EQ("mylib", cmd->getLibraryName());
+    EXPECT_EQ("myinstance", cmd->getInstanceId());
+    EXPECT_EQ("control-dest", cmd->getControlDestination());
+    EXPECT_EQ("data-dest", cmd->getDataDestination());
+    EXPECT_EQ(std::numeric_limits<int32_t>::max(), cmd->getTimeout());
 }
 
-void DocumentApiConverterTest::testCreateVisitorReplyNotReady()
-{
+TEST_F(DocumentApiConverterTest, create_visitor_reply_not_ready) {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
 
     auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
@@ -267,14 +222,13 @@ void DocumentApiConverterTest::testCreateVisitorReplyNotReady()
 
     std::unique_ptr<documentapi::CreateVisitorReply> reply(
             dynamic_cast<documentapi::CreateVisitorReply*>(cv.createReply().release()));
-    CPPUNIT_ASSERT(reply.get());
+    ASSERT_TRUE(reply.get());
     _converter->transferReplyState(cvr, *reply);
-    CPPUNIT_ASSERT_EQUAL((uint32_t)documentapi::DocumentProtocol::ERROR_NODE_NOT_READY, reply->getError(0).getCode());
-    CPPUNIT_ASSERT_EQUAL(document::BucketId(std::numeric_limits<int>::max()), reply->getLastBucket());
+    EXPECT_EQ(documentapi::DocumentProtocol::ERROR_NODE_NOT_READY, reply->getError(0).getCode());
+    EXPECT_EQ(document::BucketId(std::numeric_limits<int>::max()), reply->getLastBucket());
 }
 
-void DocumentApiConverterTest::testCreateVisitorReplyLastBucket()
-{
+TEST_F(DocumentApiConverterTest, create_visitor_reply_last_bucket) {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
 
     auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
@@ -283,75 +237,66 @@ void DocumentApiConverterTest::testCreateVisitorReplyLastBucket()
     std::unique_ptr<documentapi::CreateVisitorReply> reply(
             dynamic_cast<documentapi::CreateVisitorReply*>(cv.createReply().release()));
 
-    CPPUNIT_ASSERT(reply.get());
+    ASSERT_TRUE(reply.get());
     _converter->transferReplyState(cvr, *reply);
-    CPPUNIT_ASSERT_EQUAL(document::BucketId(123), reply->getLastBucket());
+    EXPECT_EQ(document::BucketId(123), reply->getLastBucket());
 }
 
-void DocumentApiConverterTest::testDestroyVisitor()
-{
+TEST_F(DocumentApiConverterTest, destroy_visitor) {
     documentapi::DestroyVisitorMessage cv("myinstance");
 
     auto cmd = toStorageAPI<api::DestroyVisitorCommand>(cv);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), cmd->getInstanceId());
+    EXPECT_EQ("myinstance", cmd->getInstanceId());
 }
 
-void
-DocumentApiConverterTest::testVisitorInfo()
-{
+TEST_F(DocumentApiConverterTest, visitor_info) {
     api::VisitorInfoCommand vicmd;
     std::vector<api::VisitorInfoCommand::BucketTimestampPair> bucketsCompleted;
-    bucketsCompleted.push_back(api::VisitorInfoCommand::BucketTimestampPair(document::BucketId(16, 1), 0));
-    bucketsCompleted.push_back(api::VisitorInfoCommand::BucketTimestampPair(document::BucketId(16, 2), 0));
-    bucketsCompleted.push_back(api::VisitorInfoCommand::BucketTimestampPair(document::BucketId(16, 4), 0));
+    bucketsCompleted.emplace_back(document::BucketId(16, 1), 0);
+    bucketsCompleted.emplace_back(document::BucketId(16, 2), 0);
+    bucketsCompleted.emplace_back(document::BucketId(16, 4), 0);
 
     vicmd.setBucketsCompleted(bucketsCompleted);
 
     auto mbusvi = toDocumentAPI<documentapi::VisitorInfoMessage>(vicmd);
-    CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1), mbusvi->getFinishedBuckets()[0]);
-    CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 2), mbusvi->getFinishedBuckets()[1]);
-    CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 4), mbusvi->getFinishedBuckets()[2]);
+    EXPECT_EQ(document::BucketId(16, 1), mbusvi->getFinishedBuckets()[0]);
+    EXPECT_EQ(document::BucketId(16, 2), mbusvi->getFinishedBuckets()[1]);
+    EXPECT_EQ(document::BucketId(16, 4), mbusvi->getFinishedBuckets()[2]);
 
     std::unique_ptr<mbus::Reply> reply = mbusvi->createReply();
-    CPPUNIT_ASSERT(reply.get());
+    ASSERT_TRUE(reply.get());
 
     toStorageAPI<api::VisitorInfoReply>(*reply, vicmd);
 }
 
-void
-DocumentApiConverterTest::testStatBucket()
-{
+TEST_F(DocumentApiConverterTest, stat_bucket) {
     documentapi::StatBucketMessage msg(BucketId(123), "");
     msg.setBucketSpace(defaultSpaceName);
 
     auto cmd = toStorageAPI<api::StatBucketCommand>(msg);
-    CPPUNIT_ASSERT_EQUAL(Bucket(defaultBucketSpace, BucketId(123)), cmd->getBucket());
+    EXPECT_EQ(Bucket(defaultBucketSpace, BucketId(123)), cmd->getBucket());
 
     auto mbusMsg = toDocumentAPI<documentapi::StatBucketMessage>(*cmd);
-    CPPUNIT_ASSERT_EQUAL(BucketId(123), mbusMsg->getBucketId());
-    CPPUNIT_ASSERT_EQUAL(defaultSpaceName, mbusMsg->getBucketSpace());
+    EXPECT_EQ(BucketId(123), mbusMsg->getBucketId());
+    EXPECT_EQ(defaultSpaceName, mbusMsg->getBucketSpace());
 }
 
-void
-DocumentApiConverterTest::testGetBucketList()
-{
+TEST_F(DocumentApiConverterTest, get_bucket_list) {
     documentapi::GetBucketListMessage msg(BucketId(123));
     msg.setBucketSpace(defaultSpaceName);
 
     auto cmd = toStorageAPI<api::GetBucketListCommand>(msg);
-    CPPUNIT_ASSERT_EQUAL(Bucket(defaultBucketSpace, BucketId(123)), cmd->getBucket());
+    EXPECT_EQ(Bucket(defaultBucketSpace, BucketId(123)), cmd->getBucket());
 }
 
-void
-DocumentApiConverterTest::testRemoveLocation()
-{
+TEST_F(DocumentApiConverterTest, remove_location) {
     document::BucketIdFactory factory;
     document::select::Parser parser(*_repo, factory);
     documentapi::RemoveLocationMessage msg(factory, parser, "id.group == \"mygroup\"");
     msg.setBucketSpace(defaultSpaceName);
 
     auto cmd = toStorageAPI<api::RemoveLocationCommand>(msg);
-    CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
+    EXPECT_EQ(defaultBucket, cmd->getBucket());
 }
 
 namespace {
@@ -367,16 +312,16 @@ struct ReplacementMockBucketResolver : public MockBucketResolver {
 
 }
 
-void DocumentApiConverterTest::can_replace_bucket_resolver_after_construction() {
+TEST_F(DocumentApiConverterTest, can_replace_bucket_resolver_after_construction) {
     documentapi::GetDocumentMessage get_msg(DocumentId("id::testdoctype1::baz"), "foo bar");
     auto cmd = toStorageAPI<api::GetCommand>(get_msg);
 
-    CPPUNIT_ASSERT_EQUAL(BucketSpace(0), cmd->getBucket().getBucketSpace());
+    EXPECT_EQ(BucketSpace(0), cmd->getBucket().getBucketSpace());
 
     _converter->setBucketResolver(std::make_shared<ReplacementMockBucketResolver>());
 
     cmd = toStorageAPI<api::GetCommand>(get_msg);
-    CPPUNIT_ASSERT_EQUAL(defaultBucketSpace, cmd->getBucket().getBucketSpace());
+    EXPECT_EQ(defaultBucketSpace, cmd->getBucket().getBucketSpace());
 }
 
 }