public async Task SimpleMessageTest(byte[][] payloads, int latency, int dropPercentage) { using (var server = new TestNode()) { using (var client = new TestNode(new TestSettings(latency, dropPercentage))) { server.ListenAsync(); await client.ConnectAsync(); client.TestSettings.PacketDroppingEnabled = true; await SendPayloads(server, client, payloads); await client.DisconnectAsync(); } } }
public async Task ConnectionTest(int clientCount) { using (var server = new TestNode()) { server.ListenAsync(); List<TestNode> clients = new List<TestNode>(clientCount); for (int i = 0; i < clientCount; i++) { var client = new TestNode(); await client.ConnectAsync(); clients.Add(client); var result = await server.ReadState(); Assert.Equal(result, TestNodeState.Connected); Assert.True(server.IsStatesQueueEmpty()); } foreach (var client in clients) { client.Dispose(); } } }
public async Task ManySimpleMessageTest(byte[][] payloads, int latency, int dropPercentage) { using (var server = new TestNode()) { using (var client = new TestNode(new TestSettings(latency, dropPercentage))) { server.ListenAsync(); await client.ConnectAsync(); for (int i = 0; i < 1000; i++) { await SendPayloads(server, client, payloads); } await client.DisconnectAsync(); } } }
public async Task SendSpamTest(byte[][] payloads, int latency, int dropPercentage) { using (var server = new TestNode()) { using (var client = new TestNode(new TestSettings(latency, dropPercentage))) { server.ListenAsync(); await client.ConnectAsync(); for (int i = 0; i < 100000; i++) { SendPayloadsWithoutWaiting(client, payloads); } for (int i = 0; i < 100000; i++) { await VerifySentPayloads(server, payloads); } await client.DisconnectAsync(); } } }
public async Task TestHandlingDuplicatePackets() { using (var server = new TestNode()) { server.ListenAsync(); using (var client = new TestNode()) { await client.ConnectAsync(); var payload = GenerateRandomBytes(200); var startingSequenceNumber = client.RemoteConnection.SequenceNumber; for (int i = 0; i < 10; i++) { var packet = client.BuildReliableDataPacket(payload, 0, payload.Length, (ushort)(startingSequenceNumber + i)); var sendSequenceNumber = (ushort)client.RemoteConnection.IncrementSequenceNumber(); // Send duplicates client.SendToSequenced(client.RemoteConnection, sendSequenceNumber, packet, true); client.SendToSequenced(client.RemoteConnection, sendSequenceNumber, packet, true); client.SendToSequenced(client.RemoteConnection, sendSequenceNumber, packet, true); } for (int i = 0; i < 10; i++) { using (var result = await server.ReadMessage()) { Assert.True(result.Payload.SequenceEqual(payload)); } } } } }
public async Task TestIdleConnectionKeptAliveByHearbeat() { using (var server = new TestNode()) { server.ListenAsync(); using (var client = new TestNode()) { await client.ConnectAsync(); var result = await server.ReadState(); Assert.Equal(result, TestNodeState.Connected); Assert.True(server.IsStatesQueueEmpty()); // Wait 60 seconds doing nothing await Task.Delay(60000); Assert.Equal(ConnectionState.Connected, client.RemoteConnection.State); Assert.Equal(ConnectionState.Connected, server.RemoteConnection.State); } } }
public async Task TestDroppedConnectionWithHeartbeatAndNoIncomingData() { using (var server = new TestNode()) { server.ListenAsync(); var client = new TestNode(); await client.ConnectAsync(); var result = await server.ReadState(); Assert.Equal(result, TestNodeState.Connected); Assert.True(server.IsStatesQueueEmpty()); // Dispose, not a clean disconnect client.Dispose(); result = await server.ReadState(); Assert.Equal(result, TestNodeState.Disconnected); Assert.True(server.IsStatesQueueEmpty()); } }
public async Task TestDroppedConnectionWithIncomingData() { using (var server = new TestNode()) { server.ListenAsync(); var client = new TestNode(); await client.ConnectAsync(); var result = await server.ReadState(); Assert.Equal(result, TestNodeState.Connected); Assert.True(server.IsStatesQueueEmpty()); // Dispose, not a clean disconnect client.Dispose(); var payload = GenerateRandomBytes(100); server.SendDataAsync(payload); result = await server.ReadState(); Assert.Equal(result, TestNodeState.Disconnected); Assert.True(server.IsStatesQueueEmpty()); } }
public async Task ConnectDisconnectTest() { using (var server = new TestNode()) { using (var client = new TestNode()) { server.ListenAsync(); await client.ConnectAsync(); // Ensure both the client and server are connected var result = await client.ReadState(); Assert.Equal(result, TestNodeState.Connected); Assert.True(client.IsStatesQueueEmpty()); result = await server.ReadState(); Assert.Equal(result, TestNodeState.Connected); Assert.True(server.IsStatesQueueEmpty()); await client.DisconnectAsync(); // Ensure both the client and server and disconnected result = await client.ReadState(); Assert.Equal(result, TestNodeState.Disconnected); Assert.True(client.IsStatesQueueEmpty()); result = await server.ReadState(); Assert.Equal(result, TestNodeState.Disconnected); Assert.True(server.IsStatesQueueEmpty()); } } }
public async Task PoolSizeTest(byte[][] payloads, int latency, int dropPercentage) { using (var server = new TestNode()) { using (var client = new TestNode(new TestSettings(latency, dropPercentage))) { int startingServerPacketPoolSize = server.PacketPool.Size; int startingClientPacketPoolSize = client.PacketPool.Size; int startingServerSocketPoolSize = server.SocketEventArgsPool.Size; int startingClientSocketPoolSize = client.SocketEventArgsPool.Size; server.ListenAsync(); await client.ConnectAsync(); await SendPayloads(server, client, payloads); // Let all the pool objects be released await Task.Delay(1); // There should be one less for both server and client because they are still listening/connected Assert.Equal(startingServerPacketPoolSize - 1, server.PacketPool.Size); Assert.Equal(startingClientPacketPoolSize - 1, client.PacketPool.Size); Assert.Equal(startingServerSocketPoolSize - 1, server.SocketEventArgsPool.Size); Assert.Equal(startingClientSocketPoolSize - 1, client.SocketEventArgsPool.Size); await client.DisconnectAsync(); } } }
public async Task MultipleLargeMessageTests() { using (var server = new TestNode()) { using (var client = new TestNode()) { server.ListenAsync(); await client.ConnectAsync(); for (int i = 0; i < 10; i++) { byte[] buffer = new byte[10000]; Random rand = new Random(); rand.NextBytes(buffer); await SendPayloads(server, client, new byte[][] { buffer }); } await client.DisconnectAsync(); } } }
public async Task ManySimpleMessageTestWithoutWaiting(byte[][] payloads, int latency, int dropPercentage) { using (var server = new TestNode()) { using (var client = new TestNode(new TestSettings(latency, dropPercentage))) { server.ListenAsync(); await client.ConnectAsync(); for (int n = 0; n < 50; n++) { for (int i = 0; i < payloads.Length; i++) { client.SendDataAsync(payloads[i]); } } for (int n = 0; n < 50; n++) { for (int i = 0; i < payloads.Length; i++) { using (var result = await server.ReadMessage()) { Assert.True(result.Payload.SequenceEqual(payloads[i])); } } } await client.DisconnectAsync(); } } }