public void TestMultipleClientConnections() { SocketState state = new SocketState(null, null); int i = 0; int j = 0; void toServerCall(SocketState s) { i++; } void toClientCall(SocketState s) { j++; NetworkTestHelper.WaitForOrTimeout(() => false, 2000); Assert.IsTrue(i == j); } TcpListener listener = Networking.StartServer(toServerCall, 2112); Networking.ConnectToServer(toClientCall, "localhost", 2112); Networking.ConnectToServer(toClientCall, "localhost", 2112); Networking.ConnectToServer(toClientCall, "localhost", 2112); Networking.ConnectToServer(toClientCall, "localhost", 2112); Networking.ConnectToServer(toClientCall, "localhost", 2112); }
public void TestConnectWithIPV6() { bool isCalled = false; bool serverActionCalled = false; void saveClientState(SocketState x) { isCalled = true; testLocalSocketState = x; } void saveServerState(SocketState x) { testLocalSocketState = x; serverActionCalled = true; } testListener = Networking.StartServer(saveServerState, 2112); // Try to connect without setting up a server first. Networking.ConnectToServer(saveClientState, "ipv6.google.com", 2112); // NetworkTestHelper.WaitForOrTimeout(() => isCalled, NetworkTestHelper.timeout); Assert.IsTrue(isCalled); Assert.IsTrue(testLocalSocketState.ErrorOccured); Assert.AreEqual("IPV4 addresses were not found", testLocalSocketState.ErrorMessage); }
public void TestConnectCallsDelegate() { bool serverActionCalled = false; bool clientActionCalled = false; void saveServerState(SocketState x) { testLocalSocketState = x; serverActionCalled = true; } void saveClientState(SocketState x) { testRemoteSocketState = x; clientActionCalled = true; } testListener = Networking.StartServer(saveServerState, 2112); Networking.ConnectToServer(saveClientState, "localhost", 2112); NetworkTestHelper.WaitForOrTimeout(() => serverActionCalled, NetworkTestHelper.timeout); NetworkTestHelper.WaitForOrTimeout(() => clientActionCalled, NetworkTestHelper.timeout); Assert.IsTrue(serverActionCalled); Assert.IsTrue(clientActionCalled); }
public void TestStopServer() { void saveServerState(SocketState x) { testLocalSocketState = x; } void saveClientState(SocketState x) { testLocalSocketState = x; } testListener = Networking.StartServer(saveServerState, 2112); Networking.ConnectToServer(saveClientState, "localhost", 2112); Assert.IsTrue(testLocalSocketState.TheSocket.Connected); Networking.StopServer(testListener); }
public void TestStartServer() { SocketState state = new SocketState(null, null); void toCall(SocketState s) { } bool passed = false; try { TcpListener listener = Networking.StartServer(toCall, 10000000); NetworkTestHelper.WaitForOrTimeout(() => false, 2000); } catch (Exception e) { passed = true; } Assert.IsTrue(passed); }
private TcpListener SetupSingleServerTest() { void saveServerState(SocketState x) { testLocalSocketState = x; testLocalSocketState.OnNetworkAction = s => { }; } void saveClientState(SocketState x) { testRemoteSocketState = x; } TcpListener listener = Networking.StartServer(saveServerState, 2112); Networking.ConnectToServer(saveClientState, "localhost", 2112); WaitForOrTimeout(() => (testLocalSocketState != null) && (testRemoteSocketState != null), timeout); return(listener); }
public void TestConnectCallsDelegate() { bool isCalled = false; void saveServerState(SocketState x) { testLocalSocketState = x; isCalled = true; } void saveClientState(SocketState x) { testRemoteSocketState = x; } testListener = Networking.StartServer(saveServerState, 2112); Networking.ConnectToServer(saveClientState, "localhost", 2112); WaitForOrTimeout(() => isCalled, timeout); Assert.IsTrue(isCalled); }
public static void SetupSingleConnectionTest(out TcpListener listener, out SocketState client, out SocketState server, int port) { SocketState clientResult = null; SocketState serverResult = null; void saveClientState(SocketState x) { clientResult = x; } void saveServerState(SocketState x) { serverResult = x; } listener = Networking.StartServer(saveServerState, port); Networking.ConnectToServer(saveClientState, "localhost", port); WaitForOrTimeout(() => (clientResult != null) && (serverResult != null), timeout); client = clientResult; server = serverResult; }
public void TestConnectToServerError3() { string message = "this message here"; bool firstTime = true; int times = 0; void toCall(SocketState s) { times++; testLocalSocketState = s; if (firstTime) { firstTime = false; throw new Exception(message); } } testListener = Networking.StartServer(s => { }, 2134); Networking.ConnectToServer(toCall, "localhost", 2134); NetworkTestHelper.WaitForOrTimeout(() => false, 3000); Assert.IsTrue(testLocalSocketState.ErrorOccured); Assert.IsTrue(testLocalSocketState.ErrorMessage.Equals(message)); }
public void TestTwoServers() { SocketState server2 = null; SocketState client2 = null; bool server2Connected = false; bool receive1Called = false; bool receive2Called = false; string client1Message = ""; string client2Message = ""; string server1Message = ""; string server2Message = ""; void Server2OnConnect(SocketState s) { if (s.ErrorOccured) { return; } server2Connected = true; server2 = s; server2.OnNetworkAction = Server2OnReceive; } void Client2OnConnect(SocketState s) { if (s.ErrorOccured) { return; } client2 = s; } void Server1OnReceive(SocketState s) { if (s.ErrorOccured) { return; } receive1Called = true; server1Message = s.GetData(); } void Server2OnReceive(SocketState s) { if (s.ErrorOccured) { return; } receive2Called = true; server2Message = s.GetData(); } void Client1OnReceive(SocketState s) { if (s.ErrorOccured) { return; } receive1Called = true; client1Message = s.GetData(); } void Client2OnReceive(SocketState s) { if (s.ErrorOccured) { return; } receive2Called = true; client2Message = s.GetData(); } // setup first server and client using the normal helper SetupTestConnections(false); testLocalSocketState.OnNetworkAction = Server1OnReceive; // setup second server and client TcpListener listener2 = Networking.StartServer(Server2OnConnect, 2222); Networking.ConnectToServer(Client2OnConnect, "localhost", 2222); // wait for the second pair to connect WaitForOrTimeout(() => server2 != null && client2 != null, timeout); // Receive on server1 Networking.GetData(testLocalSocketState); // Receive on server2 Networking.GetData(server2); // Receive on client1 testRemoteSocketState.OnNetworkAction = Client1OnReceive; Networking.GetData(testRemoteSocketState); // Receive on client2 client2.OnNetworkAction = Client2OnReceive; Networking.GetData(client2); // Send from client1 to server1 Networking.Send(testRemoteSocketState.TheSocket, "a"); // Send from client2 to server2 Networking.Send(client2.TheSocket, "b"); // Send from server1 to client1 Networking.Send(testLocalSocketState.TheSocket, "c"); // Send from server2to client2 Networking.Send(server2.TheSocket, "d"); WaitForOrTimeout(() => server2Connected && receive1Called && receive2Called, timeout); Assert.IsTrue(server2Connected); Assert.IsTrue(receive1Called); Assert.IsTrue(receive2Called); Assert.AreEqual("a", server1Message); Assert.AreEqual("b", server2Message); Assert.AreEqual("c", client1Message); Assert.AreEqual("d", client2Message); }
private TcpListener StartTestServer(int port) { TcpListener listener = Networking.StartServer(OnNewClient, port); return(listener); }
private void GameServer( out Dictionary <long, StringBuilder> serverSentMessages, out Dictionary <long, StringBuilder> serverReceivedMessages) { object serverConnectionsLock = new object(); Dictionary <long, SocketState> serverSocketStates = new Dictionary <long, SocketState>(); Dictionary <long, StringBuilder> sentMessages = new Dictionary <long, StringBuilder>(); Dictionary <long, StringBuilder> receivedMessages = new Dictionary <long, StringBuilder>(); Random rand = new Random(0); // Local function to serve as a callMe delegate void serverFirstContact(SocketState state) { if (state.ErrorOccured) { return; } // Save the socket state so we can broadcast to all clients // Also save the rest of the per-connection state for validating the test lock (serverConnectionsLock) { // Use one of the stringbuilder lists as a unique socket ID // since they will strictly grow (the SocketState lists will grow and shrink) //state.uid = sentMessages.Count; sentMessages[state.ID] = new StringBuilder(); receivedMessages[state.ID] = new StringBuilder(); serverSocketStates[state.ID] = state; // send the client's ID // important to do this inside the lock so the broadcast loop doesn't // run before sending the client's ID sentMessages[state.ID].Append("" + state.ID + "\n"); Networking.Send(state.TheSocket, "" + state.ID + "\n"); } // Start a receive loop from the client state.OnNetworkAction = removeMessage; Networking.GetData(state); } // Local function to serve as a callMe delegate // Receive loop for the server that just removes and saves the client's messages void removeMessage(SocketState state) { if (state.ErrorOccured) { return; } StringBuilder rcv; lock (serverConnectionsLock) { rcv = receivedMessages[state.ID]; } rcv.Append(state.GetData()); state.RemoveData(0, state.GetData().Length); Networking.GetData(state); } testListener = Networking.StartServer(serverFirstContact, 2112); // Start a stopwatch to simulate a game server's tick-rate System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch(); watch = new System.Diagnostics.Stopwatch(); watch.Start(); int nextChar = 0; // Run for 150 frames for (int frame = 0; frame < 150; frame++) { // Create several messages ranging in size between 0x - 0.5x the buffer size, StringBuilder messages = new StringBuilder(); for (int i = 0; i < 3; i++) { for (int j = 0; j < rand.Next((int)(SocketState.BufferSize * 0.5)); j++) { messages.Append((char)('a' + (nextChar++ % 26))); } // Newline separator indicates end of object messages.Append("\n"); } lock (serverConnectionsLock) { foreach (StringBuilder sb in sentMessages.Values) { sb.Append(messages); } foreach (SocketState ss in serverSocketStates.Values) { if (ss.TheSocket.Connected) { Networking.Send(ss.TheSocket, messages.ToString()); } } } // Simulate slow-ish server that gives the clients enough time to receive // between frames so that we can assume that everything sent is also received while (watch.ElapsedMilliseconds < 30) { /* just waiting */ } watch.Restart(); } // end frame loop serverSentMessages = sentMessages; serverReceivedMessages = receivedMessages; }
public void TestSimulateClientAndServer() { // For this test, we will use testRemoteSocketState as the server's SocketState // and testLocalSocketState as the client's SocketState Random rand = new Random(0); StringBuilder serverReceived = new StringBuilder(); StringBuilder clientReceived = new StringBuilder(); StringBuilder clientSent = new StringBuilder(); // Local function to serve as a callMe delegate void serverFirstContact(SocketState state) { if (state.ErrorOccured) { return; } // Save the socket state globally so that the Cleanup method can close it testRemoteSocketState = state; // Start a receive loop from the client state.OnNetworkAction = removeMessage; Networking.GetData(state); } // Local function to serve as a callMe delegate // Receive loop for the server that just removes and saves the client's messages void removeMessage(SocketState state) { if (state.ErrorOccured) { return; } serverReceived.Append(state.GetData()); state.RemoveData(0, state.GetData().Length); Networking.GetData(state); } // Local function to serve as a callMe delegate void clientFirstContact(SocketState state) { if (state.ErrorOccured) { return; } // Save the socket state globally so that the Cleanup method can close it testLocalSocketState = state; // Start a receive loop from the server state.OnNetworkAction = handleMessage; Networking.GetData(state); } // Local function to serve as a callMe delegate // Receive loop for the client that simualtes "processing" a message by // looking for a newline separator void handleMessage(SocketState state) { if (state.ErrorOccured) { return; } ProcessMessage(state, clientReceived); // Reply to the server about half of the time if (rand.Next(2) == 0) { StringBuilder reply = new StringBuilder(); for (int i = 0; i < rand.Next(10); i++) { reply.Append((char)('a' + rand.Next(26))); } reply.Append("\n"); clientSent.Append(reply); Networking.Send(state.TheSocket, reply.ToString()); } // Continue the receive loop Networking.GetData(state); } // Start the listener testListener = Networking.StartServer(serverFirstContact, 2112); // Start the client Networking.ConnectToServer(clientFirstContact, "localhost", 2112); // Wait for both sides to connect WaitForOrTimeout(() => testLocalSocketState != null && testRemoteSocketState != null, timeout); // Run the server loop StringBuilder serverSent = SingleClientServerLoop(); WaitForOrTimeout(() => clientReceived.Length == serverSent.Length, timeout); WaitForOrTimeout(() => clientSent.Length == serverReceived.Length, timeout); Assert.AreEqual(clientReceived.ToString(), serverSent.ToString()); Assert.AreEqual(clientSent.ToString(), serverReceived.ToString()); }
public void TestMyOwn() { // List to represents connections List <SocketState> server = new List <SocketState>(); void SaveServer(SocketState s) { lock (this) { server.Add(s); } } //Two clients SocketState client_1 = null; void SaveClient_1(SocketState s) { client_1 = s; } SocketState client_2 = null; void SaveClient_2(SocketState s) { client_2 = s; } // Starting a server TcpListener listener = Networking.StartServer(SaveServer, 2112); // Client1 Connect to the server Networking.ConnectToServer(SaveClient_1, "localhost", 2112); // Client2 Connect to the server Networking.ConnectToServer(SaveClient_2, "localhost", 2112); // Make sure this line is what you want to it behave NetworkTestHelper.WaitForOrTimeout(() => (client_2 != null) && (client_1 != null) && (server.Count == 2), NetworkTestHelper.timeout); // Set the action to do nothing foreach (SocketState state in server) { state.OnNetworkAction = x => { }; } client_1.OnNetworkAction = x => { }; client_2.OnNetworkAction = x => { }; foreach (SocketState state in server) { Networking.SendAndClose(state.TheSocket, "a"); } Networking.GetData(client_1); Networking.GetData(client_2); // Note that waiting for data like this is *NOT* how the networking library is // intended to be used. This is only for testing purposes. // Normally, you would provide an OnNetworkAction that handles the data. NetworkTestHelper.WaitForOrTimeout(() => client_1.GetData().Length > 0 && client_2.GetData().Length > 0, NetworkTestHelper.timeout); Assert.AreEqual("a", client_1.GetData()); Assert.AreEqual("a", client_2.GetData()); //Make sure everything close and stop properly listener.Stop(); foreach (SocketState state in server) { state.TheSocket.Close(); } client_1.TheSocket.Close(); client_2.TheSocket.Close(); }