1 files changed, 22 insertions, 39 deletions

diff --git a/storage/src/tests/persistence/provider_error_wrapper_test.cpp b/storage/src/tests/persistence/provider_error_wrapper_test.cpp
index b6b87b33666..36238abb238 100644
--- a/storage/src/tests/persistence/provider_error_wrapper_test.cpp
+++ b/storage/src/tests/persistence/provider_error_wrapper_test.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 <vespa/vdstestlib/cppunit/macros.h>
 #include <vespa/persistence/spi/test.h>
 #include <tests/persistence/persistencetestutils.h>
 #include <tests/persistence/common/persistenceproviderwrapper.h>
@@ -9,25 +8,9 @@ using storage::spi::test::makeSpiBucket;
 
 namespace storage {
 
-class ProviderErrorWrapperTest : public SingleDiskPersistenceTestUtils {
-public:
-    CPPUNIT_TEST_SUITE(ProviderErrorWrapperTest);
-    CPPUNIT_TEST(fatal_error_invokes_listener);
-    CPPUNIT_TEST(resource_exhaustion_error_invokes_listener);
-    CPPUNIT_TEST(listener_not_invoked_on_success);
-    CPPUNIT_TEST(listener_not_invoked_on_regular_errors);
-    CPPUNIT_TEST(multiple_listeners_can_be_registered);
-    CPPUNIT_TEST_SUITE_END();
-
-    void fatal_error_invokes_listener();
-    void resource_exhaustion_error_invokes_listener();
-    void listener_not_invoked_on_success();
-    void listener_not_invoked_on_regular_errors();
-    void multiple_listeners_can_be_registered();
+struct ProviderErrorWrapperTest : SingleDiskPersistenceTestUtils {
 };
 
-CPPUNIT_TEST_SUITE_REGISTRATION(ProviderErrorWrapperTest);
-
 namespace {
 
 struct MockErrorListener : ProviderErrorListener {
@@ -70,61 +53,61 @@ struct Fixture {
     void check_no_listener_invoked_for_error(MockErrorListener& listener, spi::Result::ErrorType error) {
         providerWrapper.setResult(spi::Result(error, "beep boop"));
         perform_spi_operation();
-        CPPUNIT_ASSERT(!listener._seen_fatal_error);
-        CPPUNIT_ASSERT(!listener._seen_resource_exhaustion_error);
+        EXPECT_FALSE(listener._seen_fatal_error);
+        EXPECT_FALSE(listener._seen_resource_exhaustion_error);
     }
 };
 
 }
 
-void ProviderErrorWrapperTest::fatal_error_invokes_listener() {
+TEST_F(ProviderErrorWrapperTest, fatal_error_invokes_listener) {
     Fixture f(getPersistenceProvider());
     auto listener = std::make_shared<MockErrorListener>();
     f.errorWrapper.register_error_listener(listener);
     f.providerWrapper.setResult(spi::Result(spi::Result::FATAL_ERROR, "eject! eject!"));
 
-    CPPUNIT_ASSERT(!listener->_seen_fatal_error);
+    EXPECT_FALSE(listener->_seen_fatal_error);
     f.perform_spi_operation();
 
-    CPPUNIT_ASSERT(!listener->_seen_resource_exhaustion_error);
-    CPPUNIT_ASSERT(listener->_seen_fatal_error);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("eject! eject!"), listener->_fatal_error);
+    EXPECT_FALSE(listener->_seen_resource_exhaustion_error);
+    EXPECT_TRUE(listener->_seen_fatal_error);
+    EXPECT_EQ(vespalib::string("eject! eject!"), listener->_fatal_error);
 }
 
-void ProviderErrorWrapperTest::resource_exhaustion_error_invokes_listener() {
+TEST_F(ProviderErrorWrapperTest, resource_exhaustion_error_invokes_listener) {
     Fixture f(getPersistenceProvider());
     auto listener = std::make_shared<MockErrorListener>();
     f.errorWrapper.register_error_listener(listener);
     f.providerWrapper.setResult(spi::Result(spi::Result::RESOURCE_EXHAUSTED, "out of juice"));
 
-    CPPUNIT_ASSERT(!listener->_seen_resource_exhaustion_error);
+    EXPECT_FALSE(listener->_seen_resource_exhaustion_error);
     f.perform_spi_operation();
 
-    CPPUNIT_ASSERT(!listener->_seen_fatal_error);
-    CPPUNIT_ASSERT(listener->_seen_resource_exhaustion_error);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("out of juice"), listener->_resource_exhaustion_error);
+    EXPECT_FALSE(listener->_seen_fatal_error);
+    EXPECT_TRUE(listener->_seen_resource_exhaustion_error);
+    EXPECT_EQ(vespalib::string("out of juice"), listener->_resource_exhaustion_error);
 }
 
-void ProviderErrorWrapperTest::listener_not_invoked_on_success() {
+TEST_F(ProviderErrorWrapperTest, listener_not_invoked_on_success) {
     Fixture f(getPersistenceProvider());
     auto listener = std::make_shared<MockErrorListener>();
     f.errorWrapper.register_error_listener(listener);
     f.perform_spi_operation();
 
-    CPPUNIT_ASSERT(!listener->_seen_fatal_error);
-    CPPUNIT_ASSERT(!listener->_seen_resource_exhaustion_error);
+    EXPECT_FALSE(listener->_seen_fatal_error);
+    EXPECT_FALSE(listener->_seen_resource_exhaustion_error);
 }
 
-void ProviderErrorWrapperTest::listener_not_invoked_on_regular_errors() {
+TEST_F(ProviderErrorWrapperTest, listener_not_invoked_on_regular_errors) {
     Fixture f(getPersistenceProvider());
     auto listener = std::make_shared<MockErrorListener>();
     f.errorWrapper.register_error_listener(listener);
 
-    f.check_no_listener_invoked_for_error(*listener, spi::Result::TRANSIENT_ERROR);
-    f.check_no_listener_invoked_for_error(*listener, spi::Result::PERMANENT_ERROR);
+    EXPECT_NO_FATAL_FAILURE(f.check_no_listener_invoked_for_error(*listener, spi::Result::TRANSIENT_ERROR));
+    EXPECT_NO_FATAL_FAILURE(f.check_no_listener_invoked_for_error(*listener, spi::Result::PERMANENT_ERROR));
 }
 
-void ProviderErrorWrapperTest::multiple_listeners_can_be_registered() {
+TEST_F(ProviderErrorWrapperTest, multiple_listeners_can_be_registered) {
     Fixture f(getPersistenceProvider());
     auto listener1 = std::make_shared<MockErrorListener>();
     auto listener2 = std::make_shared<MockErrorListener>();
@@ -134,8 +117,8 @@ void ProviderErrorWrapperTest::multiple_listeners_can_be_registered() {
     f.providerWrapper.setResult(spi::Result(spi::Result::RESOURCE_EXHAUSTED, "out of juice"));
     f.perform_spi_operation();
 
-    CPPUNIT_ASSERT(listener1->_seen_resource_exhaustion_error);
-    CPPUNIT_ASSERT(listener2->_seen_resource_exhaustion_error);
+    EXPECT_TRUE(listener1->_seen_resource_exhaustion_error);
+    EXPECT_TRUE(listener2->_seen_resource_exhaustion_error);
 }
 
 } // ns storage