public void AddFour_RemoveTwo_AddFour_Assert_CorrectBehviour()
{
var queue = new Queues <int>();
for (int i = 0; i < 4; i++)
{
queue.Enqueue(i);
}
for (int k = 0; k < 2; k++)
{
var item = queue.Dequeue();
Assert.AreEqual(item, k);
}
for (int j = 5; j < 8; j++)
{
queue.Enqueue(j);
}
for (int k = 2; k < 4; k++)
{
var item = queue.Dequeue();
Assert.AreEqual(item, k);
}
}
public void AddThree_RemoveTwo_AddOne_Assert_CorrectBehviourForWrappedHead()
{
var queue = new Queues <int>();
for (int i = 0; i < 3; i++)
{
queue.Enqueue(i);
}
for (int k = 0; k < 2; k++)
{
var item = queue.Dequeue();
Assert.AreEqual(item, k);
}
//Add two more
for (int j = 3; j < 5; j++)
{
queue.Enqueue(j);
}
for (int i = 2; i < 5; i++)
{
var item = queue.Dequeue();
Assert.AreEqual(item, i);
}
}
public IEnumerable <T> BreadthFirstSearch()
{
if (Root is null)
{
yield break;
}
else
{
//Create queue
Queues <Node> breadthTraversal = new Queues <Node>();
breadthTraversal.Enqueue(Root);
// check if tree is empty
while (!breadthTraversal.IsEmpty())
{
//dequeue root first
var front = breadthTraversal.Dequeue();
yield return(front.Value);
//move from left to right
if (front.Left != null)
{
breadthTraversal.Enqueue(front.Left);
}
if (front.Right != null)
{
breadthTraversal.Enqueue(front.Right);
}
}
}
}
public IEnumerable <T> GetMaxValue()
// Short way = return InOrder().Max();
// reduce
// return InOrder().Aggregate(max,next) => max > next ? max : next);
{
if (Root == null)
{
throw new Exception("Root is Null");
}
Queues <Node> nodeQueue = new Queues <Node>();
T max = Root.Value;
Node current = nodeQueue.Dequeue();
if (current.Value.CompareTo(max) > 0)
{
max = current.Value;
}
if (current.Left != null)
{
nodeQueue.Enqueue(current.Left);
}
if (current.Right != null)
{
nodeQueue.Enqueue(current.Right);
}
yield return(max);
}
public void AddFourRemoveFourThenAddFiveRemoveFiveAddFourRemoveFourAssertCorrectBehaviour()
{
var queue = new Queues <int>();
for (int i = 0; i < 4; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(i, queue.Dequeue());
}
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(i, queue.Dequeue());
}
for (int i = 0; i < 4; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(i, queue.Dequeue());
}
}
public void AddFiveRemoveFiveAddTenRemoveTenAddFour()
{
var queue = new Queues <int>();
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(i, queue.Dequeue());
}
for (int i = 0; i < 10; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(i, queue.Dequeue());
}
for (int i = 0; i < 4; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(i, queue.Dequeue());
}
}
public void EnqueueMultipleValues()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
Assert.Equal(12, queue.Rear.Value);
queue.Enqueue(20);
Assert.Equal(10, queue.Front.Value);
}
public void DequeueOnQueue()
{
Queues queue = new Queues();
Node nodeOne = new Node(1);
Node nodeTwo = new Node(2);
queue.Enqueue(nodeOne);
queue.Enqueue(nodeTwo);
Assert.True(queue.Dequeue().Value == nodeOne.Value);
Assert.True(queue.Dequeue().Value == nodeTwo.Value);
Assert.Throws <NullReferenceException>(() => queue.Dequeue());
}
public void EnqueueOnQueue()
{
Queues queue = new Queues();
Node nodeOne = new Node(1);
Node nodeTwo = new Node(2);
queue.Enqueue(nodeOne);
queue.Enqueue(nodeTwo);
Assert.True(queue.front == nodeOne);
Assert.True(queue.rear == nodeTwo);
}
public void CanDequeueOutOfQueue()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
Node <int> returned = queue.Dequeue();
int expected = 10;
Assert.Equal(expected, returned.Value);
}
public void PeekIntoQueueAndSeeExpectedValue()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
int returned = queue.Peek();
int expected = 10;
Assert.Equal(expected, returned);
}
public void PeakOnQueue()
{
Queues queue = new Queues();
Node nodeOne = new Node(1);
Node nodeTwo = new Node(2);
Node nodeThree = new Node(3);
Node nodeFour = new Node(4);
queue.Enqueue(nodeOne);
queue.Enqueue(nodeTwo);
queue.Enqueue(nodeThree);
queue.Enqueue(nodeFour);
Assert.Equal(1, queue.Peak().Value);
}
public void EmptyQueueAfterMultipleDequeues()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
queue.Dequeue();
queue.Dequeue();
queue.Dequeue();
bool expected = true;
Assert.Equal(expected, queue.IsEmpty());
}
public void CanProcessByMultipleTimes()
{
// Easiest way to add named processor for a specific type.
// Defaults to 5 items per dequeue.
Queues.AddProcessorFor <string>(items => ProcessString(items, true, null));
Queues.Enqueue <string>(new List <string>()
{
"kishore", "reddy", "kdog", "kishore", "reddy", "kdog"
});
Queues.Enqueue <string>(new List <string>()
{
"kdog", "reddy", "kishore", "kdog", "reddy", "kishore"
});
// Need to process multiple times since there are more than 5 entries which is the default
// number of items that get processed by each call to Process().
// This can then be combined w/ the scheduler to perform some scheduled processing.
// e.g.
// Scheduler.Run( Every(1.Minute), () => Queues.Process<string>());
Queues.Process <string>();
Queues.Process <string>();
Assert.IsTrue(Queues.IsIdle <string>());
}
/// <summary>
/// Run the application.
/// </summary>
public override BoolMessageItem Execute()
{
// 1. Run every 2 seconds, with maximum of 3 runs.
Scheduler.Schedule("task1", new Trigger().Every(((int)2).Seconds()).MaxRuns(3),
() => Console.WriteLine("Repeating task"),
task => OnComplete(task));
// 2. Run every 2 seconds, end in 30 seconds.
Scheduler.Schedule("task2", new Trigger().Every(((int)3).Seconds()).StopAt(DateTime.Now.AddSeconds(30)),
() => Console.WriteLine("Repeat with limit"),
task => OnComplete(task));
// 3. Combine w/ the Queue processing.
Queues.AddProcessorFor <string>(items => items.ForEach(item => Console.WriteLine(item)));
Queues.Enqueue <string>(new List <string>()
{
"a", "b", "c", "d", "e", "f"
});
Scheduler.Schedule("task3", new Trigger().Every(((int)4).Seconds()).MaxRuns(2),
() => Queues.Process <string>(),
task => OnComplete(task));
_resetevent.WaitOne();
return(BoolMessageItem.True);
}
public override void Respond(IHttpContext context)
{
var match = urlMatcher.Match(context.GetRequestUrl());
var queue = match.Groups[1].Value;
switch (context.Request.HttpMethod)
{
case "GET":
context.WriteJson(Queues.Statistics(queue));
break;
case "POST":
var metadata = context.Request.Headers.FilterHeaders(isServerDocument: true);
var msgId = Queues.Enqueue(new IncomingMessage
{
Data = context.Request.InputStream.ReadData(),
Queue = queue,
Metadata = metadata,
TimeToLive = metadata.Property("Raven-Time-To-Live") != null
? TimeSpan.FromSeconds(metadata.Value <int>("Raven-Time-To-Live"))
: TimeSpan.FromMinutes(5)
});
context.WriteJson(new { MsgId = msgId });
break;
}
}
public void CanEnqueueIntoQueue()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
Assert.Equal(10, queue.Front.Value);
}
public void EnqueueOnEmptyQueue()
{
Queues queue = new Queues();
Node node = new Node(1);
queue.Enqueue(node);
Assert.True(queue.front == node);
Assert.True(queue.rear == node);
}
public void AddFiveElementsAssertCountFive()
{
var queue = new Queues <int>();
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i);
}
Assert.AreEqual(5, queue.Count);
}
public void CanProcessByAddingProcessor()
{
// Add the named processor "my_handler", w/ the ProcessString lamda, and handle 5 items per dequeue.
Queues.AddProcessor("my_handler", new QueueProcessor <string>(5, items => ProcessString(items, false, "my_handler")));
Queues.Enqueue <string>("my_handler", "kdog");
Queues.Enqueue <string>("my_handler", new List <string>()
{
"kishore", "reddy"
});
Queues.Process("my_handler");
Assert.IsTrue(Queues.IsIdle("my_handler"));
}
/// <summary>
/// Run the application.
/// </summary>
public override BoolMessageItem Execute()
{
// NOTE:
// 1. Just showing the API for queue processing using lamdas as delegates.
// 2. Typically the Queues.Process method will be called by a scheduler to process something periodically.
// 1. Add queue processing handler for strings WITH OUT specifying a name.
// By default, the items in teh queues are processed 5 at a time on each call to Process.
Queues.AddProcessorFor <string>(items => items.ForEach(item => Console.WriteLine(item)));
Queues.Enqueue <string>(new List <string>()
{
"a", "b", "c", "d", "e", "1", "2", "3", "4", "5"
});
// 1st call only prints a-e
// 2nd call prints the remainder 1-5
Queues.Process <string>();
Queues.Process <string>();
Console.WriteLine();
// 2. Add queue processing by specifying the handler name.
// This is ideal if you have 2 handlers for the same type.
Queues.AddProcessorFor <int>("my_handler", items => items.ForEach(i => Console.WriteLine(i)));
Queues.Enqueue <int>("my_handler", new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9
});
Queues.Process("my_handler");
Console.WriteLine();
// 3. Add queue processing custom type.
Queues.AddProcessorFor <Quote>(items => PrintQuotes(items));
Queues.Enqueue <Quote>(new List <Quote>()
{
new Quote("MSFT", 20), new Quote("GOOG", 300), new Quote("CITI", 0),
new Quote("AIG", -1), new Quote("HONDA", 80), new Quote("BankOfAmerica", 30),
new Quote("TOYO", 20), new Quote("CS", 32), new Quote("GS", -1)
});
Queues.Process <Quote>();
// 4. Add queue processing by specifying the queue processor, custom name("my_quote_queue"), custom type(Quote), custom dequeue size(2).
Queues.AddProcessor("my_quote_queue", new QueueProcessor <Quote>(2, items => PrintQuotes(items)));
Queues.Enqueue <Quote>("my_quote_queue", new List <Quote>()
{
new Quote("MSFT", 20), new Quote("GOOG", 300), new Quote("CITI", 0),
new Quote("AIG", -1), new Quote("HONDA", 80), new Quote("BankOfAmerica", 30),
new Quote("TOYO", 20), new Quote("CS", 32), new Quote("GS", -1)
});
Queues.Process("my_quote_queue");
return(BoolMessageItem.True);
}
public void QueueDequeue()
{
{
Node myNode1 = new Node(1);
Node myNode2 = new Node(1);
Queues Queue = new Queues(myNode1);
Queue.Enqueue(myNode2);
Queue.Dequeue();
Assert.Equal(myNode2, Queue.Peek());
}
}
public void CanProcessByType()
{
// Easiest way to add named processor for a specific type.
// Defaults to 5 items per dequeue.
Queues.AddProcessorFor <string>(items => ProcessString(items, true, null));
Queues.Enqueue <string>("kdog");
Queues.Enqueue <string>(new List <string>()
{
"kishore", "reddy"
});
Queues.Process <string>();
Assert.IsTrue(Queues.IsIdle <string>());
}
public void AddFiveElementsAssertElementsAddedInOrder()
{
var queue = new Queues <int>();
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < 5; i++)
{
var item = queue.Dequeue();
Assert.AreEqual(i, item);
}
}
public void AddSixteenItems_RemoveNineItems_AssertCorrectBehaviourOfResize()
{
var queue = new Queues <int>();
for (int i = 0; i < 16; i++)
{
queue.Enqueue(i);
}
for (int k = 15; k > 6; k--)
{
var item = queue.Dequeue();
}
Assert.AreEqual(7, queue.Count);
}
public void CanGetQueueStates()
{
// Easiest way to add named processor for a specific type.
// Defaults to 5 items per dequeue.
Queues.AddProcessorFor <string>(items => ProcessString(items, true, null));
Queues.AddProcessor("tags_queue",
new QueueProcessor <string>(2, items => items.ForEach(item => Console.WriteLine(item))));
Queues.Enqueue <string>("tags_queue", new List <string>()
{
"python", "ruby", "erlang", "closure", "scala"
});
Queues.Enqueue <string>(new List <string>()
{
"kishore", "reddy"
});
Queues.Process <string>();
Queues.Process("tags_queue");
Queues.Process("tags_queue");
var states = Queues.GetMetaInfo();
var map = new Dictionary <string, QueueStatus>();
foreach (var state in states)
{
map[state.Name] = state;
}
Assert.AreEqual(states.Count, 2);
Assert.AreEqual(map["System.String"].Count, 0);
Assert.AreEqual(map["System.String"].DequeueSize, 10);
Assert.AreEqual(map["System.String"].NumberOfTimesProcessed, 1);
Assert.AreEqual(map["System.String"].State, QueueProcessState.Idle);
Assert.AreEqual(map["tags_queue"].Count, 1);
Assert.AreEqual(map["tags_queue"].DequeueSize, 2);
Assert.AreEqual(map["tags_queue"].NumberOfTimesProcessed, 2);
Assert.AreEqual(map["tags_queue"].State, QueueProcessState.Idle);
}
