temp: all

tests/CMakeLists.txt

@@ -50,6 +50,7 @@ set(UNITTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/unittests)
 set(UNITTESTS_SRCS
     ${UNITTESTS_SOURCE_DIR}/sdbus-c++-unit-tests.cpp
     ${UNITTESTS_SOURCE_DIR}/Message_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/PollData_test.cpp
     ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
     ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp
     ${UNITTESTS_SOURCE_DIR}/Connection_test.cpp

tests/integrationtests/DBusAsyncMethodsTests.cpp

@@ -69,7 +69,7 @@ TYPED_TEST(AsyncSdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTime
         });
 
         start = std::chrono::steady_clock::now();
-        this->m_proxy->doOperationClientSideAsyncWithTimeout(1us, 1000); // The operation will take 1s, but the timeout is 1us, so we should time out
+        this->m_proxy->doOperationClientSideAsyncWithTimeout(1us, (1s).count()); // The operation will take 1s, but the timeout is 1us, so we should time out
         future.get();
 
         FAIL() << "Expected sdbus::Error exception";

tests/integrationtests/DBusConnectionTests.cpp

@@ -41,7 +41,6 @@
 
 using ::testing::Eq;
 using namespace sdbus::test;
-using namespace std::chrono_literals;
 
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
@@ -80,7 +79,7 @@ TEST(Connection, CannotReleaseNonrequestedName)
     ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
 }
 
-TEST(Connection, CanEnterAndLeaveEventLoop)
+TEST(Connection, CanEnterAndLeaveInternalEventLoop)
 {
     auto connection = sdbus::createConnection();
     connection->requestName(BUS_NAME);
@@ -90,44 +89,3 @@ TEST(Connection, CanEnterAndLeaveEventLoop)
 
     t.join();
 }
-
-TEST(Connection, PollDataGetZeroTimeout)
-{
-    sdbus::IConnection::PollData pd{};
-    pd.timeout_usec = 0;
-    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
-    EXPECT_THAT(pd.getRelativeTimeout().value(), Eq(std::chrono::microseconds::zero()));
-    EXPECT_THAT(pd.getPollTimeout(), Eq(0));
-}
-
-TEST(Connection, PollDataGetInfiniteTimeout)
-{
-    sdbus::IConnection::PollData pd{};
-    pd.timeout_usec = UINT64_MAX;
-    ASSERT_FALSE(pd.getRelativeTimeout().has_value());
-    EXPECT_THAT(pd.getPollTimeout(), Eq(-1));
-}
-
-TEST(Connection, PollDataGetZeroRelativeTimeoutForPast)
-{
-    sdbus::IConnection::PollData pd{};
-    auto past = std::chrono::steady_clock::now() - 10s;
-    pd.timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch()).count();
-    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
-    EXPECT_THAT(pd.getRelativeTimeout().value(), Eq(0us));
-    EXPECT_THAT(pd.getPollTimeout(), Eq(0));
-}
-
-TEST(Connection, PollDataGetRelativeTimeoutInTolerance)
-{
-    sdbus::IConnection::PollData pd{};
-    constexpr auto TIMEOUT = 1s;
-    constexpr auto TOLERANCE = 100ms;
-    auto future = std::chrono::steady_clock::now() + TIMEOUT;
-    pd.timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch()).count();
-    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
-    EXPECT_GE(pd.getRelativeTimeout().value(), TIMEOUT - TOLERANCE);
-    EXPECT_LE(pd.getRelativeTimeout().value(), TIMEOUT + TOLERANCE);
-    EXPECT_GE(pd.getPollTimeout(), 900);
-    EXPECT_LE(pd.getPollTimeout(), 1100);
-}

tests/integrationtests/DBusGeneralTests.cpp

@@ -98,7 +98,7 @@ TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedS
 
     this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(this->waitUntil(matchingMessageReceived, 2s));
+    ASSERT_FALSE(this->waitUntil(matchingMessageReceived, 1s));
 }
 
 TYPED_TEST(AConnection, CanAddFloatingMatchRule)
@@ -121,7 +121,7 @@ TYPED_TEST(AConnection, CanAddFloatingMatchRule)
     con.reset();
     this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(this->waitUntil(matchingMessageReceived, 2s));
+    ASSERT_FALSE(this->waitUntil(matchingMessageReceived, 1s));
 }
 
 TYPED_TEST(AConnection, WillNotPassToMatchCallbackMessagesThatDoNotMatchTheRule)

tests/integrationtests/DBusMethodsTests.cpp

@@ -161,7 +161,7 @@ TYPED_TEST(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
 
 TYPED_TEST(SdbusTestObject, CallsMethodWithCustomTimeoutSuccessfully)
 {
-    auto res = this->m_proxy->doOperationWithTimeout(500ms, 20); // The operation will take 20ms, but the timeout is 500ms, so we are fine
+    auto res = this->m_proxy->doOperationWithTimeout(500ms, (20ms).count()); // The operation will take 20ms, but the timeout is 500ms, so we are fine
     ASSERT_THAT(res, Eq(20));
 }
 
@@ -170,7 +170,7 @@ TYPED_TEST(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
     auto start = std::chrono::steady_clock::now();
     try
     {
-        this->m_proxy->doOperationWithTimeout(1us, 1000); // The operation will take 1s, but the timeout is 1us, so we should time out
+        this->m_proxy->doOperationWithTimeout(1us, (1s).count()); // The operation will take 1s, but the timeout is 1us, so we should time out
         FAIL() << "Expected sdbus::Error exception";
     }
     catch (const sdbus::Error& e)
@@ -237,8 +237,8 @@ TYPED_TEST(SdbusTestObject, CanReceiveSignalWhileMakingMethodCall)
 {
     this->m_proxy->emitTwoSimpleSignals();
 
-    ASSERT_TRUE(this->waitUntil(this->m_proxy->m_gotSimpleSignal));
-    ASSERT_TRUE(this->waitUntil(this->m_proxy->m_gotSignalWithMap));
+    EXPECT_TRUE(this->waitUntil(this->m_proxy->m_gotSimpleSignal));
+    EXPECT_TRUE(this->waitUntil(this->m_proxy->m_gotSignalWithMap));
 }
 
 TYPED_TEST(SdbusTestObject, CanAccessAssociatedMethodCallMessageInMethodCallHandler)

tests/integrationtests/DBusSignalsTests.cpp

@@ -75,7 +75,7 @@ TYPED_TEST(SdbusTestObject, ProxyDoesNotReceiveSignalFromOtherBusName)
 
     adaptor2->emitSimpleSignal();
 
-    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 }
 
 TYPED_TEST(SdbusTestObject, EmitsSignalWithMapSuccesfully)
@@ -132,7 +132,7 @@ TYPED_TEST(SdbusTestObject, UnregistersSignalHandler)
 
     this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 }
 
 TYPED_TEST(SdbusTestObject, UnregistersSignalHandlerForSomeProxies)
@@ -146,7 +146,7 @@ TYPED_TEST(SdbusTestObject, UnregistersSignalHandlerForSomeProxies)
 
     ASSERT_TRUE(this->waitUntil(proxy1->m_gotSimpleSignal));
     ASSERT_TRUE(this->waitUntil(proxy2->m_gotSimpleSignal));
-    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 }
 
 TYPED_TEST(SdbusTestObject, ReRegistersSignalHandler)
@@ -156,7 +156,7 @@ TYPED_TEST(SdbusTestObject, ReRegistersSignalHandler)
 
     this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(this->waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 
     // re-register simple-signal handler
     ASSERT_NO_THROW(this->m_proxy->reRegisterSimpleSignalHandler());

tests/integrationtests/TestFixture.cpp

@@ -31,8 +31,10 @@ namespace sdbus { namespace test {
 std::unique_ptr<sdbus::IConnection> BaseTestFixture::s_adaptorConnection = sdbus::createSystemBusConnection();
 std::unique_ptr<sdbus::IConnection> BaseTestFixture::s_proxyConnection = sdbus::createSystemBusConnection();
 
-std::thread TestFixture<SdEventLoop>::s_eventLoopThread{};
-sd_event *TestFixture<SdEventLoop>::s_sdEvent{};
+std::thread TestFixture<SdEventLoop>::s_adaptorEventLoopThread{};
+std::thread TestFixture<SdEventLoop>::s_proxyEventLoopThread{};
+sd_event *TestFixture<SdEventLoop>::s_adaptorSdEvent{};
+sd_event *TestFixture<SdEventLoop>::s_proxySdEvent{};
 int TestFixture<SdEventLoop>::s_eventExitFd{-1};
 
 }}

tests/integrationtests/TestFixture.h

@@ -137,18 +137,24 @@ class TestFixture<SdEventLoop> : public BaseTestFixture
 public:
     static void SetUpTestCase()
     {
-        sd_event_new(&s_sdEvent);
+        sd_event_new(&s_adaptorSdEvent);
+        sd_event_new(&s_proxySdEvent);
 
-        s_proxyConnection->attachSdEventLoop(s_sdEvent);
-        s_adaptorConnection->attachSdEventLoop(s_sdEvent);
+        s_adaptorConnection->attachSdEventLoop(s_adaptorSdEvent);
+        s_proxyConnection->attachSdEventLoop(s_proxySdEvent);
 
         s_eventExitFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
         // No callback means that the event loop will exit when this event source triggers
-        sd_event_add_io(s_sdEvent, nullptr, s_eventExitFd, EPOLLIN, nullptr, NULL);
+        sd_event_add_io(s_adaptorSdEvent, nullptr, s_eventExitFd, EPOLLIN, nullptr, NULL);
+        sd_event_add_io(s_proxySdEvent, nullptr, s_eventExitFd, EPOLLIN, nullptr, NULL);
 
-        s_eventLoopThread = std::thread([]()
+        s_adaptorEventLoopThread = std::thread([]()
         {
-            sd_event_loop(s_sdEvent);
+            sd_event_loop(s_adaptorSdEvent);
+        });
+        s_proxyEventLoopThread = std::thread([]()
+        {
+            sd_event_loop(s_proxySdEvent);
         });
 
         BaseTestFixture::SetUpTestCase();
@@ -160,17 +166,21 @@ public:
         uint64_t value = 1;
         write(s_eventExitFd, &value, sizeof(value));
 
-        s_eventLoopThread.join();
+        s_adaptorEventLoopThread.join();
+        s_proxyEventLoopThread.join();
 
-        sd_event_unref(s_sdEvent);
+        sd_event_unref(s_adaptorSdEvent);
+        sd_event_unref(s_proxySdEvent);
         close(s_eventExitFd);
 
         BaseTestFixture::TearDownTestCase();
     }
 
 private:
-    static std::thread s_eventLoopThread;
-    static sd_event *s_sdEvent;
+    static std::thread s_adaptorEventLoopThread;
+    static std::thread s_proxyEventLoopThread;
+    static sd_event *s_adaptorSdEvent;
+    static sd_event *s_proxySdEvent;
     static int s_eventExitFd;
 };
 

tests/integrationtests/integrationtests-adaptor.h

@@ -43,7 +43,7 @@ protected:
         object_->registerMethod("throwError").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwError(); });
         object_->registerMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwErrorWithNoReply(); }).withNoReply();
         object_->registerMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->doPrivilegedStuff(); }).markAsPrivileged();
-        object_->registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->emitTwoSimpleSignals(); });
+        object_->registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->emitTwoSimpleSignals(); })/*.withNoReply()*/;
         object_->registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
         object_->registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>("aMap");
         object_->registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>("aVariant");

tests/integrationtests/integrationtests-proxy.h

@@ -171,7 +171,7 @@ public:
 
     void emitTwoSimpleSignals()
     {
-        proxy_->callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
+        proxy_->callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME)/*.dontExpectReply()*/;
     }
 
     void unregisterSimpleSignalHandler()

tests/unittests/PollData_test.cpp

@@ -0,0 +1,125 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file PollData_test.cpp
+ *
+ * Created on: Jan 19, 2023
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sdbus-c++/IConnection.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <chrono>
+
+using ::testing::Eq;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::AllOf;
+using namespace std::string_literals;
+using namespace std::chrono_literals;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST(PollData, ReturnsZeroRelativeTimeoutForZeroAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::zero();
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, Eq(std::chrono::microseconds::zero()));
+}
+
+TEST(PollData, ReturnsZeroPollTimeoutForZeroAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::zero();
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, Eq(0));
+}
+
+TEST(PollData, ReturnsInfiniteRelativeTimeoutForInfiniteAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::max();
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, Eq(std::chrono::microseconds::max()));
+}
+
+TEST(PollData, ReturnsNegativePollTimeoutForInfiniteAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::max();
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, Eq(-1));
+}
+
+TEST(PollData, ReturnsZeroRelativeTimeoutForPastAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto past = std::chrono::steady_clock::now() - 10s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch());
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, Eq(0us));
+}
+
+TEST(PollData, ReturnsZeroPollTimeoutForPastAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto past = std::chrono::steady_clock::now() - 10s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch());
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, Eq(0));
+}
+
+TEST(PollData, ReturnsCorrectRelativeTimeoutForFutureAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto future = std::chrono::steady_clock::now() + 1s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch());
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, AllOf(Ge(900ms), Le(1100ms)));
+}
+
+TEST(PollData, ReturnsCorrectPollTimeoutForFutureAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto future = std::chrono::steady_clock::now() + 1s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch());
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, AllOf(Ge(900), Le(1100)));
+}

tests/unittests/mocks/SdBusMock.h

@@ -75,7 +75,7 @@ public:
 
     MOCK_METHOD2(sd_bus_process, int(sd_bus *bus, sd_bus_message **r));
     MOCK_METHOD2(sd_bus_get_poll_data, int(sd_bus *bus, PollData* data));
-
+    MOCK_METHOD2(sd_bus_get_n_queued_read, int(sd_bus *bus, uint64_t *ret));
     MOCK_METHOD1(sd_bus_flush, int(sd_bus *bus));
     MOCK_METHOD1(sd_bus_flush_close_unref, sd_bus *(sd_bus *bus));
     MOCK_METHOD1(sd_bus_close_unref, sd_bus *(sd_bus *bus));