/// <summary>
/// Handle the incoming message.
/// </summary>
/// <remarks>
/// <para>
/// Normal messages are enqueued.
/// </para>
/// <para>
/// The FLUSH message type tells the Queue to write all
/// stored messages to the ouptut PipeFitting, then
/// return to normal enqueing operation.
/// </para>
/// <para>
/// The SORT message type tells the Queue to sort all
/// <I>subsequent</I> incoming messages by priority. If there
/// are unflushed messages in the queue, they will not be
/// sorted unless a new message is sent before the next FLUSH.
/// Sorting-by-priority behavior continues even after a FLUSH,
/// and can be turned off by sending a FIFO message, which is
/// the default behavior for enqueue/dequeue.
/// </para>
/// </remarks>
/// <param name="message"></param>
/// <returns></returns>
public override bool Write(IPipeMessage message)
{
bool success = true;
switch (message.Type)
{
// Store normal messages
case Message.NORMAL:
Store(message);
break;
// Flush the queue
case QueueControlMessage.FLUSH:
success = Flush();
break;
// Put Queue into Priority Sort or FIFO mode
// Subsequent messages written to the queue
// will be affected. Sorted messages cannot
// be put back into FIFO order!
case QueueControlMessage.SORT:
case QueueControlMessage.FIFO:
Mode = message.Type;
break;
}
return(success);
}
public void TestWritingMultipleMessagesAndFlush()
{
// create messages to send to the queue
IPipeMessage message1 = new Message(Message.NORMAL, new { testProp = 1 });
IPipeMessage message2 = new Message(Message.NORMAL, new { testProp = 2 });
IPipeMessage message3 = new Message(Message.NORMAL, new { testProp = 3 });
// create queue control flush message
IPipeMessage flush = new QueueControlMessage(QueueControlMessage.FLUSH);
// create queue, attaching an anonymous listener to its output
Queue queue = new Queue(new PipeListener(this, CallBackMethod));
// write messages to the queue
bool message1written = queue.Write(message1);
bool message2written = queue.Write(message2);
bool message3written = queue.Write(message3);
// test assertions
Assert.IsTrue(message1 is IPipeMessage, "Expecting message1 is IPipeMessage");
Assert.IsTrue(message2 is IPipeMessage, "Expecting message2 is IPipeMessage");
Assert.IsTrue(message3 is IPipeMessage, "Expecting message3 is IPipeMessage");
Assert.IsTrue(flush is IPipeMessage, "Expecting flush is IPipeMessage");
Assert.IsTrue(queue is Queue, "Expecting queue is Queue");
Assert.IsTrue(message1written, "Expecting wrote message1 to queue");
Assert.IsTrue(message2written, "Expecting wrote message2 to queue");
Assert.IsTrue(message3written, "Expecting wrote message3 to queue");
// test that no messages were received (they've been enqueued)
Assert.IsTrue(messagesReceived.Count == 0, "Expecting received 0 messages");
// write flush control message to the queue
bool flushWritten = queue.Write(flush);
// test that all messages were received, then test
// FIFO order by inspecting the messages themselves
Assert.IsTrue(messagesReceived.Count == 3, "Expected received 3 messages");
// test message 1 assertions
IPipeMessage received1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received1 is IPipeMessage, "Expected received1 is IPipeMessage");
Assert.IsTrue(received1 == message1, "Expected received1 == message1"); // object equality
// test message 2 assertions
IPipeMessage received2 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received2 is IPipeMessage, "Expected received2 is IPipeMessage");
Assert.IsTrue(received2 == message2, "Expected received2 == message2"); // object equality
// test message 3 assertions
IPipeMessage received3 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received3 is IPipeMessage, "Expected received3 is IPipeMessage");
Assert.IsTrue(received3 == message3, "Expected received3 == message3"); // object equality
}
public void TestFilteringNormalMessage()
{
// create messages to send to the queue
IPipeMessage message = new Message(Message.NORMAL, new { width = 10, height = 2 });
// create filter, attach an anonymous listener to the filter output to receive the message,
// pass in an anonymous function an parameter object
IPipeFitting filter = new Filter("scale", new PipeListener(this, CallBackMethod), (IPipeMessage msg, dynamic _params) => {
msg.Header = new
{
width = ((dynamic)msg.Header).width * ((dynamic)_params).factor,
height = ((dynamic)msg.Header).height * ((dynamic)_params).factor
};
return(true);
}, new { factor = 10 });
// write messages to the filter
bool written = filter.Write(message);
// test assertions
Assert.IsTrue(message is IPipeMessage, "Expecting message is IPipeMessage");
Assert.IsTrue(filter is Filter, "Expecting filter is Filter");
Assert.IsTrue(written, "Expecting wrote normal message to filter");
Assert.IsTrue(messagesReceived.Count == 1, "Expecting received 1 messages");
// test filtered message assertions
IPipeMessage received = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received is IPipeMessage, "Expecting received is IPipeMessage");
Assert.IsTrue(received == message, "Expecting received == message");
Assert.IsTrue(((dynamic)received.Header).width == 100, "Expecting ((dynamic)received.Header).width == 100");
Assert.IsTrue(((dynamic)received.Header).height == 20, "Expecting ((dynamic)received.Header).height == 20");
}
public void TestReceiveMessagesFromTwoPipesViaTeeMerge()
{
// create a message to send on pipe 1
IPipeMessage pipe1Message = new Message(Message.NORMAL, new { testProp = 1 }, xmlDocument, Message.PRIORITY_LOW);
// create a message to send on pipe 2
IPipeMessage pipe2Message = new Message(Message.NORMAL, new { testProp = 2 }, xmlDocument, Message.PRIORITY_HIGH);
// create pipes 1 and 2
IPipeFitting pipe1 = new Pipe();
IPipeFitting pipe2 = new Pipe();
// create merging tee (args are first two input fittings of tee)
TeeMerge teeMerge = new TeeMerge(pipe1, pipe2);
// create listener
PipeListener listener = new PipeListener(this, CallBackMethod);
// connect the listener to the tee and write the messages
bool connected = teeMerge.Connect(listener);
// write messages to their respective pipes
bool pipe1written = pipe1.Write(pipe1Message);
bool pipe2written = pipe2.Write(pipe2Message);
// test assertions
Assert.IsTrue(pipe1Message is IPipeMessage, "Expecting pipe1Message is IPipeMessage");
Assert.IsTrue(pipe2Message is IPipeMessage, "Expecting pipe2Message is IPipeMessage");
Assert.IsTrue(pipe1 is Pipe, "Expecting pipe1 is Pipe");
Assert.IsTrue(pipe2 is Pipe, "Expecting pipe2 is Pipe");
Assert.IsTrue(teeMerge is TeeMerge, "Expecting teeMerge is TeeMerge");
Assert.IsTrue(listener is PipeListener, "Expecting listener is PipeListener");
Assert.IsTrue(connected, "Expecting connected listener to merging tee");
Assert.IsTrue(pipe1written, "Expecting wrote message to pipe1");
Assert.IsTrue(pipe2written, "Expecting wrote message to pipe2");
// test that both messages were received, then test
// FIFO order by inspecting the messages themselves
Assert.IsTrue(messagesReceived.Count == 2, "Expecting received 2 messages");
// test message 1 assertions
IPipeMessage message1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message1 is IPipeMessage, "Expecing message1 is IPipeMessage");
Assert.IsTrue(message1 == pipe1Message, "Expecting message1 == pipe1Message");
Assert.IsTrue(message1.Type == Message.NORMAL, "Expecting message1.Type == Message.NORMAL");
Assert.IsTrue(((dynamic)message1.Header).testProp == 1, "Expecting ((dynamic)message1.Header).testProp");
Assert.IsTrue(message1.Priority == Message.PRIORITY_LOW, "Expecting message1.Priority == Message.PRIORITY_LOW");
// test message 2 assertions
IPipeMessage message2 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message2 is IPipeMessage, "Expecing message2 is IPipeMessage");
Assert.IsTrue(message2 == pipe2Message, "Expecting message2 == pipe1Message");
Assert.IsTrue(message2.Type == Message.NORMAL, "Expecting message2.Type == Message.NORMAL");
Assert.IsTrue(((dynamic)message2.Header).testProp == 2, "Expecting ((dynamic)message2.Header).testProp");
Assert.IsTrue(message2.Priority == Message.PRIORITY_HIGH, "Expecting message1.Priority == Message.PRIORITY_HIGH");
}
/// <summary>
/// Send a message on an OUTPUT pipe.
/// </summary>
/// <param name="outputPipeName">name the OUTPUT pipe to send the message on</param>
/// <param name="message">message the IPipeMessage to send </param>
/// <returns>Boolean true if message was sent successfully</returns>
public virtual bool SendMessage(string outputPipeName, IPipeMessage message)
{
bool success = false;
if (HasOutputPipe(outputPipeName) && PipesMaps.TryGetValue(outputPipeName, out IPipeFitting pipe))
{
success = pipe.Write(message);
}
return(success);
}
/// <summary>
/// Write the message to all connected outputs.
/// </summary>
/// <remarks>
/// <para>
/// Returns false if any output returns false,
/// but all outputs are written to regardless.
/// </para>
/// </remarks>
/// <param name="message">the message to write</param>
/// <returns>whether any connected outputs failed</returns>
public virtual bool Write(IPipeMessage message)
{
bool success = true;
List <IPipeFitting> temp = new List <IPipeFitting>(outputs);
foreach (IPipeFitting output in temp)
{
if (!output.Write(message))
{
success = false;
}
}
return(success);
}
public void TestReceiveMessagesFromTwoTeeSplitOutputs()
{
messagesReceived = new List <IPipeMessage>();
// create a message to send on pipe 1
IPipeMessage message = new Message(Message.NORMAL, new { testProp = 1 });
// create output pipes 1 and 2
IPipeFitting pipe1 = new Pipe();
IPipeFitting pipe2 = new Pipe();
// create and connect anonymous listeners
bool connected1 = pipe1.Connect(new PipeListener(this, CallBackMethod));
bool connected2 = pipe2.Connect(new PipeListener(this, CallBackMethod));
// create splitting tee (args are first two output fittings of tee)
TeeSplit teeSplit = new TeeSplit(pipe1, pipe2);
// write messages to their respective pipes
bool written = teeSplit.Write(message);
// test assertions
Assert.IsTrue(message is IPipeMessage, "Expecting message is IPipeMessage");
Assert.IsTrue(pipe1 is Pipe, "Expecting pipe1 is Pipe");
Assert.IsTrue(pipe2 is Pipe, "Expecting pipe2 is Pipe");
Assert.IsTrue(teeSplit is TeeSplit, "Expecting teeSplit is TeeSplit");
Assert.IsTrue(connected1, "Expecting connected anonymous listener to pipe 1");
Assert.IsTrue(connected2, "Expecting connected anonymous listener to pipe 2");
Assert.IsTrue(written, "Expecting wrote single message to tee");
// test that both messages were received, then test
// FIFO order by inspecting the messages themselves
Assert.IsTrue(messagesReceived.Count == 2, "Expecting received 2 messages");
// test message 1 assertions
IPipeMessage message1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message1 is IPipeMessage, "Expecting message1 is IPipeMessage");
Assert.IsTrue(message1 == message, "Expecting message1 == message");
// test message 2 assertions
IPipeMessage message2 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message2 is IPipeMessage, "Expecting message2 is IPipeMessage");
Assert.IsTrue(message2 == message, "Expecting message2 == message");
}
/// <summary>
/// Helper for sending messages
/// </summary>
private void SendMessage(IPipeMessage message)
{
PipeHeader h = PipeHeader.Next();
h.TypeID = message.TypeID;
//Send Header
#if DEBUG
//Console.WriteLine("PipeRepo: Header(" + h.TypeID + ", " + h.DebugNumber + ")");
#endif
ProtocolParser.WriteBytes(output, PipeHeader.SerializeToBytes(h));
//Send Message
#if DEBUG
//Console.WriteLine("PipeRepo: Message(" + message + ")");
#endif
byte[] messageBytes = GetMessageBytes(message);
ProtocolParser.WriteBytes(output, messageBytes);
}
/// <summary>
/// Store a message.
/// </summary>
/// <param name="message">the IPipeMessage to enqueue.</param>
protected virtual void Store(IPipeMessage message)
{
Messages.Add(message);
// Sort the Messages by priority.
if (Mode == QueueControlMessage.SORT)
{
Messages.Sort(delegate(IPipeMessage msgA, IPipeMessage msgB) {
int num = 0;
if (msgA.Priority < msgB.Priority)
{
num = -1;
}
if (msgA.Priority > msgB.Priority)
{
num = 1;
}
return(num);
});
}
}
public void TestSetParamsByControlMessage()
{
// create messages to send to the queue
IPipeMessage message = new Message(Message.NORMAL, new { width = 10, height = 2 });
// create filter, attach an anonymous listener to the filter output to receive the message,
// pass in an anonymous function an parameter object
IPipeFitting filter = new Filter("scale", new PipeListener(this, CallBackMethod), (IPipeMessage msg, object _params) => {
msg.Header = new
{
width = ((dynamic)msg.Header).width * ((dynamic)_params).factor,
height = ((dynamic)msg.Header).height * ((dynamic)_params).factor
};
return(true);
}, new { factor = 10 });
// create setParams control message
IPipeMessage setParamsMessage = new FilterControlMessage(FilterControlMessage.SET_PARAMS, "scale", null, new { factor = 5 });
// write filter control message to the filter
bool setParamsWritten = filter.Write(setParamsMessage);
// write normal message to the filter
bool written = filter.Write(message);
// test assertions
Assert.IsTrue(message is IPipeMessage, "Expecting message is IPipeMessage");
Assert.IsTrue(filter is Filter, "Expecting filter is Filter");
Assert.IsTrue(setParamsWritten, "Expecting wrote set_params message to filter");
Assert.IsTrue(messagesReceived.Count == 1, "Expecting received 1 messages");
// test filtered message assertions (message filtered with overridden parameters)
IPipeMessage received1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received1 is IPipeMessage, "Expecting received 2 is IPipeMessage");
Assert.IsTrue(received1 == message, "received2 == message");
Assert.IsTrue(((dynamic)received1.Header).width == 50, "Expecting ((dynamic)received2.Header).width == 50");
Assert.IsTrue(((dynamic)received1.Header).height == 10, "Expecting ((dynamic)received2.Header).height == 10");
}
public void TestUseFilterToStopAMessage()
{
// create messages to send to the queue
IPipeMessage message1 = new Message(Message.NORMAL, new { bozoLevel = 10, user = "******" });
IPipeMessage message2 = new Message(Message.NORMAL, new { bozoLevel = 3, user = "******" });
// create filter, attach an anonymous listener to the filter output to receive the message,
// pass in an anonymous function and an anonymous parameter object
Filter filter = new Filter("bozoFilter", new PipeListener(this, CallBackMethod), (IPipeMessage msg, object _params) =>
{
if (((dynamic)msg.Header).bozoLevel > ((dynamic)_params).bozoThreshold)
{
return(false);
}
else
{
return(true);
}
}, new { bozoThreshold = 5 });
// write normal message to the filter
bool written1 = filter.Write(message1);
bool written2 = filter.Write(message2);
// test assertions
Assert.IsTrue(message1 is IPipeMessage, "Expecting message is IPipeMessage");
Assert.IsTrue(message2 is IPipeMessage, "Expecting message is IPipeMessage");
Assert.IsTrue(filter is Filter, "Expecting filter is Filter");
Assert.IsTrue(written1 == false, "Expecting written1 == false");
Assert.IsTrue(written2 == true, "Expecting wrote good message");
Assert.IsTrue(messagesReceived.Count == 1, "Expecting received 1 messages");
// test filtered message assertions (message with good auth token passed
IPipeMessage received = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received is Message, "Expecting received is Message");
Assert.IsTrue(received == message2, "Expecting received == message2");
}
static byte[] GetMessageBytes(IPipeMessage message)
{
if (message is RequestCustomHash)
{
return(RequestCustomHash.SerializeToBytes((RequestCustomHash)message));
}
if (message is RequestMessageList)
{
return(RequestMessageList.SerializeToBytes((RequestMessageList)message));
}
if (message is RequestReadChunk)
{
return(RequestReadChunk.SerializeToBytes((RequestReadChunk)message));
}
if (message is RequestStoreMessage)
{
return(RequestStoreMessage.SerializeToBytes((RequestStoreMessage)message));
}
if (message is RequestWriteChunk)
{
return(RequestWriteChunk.SerializeToBytes((RequestWriteChunk)message));
}
throw new NotImplementedException();
}
/// <summary>Write the message to the listener</summary>
public virtual bool Write(IPipeMessage message)
{
Listener(message);
return(true);
}
public void TestBypassAndFilterModeToggle()
{
// create messages to send to the queue
IPipeMessage message = new Message(Message.NORMAL, new { width = 10, height = 2 });
// create filter, attach an anonymous listener to the filter output to receive the message,
// pass in an anonymous function an parameter object
IPipeFitting filter = new Filter("scale", new PipeListener(this, CallBackMethod), (IPipeMessage msg, object _params) => {
msg.Header = new
{
width = ((dynamic)msg.Header).width * ((dynamic)_params).factor,
height = ((dynamic)msg.Header).height * ((dynamic)_params).factor
};
return(true);
}, new { factor = 10 });
// create bypass control message
IPipeMessage byPassMessage = new FilterControlMessage(FilterControlMessage.BYPASS, "scale");
// write bypass control message to the filter
bool bypassWritten = filter.Write(byPassMessage);
// write normal message to the filter
bool written1 = filter.Write(message);
// test assertions
Assert.IsTrue(message is IPipeMessage, "Expecting message is IPipeMessage");
Assert.IsTrue(filter is Filter, "Expecting filter is Filter");
Assert.IsTrue(bypassWritten, "Expecting wrote bypass message to filter");
Assert.IsTrue(written1, "Expecting wrote normal message to filter");
Assert.IsTrue(messagesReceived.Count == 1, "Expecting received 1 messages");
// test filtered message assertions (no change to message)
IPipeMessage received1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received1 == message, "Expecting received == message");
Assert.IsTrue(((dynamic)received1.Header).width == 10, "Expecting ((dynamic)received1.Header).width == 10");
Assert.IsTrue(((dynamic)received1.Header).height == 2, "((dynamic)received1.Header).height == 2");
// create filter control message
IPipeMessage filterMessage = new FilterControlMessage(FilterControlMessage.FILTER, "scale");
// write bypass control message to the filter
bool filterWritten = filter.Write(filterMessage);
// write normal message to the filter again
bool written2 = filter.Write(message);
// test assertions
Assert.IsTrue(filterWritten, "Expecing worte filter message to filter");
Assert.IsTrue(written2, "Expecting wrote normal message to filter");
Assert.IsTrue(messagesReceived.Count == 1, "Expecing received 1 messages");
// test filtered message assertions (message filtered)
IPipeMessage received2 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(received2 is IPipeMessage, "Expecting received 2 is IPipeMessage");
Assert.IsTrue(received2 == message, "received2 == message");
Assert.IsTrue(((dynamic)received2.Header).width == 100, "Expecting ((dynamic)received2.Header).width == 100");
Assert.IsTrue(((dynamic)received2.Header).height == 20, "Expecting ((dynamic)received2.Header).height == 20");
}
/// <summary>
/// Handle incoming pipe messages.
/// <para>
/// Override in subclass and handle messages appropriately for the module.
/// </para>
/// </summary>
/// <param name="message"></param>
public virtual void HandlePipeMessage(IPipeMessage message)
{
}
/// <summary>
/// Callback given to <code>PipeListener</code> for incoming message.
/// <para>
/// Used by <code>testReceiveMessageViaPipeListener</code>
/// to get the output of pipe back into this test to see
/// that a message passes through the pipe.
/// </para>
/// </summary>
/// <param name="message"></param>
private void CallBackMethod(IPipeMessage message)
{
messagesReceived.Add(message);
}
/// <summary>
/// Handle the incoming message.
/// </summary>
/// <remarks>
/// <para>
/// If message type is normal, filter the message (unless in BYPASS mode)
/// and write the result to the output pipe fitting if the filter
/// operation is successful.
/// </para>
/// <para>
/// The FilterControlMessage.SET_PARAMS message type tells the Filter
/// that the message class is FilterControlMessage, which it
/// casts the message to in order to retrieve the filter parameters
/// object if the message is addressed to this filter.
/// </para>
/// <para>
/// The FilterControlMessage.SET_FILTER message type tells the Filter
/// that the message class is FilterControlMessage, which it
/// casts the message to in order to retrieve the filter function.
/// </para>
/// <para>
/// The FilterControlMessage.BYPASS message type tells the Filter
/// that it should go into Bypass mode operation, passing all normal
/// messages through unfiltered.
/// </para>
/// <para>
/// The FilterControlMessage.FILTER message type tells the Filter
/// that it should go into Filtering mode operation, filtering all
/// normal normal messages before writing out. This is the default
/// mode of operation and so this message type need only be sent to
/// cancel a previous BYPASS message.
/// </para>
/// <para>
/// The Filter only acts on the control message if it is targeted
/// to this named filter instance. Otherwise it writes through to the
/// output.
/// </para>
/// </remarks>
/// <param name="message">Message</param>
/// <returns>Boolean True if the filter process does not throw an error and subsequent operations in the pipeline succede.</returns>
public override bool Write(IPipeMessage message)
{
bool success = true;
// Filter normal messages
switch (message.Type)
{
case Message.NORMAL:
if (Mode == FilterControlMessage.FILTER)
{
success = ApplyFilter(message) ? Output.Write(message) : false;
}
else
{
success = Output.Write(message);
}
break;
// Accept parameters from control message
case FilterControlMessage.SET_PARAMS:
if (IsTarget(message))
{
SetParams(((FilterControlMessage)message).Params);
}
else
{
success = Output.Write(message);
}
break;
// Accept filter function from control message
case FilterControlMessage.SET_FILTER:
if (IsTarget(message))
{
SetFilter(((FilterControlMessage)message).Filter);
}
else
{
success = Output.Write(message);
}
break;
// Toggle between Filter or Bypass operational modes
case FilterControlMessage.BYPASS:
case FilterControlMessage.FILTER:
if (IsTarget(message))
{
Mode = message.Type;
}
else
{
success = Output.Write(message);
}
break;
// Write control messages for other fittings through
default:
success = Output.Write(message);
break;
}
return(success);
}
/// <summary>
/// Filter the message.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
protected virtual bool ApplyFilter(IPipeMessage message)
{
return(filter(message, @params));
}
/// <summary>
/// Is the message directed at this filter instance?
/// </summary>
/// <param name="message">message</param>
/// <returns></returns>
protected virtual bool IsTarget(IPipeMessage message)
{
return(((FilterControlMessage)message).Name == name);
}
/// <summary>
/// Write the message to the connected output.
/// </summary>
/// <param name="message">the message to writ</param>
/// <returns>Boolean whether any connected downpipe outputs failed</returns>
public virtual bool Write(IPipeMessage message)
{
return(Output.Write(message));
}
/// <summary>
/// Callback given to <code>PipeListener</code> for incoming message.
/// <para>
/// Used by <code>testReceiveMessageViaPipeListener</code>
/// to get the output of pipe back into this test to see
/// that a message passes through the pipe.
/// </para>
/// </summary>
/// <param name="message"></param>
private void CallBackMethod(IPipeMessage message)
{
messageReceived = message;
}
public void TestSortByPriorityAndFIFO()
{
// create messages to send to the queue
IPipeMessage message1 = new Message(Message.NORMAL, null, null, Message.PRIORITY_MED);
IPipeMessage message2 = new Message(Message.NORMAL, null, null, Message.PRIORITY_LOW);
IPipeMessage message3 = new Message(Message.NORMAL, null, null, Message.PRIORITY_HIGH);
// create queue, attaching an anonymous listener to its output
Queue queue = new Queue(new PipeListener(this, CallBackMethod));
// begin sort-by-priority order mode
bool sortWritten = queue.Write(new QueueControlMessage(QueueControlMessage.SORT));
// write messages to the queue
var message1written = queue.Write(message1);
var message2written = queue.Write(message2);
var message3written = queue.Write(message3);
// flush the queue
bool flushWritten = queue.Write(new QueueControlMessage(QueueControlMessage.FLUSH));
// test assertions
Assert.IsTrue(sortWritten, "Expecting wrote sort message to queue");
Assert.IsTrue(message1written, "Expecting wrote message1 to queue");
Assert.IsTrue(message2written, "Expecting wrote message2 to queue");
Assert.IsTrue(message3written, "Expecting wrote message3 to queue");
Assert.IsTrue(flushWritten, "Expecting wrote flush message to queue");
// test that 3 messages were received
Assert.IsTrue(messagesReceived.Count == 3, "Expecting received 3 messages");
// get the messages
IPipeMessage received1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
IPipeMessage received2 = messagesReceived[0];
messagesReceived.RemoveAt(0);
IPipeMessage received3 = messagesReceived[0];
messagesReceived.RemoveAt(0);
// test that the message order is sorted
Assert.IsTrue(received1.Priority < received2.Priority, "Expecting received1 is higher priority than received 2");
Assert.IsTrue(received2.Priority < received3.Priority, "Expecting received2 is higher priority than received 3");
Assert.IsTrue(received1 == message3, "Expected received1 == message3"); // object equality
Assert.IsTrue(received2 == message1, "Expected received2 == message1"); // object equality
Assert.IsTrue(received3 == message2, "Expected received3 == message2"); // object equality
// begin FIFO order mode
bool fifowritten = queue.Write(new QueueControlMessage(QueueControlMessage.FIFO));
// write messages to the queue
bool message1writtenAgain = queue.Write(message1);
bool message2writtenAgain = queue.Write(message2);
bool message3writtenAgain = queue.Write(message3);
// flush the queue
bool flushwrittenAgain = queue.Write(new QueueControlMessage(QueueControlMessage.FLUSH));
// test assertions
Assert.IsTrue(fifowritten, "Expecting wrote fifo message to queue");
Assert.IsTrue(message1writtenAgain, "Expecting worte message1 to queue again");
Assert.IsTrue(message2writtenAgain, "Expecting worte message2 to queue again");
Assert.IsTrue(message3writtenAgain, "Expecting worte message3 to queue again");
// test that 3 messages were received
Assert.IsTrue(messagesReceived.Count == 3, "Expecting received 3 messages");
// get the messages
IPipeMessage received1Again = messagesReceived[0];
messagesReceived.RemoveAt(0);
IPipeMessage received2Again = messagesReceived[0];
messagesReceived.RemoveAt(0);
IPipeMessage received3Again = messagesReceived[0];
messagesReceived.RemoveAt(0);
// test message order is FIFO
Assert.IsTrue(received1Again == message1, "Expecting received1Again == message1");
Assert.IsTrue(received2Again == message2, "Expecting received2Again == message2");
Assert.IsTrue(received3Again == message3, "Expecting received3Again == message3");
}
public void TestReceiveMessagesFromFourPipesViaTeeMerge()
{
// create a message to send on pipe 1
IPipeMessage pipe1Message = new Message(Message.NORMAL, new { testProp = 1 });
IPipeMessage pipe2Message = new Message(Message.NORMAL, new { testProp = 2 });
IPipeMessage pipe3Message = new Message(Message.NORMAL, new { testProp = 3 });
IPipeMessage pipe4Message = new Message(Message.NORMAL, new { testProp = 4 });
// create pipes 1, 2, 3 and 4
IPipeFitting pipe1 = new Pipe();
IPipeFitting pipe2 = new Pipe();
IPipeFitting pipe3 = new Pipe();
IPipeFitting pipe4 = new Pipe();
// create merging tee
TeeMerge teeMerge = new TeeMerge(pipe1, pipe2);
bool connectedExtraInput3 = teeMerge.ConnectInput(pipe3);
bool connectedExtraInput4 = teeMerge.ConnectInput(pipe4);
// create listener
PipeListener listener = new PipeListener(this, CallBackMethod);
// connect the listener to the tee and write the messages
bool connected = teeMerge.Connect(listener);
// write messages to their respective pipes
bool pipe1written = pipe1.Write(pipe1Message);
bool pipe2written = pipe2.Write(pipe2Message);
bool pipe3written = pipe3.Write(pipe3Message);
bool pipe4written = pipe4.Write(pipe4Message);
// test assertions
Assert.IsTrue(pipe1Message is IPipeMessage);
Assert.IsTrue(pipe2Message is IPipeMessage);
Assert.IsTrue(pipe3Message is IPipeMessage);
Assert.IsTrue(pipe4Message is IPipeMessage);
Assert.IsTrue(pipe1 is Pipe);
Assert.IsTrue(pipe2 is Pipe);
Assert.IsTrue(pipe3 is Pipe);
Assert.IsTrue(pipe4 is Pipe);
Assert.IsTrue(teeMerge is TeeMerge, "Expecting teeMerge is TeeMerge");
Assert.IsTrue(listener is PipeListener, "Expecing listner is PipeListener");
Assert.IsTrue(connected, "Expecting connected listener to merging tee");
Assert.IsTrue(connectedExtraInput3, "Expecting connected extra input 3 to merging tee");
Assert.IsTrue(connectedExtraInput4, "Expecting connected extra input 4 to merging tee");
Assert.IsTrue(pipe1written, "Expecting wrote message to pipe 1");
Assert.IsTrue(pipe2written, "Expecting wrote message to pipe 2");
Assert.IsTrue(pipe3written, "Expecting wrote message to pipe 3");
Assert.IsTrue(pipe4written, "Expecting wrote message to pipe 4");
// test that both messages were received, then test
// FIFO order by inspecting the messages themselves
Assert.IsTrue(messagesReceived.Count == 4, "Expecting received 4 messages");
// test message 1 assertions
IPipeMessage message1 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message1 is IPipeMessage, "Expecting message1 is IPipeMessage");
Assert.IsTrue(message1 == pipe1Message, "Expecing message1 == pipe1Message");
Assert.IsTrue(message1.Type == Message.NORMAL, "Expecting message1.Type == Message.NORMAL");
Assert.IsTrue(((dynamic)message1.Header).testProp == 1, "Expecting ((dynamic)message1.Header).testProp == 1");
// test message 2 assertions
IPipeMessage message2 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message2 is IPipeMessage, "Expecting message2 is IPipeMessage");
Assert.IsTrue(message2 == pipe2Message, "Expecing message2 == pipe1Message");
Assert.IsTrue(message2.Type == Message.NORMAL, "Expecting message2.Type == Message.NORMAL");
Assert.IsTrue(((dynamic)message2.Header).testProp == 2, "Expecting ((dynamic)message2.Header).testProp == 2");
// test message 3 assertions
IPipeMessage message3 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message3 is IPipeMessage, "Expecting message3 is IPipeMessage");
Assert.IsTrue(message3 == pipe3Message, "Expecing message3 == pipe1Message");
Assert.IsTrue(message3.Type == Message.NORMAL, "Expecting message3.Type == Message.NORMAL");
Assert.IsTrue(((dynamic)message3.Header).testProp == 3, "Expecting ((dynamic)message3.Header).testProp == 3");
// test message 4 assertions
IPipeMessage message4 = messagesReceived[0];
messagesReceived.RemoveAt(0);
Assert.IsTrue(message4 is IPipeMessage, "Expecting message4 is IPipeMessage");
Assert.IsTrue(message4 == pipe4Message, "Expecing message4 == pipe1Message");
Assert.IsTrue(message4.Type == Message.NORMAL, "Expecting message4.Type == Message.NORMAL");
Assert.IsTrue(((dynamic)message4.Header).testProp == 4, "Expecting ((dynamic)message4.Header).testProp == 4");
}
