internal/sdref: Remove in favor of stdplus/handle

We no longer need to roll our own managed handle type now that stdplus
implements a generic one.

Tested:
    Built and run through unit tests.

Change-Id: Id34cd8d3ffacf7901d49cac335fa93f744f0e310
Signed-off-by: William A. Kennington III <wak@google.com>

4 files changed, 9 insertions, 249 deletions

diff --git a/test/Makefile.am b/test/Makefile.am
index e45b11f..76a82b8 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -21,11 +21,6 @@ exception_SOURCES = exception.cpp
 exception_CPPFLAGS = $(gtest_cppflags)
 exception_LDADD = $(gtest_ldadd)
 
-check_PROGRAMS += internal/sdref
-internal_sdref_SOURCES = internal/sdref.cpp
-internal_sdref_CPPFLAGS = $(gtest_cppflags)
-internal_sdref_LDADD = $(gtest_ldadd)
-
 check_PROGRAMS += internal/utils
 internal_utils_SOURCES = internal/utils.cpp
 internal_utils_CPPFLAGS = $(gtest_cppflags)
diff --git a/test/internal/sdref.cpp b/test/internal/sdref.cpp
deleted file mode 100644
index e8effa9..0000000
--- a/test/internal/sdref.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <sdeventplus/internal/sdref.hpp>
-#include <sdeventplus/test/sdevent.hpp>
-#include <systemd/sd-event.h>
-#include <type_traits>
-#include <utility>
-
-namespace sdeventplus
-{
-namespace internal
-{
-namespace
-{
-
-class SdRefTest : public testing::Test
-{
-  protected:
-    sd_event* const expected_event = reinterpret_cast<sd_event*>(1234);
-    sd_event* const expected_event2 = reinterpret_cast<sd_event*>(2345);
-    testing::StrictMock<test::SdEventMock> mock;
-    testing::StrictMock<test::SdEventMock> mock2;
-};
-
-TEST_F(SdRefTest, ConstructRef)
-{
-    EXPECT_CALL(mock, sd_event_ref(expected_event))
-        .WillOnce(testing::Return(expected_event));
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, ConstructNoRef)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, CopyConstruct)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-
-    EXPECT_CALL(mock, sd_event_ref(expected_event))
-        .WillOnce(testing::Return(expected_event));
-    SdRef<sd_event> event2(event);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event, event2.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .Times(2)
-        .WillRepeatedly(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, MoveConstruct)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-
-    SdRef<sd_event> event2(std::move(event));
-    EXPECT_FALSE(event);
-    EXPECT_EQ(nullptr, event.get());
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event, event2.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, CopyAssignOverValid)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    SdRef<sd_event> event2(expected_event2, &SdEvent::sd_event_ref,
-                           &SdEvent::sd_event_unref, std::false_type(), &mock2);
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event2, event2.get());
-
-    EXPECT_CALL(mock2, sd_event_unref(expected_event2))
-        .WillOnce(testing::Return(nullptr));
-    EXPECT_CALL(mock, sd_event_ref(expected_event))
-        .WillOnce(testing::Return(expected_event));
-    event2 = event;
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event, event2.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .Times(2)
-        .WillRepeatedly(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, CopyAssignOverMoved)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    SdRef<sd_event> event2(expected_event2, &SdEvent::sd_event_ref,
-                           &SdEvent::sd_event_unref, std::false_type(), &mock2);
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event2, event2.get());
-    {
-        SdRef<sd_event> event_mover(std::move(event2));
-        EXPECT_FALSE(event2);
-        EXPECT_EQ(nullptr, event2.get());
-        EXPECT_TRUE(event_mover);
-        EXPECT_EQ(expected_event2, event_mover.get());
-
-        EXPECT_CALL(mock2, sd_event_unref(expected_event2))
-            .WillOnce(testing::Return(nullptr));
-    }
-
-    EXPECT_CALL(mock, sd_event_ref(expected_event))
-        .WillOnce(testing::Return(expected_event));
-    event2 = event;
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event, event2.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .Times(2)
-        .WillRepeatedly(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, CopySelf)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-
-    event = event;
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, MoveAssignOverValid)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    SdRef<sd_event> event2(expected_event2, &SdEvent::sd_event_ref,
-                           &SdEvent::sd_event_unref, std::false_type(), &mock2);
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event2, event2.get());
-
-    EXPECT_CALL(mock2, sd_event_unref(expected_event2))
-        .WillOnce(testing::Return(nullptr));
-    event2 = std::move(event);
-    EXPECT_FALSE(event);
-    EXPECT_EQ(nullptr, event.get());
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event, event2.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, MoveAssignOverMoved)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_EQ(expected_event, event.get());
-    SdRef<sd_event> event2(expected_event2, &SdEvent::sd_event_ref,
-                           &SdEvent::sd_event_unref, std::false_type(), &mock2);
-    EXPECT_EQ(expected_event2, event2.get());
-    {
-        SdRef<sd_event> event_mover(std::move(event2));
-        EXPECT_FALSE(event2);
-        EXPECT_EQ(nullptr, event2.get());
-        EXPECT_TRUE(event_mover);
-        EXPECT_EQ(expected_event2, event_mover.get());
-
-        EXPECT_CALL(mock2, sd_event_unref(expected_event2))
-            .WillOnce(testing::Return(nullptr));
-    }
-
-    event2 = std::move(event);
-    EXPECT_FALSE(event);
-    EXPECT_EQ(nullptr, event.get());
-    EXPECT_TRUE(event2);
-    EXPECT_EQ(expected_event, event2.get());
-
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-TEST_F(SdRefTest, MoveSelf)
-{
-    SdRef<sd_event> event(expected_event, &SdEvent::sd_event_ref,
-                          &SdEvent::sd_event_unref, std::false_type(), &mock);
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wself-move"
-#endif
-    event = std::move(event);
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-    EXPECT_TRUE(event);
-    EXPECT_EQ(expected_event, event.get());
-    EXPECT_CALL(mock, sd_event_unref(expected_event))
-        .WillOnce(testing::Return(nullptr));
-}
-
-} // namespace
-} // namespace internal
-} // namespace sdeventplus
diff --git a/test/meson.build b/test/meson.build
index d894a3f..8fa22a7 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -5,7 +5,6 @@ tests = [
   'clock',
   'event',
   'exception',
-  'internal/sdref',
   'internal/utils',
   'source/base',
   'source/child',
diff --git a/test/source/base.cpp b/test/source/base.cpp
index 75a6dde..2139dd0 100644
--- a/test/source/base.cpp
+++ b/test/source/base.cpp
@@ -2,6 +2,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <memory>
+#include <optional>
 #include <sdeventplus/event.hpp>
 #include <sdeventplus/exception.hpp>
 #include <sdeventplus/internal/sdevent.hpp>
@@ -93,8 +94,8 @@ class BaseTest : public testing::Test
             .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
         BaseImpl mover(std::move(other));
         EXPECT_EQ(&mover, userdata);
-        EXPECT_EQ(nullptr, other.get());
-        EXPECT_EQ(nullptr, other.get_event().get());
+        EXPECT_THROW(other.get(), std::bad_optional_access);
+        EXPECT_THROW(other.get_event().get(), std::bad_optional_access);
         EXPECT_FALSE(other.get_prepare());
 
         expect_base_destruct(mover.get_event(), mover.get());
@@ -160,8 +161,8 @@ TEST_F(BaseTest, MoveConstruct)
         .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
     BaseImpl source2(std::move(*source1));
     EXPECT_EQ(&source2, userdata);
-    EXPECT_EQ(nullptr, source1->get());
-    EXPECT_EQ(nullptr, source1->get_event().get());
+    EXPECT_THROW(source1->get(), std::bad_optional_access);
+    EXPECT_THROW(source1->get_event().get(), std::bad_optional_access);
     EXPECT_FALSE(source1->get_prepare());
     EXPECT_EQ(expected_source, source2.get());
     EXPECT_EQ(expected_event, source2.get_event().get());
@@ -199,8 +200,8 @@ TEST_F(BaseTest, MoveAssignEmpty)
         *source2 = std::move(*source1);
         EXPECT_EQ(source2.get(), userdata);
     }
-    EXPECT_EQ(nullptr, source1->get());
-    EXPECT_EQ(nullptr, source1->get_event().get());
+    EXPECT_THROW(source1->get(), std::bad_optional_access);
+    EXPECT_THROW(source1->get_event().get(), std::bad_optional_access);
     EXPECT_FALSE(source1->get_prepare());
     EXPECT_EQ(expected_source, source2->get());
     EXPECT_EQ(expected_event, source2->get_event().get());
@@ -232,8 +233,8 @@ TEST_F(BaseTest, MoveAssignExisting)
         *source2 = std::move(*source1);
         EXPECT_EQ(source2.get(), userdata);
     }
-    EXPECT_EQ(nullptr, source1->get());
-    EXPECT_EQ(nullptr, source1->get_event().get());
+    EXPECT_THROW(source1->get(), std::bad_optional_access);
+    EXPECT_THROW(source1->get_event().get(), std::bad_optional_access);
     EXPECT_FALSE(source1->get_prepare());
     EXPECT_EQ(expected_source, source2->get());
     EXPECT_EQ(expected_event, source2->get_event().get());