--- a/C++/tests/Socket/main.cpp	Thu Jun 18 14:24:01 2015 +0200
+++ b/C++/tests/Socket/main.cpp	Fri Jun 19 10:52:54 2015 +0200
@@ -76,7 +76,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
+		m_client.connect(std::make_unique<Internet>("127.0.0.1", 16000, AF_INET));
 
 		ASSERT_EQ(SocketState::Connected, m_client.state());
 
@@ -91,25 +91,20 @@
 		m_server.listen();
 
 		auto client = m_server.accept();
-		auto msg = client.recv(512);
+		auto msg = client->recv(512);
 
 		ASSERT_EQ("hello world", msg);
 
-		client.send(msg);
-		client.close();
-
-		m_server.close();
+		client->send(msg);
 	});
 
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
+		m_client.connect(std::make_unique<Internet>("127.0.0.1", 16000, AF_INET));
 		m_client.send("hello world");
 
 		ASSERT_EQ("hello world", m_client.recv(512));
-
-		m_client.close();
 	});
 }
 
@@ -178,25 +173,25 @@
 	bool m_added{false};
 	int m_flags{0};
 
-	inline void set(const SocketTable &, Socket sc, int flags, bool add) noexcept
+	inline void set(const SocketTable &, const std::shared_ptr<Socket> &sc, int flags, bool add) noexcept
 	{
 		m_callcount ++;
 		m_added = add;
 		m_flags |= flags;
 	}
 
-	inline void unset(const SocketTable &, Socket, int, bool) noexcept {}
+	inline void unset(const SocketTable &, const std::shared_ptr<Socket> &, int, bool) noexcept {}
 	std::vector<SocketStatus> wait(const SocketTable &table, int ms) {}
 };
 
 class TestBackendSetFail {
 public:
-	inline void set(const SocketTable &, Socket, int, bool)
+	inline void set(const SocketTable &, const std::shared_ptr<Socket> &, int, bool)
 	{
 		throw "fail";
 	}
 
-	inline void unset(const SocketTable &, Socket, int, bool) noexcept {}
+	inline void unset(const SocketTable &, const std::shared_ptr<Socket> &, int, bool) noexcept {}
 	std::vector<SocketStatus> wait(const SocketTable &table, int ms) {}
 };
 
@@ -204,7 +199,7 @@
 {
 	SocketListenerBase<TestBackendSet> listener;
 
-	listener.set(Socket(0), SocketListener::Read);
+	listener.set(std::make_shared<Socket>(0), SocketListener::Read);
 
 	ASSERT_EQ(1U, listener.size());
 	ASSERT_EQ(1, listener.backend().m_callcount);
@@ -215,7 +210,7 @@
 TEST(ListenerSet, readThenWrite)
 {
 	SocketListenerBase<TestBackendSet> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read);
 	listener.set(sc, SocketListener::Write);
@@ -229,7 +224,7 @@
 TEST(ListenerSet, allOneShot)
 {
 	SocketListenerBase<TestBackendSet> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read | SocketListener::Write);
 
@@ -242,7 +237,7 @@
 TEST(ListenerSet, readTwice)
 {
 	SocketListenerBase<TestBackendSet> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read);
 	listener.set(sc, SocketListener::Read);
@@ -258,7 +253,7 @@
 	SocketListenerBase<TestBackendSetFail> listener;
 
 	try {
-		listener.set(Socket(0), SocketListener::Read);
+		listener.set(std::make_shared<Socket>(0), SocketListener::Read);
 		FAIL() << "exception expected";
 	} catch (...) {
 	}
@@ -277,13 +272,13 @@
 	int m_flags{0};
 	bool m_removal{false};
 
-	inline void set(const SocketTable &, Socket, int flags, bool) noexcept
+	inline void set(const SocketTable &, const std::shared_ptr<Socket> &, int flags, bool) noexcept
 	{
 		m_isset = true;
 		m_flags |= flags;
 	}
 
-	inline void unset(const SocketTable &, Socket, int flags, bool remove) noexcept
+	inline void unset(const SocketTable &, const std::shared_ptr<Socket> &, int flags, bool remove) noexcept
 	{
 		m_isunset = true;
 		m_flags &= ~(flags);
@@ -295,9 +290,9 @@
 
 class TestBackendUnsetFail {
 public:
-	inline void set(const SocketTable &, Socket, int, bool) noexcept {}
+	inline void set(const SocketTable &, const std::shared_ptr<Socket> &, int, bool) noexcept {}
 
-	inline void unset(const SocketTable &, Socket, int, bool)
+	inline void unset(const SocketTable &, const std::shared_ptr<Socket> &, int, bool)
 	{
 		throw "fail";
 	}
@@ -308,7 +303,7 @@
 TEST(ListenerUnsetRemove, unset)
 {
 	SocketListenerBase<TestBackendUnset> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read);
 	listener.unset(sc, SocketListener::Read);
@@ -323,7 +318,7 @@
 TEST(ListenerUnsetRemove, unsetOne)
 {
 	SocketListenerBase<TestBackendUnset> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read | SocketListener::Write);
 	listener.unset(sc, SocketListener::Read);
@@ -338,7 +333,7 @@
 TEST(ListenerUnsetRemove, unsetAll)
 {
 	SocketListenerBase<TestBackendUnset> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read | SocketListener::Write);
 	listener.unset(sc, SocketListener::Read);
@@ -354,7 +349,7 @@
 TEST(ListenerUnsetRemove, remove)
 {
 	SocketListenerBase<TestBackendUnset> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read | SocketListener::Write);
 	listener.remove(sc);
@@ -369,7 +364,7 @@
 TEST(ListenerUnsetRemove, failure)
 {
 	SocketListenerBase<TestBackendUnsetFail> listener;
-	Socket sc(0);
+	std::shared_ptr<Socket> sc = std::make_shared<Socket>(0);
 
 	listener.set(sc, SocketListener::Read | SocketListener::Write);
 
@@ -390,18 +385,20 @@
 class ListenerTest : public testing::Test {
 protected:
 	SocketListenerBase<backend::Select> m_listener;
-	SocketTcp m_masterTcp{AF_INET, 0};
-	SocketTcp m_clientTcp{AF_INET, 0};
+	std::shared_ptr<SocketTcp> m_masterTcp;
+	std::shared_ptr<SocketTcp> m_clientTcp;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
 
 public:
 	ListenerTest()
+		: m_masterTcp{std::make_shared<SocketTcp>(AF_INET, 0)}
+		, m_clientTcp{std::make_shared<SocketTcp>(AF_INET, 0)}
 	{
-		m_masterTcp.set(SOL_SOCKET, SO_REUSEADDR, 1);
-		m_masterTcp.bind(Internet("*", 16000, AF_INET));
-		m_masterTcp.listen();
+		m_masterTcp->set(SOL_SOCKET, SO_REUSEADDR, 1);
+		m_masterTcp->bind(Internet("*", 16000, AF_INET));
+		m_masterTcp->listen();
 	}
 
 	~ListenerTest()
@@ -421,8 +418,8 @@
 		try {
 			m_listener.set(m_masterTcp, SocketListener::Read);
 			m_listener.wait();
-			m_masterTcp.accept();
-			m_masterTcp.close();
+			m_masterTcp->accept();
+			m_masterTcp->close();
 		} catch (const std::exception &ex) {
 			FAIL() << ex.what();
 		}
@@ -431,7 +428,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_clientTcp.connect(Internet("127.0.0.1", 16000, AF_INET));
+		m_clientTcp->connect(std::make_unique<Internet>("127.0.0.1", 16000, AF_INET));
 	});
 }
 
@@ -442,11 +439,9 @@
 			m_listener.set(m_masterTcp, SocketListener::Read);
 			m_listener.wait();
 
-			auto sc = m_masterTcp.accept();
+			auto sc = m_masterTcp->accept();
 
-			ASSERT_EQ("hello", sc.recv(512));
-
-			m_masterTcp.close();
+			ASSERT_EQ("hello", sc->recv(512));
 		} catch (const std::exception &ex) {
 			FAIL() << ex.what();
 		}
@@ -455,8 +450,8 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_clientTcp.connect(Internet("127.0.0.1", 16000, AF_INET));
-		m_clientTcp.send("hello");
+		m_clientTcp->connect(std::make_unique<Internet>("127.0.0.1", 16000, AF_INET));
+		m_clientTcp->send("hello");
 	});
 }
 
@@ -487,54 +482,6 @@
 	}
 };
 
-TEST_F(NonBlockingConnectTest, success)
-{
-	m_server.set(SOL_SOCKET, SO_REUSEADDR, 1);
-	m_server.bind(Internet("*", 16000, AF_INET));
-	m_server.listen();
-
-	m_tserver = std::thread([this] () {
-		SocketTcp client = m_server.accept();
-
-		std::this_thread::sleep_for(100ms);
-
-		m_server.close();
-		client.close();
-	});
-
-	std::this_thread::sleep_for(100ms);
-
-	m_tclient = std::thread([this] () {
-		try {
-			m_client.waitConnect(Internet("127.0.0.1", 16000, AF_INET), 3000);
-		} catch (const SocketError &error) {
-			FAIL() << error.function() << ": " << error.what();
-		}
-
-		ASSERT_EQ(SocketState::Connected, m_client.state());
-
-		m_client.close();
-	});
-}
-
-TEST_F(NonBlockingConnectTest, fail)
-{
-	/*
-	 * /!\ If you find a way to test this locally please tell me /!\
-	 */
-	m_tclient = std::thread([this] () {
-		try {
-			m_client.waitConnect(Internet("google.fr", 9000, AF_INET), 100);
-
-			FAIL() << "Expected exception, got success";
-		} catch (const SocketError &error) {
-			ASSERT_EQ(SocketError::Timeout, error.code());
-		}
-
-		m_client.close();
-	});
-}
-
 /* --------------------------------------------------------
  * TCP accept
  * -------------------------------------------------------- */
@@ -564,62 +511,6 @@
 	}
 };
 
-TEST_F(TcpAcceptTest, blockingWaitSuccess)
-{
-	m_tserver = std::thread([this] () {
-		try {
-			m_server.waitAccept(3000).close();
-		} catch (const SocketError &error) {
-			FAIL() << error.what();
-		}
-
-		m_server.close();
-	});
-
-	std::this_thread::sleep_for(100ms);
-
-	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
-		m_client.close();
-	});
-}
-
-TEST_F(TcpAcceptTest, nonBlockingWaitSuccess)
-{
-	m_tserver = std::thread([this] () {
-		try {
-			m_server.setBlockMode(false);
-			m_server.waitAccept(3000).close();
-		} catch (const SocketError &error) {
-			FAIL() << error.what();
-		}
-
-		m_server.close();
-	});
-
-	std::this_thread::sleep_for(100ms);
-
-	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
-		m_client.close();
-	});
-}
-
-TEST_F(TcpAcceptTest, nonBlockingWaitFail)
-{
-	// No client, no accept
-	try {
-		m_server.setBlockMode(false);
-		m_server.waitAccept(100).close();
-
-		FAIL() << "Expected exception, got success";
-	} catch (const SocketError &error) {
-		ASSERT_EQ(SocketError::Timeout, error.code());
-	}
-
-	m_server.close();
-}
-
 /* --------------------------------------------------------
  * TCP recv
  * -------------------------------------------------------- */
@@ -652,60 +543,15 @@
 TEST_F(TcpRecvTest, blockingSuccess)
 {
 	m_tserver = std::thread([this] () {
-		SocketTcp client = m_server.accept();
+		auto client = m_server.accept();
 
-		ASSERT_EQ("hello", client.recv(32));
-
-		client.close();
-		m_server.close();
+		ASSERT_EQ("hello", client->recv(32));
 	});
 
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
-		m_client.send("hello");
-		m_client.close();
-	});
-}
-
-TEST_F(TcpRecvTest, blockingWaitSuccess)
-{
-	m_tserver = std::thread([this] () {
-		SocketTcp client = m_server.accept();
-
-		ASSERT_EQ("hello", client.waitRecv(32, 3000));
-
-		client.close();
-		m_server.close();
-	});
-
-	std::this_thread::sleep_for(100ms);
-
-	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
-		m_client.send("hello");
-		m_client.close();
-	});
-}
-
-TEST_F(TcpRecvTest, nonBlockingWaitSuccess)
-{
-	m_tserver = std::thread([this] () {
-		SocketTcp client = m_server.accept();
-
-		client.setBlockMode(false);
-
-		ASSERT_EQ("hello", client.waitRecv(32, 3000));
-
-		client.close();
-		m_server.close();
-	});
-
-	std::this_thread::sleep_for(100ms);
-
-	m_tclient = std::thread([this] () {
-		m_client.connect(Internet("127.0.0.1", 16000, AF_INET));
+		m_client.connect(std::make_unique<Internet>("127.0.0.1", 16000, AF_INET));
 		m_client.send("hello");
 		m_client.close();
 	});
@@ -723,7 +569,7 @@
 TEST_F(SslTest, connect)
 {
 	try {
-		client.connect(Internet("google.fr", 443, AF_INET));
+		client.connect(std::make_unique<Internet>("google.fr", 443, AF_INET));
 		client.close();
 	} catch (const SocketError &error) {
 		FAIL() << error.what();
@@ -733,7 +579,7 @@
 TEST_F(SslTest, recv)
 {
 	try {
-		client.connect(Internet("google.fr", 443, AF_INET));
+		client.connect(std::make_unique<Internet>("google.fr", 443, AF_INET));
 		client.send("GET / HTTP/1.0\r\n\r\n");
 
 		std::string msg = client.recv(512);