public void TestDisconnectedSend()
{
TcpClient client = new();
PacketSocket socket = new PacketSocket(client);
byte[] payload = new byte[1024];
TestUtils.AssertException <InvalidOperationException>(socket.SendAsync(payload));
}
private void TestPacketSocket_communication(PacketSocket server, PacketSocket client)
{
const int PAYLOAD_SIZE = 1024;
const int COUNT = 100;
Assert.IsTrue(server.IsConnected);
Assert.IsTrue(client.IsConnected);
byte[] payload = new byte[PAYLOAD_SIZE];
for (int i = 0; i < payload.Length; i++)
{
payload[i] = (byte)i;
}
ActionBlock <byte[]> serverMessageBlock = new(buffer =>
{
CollectionAssert.AreEqual(payload, buffer);
});
ActionBlock <byte[]> clientMessageBlock = new(buffer =>
{
CollectionAssert.AreEqual(payload, buffer);
});
using var serverDisp = server.IncomingBufferBlock.LinkTo(serverMessageBlock);
using var clientDisp = client.IncomingBufferBlock.LinkTo(clientMessageBlock);
List <Task> taskList = new();
for (int i = 0; i < COUNT; i++)
{
taskList.Add(Task.Run(async() =>
{
Assert.IsTrue(await client.SendAsync(payload));
}));
taskList.Add(Task.Run(async() =>
{
Assert.IsTrue(await server.SendAsync(payload));
}));
}
Assert.IsTrue(Task.WhenAll(taskList).Wait(1000));
}
public void TestBasicFunctionality()
{
const int PORT = 1234;
EndpointManager endpointManager = new();
BufferBlock <TcpClient> block = new();
block.LinkTo(endpointManager.IncomingClientBlock);
using TcpClientListener listener = new TcpClientListener();
listener.StartListeningForConnections(PORT);
listener.ConnectingClientBlock.LinkTo(endpointManager.IncomingClientBlock);
//
// add unconnected client
// add client -> multiple clients
// disconnect client (extern)
// disconnect client (local, null)
// disconnect client (local, unregistered)
// disconnect client (local)
// add 2 clients
// send message via client 1
// send message via client 2
//
AsyncBarrier barrier = null;
EndpointEventType expectedType = new();
TcpClient clientUnconnected = new();
TcpClient client1 = new();
TcpClient client2 = new();
TcpClient client3 = new();
TcpClient clientRemoteDisconnect = new();
TcpClient clientLocalDisconnect = new();
IEndpoint ep = new Endpoint(new PacketSocket(clientUnconnected));
IEndpoint localDisconnectEp = null;
bool local = false;
bool remoteDisconnect = false;
List <IEndpoint> epList = new List <IEndpoint>();
SemaphoreSlim sem = new(1);
endpointManager.EndpointConnectedHandler = async ep =>
{
Assert.IsTrue(expectedType == EndpointEventType.Connect);
await sem.WaitAsync();
epList.Add(ep);
if (local)
{
localDisconnectEp = ep;
}
TestUtils.AssertTask(barrier.SignalAsync());
sem.Release();
};
endpointManager.EndpointDisconnectedHandler = async(ep, remote) =>
{
Assert.AreEqual(remoteDisconnect, remote);
Assert.IsTrue(expectedType == EndpointEventType.Disconnect);
await sem.WaitAsync();
Assert.IsTrue(epList.Remove(ep));
TestUtils.AssertTask(barrier.SignalAsync());
sem.Release();
};
expectedType = EndpointEventType.Connect;
barrier = new(4, false);
// add unconnected client
TestUtils.AssertTask(block.SendAsync(clientUnconnected));
var tasks = new List <Task>();
// add client -> multiple clients
tasks.Add(Task.Run(() => client1.Connect("localhost", PORT)));
tasks.Add(Task.Run(() => client2.Connect("localhost", PORT)));
tasks.Add(Task.Run(() => client3.Connect("localhost", PORT)));
tasks.Add(Task.Run(() => clientRemoteDisconnect.Connect("localhost", PORT)));
TestUtils.AssertTask(barrier.WaitAsync(), 3000);
local = true;
barrier = new(1, false);
tasks.Add(Task.Run(() => clientLocalDisconnect.Connect("localhost", PORT)));
TestUtils.AssertTask(barrier.WaitAsync(), 3000);
local = false;
CollectionAssert.Contains(epList, localDisconnectEp);
CollectionAssert.Contains(endpointManager.ConnectedEndpoints, localDisconnectEp);
Assert.AreEqual(5, endpointManager.ConnectedEndpoints.Count);
CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints);
Assert.IsNotNull(localDisconnectEp);
// disconnect client (remote)
expectedType = EndpointEventType.Disconnect;
remoteDisconnect = true;
barrier = new(1, false);
clientRemoteDisconnect.Close();
TestUtils.AssertTask(barrier.WaitAsync());
Assert.AreEqual(4, endpointManager.ConnectedEndpoints.Count);
Assert.AreEqual(4, epList.Count);
CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints);
CollectionAssert.Contains(epList, localDisconnectEp);
CollectionAssert.Contains(endpointManager.ConnectedEndpoints, localDisconnectEp);
// disconnect client (local, null)
remoteDisconnect = false;
TestUtils.AssertException <ArgumentNullException>(endpointManager.DisconnectEndpointAsync(null));
// disconnect client (local, unregistered)
TestUtils.AssertException <ArgumentException>(endpointManager.DisconnectEndpointAsync(ep));
CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints);
// disconnect client (local)
barrier = new(1, false);
CollectionAssert.Contains(endpointManager.ConnectedEndpoints, localDisconnectEp);
TestUtils.AssertTask(endpointManager.DisconnectEndpointAsync(localDisconnectEp));
TestUtils.AssertTask(barrier.WaitAsync());
CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints);
CollectionAssert.DoesNotContain(endpointManager.ConnectedEndpoints, localDisconnectEp);
barrier = new(1, false);
byte[] buffer = Encoding.ASCII.GetBytes("Hello World!");
ActionBlock <RawMessage> aB = new(m =>
{
CollectionAssert.AreEqual(buffer, m.Data);
_ = barrier.SignalAsync();
});
foreach (var e in endpointManager.ConnectedEndpoints)
{
Assert.IsTrue(e.Socket.IsConnected);
}
Assert.IsTrue(client1.Connected);
PacketSocket socket1 = new PacketSocket(client1);
Assert.IsTrue(socket1.IsReceiving);
Assert.IsTrue(socket1.IsConnected);
endpointManager.RawMessageBlock.LinkTo(aB);
Assert.IsTrue(TestUtils.AssertTask(socket1.SendAsync(buffer)));
TestUtils.AssertTask(barrier.WaitAsync());
}
