Improve coverage

examples/meson.build

@@ -1,5 +1,7 @@
 progs = [['socket_tcp_server', ['socket_tcp_server.cpp']],
-		['socket_tcp_client', ['socket_tcp_client.cpp']]]
+		['socket_tcp_client', ['socket_tcp_client.cpp']],
+    ['socket_unix_udp_server',['socket_unix_udp_server.cpp']],
+    ['socket_unix_udp_client',['socket_unix_udp_client.cpp']]]
 
 foreach p : progs
   executable(p[0], p[1], include_directories : inc, link_with : netlib)

examples/socket_unix_udp_client.cpp

@@ -0,0 +1,25 @@
+#include "socket.hpp"
+#include <iostream>
+
+using namespace net;
+
+int main()
+{
+	try {
+		Socket unixClient(Domain::UNIX, Type::UDP);
+		std::string clientPath("/tmp/unixClient");
+		std::string serverPath("/tmp/unixServer");
+
+		unixClient.bind([&](AddrUnix &s) {
+			return methods::construct(s, clientPath.c_str());
+		});
+
+		unixClient.connect(serverPath.c_str());
+
+		unixClient.write("hello server");
+	} catch (std::exception &e) {
+		std::cout << "  Something unexpected happened: " << e.what() << '\n';
+	}
+
+	return 0;
+}

examples/socket_unix_udp_server.cpp

@@ -0,0 +1,25 @@
+#include "socket.hpp"
+#include <iostream>
+
+using namespace net;
+
+int main()
+{
+	try {
+		Socket unixServer(Domain::UNIX, Type::UDP);
+		std::string serverPath("/tmp/unixServer");
+
+		unixServer.bind([&](AddrUnix &s) {
+			return methods::construct(s, serverPath.c_str());
+		});
+
+		const auto res = unixServer.read(12);
+
+		std::cout << "Some client sent: " << res << '\n';
+
+	} catch (std::exception &e) {
+		std::cout << "  Something unexpected happened: " << e.what() << '\n';
+	}
+
+	return 0;
+}

include/socket.hpp

@@ -193,7 +193,6 @@ class Socket final {
 	auto bind(F _fn) -> decltype(_fn(std::declval<AddrIPv4 &>()), void()) const
 	{
 		AddrIPv4 addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		auto res = _fn(addr);
 		if (res >= 1) {
@@ -226,7 +225,6 @@ class Socket final {
 	auto bind(F _fn) -> decltype(_fn(std::declval<AddrIPv6 &>()), void()) const
 	{
 		AddrIPv6 addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		auto res = _fn(addr);
 		if (res >= 1) {
@@ -259,7 +257,6 @@ class Socket final {
 	auto bind(F _fn) -> decltype(_fn(std::declval<AddrUnix &>()), void()) const
 	{
 		AddrUnix addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		auto res = _fn(addr);
 		if (res >= 1) {
@@ -309,7 +306,6 @@ class Socket final {
 	  -> decltype(_fn(std::declval<AddrIPv4 &>()), void()) const
 	{
 		AddrIPv4 addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		auto res = _fn(addr);
 		if (res >= 1) {
@@ -352,7 +348,6 @@ class Socket final {
 	  -> decltype(_fn(std::declval<AddrIPv6 &>()), void()) const
 	{
 		AddrIPv6 addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		auto res = _fn(addr);
 		if (res >= 1) {
@@ -395,7 +390,6 @@ class Socket final {
 	  -> decltype(_fn(std::declval<AddrUnix &>()), void()) const
 	{
 		AddrUnix addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		auto res = _fn(addr);
 		if (res >= 1) {
@@ -517,7 +511,6 @@ class Socket final {
 	  -> decltype(_fn(std::declval<AddrIPv4 &>()), void()) const
 	{
 		AddrIPv4 addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		const auto flags = static_cast<int>(_flags);
 		const auto res   = _fn(addr);
@@ -569,7 +562,6 @@ class Socket final {
 	  -> decltype(_fn(std::declval<AddrIPv6 &>()), void()) const
 	{
 		AddrIPv6 addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		const auto flags = static_cast<int>(_flags);
 		const auto res   = _fn(addr);
@@ -621,7 +613,6 @@ class Socket final {
 	  -> decltype(_fn(std::declval<AddrUnix &>()), void()) const
 	{
 		AddrUnix addr;
-		std::memset(&addr, 0, sizeof(addr));
 
 		const auto flags = static_cast<int>(_flags);
 		const auto res   = _fn(addr);

test/meson.build

@@ -1,6 +1,6 @@
 test_sources = ['socket_bind_test.cpp', 'socket_constructor_test.cpp',
 				'socket_options_test.cpp', 'socket_getSocket_test.cpp',
-        'socket_send_test.cpp', 'socket_recv_test.cpp', 'socket_connect_test.cpp']
+        'socket_send_test.cpp', 'socket_recv_test.cpp', 'socket_read_write_test.cpp', 'socket_connect_test.cpp']
 
 testexe = executable('testexe', test_sources,
         include_directories : inc, link_with : netlib,

test/socket_bind_test.cpp

@@ -57,11 +57,6 @@ TEST(Socket, Bind)
 		return 1;
 	}));
 
-	// when given callable doesn't fill it's structure object argument.
-	Socket sock_liar(Domain::IPv4, Type::TCP);
-	ASSERT_NO_THROW(sock_liar.bind([](AddrIPv4 &s) { return 5; }));
-	ASSERT_ANY_THROW(sock_liar.connect("127.0.0.1", 15000));
-
 
 	Socket sock_liar_ipv4(Domain::IPv4, Type::TCP);
 	ASSERT_THROW(sock_liar_ipv4.bind([](AddrIPv6 &s) {
@@ -101,4 +96,17 @@ TEST(Socket, Bind)
 		return methods::construct(s, "::::::127.0.0.1", -1300000);
 	}),
 	             std::invalid_argument);
+
+	Socket unixSocket(Domain::UNIX, Type::TCP);
+	std::string unixSocketPath("/tmp/unixSocketFile");
+	unixSocket.bind([&](AddrUnix &s) {
+		return methods::construct(s, unixSocketPath.c_str());
+	});
+	AddrUnix actualUnixSocket;
+	socklen_t actualUnixSocketSize = sizeof(actualUnixSocket);
+	ASSERT_NE(getsockname(unixSocket.getSocket(),
+	                      (sockaddr *) &actualUnixSocket,
+	                      &actualUnixSocketSize),
+	          -1);
+	EXPECT_EQ(actualUnixSocket.sun_path, unixSocketPath);
 }

test/socket_connect_test.cpp

@@ -2,14 +2,22 @@
 #include <gtest/gtest.h>
 #include <thread>
 #include <functional>
-#include <iostream>
 
 
 using namespace net;
 using namespace std::chrono_literals;
 
 namespace {
-void runServer(Socket &s, const unsigned int port)
+
+void runUnixServer(Socket &s, const char path[])
+{
+	s.start(path);
+	if (s.getType() == Type::TCP) {
+		auto peer = s.accept();
+	}
+}
+
+void runNonUnixServer(Socket &s, const unsigned int port)
 {
 	std::string address;
 	switch (s.getDomain()) {
@@ -32,7 +40,7 @@ TEST(Socket, Connectv4)
 {
 	Socket server4(Domain::IPv4, Type::TCP);
 
-	std::thread serverThread1(runServer, std::ref(server4), 15010);
+	std::thread serverThread1(runNonUnixServer, std::ref(server4), 15010);
 	serverThread1.detach();
 	std::this_thread::sleep_for(1s);
 
@@ -45,11 +53,50 @@ TEST(Socket, Connectv4)
 TEST(Socket, Connectv6)
 {
 	Socket server6(Domain::IPv6, Type::TCP);
-	std::thread serverThread1(runServer, std::ref(server6), 15020);
+	std::thread serverThread1(runNonUnixServer, std::ref(server6), 15020);
 	serverThread1.detach();
 	std::this_thread::sleep_for(1s);
 
 	Socket client6(Domain::IPv6, Type::TCP);
 	ASSERT_NO_THROW(client6.connect("::1", 15020));
 	client6.close();
 }
+
+TEST(Socket, ConnectUnixTCP)
+{
+	std::string unixPathServer("/tmp/unixSocketFileServer7");
+	Socket serverUnixTCP(Domain::UNIX, Type::TCP);
+	std::thread serverThread1(runUnixServer, std::ref(serverUnixTCP),
+	                          unixPathServer.c_str());
+	serverThread1.detach();
+	std::this_thread::sleep_for(1s);
+
+	std::string unixPathClient("/tmp/unixSocketFileClient7");
+	Socket clientUnixTCP(Domain::UNIX, Type::TCP);
+	EXPECT_NO_THROW(clientUnixTCP.bind([&](AddrUnix &s) {
+		return methods::construct(s, unixPathClient.c_str());
+	}));
+	EXPECT_NO_THROW(clientUnixTCP.connect([&](AddrUnix &s) {
+		return methods::construct(s, unixPathServer.c_str());
+	}););
+	clientUnixTCP.close();
+}
+
+TEST(Socket, ConnectUnixUDP)
+{
+	std::string unixPathServer("/tmp/unixSocketFileServer2");
+	Socket serverUnixUDP(Domain::UNIX, Type::UDP);
+	std::thread serverThread1(
+	  [&]() { runUnixServer(serverUnixUDP, unixPathServer.c_str()); });
+	serverThread1.detach();
+	std::this_thread::sleep_for(1s);
+
+	std::string unixPathClient("/tmp/unixSocketFileClient2");
+	Socket clientUnixUDP(Domain::UNIX, Type::UDP);
+	EXPECT_NO_THROW(clientUnixUDP.bind([&](AddrUnix &s) {
+		return methods::construct(s, unixPathClient.c_str());
+	}));
+	EXPECT_NO_THROW(clientUnixUDP.connect([&](AddrUnix &s) {
+		return methods::construct(s, unixPathServer.c_str());
+	}));
+}

test/socket_constructor_test.cpp

@@ -13,6 +13,9 @@ TEST(Socket, ConstructorIPv4)
 
 	EXPECT_ANY_THROW(Socket s(Domain::IPv4, Type::TCP, 41));
 	EXPECT_ANY_THROW(Socket s(Domain::IPv4, Type::UDP, 6));
+
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::IPv4, Type::TCP)));
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::IPv4, Type::UDP)));
 }
 
 
@@ -25,6 +28,9 @@ TEST(Socket, ConstructorIPv6)
 
 	EXPECT_ANY_THROW(Socket s(Domain::IPv6, Type::TCP, 41));
 	EXPECT_ANY_THROW(Socket s(Domain::IPv6, Type::UDP, 6));
+
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::IPv6, Type::TCP)));
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::IPv6, Type::UDP)));
 }
 
 
@@ -35,11 +41,17 @@ TEST(socket, ConstructorUnix)
 	EXPECT_NO_THROW(Socket s(Domain::UNIX, Type::SEQPACKET));
 
 	EXPECT_ANY_THROW(Socket s(Domain::UNIX, Type::TCP, 3));
+
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::UNIX, Type::TCP)));
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::UNIX, Type::UDP)));
 }
 
 
 TEST(Socket, ConstructorRaw)
 {
 	EXPECT_NO_THROW(Socket s(Domain::IPv4, Type::RAW, 4));
 	EXPECT_NO_THROW(Socket s(Domain::IPv6, Type::RAW, 4));
+
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::IPv4, Type::RAW, 4)));
+	EXPECT_NO_THROW(Socket otherS(Socket(Domain::IPv6, Type::RAW, 4)));
 }