public async Task T10_Receive_Observable()
{
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
var acceptTask = server.AcceptAllAsync().FirstAsync();
var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
var accept = await acceptTask;
var sub = client.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Subscribe(str =>
{
Write(str);
});
accept.Send("Welcome!".ToByteArray());
accept.Send("Welcome Again!".ToByteArray());
await Task.Delay(100);
sub.Dispose();
await server.DisposeAsync();
await client.DisposeAsync();
}
public async Task T00_SendAndReceiveStringMessage()
{
// Create a socket server on the endpoint.
var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
// Start a task to allow the server to accept the next client connection.
var acceptTask = server.AcceptObservable.FirstAsync().ToTask();
// Create a socket client by successfully connecting to the server at EndPoint.
var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
// Get the client socket accepted by the server.
var accept = await acceptTask;
Assert.True(accept.Connected && client.Connected);
// start a task to receive the first string from the server.
var dataTask = client.ReceiveObservable.ToStrings().FirstAsync().ToTask();
// The server sends a string to the client.
accept.Send("Welcome!".ToByteArray());
Assert.Equal("Welcome!", await dataTask);
client.Dispose();
server.Dispose();
}
public async Task T01_Send_And_Receive_String_Message()
{
var server = RxSocketServer.Create(SocketServerLogger);
var ipEndPoint = server.IPEndPoint;
// Start a task to allow the server to accept the next client connection.
var acceptTask = server.AcceptAllAsync().FirstAsync();
// Create a socket client by successfully connecting to the server at EndPoint.
var client = await ipEndPoint.CreateRxSocketClientAsync(SocketClientLogger);
// Get the client socket accepted by the server.
var accept = await acceptTask;
Assert.True(accept.Connected && client.Connected);
// start a task to receive the first string from the server.
var dataTask = client.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().FirstAsync().ToTask();
// The server sends a string to the client.
accept.Send("Welcome!".ToByteArray());
Assert.Equal("Welcome!", await dataTask);
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T20_Accept_Observable()
{
var s = String.Create <double>(10, 99, (span, state) =>
{
//Span<char> xxx;
span[1] = 's';
//span.
return;
});
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
server.AcceptAllAsync().ToObservableFromAsyncEnumerable()
.Subscribe(accepted => accepted.Send("Welcome!".ToByteArray()));
var client1 = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
var client2 = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
var client3 = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
Assert.Equal("Welcome!", await client1.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Take(1).FirstAsync());
Assert.Equal("Welcome!", await client2.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Take(1).FirstAsync());
Assert.Equal("Welcome!", await client3.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Take(1).FirstAsync());
await client1.DisposeAsync();
await client2.DisposeAsync();
await client3.DisposeAsync();
await server.DisposeAsync();
}
public async Task Example()
{
// Create a server using a random available port on the local machine.
IRxSocketServer server = RxSocketServer.Create();
// Start accepting connections from clients.
server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(acceptClient =>
{
// After the server accepts a client connection,
// start receiving messages from the client and ...
acceptClient.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Subscribe(message =>
{
// echo each message received back to the client.
acceptClient.Send(message.ToByteArray());
});
});
// Find the address of the server.
var ipEndPoint = server.IPEndPoint;
// Create a client by connecting to the server.
IRxSocketClient client = await ipEndPoint.CreateRxSocketClientAsync();
// Send the message "Hello" to the server, which the server will then echo back to the client.
client.Send("Hello!".ToByteArray());
// Receive the message from the server.
string message = await client.ReceiveAllAsync().ToStrings().FirstAsync();
Assert.Equal("Hello!", message);
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T00_Example()
{
// Create a socket server on the Endpoint.
var server = RxSocketServer.Create(IPEndPoint);
// Start accepting connections from clients.
server.AcceptObservable.Subscribe(acceptClient =>
{
acceptClient.ReceiveObservable.ToStrings().Subscribe(onNext: message =>
{
// Echo each message received back to the client.
acceptClient.Send(message.ToByteArray());
});
});
// Create a socket client by connecting to the server at EndPoint.
var client = await RxSocketClient.ConnectAsync(IPEndPoint);
client.ReceiveObservable.ToStrings().Subscribe(onNext: message =>
{
Assert.Equal("Hello!", message);
});
client.Send("Hello!".ToByteArray());
await Task.Delay(100);
client.Dispose();
server.Dispose();
}
public async Task T30_Both()
{
var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); //.AddDisconnectableTo(disconnectables);
server.AcceptObservable.Subscribe(accepted =>
{
"Welcome!".ToByteArray().SendTo(accepted);
accepted
.ReceiveObservable
.ToStrings()
.Subscribe(s => s.ToByteArray().SendTo(accepted));
});
var clients = new List <IRxSocketClient>();
for (var i = 0; i < 10; i++)
{
var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
client.Send("Hello".ToByteArray());
clients.Add(client);
}
foreach (var client in clients)
{
Assert.Equal("Hello", await client.ReceiveObservable.ToStrings().Skip(1).Take(1).FirstAsync());
}
foreach (var client in clients)
{
client.Dispose();
}
server.Dispose();
}
public async Task T06_Dispose_During_Send()
{
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
var sendTask = Task.Run(() => client.Send(new byte[100_000_000]));
public async Task T05_Dispose_Before_Send()
{
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
await client.DisposeAsync();
Assert.ThrowsAny <Exception>(() => client.Send(new byte[] { 0 }));
await server.DisposeAsync();
}
public async Task T01_Dispose_Before_Receive()
{
var server = RxSocketServer.Create(SocketServerLogger);
var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger);
await client.DisposeAsync();
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.ReceiveAllAsync().ToListAsync());
await server.DisposeAsync();
}
public async Task T04_DisconnectWhileAccept()
{
var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
var acceptTask = server.AcceptObservable.LastOrDefaultAsync().ToTask();
await Task.Delay(100);
server.Dispose();
//Assert.Equal(SocketError.Success, error);
var result = await acceptTask;
Assert.Null(result);
}
public async Task T01_Handshake()
{
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(async acceptClient =>
{
var message1 = await acceptClient.ReceiveAllAsync().ToStrings().FirstAsync();
Assert.Equal("Hello1FromClient", message1);
acceptClient.Send(new[] { "Hello1FromServer" }.ToByteArray());
var messages = await acceptClient.ReceiveAllAsync().ToArraysFromBytesWithLengthPrefix().ToStringArrays().FirstAsync();
Assert.Equal("Hello2FromClient", messages[0]);
acceptClient.Send(new[] { "Hello2FromServer" }.ToByteArray().ToByteArrayWithLengthPrefix());
acceptClient.Send(new[] { "Hello3FromServer" }.ToByteArray().ToByteArrayWithLengthPrefix());
});
var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
// Send the first message without prefix.
client.Send("Hello1FromClient".ToByteArray());
// Receive the response message without prefix.
var message1 = await client.ReceiveAllAsync().ToStrings().FirstAsync();
Assert.Equal("Hello1FromServer", message1);
// Start sending and receiving messages with an int32 message length prefix.
client.Send(new[] { "Hello2FromClient" }.ToByteArray().ToByteArrayWithLengthPrefix());
var message3 = await client.ReceiveAllAsync().ToArraysFromBytesWithLengthPrefix().ToStringArrays().FirstAsync();
Assert.Equal("Hello2FromServer", message3.Single());
client.ReceiveAllAsync()
.ToArraysFromBytesWithLengthPrefix()
.ToStringArrays()
.ToObservableFromAsyncEnumerable()
.Subscribe(x =>
{
Logger.LogInformation(x[0]);
});
await Task.Delay(10);
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T00_All_Ok()
{
var server = RxSocketServer.Create(SocketServerLogger);
var client = await server.IPEndPoint.CreateRxSocketClientAsync(Logger);
//await server.AcceptObservable.FirstAsync();
//await server.AcceptAllAsync().ToObservableFromAsyncEnumerable().FirstAsync();
await server.AcceptAllAsync().FirstAsync();
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T03_External_Dispose_Before_Receive()
{
var server = RxSocketServer.Create(SocketServerLogger);
var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger);
var accept = await server.AcceptAllAsync().FirstAsync();
await accept.DisposeAsync();
await client.ReceiveAllAsync().LastOrDefaultAsync();
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T02_Dispose_During_Receive()
{
var server = RxSocketServer.Create(SocketServerLogger);
var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger);
var receiveTask = client.ReceiveAllAsync().LastOrDefaultAsync();
//await Task.Delay(100);
await client.DisposeAsync();
//await Assert.ThrowsAsync<SocketException>(async () =>
// await receiveTask);
await receiveTask;
await server.DisposeAsync();
}
public async Task T04_External_Dispose_During_Receive()
{
var server = RxSocketServer.Create(SocketServerLogger);
var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger);
var accept = await server.AcceptAllAsync().FirstAsync();
var receiveTask = client.ReceiveAllAsync().FirstAsync();
await accept.DisposeAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await receiveTask);
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T02_AcceptSuccess()
{
var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
var acceptTask = server.AcceptObservable.FirstAsync().ToTask();
var clientSocket = Utilities.CreateSocket();
clientSocket.Connect(IPEndPoint);
var acceptedSocket = await acceptTask;
Assert.True(clientSocket.Connected && acceptedSocket.Connected);
acceptedSocket.Dispose();
clientSocket.Disconnect(false);
server.Dispose();
}
public async Task T02_ReceiveStringsFromPrefixedBytes()
{
var server = RxSocketServer.Create();
var endPoint = server.IPEndPoint;
var acceptFirstClientTask = server.AcceptAllAsync().FirstAsync();
var client = await endPoint.CreateRxSocketClientAsync();
Assert.True(client.Connected);
var countTask = client.ReceiveAllAsync().ToArraysFromBytesWithLengthPrefix().ToStringArrays().CountAsync();
var acceptClient = await acceptFirstClientTask;
Assert.True(acceptClient.Connected);
var message = new[] { "Welcome!" }.ToByteArray().ToByteArrayWithLengthPrefix();
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < numberOfMessages; i++)
{
acceptClient.Send(message);
}
// end count task
await acceptClient.DisposeAsync();
int count = await countTask;
watch.Stop();
Assert.Equal(numberOfMessages, count);
var frequency = Stopwatch.Frequency * numberOfMessages / watch.ElapsedTicks;
Write($"{frequency:N0} messages / second");
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T02_ReceiveStringsFromPrefixedBytes()
{
//var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
var server = RxSocketServer.Create(IPEndPoint);
var acceptTask = server.AcceptObservable.FirstAsync().ToTask();
//var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
var client = await RxSocketClient.ConnectAsync(IPEndPoint);
Assert.True(client.Connected);
var countTask = client.ReceiveObservable.ToByteArrayOfLengthPrefix().ToStringArray().Count().ToTask();
var accept = await acceptTask;
Assert.True(accept.Connected);
var message = new [] { "Welcome!" }.ToByteArrayWithLengthPrefix();
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < messages; i++)
{
accept.Send(message);
}
accept.Dispose();
int count = await countTask;
watch.Stop();
Assert.Equal(messages, count);
var frequency = Stopwatch.Frequency * messages / watch.ElapsedTicks;
Write($"{frequency:N0} messages / second");
client.Dispose();
server.Dispose();
}
public async Task T40_Client_Disconnect()
{
var semaphore = new SemaphoreSlim(0, 1);
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
IRxSocketClient?acceptClient = null;
server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(ac =>
{
acceptClient = ac;
semaphore.Release();
acceptClient.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Subscribe(onNext: message =>
{
acceptClient.Send(message.ToByteArray());
});
});
var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
client.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Subscribe(onNext: message =>
{
Write(message);
});
client.Send("Hello!".ToByteArray());
await semaphore.WaitAsync();
if (acceptClient is null)
{
throw new NullReferenceException(nameof(acceptClient));
}
await server.DisposeAsync();
await client.DisposeAsync();
semaphore.Dispose();
}
public async Task T10_ReceiveObservable()
{
var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
var acceptTask = server.AcceptObservable.FirstAsync().ToTask();
var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
var accept = await acceptTask;
Assert.True(accept.Connected && client.Connected);
client.ReceiveObservable.ToStrings().Subscribe(str =>
{
Write(str);
});
accept.Send("Welcome!".ToByteArray());
"Welcome Again!".ToByteArray().SendTo(accept); // Note SendTo() extension method.
client.Dispose();
server.Dispose();
}
public async Task T01_ReceiveStrings()
{
var server = RxSocketServer.Create(IPEndPoint);
var acceptTask = server.AcceptObservable.FirstAsync().ToTask();
var client = await RxSocketClient.ConnectAsync(IPEndPoint);
Assert.True(client.Connected);
var countTask = client.ReceiveObservable.ToStrings().Count().ToTask();
var accept = await acceptTask;
Assert.True(accept.Connected);
var watch = new Stopwatch();
watch.Start();
// send messages from server to client
var message = "Welcome!".ToByteArray();
for (var i = 0; i < messages; i++)
{
accept.Send(message);
}
accept.Dispose();
var count = await countTask;
watch.Stop();
Assert.Equal(messages, count);
var frequency = Stopwatch.Frequency * messages / watch.ElapsedTicks;
Write($"{frequency:N0} messages / second");
client.Dispose();
server.Dispose();
}
public async Task T00_Example()
{
// Create a socket server.
var server = RxSocketServer.Create(SocketServerLogger);
// The IPEndPoint is chosen automatically.
var ipEndPoint = server.IPEndPoint;
// Start accepting connections from clients.
server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(acceptClient =>
{
// After the server accepts a client connection...
acceptClient.ReceiveAllAsync().ToStrings().ToObservable().Subscribe(onNext: message =>
{
// Echo each message received back to the client.
acceptClient.Send(message.ToByteArray());
});
});
// Create a socket client by first connecting to the server at the EndPoint.
var client = await ipEndPoint.CreateRxSocketClientAsync(SocketClientLogger);
// Start receiving messages from the server.
client.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Subscribe(onNext: message =>
{
// The message received from the server is "Hello!".
Assert.Equal("Hello!", message);
});
// Send the message "Hello" to the server (which will be echoed back to the client).
client.Send("Hello!".ToByteArray());
await Task.Delay(100);
// Disconnect and dispose.
await client.DisposeAsync();
await server.DisposeAsync();
}
public async Task T01_ReceiveStrings()
{
var server = RxSocketServer.Create();
var endPoint = server.IPEndPoint;
var acceptFirstClientTask = server.AcceptAllAsync().FirstAsync();
var client = await endPoint.CreateRxSocketClientAsync();
var acceptClient = await acceptFirstClientTask;
var countTask = acceptClient.ReceiveAllAsync().ToStrings().CountAsync();
var watch = new Stopwatch();
watch.Start();
// send messages from server to client
var message = "Welcome!".ToByteArray();
for (var i = 0; i < numberOfMessages; i++)
{
client.Send(message);
}
// end countTask
await client.DisposeAsync();
var count = await countTask;
watch.Stop();
Assert.Equal(numberOfMessages, count);
var frequency = Stopwatch.Frequency * numberOfMessages / watch.ElapsedTicks;
Write($"{frequency:N0} messages / second");
await server.DisposeAsync();
}
public async Task T30_Both()
{
var server = RxSocketServer.Create(SocketServerLogger);
var endPoint = server.IPEndPoint;
server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(accepted =>
{
accepted.Send("Welcome!".ToByteArray());
accepted
.ReceiveAllAsync()
.ToObservableFromAsyncEnumerable()
.ToStrings()
.Subscribe(s => accepted.Send(s.ToByteArray()));
});
var clients = new List <IRxSocketClient>();
for (var i = 0; i < 3; i++)
{
var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger);
client.Send("Hello".ToByteArray());
clients.Add(client);
}
foreach (var client in clients)
{
Assert.Equal("Hello", await client.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Skip(1).Take(1).FirstAsync());
}
foreach (var client in clients)
{
await client.DisposeAsync();
}
await server.DisposeAsync();
}
public async Task T20_AcceptObservable()
{
var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
server.AcceptObservable.Subscribe(accepted =>
{
"Welcome!".ToByteArray().SendTo(accepted);
});
var client1 = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
var client2 = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
var client3 = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger);
Assert.Equal("Welcome!", await client1.ReceiveObservable.ToStrings().Take(1).FirstAsync());
Assert.Equal("Welcome!", await client2.ReceiveObservable.ToStrings().Take(1).FirstAsync());
Assert.Equal("Welcome!", await client3.ReceiveObservable.ToStrings().Take(1).FirstAsync());
client1.Dispose();
client2.Dispose();
client3.Dispose();
server.Dispose();
}
/// <summary> /// Create an RxSocketServer on IPEndPoint. /// </summary> public static IRxSocketServer CreateRxSocketServer(this IPEndPoint ipEndPoint, ILogger logger, int backLog = 10) => RxSocketServer.Create(ipEndPoint, logger, backLog);
public void T01_InvalidEndPoint()
{
var endPoint = new IPEndPoint(IPAddress.Parse("111.111.111.111"), 1111);
Assert.Throws <SocketException>(() => RxSocketServer.Create(endPoint, SocketServerLogger));
}
public RxSocketClientServerTest(ITestOutputHelper output) : base(output)
{
Server = RxSocketServer.Create(IPEndPoint, SocketServerLogger);
AcceptTask = Server.AcceptObservable.FirstAsync().ToTask();
}
/// <summary> /// Create an RxSocketServer on IPEndPoint. /// </summary> public static IRxSocketServer CreateRxSocketServer(this IPEndPoint ipEndPoint, int backLog = 10) => RxSocketServer.Create(ipEndPoint, NullLogger.Instance, backLog);
