Mercurial > code

changeset 435:b9c8b1792889

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Sockets: put back Listener
author David Demelier <markand@malikania.fr>
date Wed, 21 Oct 2015 22:08:55 +0200
parents da92b98de599
children 2dbaf2fb03ef
files C++/tests/Socket/main.cpp
diffstat 1 files changed, 67 insertions(+), 65 deletions(-) [+]
line wrap: on
line diff
--- a/C++/tests/Socket/main.cpp	Wed Oct 21 21:24:13 2015 +0200
+++ b/C++/tests/Socket/main.cpp	Wed Oct 21 22:08:55 2015 +0200
@@ -24,12 +24,9 @@
 
 #include <gtest/gtest.h>
 
-#include <Socket.h>
-#include <SocketAddress.h>
-#include <SocketListener.h>
-#include <SocketSsl.h>
+#include <Sockets.h>
 
-using namespace address;
+using namespace net;
 using namespace std::literals::chrono_literals;
 
 /* --------------------------------------------------------
@@ -38,8 +35,8 @@
 
 class TcpServerTest : public testing::Test {
 protected:
-	SocketTcp<Ipv4> m_server{AF_INET, 0};
-	SocketTcp<Ipv4> m_client{AF_INET, 0};
+	SocketTcp<Ipv4> m_server;
+	SocketTcp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -106,8 +103,8 @@
 
 class UdpServerTest : public testing::Test {
 protected:
-	SocketUdp<Ipv4> m_server{AF_INET, 0};
-	SocketUdp<Ipv4> m_client{AF_INET, 0};
+	SocketUdp<Ipv4> m_server;
+	SocketUdp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -130,14 +127,15 @@
 TEST_F(UdpServerTest, io)
 {
 	m_tserver = std::thread([this] () {
+		Ipv4 client;
 		Ipv4 info{"*", 16000};
 
 		m_server.bind(info);
-		auto msg = m_server.recvfrom(512, info);
+		auto msg = m_server.recvfrom(512, client);
 
 		ASSERT_EQ("hello world", msg);
 
-		m_server.sendto(msg, info);
+		m_server.sendto(msg, client);
 		m_server.close();
 	});
 
@@ -164,18 +162,18 @@
 	bool m_added{false};
 	int m_flags{0};
 
-	inline void set(const SocketTable &, SocketAbstract &, int flags, bool add) noexcept
+	inline void set(const ListenerTable &, Handle, int flags, bool add) noexcept
 	{
 		m_callcount ++;
 		m_added = add;
 		m_flags |= flags;
 	}
 
-	inline void unset(const SocketTable &, SocketAbstract &, int, bool) noexcept
+	inline void unset(const ListenerTable &, Handle, int, bool) noexcept
 	{
 	}
 
-	std::vector<SocketStatus> wait(const SocketTable &, int)
+	std::vector<ListenerStatus> wait(const ListenerTable &, int)
 	{
 		return {};
 	}
@@ -183,16 +181,16 @@
 
 class TestBackendSetFail {
 public:
-	inline void set(const SocketTable &, SocketAbstract &, int, bool)
+	inline void set(const ListenerTable &, Handle, int, bool)
 	{
 		throw "fail";
 	}
 
-	inline void unset(const SocketTable &, const SocketAbstract &, int, bool) noexcept
+	inline void unset(const ListenerTable &, Handle, int, bool) noexcept
 	{
 	}
 
-	std::vector<SocketStatus> wait(const SocketTable &, int)
+	std::vector<ListenerStatus> wait(const ListenerTable &, int)
 	{
 		return {};
 	}
@@ -200,24 +198,24 @@
 
 TEST(ListenerSet, initialAdd)
 {
-	SocketListenerAbstract<TestBackendSet> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendSet> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read);
+	listener.set(s, FlagRead);
 
 	ASSERT_EQ(1U, listener.size());
 	ASSERT_EQ(1, listener.backend().m_callcount);
 	ASSERT_TRUE(listener.backend().m_added);
-	ASSERT_TRUE(listener.backend().m_flags == SocketListener::Read);
+	ASSERT_TRUE(listener.backend().m_flags == FlagRead);
 }
 
 TEST(ListenerSet, readThenWrite)
 {
-	SocketListenerAbstract<TestBackendSet> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendSet> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read);
-	listener.set(s, SocketListener::Write);
+	listener.set(s, FlagRead);
+	listener.set(s, FlagWrite);
 
 	ASSERT_EQ(1U, listener.size());
 	ASSERT_EQ(2, listener.backend().m_callcount);
@@ -227,10 +225,10 @@
 
 TEST(ListenerSet, allOneShot)
 {
-	SocketListenerAbstract<TestBackendSet> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendSet> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read | SocketListener::Write);
+	listener.set(s, FlagRead | FlagWrite);
 
 	ASSERT_EQ(1U, listener.size());
 	ASSERT_EQ(1, listener.backend().m_callcount);
@@ -240,25 +238,25 @@
 
 TEST(ListenerSet, readTwice)
 {
-	SocketListenerAbstract<TestBackendSet> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendSet> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read);
-	listener.set(s, SocketListener::Read);
+	listener.set(s, FlagRead);
+	listener.set(s, FlagRead);
 
 	ASSERT_EQ(1U, listener.size());
 	ASSERT_EQ(1, listener.backend().m_callcount);
 	ASSERT_TRUE(listener.backend().m_added);
-	ASSERT_TRUE(listener.backend().m_flags == SocketListener::Read);
+	ASSERT_TRUE(listener.backend().m_flags == FlagRead);
 }
 
 TEST(ListenerSet, failure)
 {
-	SocketListenerAbstract<TestBackendSetFail> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendSetFail> listener;
+	Handle s{0};
 
 	try {
-		listener.set(s, SocketListener::Read);
+		listener.set(s, FlagRead);
 		FAIL() << "exception expected";
 	} catch (...) {
 	}
@@ -266,6 +264,8 @@
 	ASSERT_EQ(0U, listener.size());
 }
 
+#if 0
+
 /* --------------------------------------------------------
  * Listener: unset / remove functions
  * -------------------------------------------------------- */
@@ -277,20 +277,20 @@
 	int m_flags{0};
 	bool m_removal{false};
 
-	inline void set(const SocketTable &, SocketAbstract &, int flags, bool) noexcept
+	inline void set(const ListenerTable &, Handle &, int flags, bool) noexcept
 	{
 		m_isset = true;
 		m_flags |= flags;
 	}
 
-	inline void unset(const SocketTable &, SocketAbstract &, int flags, bool remove) noexcept
+	inline void unset(const ListenerTable &, Handle &, int flags, bool remove) noexcept
 	{
 		m_isunset = true;
 		m_flags &= ~(flags);
 		m_removal = remove;
 	}
 
-	std::vector<SocketStatus> wait(const SocketTable &, int) noexcept
+	std::vector<ListenerStatus> wait(const ListenerTable &, int) noexcept
 	{
 		return {};
 	}
@@ -298,16 +298,16 @@
 
 class TestBackendUnsetFail {
 public:
-	inline void set(const SocketTable &, SocketAbstract &, int, bool) noexcept
+	inline void set(const ListenerTable &, Handle &, int, bool) noexcept
 	{
 	}
 
-	inline void unset(const SocketTable &, SocketAbstract &, int, bool)
+	inline void unset(const ListenerTable &, Handle &, int, bool)
 	{
 		throw "fail";
 	}
 
-	std::vector<SocketStatus> wait(const SocketTable &, int)
+	std::vector<ListenerStatus> wait(const ListenerTable &, int)
 	{
 		return {};
 	}
@@ -315,11 +315,11 @@
 
 TEST(ListenerUnsetRemove, unset)
 {
-	SocketListenerAbstract<TestBackendUnset> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendUnset> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read);
-	listener.unset(s, SocketListener::Read);
+	listener.set(s, FlagRead);
+	listener.unset(s, FlagRead);
 
 	ASSERT_EQ(0U, listener.size());
 	ASSERT_TRUE(listener.backend().m_isset);
@@ -330,27 +330,27 @@
 
 TEST(ListenerUnsetRemove, unsetOne)
 {
-	SocketListenerAbstract<TestBackendUnset> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendUnset> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read | SocketListener::Write);
-	listener.unset(s, SocketListener::Read);
+	listener.set(s, FlagRead | FlagWrite);
+	listener.unset(s, FlagRead);
 
 	ASSERT_EQ(1U, listener.size());
 	ASSERT_TRUE(listener.backend().m_isset);
 	ASSERT_TRUE(listener.backend().m_isunset);
-	ASSERT_TRUE(listener.backend().m_flags == SocketListener::Write);
+	ASSERT_TRUE(listener.backend().m_flags == FlagWrite);
 	ASSERT_FALSE(listener.backend().m_removal);
 }
 
 TEST(ListenerUnsetRemove, unsetAll)
 {
-	SocketListenerAbstract<TestBackendUnset> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendUnset> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read | SocketListener::Write);
-	listener.unset(s, SocketListener::Read);
-	listener.unset(s, SocketListener::Write);
+	listener.set(s, FlagRead | FlagWrite);
+	listener.unset(s, FlagRead);
+	listener.unset(s, FlagWrite);
 
 	ASSERT_EQ(0U, listener.size());
 	ASSERT_TRUE(listener.backend().m_isset);
@@ -361,10 +361,10 @@
 
 TEST(ListenerUnsetRemove, remove)
 {
-	SocketListenerAbstract<TestBackendUnset> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendUnset> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read | SocketListener::Write);
+	listener.set(s, FlagRead | FlagWrite);
 	listener.remove(s);
 
 	ASSERT_EQ(0U, listener.size());
@@ -376,10 +376,10 @@
 
 TEST(ListenerUnsetRemove, failure)
 {
-	SocketListenerAbstract<TestBackendUnsetFail> listener;
-	SocketAbstract s{0};
+	Listener<TestBackendUnsetFail> listener;
+	Handle s{0};
 
-	listener.set(s, SocketListener::Read | SocketListener::Write);
+	listener.set(s, FlagRead | FlagWrite);
 
 	try {
 		listener.remove(s);
@@ -397,7 +397,7 @@
 
 class ListenerTest : public testing::Test {
 protected:
-	SocketListenerAbstract<backend::Select> m_listener;
+	Listener<backend::Select> m_listener;
 	SocketTcp<Ipv4> m_masterTcp;
 	SocketTcp<Ipv4> m_clientTcp;
 
@@ -429,7 +429,7 @@
 {
 	m_tserver = std::thread([this] () {
 		try {
-			m_listener.set(m_masterTcp, SocketListener::Read);
+			m_listener.set(m_masterTcp, FlagRead);
 			m_listener.wait();
 			m_masterTcp.accept();
 			m_masterTcp.close();
@@ -449,7 +449,7 @@
 {
 	m_tserver = std::thread([this] () {
 		try {
-			m_listener.set(m_masterTcp, SocketListener::Read);
+			m_listener.set(m_masterTcp, FlagRead);
 			m_listener.wait();
 
 			auto sc = m_masterTcp.accept();
@@ -626,6 +626,8 @@
 	ASSERT_EQ(ip1, ip2);
 }
 
+#endif
+
 int main(int argc, char **argv)
 {
 	testing::InitGoogleTest(&argc, argv);