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); }