private void WriteAndReadTestData(
ISocketWrapper socket,
ITestCallbackHandler callbackHandler,
int inputToHandler)
{
Stream inputStream = socket.InputStream;
Stream outputStream = socket.OutputStream;
SerDe.Write(outputStream, (int)CallbackFlags.CALLBACK);
SerDe.Write(outputStream, callbackHandler.Id);
SerDe.Write(outputStream, sizeof(int));
SerDe.Write(outputStream, inputToHandler);
SerDe.Write(outputStream, (int)CallbackFlags.END_OF_STREAM);
outputStream.Flush();
int callbackFlag = SerDe.ReadInt32(inputStream);
if (callbackFlag == (int)CallbackFlags.DOTNET_EXCEPTION_THROWN)
{
string exceptionMessage = SerDe.ReadString(inputStream);
Assert.False(string.IsNullOrEmpty(exceptionMessage));
Assert.Contains(callbackHandler.ExceptionMessage, exceptionMessage);
}
else
{
Assert.Equal((int)CallbackFlags.END_OF_STREAM, callbackFlag);
}
}
private void TestCallbackConnection(
ConcurrentDictionary <int, ICallbackHandler> callbackHandlersDict,
ITestCallbackHandler callbackHandler,
int inputToHandler,
CancellationToken token)
{
using ISocketWrapper serverListener = SocketFactory.CreateSocket();
serverListener.Listen();
var ipEndpoint = (IPEndPoint)serverListener.LocalEndPoint;
using ISocketWrapper clientSocket = SocketFactory.CreateSocket();
clientSocket.Connect(ipEndpoint.Address, ipEndpoint.Port);
// Don't use "using" here. The CallbackConnection will dispose the socket.
ISocketWrapper serverSocket = serverListener.Accept();
var callbackConnection = new CallbackConnection(0, serverSocket, callbackHandlersDict);
Task task = Task.Run(() => callbackConnection.Run(token));
if (token.IsCancellationRequested)
{
task.Wait();
Assert.False(callbackConnection.IsRunning);
}
else
{
WriteAndReadTestData(clientSocket, callbackHandler, inputToHandler);
if (callbackHandler.Throws)
{
task.Wait();
Assert.False(callbackConnection.IsRunning);
}
else
{
Assert.True(callbackConnection.IsRunning);
// Clean up CallbackConnection
Stream outputStream = clientSocket.OutputStream;
SerDe.Write(outputStream, (int)CallbackConnection.ConnectionStatus.REQUEST_CLOSE);
outputStream.Flush();
task.Wait();
Assert.False(callbackConnection.IsRunning);
}
}
}
private void TestCallbackConnection(
ConcurrentDictionary <int, ICallbackHandler> callbackHandlersDict,
ITestCallbackHandler callbackHandler,
int inputToHandler,
CancellationToken token)
{
using ISocketWrapper serverListener = SocketFactory.CreateSocket();
serverListener.Listen();
var ipEndpoint = (IPEndPoint)serverListener.LocalEndPoint;
ISocketWrapper clientSocket = SocketFactory.CreateSocket();
clientSocket.Connect(ipEndpoint.Address, ipEndpoint.Port);
var callbackConnection = new CallbackConnection(0, clientSocket, callbackHandlersDict);
Task.Run(() => callbackConnection.Run(token));
using ISocketWrapper serverSocket = serverListener.Accept();
WriteAndReadTestData(serverSocket, callbackHandler, inputToHandler, token);
}
