public static async Task CanSendMessageAndWaitAsync()
{
var port = Utils.GetRandomClientPort();
using var messageReceivedEvent = new ManualResetEventSlim();
byte[] testMessage = Encoding.UTF8.GetBytes("Test");
Task messageWriteTask = null;
using var server = new ConcurrentFlareTcpServer();
server.ClientConnected += clientId => {
messageWriteTask = server.EnqueueMessageAndWaitUntilSentAsync(clientId, testMessage);
messageReceivedEvent.Set();
};
var listenTask = Task.Run(() => server.ListenAsync(port));
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
Assert.IsTrue(messageReceivedEvent.Wait(TimeSpan.FromSeconds(5)));
Assert.IsNotNull(messageWriteTask);
await Utils.WithTimeout(messageWriteTask, TimeSpan.FromSeconds(5));
using var message = client.ReadNextMessage();
Assert.AreEqual(message.Span.ToArray(), testMessage);
client.Disconnect();
server.Shutdown();
await Utils.WithTimeout(listenTask, TimeSpan.FromSeconds(5));
}
public void Setup()
{
var port = Utils.GetRandomClientPort();
var random = new Random();
data = new byte[MessageBytes];
random.NextBytes(data);
server = new ConcurrentFlareTcpServer();
client = new FlareTcpClient();
server.MessageReceived += (clientId, message) => {
server.EnqueueMessage(clientId, message);
};
_ = Task.Run(() => server.ListenAsync(port));
client.Connect(IPAddress.Loopback, port);
}
public static void FreesSocket()
{
var port = Utils.GetRandomClientPort();
using var server = new ConcurrentFlareTcpServer();
var clientTask = Task.Run(() => {
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
client.Disconnect();
});
server.ClientDisconnected += _ => {
server.Shutdown();
};
server.Listen(port);
Assert.IsTrue(clientTask.Wait(TimeSpan.FromSeconds(5)), "Client Task did not complete successfully.");
Assert.IsFalse(Utils.IsPortInUse(port), "Port is still in use after server shutdown.");
}
public static async Task CanAcceptClientAsync()
{
var port = Utils.GetRandomClientPort();
using var server = new FlareTcpServer();
server.Start(port);
var clientTask = Task.Run(() => {
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
client.Disconnect();
});
using var client = await server.AcceptClientAsync().ConfigureAwait(false);
Assert.IsNotNull(client);
server.Shutdown();
await clientTask.ConfigureAwait(false);
}
public static void CanAcceptClient()
{
var port = Utils.GetRandomClientPort();
using var server = new FlareTcpServer();
server.Start(port);
var clientTask = Task.Run(() => {
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
client.Disconnect();
});
using var client = server.AcceptClient();
client.Disconnect();
Assert.IsNotNull(client);
server.Shutdown();
Assert.IsTrue(clientTask.Wait(TimeSpan.FromSeconds(5)), "Client Task did not complete successfully.");
}
public static void ConnectedEventRaised()
{
var port = Utils.GetRandomClientPort();
using var clientConnectedEvent = new ManualResetEventSlim();
using var server = new ConcurrentFlareTcpServer();
server.ClientConnected += _ => {
clientConnectedEvent.Set();
};
var listenTask = Task.Run(() => server.ListenAsync(port));
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
Assert.IsTrue(clientConnectedEvent.Wait(TimeSpan.FromSeconds(5)));
client.Disconnect();
server.Shutdown();
Assert.IsTrue(listenTask.Wait(TimeSpan.FromSeconds(5)));
}
public static void CanSendMessage()
{
var port = Utils.GetRandomClientPort();
byte[] testMessage = Encoding.UTF8.GetBytes("Test");
using var server = new ConcurrentFlareTcpServer();
server.ClientConnected += clientId => {
server.EnqueueMessage(clientId, testMessage);
};
var listenTask = Task.Run(() => server.ListenAsync(port));
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
using var message = client.ReadNextMessage();
Assert.AreEqual(message.Span.ToArray(), testMessage);
client.Disconnect();
server.Shutdown();
Assert.IsTrue(listenTask.Wait(TimeSpan.FromSeconds(5)));
}
public static async Task CanSendMessageAndFree()
{
var port = Utils.GetRandomClientPort();
byte[] testMessage = Encoding.UTF8.GetBytes("Test");
using var server = new ConcurrentFlareTcpServer();
server.MessageReceived += (clientId, message) => {
server.EnqueueMessage(clientId, message);
};
var listenTask = Task.Run(() => server.ListenAsync(port));
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
client.WriteMessage(testMessage);
using var message = client.ReadNextMessage();
Assert.AreEqual(message.Span.ToArray(), testMessage);
client.Disconnect();
server.Shutdown();
await Utils.WithTimeout(listenTask, TimeSpan.FromSeconds(5));
}
public static void CanSendMessage()
{
var port = Utils.GetRandomClientPort();
byte[] testMessage = Encoding.UTF8.GetBytes("Test");
using var server = new FlareTcpServer();
server.Start(port);
var clientTask = Task.Run(() => {
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
using var message = client.ReadNextMessage();
Assert.AreEqual(message.Span.ToArray(), testMessage);
client.Disconnect();
});
using var client = server.AcceptClient();
client.WriteMessage(testMessage);
server.Shutdown();
clientTask.Wait(TimeSpan.FromSeconds(5));
}
public static async Task CanSendMessageAsync()
{
var port = Utils.GetRandomClientPort();
byte[] testMessage = Encoding.UTF8.GetBytes("Test");
using var server = new FlareTcpServer();
server.Start(port);
var clientTask = Task.Run(() => {
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
using var message = client.ReadNextMessage();
Assert.AreEqual(message.Span.ToArray(), testMessage);
client.Disconnect();
});
using var client = await server.AcceptClientAsync().ConfigureAwait(false);
await client.WriteMessageAsync(testMessage).ConfigureAwait(false);
server.Shutdown();
await clientTask.ConfigureAwait(false);
}
public static void CanReceiveMessage()
{
var port = Utils.GetRandomClientPort();
byte[] testMessage = Encoding.UTF8.GetBytes("Test");
using var messageReceivedEvent = new ManualResetEventSlim();
using var server = new ConcurrentFlareTcpServer();
server.MessageReceived += (_, message) => {
Assert.AreEqual(message.Span.ToArray(), testMessage);
messageReceivedEvent.Set();
message.Dispose();
};
var listenTask = Task.Run(() => server.ListenAsync(port));
using var client = new FlareTcpClient();
client.Connect(IPAddress.Loopback, port);
Assert.IsFalse(messageReceivedEvent.IsSet);
client.WriteMessage(testMessage);
client.Disconnect();
Assert.IsTrue(messageReceivedEvent.Wait(TimeSpan.FromSeconds(5)));
server.Shutdown();
Assert.IsTrue(listenTask.Wait(TimeSpan.FromSeconds(5)));
}
