public void SendReceive_1Message()
{
// The test can be performed from more thread therefore we must synchronize.
AutoResetEvent aMessageReceivedEvent = new AutoResetEvent(false);
int aReceivedMessage = 0;
Responser.MessageReceived += (x, y) =>
{
aReceivedMessage = y.RequestMessage;
// Send the response
Responser.SendResponseMessage(y.ResponseReceiverId, 1000);
};
int aReceivedResponse = 0;
Requester.ResponseReceived += (x, y) =>
{
aReceivedResponse = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aMessageReceivedEvent.Set();
};
try
{
Responser.AttachDuplexInputChannel(DuplexInputChannel);
Requester.AttachDuplexOutputChannel(DuplexOutputChannel);
Requester.SendRequestMessage(2000);
// Wait for the signal that the message is received.
aMessageReceivedEvent.WaitOne();
//Assert.IsTrue(aMessageReceivedEvent.WaitOne(2000));
}
finally
{
Requester.DetachDuplexOutputChannel();
Responser.DetachDuplexInputChannel();
}
// Check received values
Assert.AreEqual(2000, aReceivedMessage);
Assert.AreEqual(1000, aReceivedResponse);
}
public void SendReceive_NullMessage()
{
// The test can be performed from more threads therefore we must synchronize.
AutoResetEvent aMessageReceivedEvent = new AutoResetEvent(false);
CustomClass aReceivedMessage2 = null;
Responser.RegisterRequestMessageReceiver <CustomClass>((x, y) =>
{
aReceivedMessage2 = y.RequestMessage;
Responser.SendResponseMessage <CustomClass>(y.ResponseReceiverId, null);
});
Responser.AttachDuplexInputChannel(DuplexInputChannel);
CustomClass aReceivedResponse2 = new CustomClass();
Requester.RegisterResponseMessageReceiver <CustomClass>((x, y) =>
{
aReceivedResponse2 = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aMessageReceivedEvent.Set();
});
Requester.AttachDuplexOutputChannel(DuplexOutputChannel);
try
{
Requester.SendRequestMessage <int>(1000);
Requester.SendRequestMessage <CustomClass>(null);
// Wait for the signal that the message is received.
aMessageReceivedEvent.WaitOne();
//Assert.IsTrue(aMessageReceivedEvent.WaitOne(2000));
}
finally
{
Requester.DetachDuplexOutputChannel();
Responser.DetachDuplexInputChannel();
}
// Check received values
Assert.IsNull(aReceivedMessage2);
Assert.IsNull(aReceivedResponse2);
}
public void SendReceive_Message()
{
// The test can be performed from more threads therefore we must synchronize.
AutoResetEvent aMessageReceivedEvent = new AutoResetEvent(false);
int aReceivedMessage1 = 0;
Responser.RegisterRequestMessageReceiver <int>((x, y) =>
{
aReceivedMessage1 = y.RequestMessage;
// Send the response
Responser.SendResponseMessage <string>(y.ResponseReceiverId, "hello");
});
CustomClass aReceivedMessage2 = null;
Responser.RegisterRequestMessageReceiver <CustomClass>((x, y) =>
{
aReceivedMessage2 = y.RequestMessage;
// Send the response
CustomClass aResponse = new CustomClass();
aResponse.Name = "Car";
aResponse.Count = 100;
Responser.SendResponseMessage <CustomClass>(y.ResponseReceiverId, aResponse);
});
Responser.AttachDuplexInputChannel(DuplexInputChannel);
string aReceivedResponse1 = "";
Requester.RegisterResponseMessageReceiver <string>((x, y) =>
{
aReceivedResponse1 = y.ResponseMessage;
});
CustomClass aReceivedResponse2 = null;
Requester.RegisterResponseMessageReceiver <CustomClass>((x, y) =>
{
aReceivedResponse2 = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aMessageReceivedEvent.Set();
});
Requester.AttachDuplexOutputChannel(DuplexOutputChannel);
try
{
Requester.SendRequestMessage <int>(1000);
CustomClass aCustomRequest = new CustomClass();
aCustomRequest.Name = "House";
aCustomRequest.Count = 1000;
Requester.SendRequestMessage <CustomClass>(aCustomRequest);
// Wait for the signal that the message is received.
aMessageReceivedEvent.WaitOne();
//Assert.IsTrue(aMessageReceivedEvent.WaitOne(2000));
}
finally
{
Requester.DetachDuplexOutputChannel();
Responser.DetachDuplexInputChannel();
Responser.DetachDuplexInputChannel();
}
// Check received values
Assert.AreEqual(1000, aReceivedMessage1);
Assert.AreEqual("hello", aReceivedResponse1);
Assert.IsNotNull(aReceivedMessage2);
Assert.AreEqual("House", aReceivedMessage2.Name);
Assert.AreEqual(1000, aReceivedMessage2.Count);
Assert.IsNotNull(aReceivedResponse2);
Assert.AreEqual("Car", aReceivedResponse2.Name);
Assert.AreEqual(100, aReceivedResponse2.Count);
}
public void SendReceive_MultiThreadAccess_1000Messages()
{
// The test can be performed from more thread therefore we must synchronize.
AutoResetEvent aMessageReceivedEvent = new AutoResetEvent(false);
List <int> aReceivedMessages = new List <int>();
Responser.MessageReceived += (x, y) =>
{
lock (aReceivedMessages)
{
aReceivedMessages.Add(y.RequestMessage);
}
// Send the response
Responser.SendResponseMessage(y.ResponseReceiverId, 1000);
};
List <int> aReceivedResponses = new List <int>();
Requester.ResponseReceived += (x, y) =>
{
lock (aReceivedResponses)
{
aReceivedResponses.Add(y.ResponseMessage);
if (aReceivedResponses.Count == 1000)
{
// Signal that the message was received.
aMessageReceivedEvent.Set();
}
}
};
try
{
Responser.AttachDuplexInputChannel(DuplexInputChannel);
Requester.AttachDuplexOutputChannel(DuplexOutputChannel);
List <Thread> aThreads = new List <Thread>();
for (int i = 0; i < 10; ++i)
{
Thread aThread = new Thread(() =>
{
for (int ii = 0; ii < 100; ++ii)
{
Requester.SendRequestMessage(2000);
Thread.Sleep(1);
}
});
aThreads.Add(aThread);
}
aThreads.ForEach(x => x.Start());
// Wait for the signal that the message is received.
Assert.IsTrue(aMessageReceivedEvent.WaitOne(10000));
}
finally
{
Requester.DetachDuplexOutputChannel();
Responser.DetachDuplexInputChannel();
}
// Check received values
Assert.AreEqual(1000, aReceivedMessages.Count);
aReceivedMessages.ForEach(x => Assert.AreEqual(2000, x));
Assert.AreEqual(1000, aReceivedResponses.Count);
aReceivedResponses.ForEach(x => Assert.AreEqual(1000, x));
}
