Add support for Unix fd D-Bus type

tests/integrationtests/AdaptorAndProxy_test.cpp

@@ -209,6 +209,12 @@ TEST_F(SdbusTestObject, CallsMethodWithObjectPathSuccesfully)
     ASSERT_THAT(resObjectPath, Eq(OBJECT_PATH_VALUE));
 }
 
+TEST_F(SdbusTestObject, CallsMethodWithUnixFdSuccesfully)
+{
+    auto resUnixFd = m_proxy->getUnixFd();
+    ASSERT_THAT(resUnixFd, Gt(UNIX_FD_VALUE));
+}
+
 TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
 {
     auto resComplex = m_proxy->getComplex();

tests/integrationtests/TestingAdaptor.h

@@ -157,6 +157,10 @@ protected:
     {
         return OBJECT_PATH_VALUE;
     }
+    sdbus::UnixFd getUnixFd() const
+    {
+        return UNIX_FD_VALUE;
+    }
 
     ComplexType getComplex() const
     {

tests/integrationtests/adaptor-glue.h

@@ -97,6 +97,7 @@ protected:
 
         object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getSignature(); });
         object_.registerMethod("getObjectPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjectPath(); });
+        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getUnixFd(); });
 
         object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getComplex(); }).markAsDeprecated();
 
@@ -163,6 +164,7 @@ protected:
     virtual void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result) = 0;
     virtual sdbus::Signature getSignature() const  = 0;
     virtual sdbus::ObjectPath getObjectPath() const = 0;
+    virtual sdbus::UnixFd getUnixFd() const  = 0;
     virtual ComplexType getComplex() const = 0;
     virtual void throwError() const = 0;
 
@@ -266,6 +268,9 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <arg type="u" direction="out"/>
    <arg type="s" direction="out"/>
   </method>
+  <method name="getUnixFd">
+   <arg type="h" direction="out"/>
+  </method>
   <method name="multiply">
    <arg type="x" direction="in"/>
    <arg type="d" direction="in"/>

tests/integrationtests/defs.h

@@ -40,6 +40,7 @@ constexpr const int32_t INT64_VALUE{-1024};
 const std::string STRING_VALUE{"sdbus-c++-testing"};
 const sdbus::Signature SIGNATURE_VALUE{"a{is}"};
 const sdbus::ObjectPath OBJECT_PATH_VALUE{"/"};
+const int UNIX_FD_VALUE = 0;
 
 const std::string DEFAULT_STATE_VALUE{"default-state-value"};
 const uint32_t DEFAULT_ACTION_VALUE{999};

tests/integrationtests/proxy-glue.h

@@ -175,6 +175,13 @@ public:
         return result;
     }
 
+    sdbus::UnixFd getUnixFd()
+    {
+        sdbus::UnixFd result;
+        object_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
     ComplexType getComplex()
     {
         ComplexType result;

tests/unittests/Message_test.cpp

@@ -30,6 +30,7 @@
 #include <cstdint>
 
 using ::testing::Eq;
+using ::testing::Gt;
 using ::testing::DoubleEq;
 using namespace std::string_literals;
 
@@ -125,6 +126,21 @@ TEST(AMessage, CanCarryASimpleInteger)
     ASSERT_THAT(dataRead, Eq(dataWritten));
 }
 
+TEST(AMessage, CanCarryAUnixFd)
+{
+    sdbus::Message msg{sdbus::createPlainMessage()};
+
+    sdbus::UnixFd dataWritten = 0;
+    msg << dataWritten;
+
+    msg.seal();
+
+    sdbus::UnixFd dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead, Gt(dataWritten));
+}
+
 TEST(AMessage, CanCarryAVariant)
 {
     sdbus::Message msg{sdbus::createPlainMessage()};

tests/unittests/TypeTraits_test.cpp

@@ -72,6 +72,7 @@ namespace
     TYPE(sdbus::ObjectPath)HAS_DBUS_TYPE_SIGNATURE("o")
     TYPE(sdbus::Signature)HAS_DBUS_TYPE_SIGNATURE("g")
     TYPE(sdbus::Variant)HAS_DBUS_TYPE_SIGNATURE("v")
+    TYPE(sdbus::UnixFd)HAS_DBUS_TYPE_SIGNATURE("h")
     TYPE(sdbus::Struct<bool>)HAS_DBUS_TYPE_SIGNATURE("(b)")
     TYPE(sdbus::Struct<uint16_t, double, std::string, sdbus::Variant>)HAS_DBUS_TYPE_SIGNATURE("(qdsv)")
     TYPE(std::vector<int16_t>)HAS_DBUS_TYPE_SIGNATURE("an")
@@ -91,10 +92,11 @@ namespace
                                     >
                                 >,
                                 sdbus::Signature,
+                                sdbus::UnixFd,
                                 const char*
                             >
                         >;
-    TYPE(ComplexType)HAS_DBUS_TYPE_SIGNATURE("a{t(a{ya(obva{is})}gs)}")
+    TYPE(ComplexType)HAS_DBUS_TYPE_SIGNATURE("a{t(a{ya(obva{is})}ghs)}")
 
     typedef ::testing::Types< bool
                             , uint8_t
@@ -110,6 +112,7 @@ namespace
                             , sdbus::ObjectPath
                             , sdbus::Signature
                             , sdbus::Variant
+                            , sdbus::UnixFd
                             , sdbus::Struct<bool>
                             , sdbus::Struct<uint16_t, double, std::string, sdbus::Variant>
                             , std::vector<int16_t>

tests/unittests/Types_test.cpp

@@ -240,3 +240,10 @@ TEST(ASignature, CanBeConstructedFromStdString)
 
     ASSERT_THAT(sdbus::Signature{aSignature}, Eq(aSignature));
 }
+
+TEST(AUnixFd, CanBeConstructedFromInt)
+{
+    int fd{2};
+
+    ASSERT_THAT((int)sdbus::UnixFd{fd}, Eq(fd));
+}