More unit tests (#26)

- "Own" -> "Owned"
- I bit less code duplication at IPC clients (added `ClientContext`)
- Added unit tests for SDK Publisher.

Author: serges147

include/ocvsmd/sdk/defines.hpp

@@ -124,7 +124,7 @@ enum class CyphalPriority : std::uint8_t
 
 /// Defines helper which owns mutable raw data buffer.
 ///
-struct OwnMutablePayload
+struct OwnedMutablePayload
 {
     /// Holds the size of the raw data buffer. It could be less than it was allocated.
     std::size_t size;

include/ocvsmd/sdk/node_pub_sub.hpp

@@ -52,7 +52,7 @@ class Publisher
     /// @param timeout The maximum time to keep the published raw message as valid in the Cyphal network.
     /// @return An execution sender which emits the async result of the operation.
     ///
-    virtual SenderOf<OptError>::Ptr rawPublish(OwnMutablePayload&&             raw_payload,
+    virtual SenderOf<OptError>::Ptr rawPublish(OwnedMutablePayload&&           raw_payload,
                                                const std::chrono::microseconds timeout) = 0;
 
     /// Sets priority for messages to be issued by this publisher.
@@ -98,7 +98,7 @@ class Publisher
             //
             constexpr std::size_t BufferSize = Message::_traits_::SerializationBufferSizeBytes;
             // NOLINTNEXTLINE(*-avoid-c-arrays)
-            OwnMutablePayload payload{BufferSize, std::make_unique<cetl::byte[]>(BufferSize)};
+            OwnedMutablePayload payload{BufferSize, std::make_unique<cetl::byte[]>(BufferSize)};
             //
             // No lint b/c of integration with Nunavut.
             // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
@@ -150,7 +150,7 @@ class Subscriber
     {
         struct Success
         {
-            OwnMutablePayload            payload;
+            OwnedMutablePayload          payload;
             CyphalPriority               priority;
             cetl::optional<CyphalNodeId> publisher_node_id;
         };

src/cli/main.cpp

@@ -479,7 +479,7 @@ void tryPublisherScenario(Executor& executor, cetl::pmr::memory_resource& memory
 
     if (const auto opt_error = publisher->setPriority(ocvsmd::sdk::CyphalPriority::Low))
     {
-        spdlog::warn("Failed to set 'low' priority publisher (err={}).", *opt_error);
+        spdlog::warn("Failed to set 'low' priority publishing (err={}).", *opt_error);
     }
 
     uavcan::time::Synchronization_1_0 sync_msg{&memory};
@@ -495,7 +495,7 @@ void tryPublisherScenario(Executor& executor, cetl::pmr::memory_resource& memory
         {
             if (const auto opt_error = publisher->setPriority(ocvsmd::sdk::CyphalPriority::High))
             {
-                spdlog::warn("Failed to set 'high' priority publisher (err={}).", *opt_error);
+                spdlog::warn("Failed to set 'high' priority publishing (err={}).", *opt_error);
             }
         }
 

src/common/io/io.cpp

@@ -14,7 +14,7 @@ namespace common
 namespace io
 {
 
-void OwnFd::reset() noexcept
+void OwnedFd::reset() noexcept
 {
     if (fd_ >= 0)
     {
@@ -24,7 +24,7 @@ void OwnFd::reset() noexcept
     }
 }
 
-OwnFd::~OwnFd()
+OwnedFd::~OwnedFd()
 {
     reset();
 }

src/common/io/io.hpp

@@ -17,40 +17,40 @@ namespace io
 
 /// RAII wrapper for a file descriptor.
 ///
-class OwnFd final
+class OwnedFd final
 {
 public:
-    OwnFd()
+    OwnedFd()
         : fd_{-1}
     {
     }
 
-    explicit OwnFd(const int fd)
+    explicit OwnedFd(const int fd)
         : fd_{fd}
     {
     }
 
-    OwnFd(OwnFd&& other) noexcept
+    OwnedFd(OwnedFd&& other) noexcept
         : fd_{std::exchange(other.fd_, -1)}
     {
     }
 
-    OwnFd& operator=(OwnFd&& other) noexcept
+    OwnedFd& operator=(OwnedFd&& other) noexcept
     {
-        const OwnFd old{std::move(*this)};
+        const OwnedFd old{std::move(*this)};
         fd_ = std::exchange(other.fd_, -1);
         return *this;
     }
 
-    OwnFd& operator=(std::nullptr_t)
+    OwnedFd& operator=(std::nullptr_t)
     {
-        const OwnFd old{std::move(*this)};
+        const OwnedFd old{std::move(*this)};
         return *this;
     }
 
     // Disallow copy.
-    OwnFd(const OwnFd&)            = delete;
-    OwnFd& operator=(const OwnFd&) = delete;
+    OwnedFd(const OwnedFd&)            = delete;
+    OwnedFd& operator=(const OwnedFd&) = delete;
 
     int get() const
     {
@@ -59,12 +59,12 @@ class OwnFd final
 
     void reset() noexcept;
 
-    ~OwnFd();
+    ~OwnedFd();
 
 private:
     int fd_;
 
-};  // OwnFd
+};  // OwnedFd
 
 }  // namespace io
 }  // namespace common

src/common/io/socket_address.cpp

@@ -121,15 +121,15 @@ std::string SocketAddress::toString() const
 
 SocketAddress::SocketResult::Var SocketAddress::socket(const int socket_type) const
 {
-    OwnFd out_fd;
+    OwnedFd out_fd;
 
     const auto& addr_generic = asGenericAddr();
     if (const int err = platform::posixSyscallError([this, socket_type, &addr_generic, &out_fd] {
             //
             const int fd = ::socket(addr_generic.sa_family, socket_type, 0);
             if (fd != -1)
             {
-                out_fd = OwnFd{fd};
+                out_fd = OwnedFd{fd};
             }
             return fd;
         }))
@@ -158,7 +158,7 @@ SocketAddress::SocketResult::Var SocketAddress::socket(const int socket_type) co
     return out_fd;
 }
 
-sdk::OptError SocketAddress::bind(const OwnFd& socket_fd) const
+sdk::OptError SocketAddress::bind(const OwnedFd& socket_fd) const
 {
     const int raw_fd = socket_fd.get();
     CETL_DEBUG_ASSERT(raw_fd != -1, "");
@@ -190,7 +190,7 @@ sdk::OptError SocketAddress::bind(const OwnFd& socket_fd) const
     return sdk::OptError{};
 }
 
-sdk::OptError SocketAddress::connect(const OwnFd& socket_fd) const
+sdk::OptError SocketAddress::connect(const OwnedFd& socket_fd) const
 {
     const int raw_fd = socket_fd.get();
     CETL_DEBUG_ASSERT(raw_fd != -1, "");
@@ -212,14 +212,14 @@ sdk::OptError SocketAddress::connect(const OwnFd& socket_fd) const
     }
 }
 
-cetl::optional<OwnFd> SocketAddress::accept(const OwnFd& server_fd)
+cetl::optional<OwnedFd> SocketAddress::accept(const OwnedFd& server_fd)
 {
     CETL_DEBUG_ASSERT(server_fd.get() != -1, "");
 
     while (true)
     {
         addr_len_ = sizeof(addr_storage_);
-        OwnFd client_fd{::accept(server_fd.get(), &asGenericAddr(), &addr_len_)};
+        OwnedFd client_fd{::accept(server_fd.get(), &asGenericAddr(), &addr_len_)};
         if (client_fd.get() >= 0)
         {
             if (const int err = platform::posixSyscallError([&client_fd] {
@@ -289,7 +289,7 @@ cetl::optional<OwnFd> SocketAddress::accept(const OwnFd& server_fd)
 
 /// Disables Nagle's algorithm for TCP sockets, so that our small IPC packets are sent immediately.
 ///
-void SocketAddress::configureNoDelay(const OwnFd& fd)
+void SocketAddress::configureNoDelay(const OwnedFd& fd)
 {
     if (const int err = platform::posixSyscallError([&fd] {
             //

src/common/io/socket_address.hpp

@@ -57,17 +57,17 @@ class SocketAddress final
     struct SocketResult
     {
         using Failure = sdk::Error;
-        using Success = OwnFd;
+        using Success = OwnedFd;
         using Var     = cetl::variant<Success, Failure>;
     };
     SocketResult::Var socket(const int socket_type) const;
 
-    sdk::OptError         bind(const OwnFd& socket_fd) const;
-    sdk::OptError         connect(const OwnFd& socket_fd) const;
-    cetl::optional<OwnFd> accept(const OwnFd& server_fd);
+    sdk::OptError           bind(const OwnedFd& socket_fd) const;
+    sdk::OptError           connect(const OwnedFd& socket_fd) const;
+    cetl::optional<OwnedFd> accept(const OwnedFd& server_fd);
 
 private:
-    static void                             configureNoDelay(const OwnFd& fd);
+    static void                             configureNoDelay(const OwnedFd& fd);
     static cetl::optional<ParseResult::Var> tryParseAsUnixDomain(const std::string& conn_str);
     static cetl::optional<ParseResult::Var> tryParseAsAbstractUnixDomain(const std::string& conn_str);
     static cetl::optional<ParseResult::Var> tryParseAsTcpAddress(const std::string&  conn_str,

src/common/ipc/pipe/client_context.hpp

@@ -32,7 +32,7 @@ class ClientContext final
 public:
     using Ptr = std::unique_ptr<ClientContext>;
 
-    ClientContext(const ServerPipe::ClientId id, io::OwnFd&& fd, Logger& logger)
+    ClientContext(const ServerPipe::ClientId id, io::OwnedFd&& fd, Logger& logger)
         : id_{id}
         , logger_{logger}
     {

src/common/ipc/pipe/socket_base.hpp

@@ -45,7 +45,7 @@ class SocketBase
         };
         using MsgPart = cetl::variant<MsgHeader, MsgPayload>;
 
-        io::OwnFd                                 fd;
+        io::OwnedFd                               fd;
         std::size_t                               rx_partial_size{0};
         MsgPart                                   rx_msg_part{MsgHeader{}};
         std::function<sdk::OptError(io::Payload)> on_rx_msg_payload;

src/common/ipc/pipe/socket_server.hpp

@@ -52,7 +52,7 @@ class SocketServer final : public SocketBase, public ServerPipe
     CETL_NODISCARD sdk::OptError start(EventHandler event_handler) override;
     CETL_NODISCARD sdk::OptError send(const ClientId client_id, io::SocketBuffer& sock_buff) override;
 
-    io::OwnFd                                        server_fd_;
+    io::OwnedFd                                      server_fd_;
     io::SocketAddress                                socket_address_;
     platform::IPosixExecutorExtension* const         posix_executor_ext_;
     ClientId                                         unique_client_id_counter_;