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();
}
}
}
private async Task VerifySentPayloads(TestNode server, byte[][] payloads) {
for (int i = 0; i < payloads.Length; i++) {
using (var result = await server.ReadMessage()) {
Assert.True(result.Payload.SequenceEqual(payloads[i]));
}
}
}
private void SendPayloadsWithoutWaiting(TestNode client, byte[][] payloads) {
for (int i = 0; i < payloads.Length; i++) {
client.SendDataAsync(payloads[i]);
}
}
private async Task SendPayloads(TestNode server, TestNode client, byte[][] payloads) {
for (int i = 0; i < payloads.Length; i++) {
client.SendDataAsync(payloads[i]);
using (var result = await server.ReadMessage()) {
Assert.True(result.Payload.SequenceEqual(payloads[i]));
}
}
}
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();
}
}
}
