public void ItShouldBePossibleToInterceptExceptionsOnAMessagingThreadDuringTheMessageHandling()
{
const int sleepTime = 1;
const string testName = "TestThread";
const int messagesToSend = 100;
var expectedException = new Exception("TEST");
var th = new SimpleMessageThreadConsumer(sleepTime, testName, false);
th.RunThread();
Thread.Sleep(100);
for (int i = 0; i < messagesToSend; i++)
{
th.SendMessageToThread(new TestMessage());
}
th.ThrowExceptionOnMessageHandling = expectedException;
for (int i = 0; i < messagesToSend; i++)
{
th.SendMessageToThread(new TestMessage());
}
Thread.Sleep(100);
Assert.AreEqual(RunningStatus.ExceptionThrown, th.Status);
Exception expectedEx = th.LastError;
Assert.IsNotNull(expectedEx);
Assert.AreEqual(expectedEx.Message, expectedException.Message);
Assert.IsTrue(th.IsInitialized);
Assert.IsFalse(th.IsCleanedUp);
Assert.AreNotEqual(messagesToSend*2, th.HandledMessages);
}
public void ItShouldBePossibleToInitializeAMessageingThread()
{
const int sleepTime = 100;
const string testName = "TestThread";
string expectedTestName = testName.ToUpperInvariant();
var th = new SimpleMessageThreadConsumer(sleepTime, testName);
Assert.AreEqual(expectedTestName, th.ThreadName);
Assert.AreEqual(null, th.LastError);
Assert.AreEqual(RunningStatus.None, th.Status);
}
public void ItShouldBePossibleToGetAndSetAThreadManager()
{
const int sleepTime = 1;
const string testName = "TestThread";
var th = new SimpleMessageThreadConsumer(sleepTime, testName);
var tm = new ThreadManager(NullLogger.Create());
var tm1 = new ThreadManager(NullLogger.Create());
th.Manager = tm;
th.Manager = tm1;
Assert.AreNotSame(tm1,th.Manager);
Assert.AreSame(tm, th.Manager);
}
public void ItShouldBePossibleToRegisterAMessageFromAChildThread()
{
var subThread = new SimpleMessageThreadConsumer(1, "SUBTHREAD");
var threadManager = new ThreadManager(NullLogger.Create());
var privateObject = new PrivateObject(threadManager);
threadManager.RunThread();
threadManager.AddThread(subThread);
threadManager.RunThread(subThread.ThreadName);
Thread.Sleep(100);
Assert.IsTrue(threadManager.Status == RunningStatus.Running);
threadManager.SendMessageToThread(new InternalMessage(InternalMessageTypes.RegisterMessageType,
typeof(TestMessage)){SourceThread = subThread.ThreadName});
Thread.Sleep(100);
var result = privateObject.Invoke("IsTypeRegistered", subThread.ThreadName, typeof(TestMessage)) as Boolean?;
Assert.IsNotNull(result);
Assert.AreEqual(true, result);
Thread.Sleep(100);
threadManager.Terminate();
Thread.Sleep(500);
Assert.IsTrue(threadManager.Status == RunningStatus.Halted);
}
public void ItShouldBePossibleToPeekMessagesForAMessagingThread()
{
const int sleepTime = 1;
const string testName = "TestThread";
const int messagesToSend = 100;
var th = new SimpleMessageThreadConsumer(sleepTime, testName);
var messages = new List<TestMessage>();
th.ForwardMessages = true;
th.RunThread();
Thread.Sleep(100);
for (int i = 0; i < messagesToSend; i++)
{
var newMsg = new TestMessage();
th.SendMessageToThread(newMsg);
messages.Add(newMsg);
}
Assert.AreEqual(RunningStatus.Running, th.Status);
Thread.Sleep(100);
var msg = th.PeekMessageFromThread() as TestMessage;
Assert.IsNotNull(msg);
Assert.AreSame(msg, messages[0]);
var resultingMessages = new List<TestMessage>();
foreach (var item in th.PeekMessagesFromThread())
{
msg = item as TestMessage;
if(msg!=null)
resultingMessages.Add(msg);
}
Assert.AreEqual(messages.Count-1,resultingMessages.Count);
th.Terminate();
Thread.Sleep(100);
Assert.AreEqual(RunningStatus.Halted, th.Status);
Assert.IsNull(th.LastError);
Assert.IsTrue(th.IsInitialized);
Assert.IsTrue(th.IsCleanedUp);
Assert.AreEqual(messagesToSend, th.HandledMessages);
th.Dispose();
}
public void ItShouldBePossibleToTerminateTheThreadUponReceivingAMessage()
{
const int sleepTime = 1;
const string testName = "TestThread";
const int messagesToSend = 100;
var th = new SimpleMessageThreadConsumer(sleepTime, testName) {ReceiveAStopMessage = true};
th.RunThread();
Thread.Sleep(100);
Assert.AreEqual(RunningStatus.Running, th.Status);
for (int i = 0; i < messagesToSend; i++)
{
th.SendMessageToThread(new TestMessage());
}
Thread.Sleep(100);
Assert.AreEqual(RunningStatus.Halted, th.Status);
Assert.IsNull(th.LastError);
Assert.IsTrue(th.IsInitialized);
Assert.IsTrue(th.IsCleanedUp);
Assert.AreEqual(1, th.HandledMessages);
}
public void ItShouldBePossibleToStartAndStopAMessagingThread()
{
const int sleepTime = 100;
const string testName = "TestThread";
var th = new SimpleMessageThreadConsumer(sleepTime, testName);
th.RunThread();
Thread.Sleep(100);
Assert.AreEqual(RunningStatus.Running, th.Status);
th.Terminate();
Thread.Sleep(200);
Assert.AreEqual(RunningStatus.Halted, th.Status);
Assert.IsNull(th.LastError);
Assert.IsTrue(th.IsInitialized);
Assert.IsTrue(th.IsCleanedUp);
}
public void ItShouldBePossibleToRestartAutomaticallyAMessageThreadOnErrorInMessageHandling()
{
const int sleepTime = 1;
const string testName = "TestThread";
const int messagesToSend = 100;
var expectedException = new Exception("TEST");
var th = new SimpleMessageThreadConsumer(sleepTime, testName);
th.RunThread();
Thread.Sleep(100);
for (int i = 0; i < messagesToSend; i++)
{
th.SendMessageToThread(new TestMessage());
}
Thread.Sleep(100);
th.ThrowExceptionOnMessageHandling = expectedException;
Thread.Sleep(100);
for (int i = 0; i < messagesToSend; i++)
{
th.SendMessageToThread(new TestMessage());
}
Thread.Sleep(100);
th.Terminate();
Thread.Sleep(500);
Assert.AreEqual(RunningStatus.Halted, th.Status);
Assert.IsNull(th.LastError);
Assert.IsTrue(th.IsInitialized);
Assert.IsTrue(th.IsCleanedUp);
Assert.AreEqual(messagesToSend*2, th.HandledMessages);
}
