public void TestCircularBuffer_Enqueue20ElementsDequeue10ElementsEnqueue10Elements_Capacity20() { CustomQueue <int> queue = new CustomQueue <int>(); for (int i = 0; i < 20; i++) { queue.Enqueue(i); } System.Diagnostics.Debug.WriteLine("\n\n\tCount = {0}\n\n", queue.Count); for (int i = 0; i < 10; i++) { queue.Dequeue(); } System.Diagnostics.Debug.WriteLine("\n\n\tCount = {0}\n\n", queue.Count); for (int i = 0; i < 10; i++) { queue.Enqueue(i); } System.Diagnostics.Debug.WriteLine("\n\n\tCount = {0}\n\n", queue.Count); bool isRightOrder = true; for (int i = 10; i < 30; i++) { isRightOrder &= queue.Dequeue() == i % 20; } Assert.IsTrue(isRightOrder && queue.Capacity == 20); }
public void TestCircularBuffer_Enqueue20ElementsDequeue10ElementsEnqueue10Elements_Capacity20() { CustomQueue<int> queue = new CustomQueue<int>(); for (int i = 0; i < 20; i++) { queue.Enqueue(i); } System.Diagnostics.Debug.WriteLine("\n\n\tCount = {0}\n\n", queue.Count); for (int i = 0; i < 10; i++) { queue.Dequeue(); } System.Diagnostics.Debug.WriteLine("\n\n\tCount = {0}\n\n", queue.Count); for (int i = 0; i < 10; i++) { queue.Enqueue(i); } System.Diagnostics.Debug.WriteLine("\n\n\tCount = {0}\n\n", queue.Count); bool isRightOrder = true; for (int i = 10; i < 30; i++) { isRightOrder &= queue.Dequeue() == i % 20; } Assert.IsTrue(isRightOrder && queue.Capacity == 20); }
public static void Run() { CustomQueue<int> queue = new CustomQueue<int>(); for (int i = 0; i < 24; i++) queue.Enqueue(i + 1); for (int i = 0; i < 24; i++) queue.Dequeue(); // queue.Dequeue(); // queue.Dequeue(); queue.Enqueue(7); queue.Enqueue(8); // queue.Dequeue(); // queue.Dequeue(); queue.Enqueue(9); queue.Enqueue(10); queue.Dequeue(); Console.WriteLine("For:"); for (int i = 0; i < queue.Count; i++) Console.WriteLine(queue[i]); Console.WriteLine("Peek: {0}", queue.Peek()); Console.WriteLine("Peek: {0}", queue.Peek()); Console.WriteLine("Peek: {0}", queue.Peek()); Console.WriteLine("Foreach:"); foreach (int i in queue) Console.WriteLine(i); }
static void Main(string[] args) { CustomQueue<int> queue = new CustomQueue<int>(9); queue.Enqueue(4); queue.Enqueue(3); queue.Enqueue(2); queue.Enqueue(1); queue.Enqueue(0); queue.Enqueue(-1); foreach (var a in queue) Console.WriteLine(a); Console.WriteLine("---------------"); Console.WriteLine("Peek = {0}",queue.Peek()); Console.WriteLine("---------------"); Console.WriteLine("Dequeue = {0}", queue.Dequeue()); Console.WriteLine("Dequeue = {0}", queue.Dequeue()); Console.WriteLine("Dequeue = {0}", queue.Dequeue()); Console.WriteLine("---------------"); foreach (var a in queue) Console.WriteLine(a); }
public void Queue_DequeueInEmptyQueue_InvalidOperationException() { CustomQueue <int> queue = new CustomQueue <int>(); queue.Enqueue(1); queue.Dequeue(); Assert.Throws <InvalidOperationException>(() => queue.Dequeue()); }
public void CustomQueue_Exeption_DequeueTest() { CustomQueue<int> queue = new CustomQueue<int>(1); queue.Enqueue(1); queue.Enqueue(2); queue.Dequeue(); queue.Dequeue(); queue.Dequeue(); }
public void CustomQueue_UsualDaten_DequeueTest() { CustomQueue<int> queue = new CustomQueue<int>(1); queue.Enqueue(1); queue.Enqueue(2); queue.Dequeue(); queue.Dequeue(); Assert.AreEqual(0, queue.Count); }
public void PeekTestMethod() { intQueue.Enqueue(1); intQueue.Enqueue(2); intQueue.Enqueue(3); intQueue.Enqueue(4); intQueue.Enqueue(5); intQueue.Dequeue(); Assert.AreEqual(intQueue.Peek(), 2); }
public void TestMethod1() { var queue = new CustomQueue<int>(); queue.Enqueue(1); Assert.AreEqual(queue.Dequeue(), 1); queue.Dequeue(); queue.Enqueue(1); Assert.AreEqual(queue.Dequeue(),1); queue.Dequeue(); }
public void QueueRemoveElementsCorrectly() { var queue = new CustomQueue <int>(); queue.Enqueue(1); queue.Enqueue(3); queue.Enqueue(19); queue.Dequeue(); queue.Dequeue(); Assert.Equal(1, queue.Count); }
static void Main() { CustomQueue<int> testQueue = new CustomQueue<int>(); testQueue.Enqueue(1); testQueue.Enqueue(2); testQueue.Enqueue(3); Console.WriteLine("Queue Lenght: {0}", testQueue.Count); Console.WriteLine("Dequeued Item: {0}", testQueue.Dequeue()); Console.WriteLine("Dequeued Item: {0}", testQueue.Dequeue()); Console.WriteLine("Peeking at Item: {0}", testQueue.Peek()); }
public void QueueRemoveSeveralElementsCorrectly() { var queue = new CustomQueue <int>(); queue.Enqueue(7); queue.Enqueue(18); queue.Enqueue(25); queue.Dequeue(); var lastElement = queue.Dequeue(); Assert.Equal(18, lastElement); Assert.Equal(1, queue.Count); }
static void Main() { Queue<int> abv = new Queue<int>(); //abv.Pe CustomQueue<int> customList = new CustomQueue<int>(); customList.Enqueue(3); customList.Enqueue(5); customList.Enqueue(1); Console.WriteLine(customList.Dequeue()); Console.WriteLine(customList.Dequeue()); customList.Enqueue(12); Console.WriteLine(customList.Dequeue()); Console.WriteLine(customList.Count); }
static void Main(string[] args) { using (reader = File.OpenText("input.txt")) using (writer = new StreamWriter(File.Create("output.txt"))) { int m = reader.ReadInt(); CustomQueue <int> queue = new CustomQueue <int>(m); for (int i = 0; i < m; i++) { string cmd = reader.ReadToken(); switch (cmd) { case "-": writer.Write(queue.Dequeue()); writer.WriteLine(); break; case "+": int value = reader.ReadInt(); queue.Enqueue(value); break; } } } }
public void Dequeue_GivenArray_ReturnsFirstElementOfGivenQueue() { var queue = new CustomQueue <int>(new[] { 1, 2, 3, 4, 5 }); var firstElement = queue.Dequeue(); Assert.AreEqual(1, firstElement); }
public void TestDequeueAfterCreationWithArray() { var testArray = new int[] { 0, 3, 5, 7, 9 }; var queue = new CustomQueue <int>(testArray); Assert.AreEqual(testArray[0], queue.Dequeue()); }
static void Queue() { CustomQueue cq = new CustomQueue(20); cq.Enqueue(10); cq.Enqueue(20); cq.Enqueue(30); Console.WriteLine(cq.Count); var tmp = cq.GetItem(); for (int i = 0; i < tmp.Length; i++) { Console.WriteLine("Item -> " + tmp[i]); } cq.Dequeue(); Console.WriteLine("After Dequeuing : "); tmp = cq.GetItem(); for (int i = 0; i < tmp.Length; i++) { Console.WriteLine("Item -> " + tmp[i]); } cq.Enqueue(40); Console.WriteLine("After adding 40 : "); tmp = cq.GetItem(); for (int i = 0; i < tmp.Length; i++) { Console.WriteLine("Item -> " + tmp[i]); } }
public void Dequeue_OneTime_DeletesFirstElementFromBegining() { CustomQueue<int> queue = new CustomQueue<int>(new int[] { 5, 11, 6, 5, 9, 5 }); queue.Dequeue(); Assert.AreEqual(11, queue.Peek()); }
static void Main(string[] args) { using (reader = File.OpenText("input.txt")) using (writer = new StreamWriter(File.Create("output.txt"))) { int m = reader.ReadInt(); CustomQueue <int> queue = new CustomQueue <int>(m + 1); while (m > 0) { var cmd = reader.ReadToken(); int value; switch (cmd) { case "+": int number = reader.ReadInt(); queue.Enqueue(number); break; case "-": value = queue.Dequeue(); break; case "?": value = queue.Min(); writer.WriteLine(value); break; } m--; } } }
static void QueueUsingTwoStacks() { CustomQueue queue = new CustomQueue(); int n = int.Parse(Console.ReadLine()); while (n > 0) { string Line = Console.ReadLine(); int query = int.Parse(Line.Substring(0, 1)); if (query == 1) { int num = int.Parse(Line.Substring(2)); queue.Enqueue(num); } else if (query == 2) { queue.Dequeue(); } else { if (queue.Count > 0) { Console.WriteLine(queue.Peek()); } } n--; } }
public void TestEnumerator_Enqueue20ElementsDequeue10ElementsEnqueue10Elements_Capacity20() { CustomQueue <int> queue = new CustomQueue <int>(); for (int i = 0; i < 20; i++) { queue.Enqueue(i); } for (int i = 0; i < 9; i++) { queue.Dequeue(); } for (int i = 0; i < 8; i++) { queue.Enqueue(i); } bool isRightOrder = true; int expectedValue = 9; foreach (var item in queue) { isRightOrder &= item == expectedValue % 20; expectedValue++; } Assert.IsTrue(isRightOrder); }
public void Dequeue_GetFirstItemFromEmptyQueue_ThrowInvalidOperationException() { queue = new CustomQueue <int>(); var e = Assert.Throws <InvalidOperationException>(() => queue.Dequeue()); Assert.Equal("Queue is empty", e.Message); }
public double[] Queue_Dequeue_IsCorrect(double[] input) { CustomQueue <double> queue = new CustomQueue <double>(input); queue.Dequeue(); return(queue.ToArray()); }
static void Main(string[] args) { /*var test = new CounterEvent(); var timer = new EventNumber(1,test); var timer2 = new EventNumber(2,test); test.StartEvent(3); Console.WriteLine("\nFibonacci"); foreach (var number in Fibonacci.GetNumbers(5)) { Console.WriteLine(number); } */ var qqq = new CustomQueue<int>(); qqq.Enqueue(112); qqq.Enqueue(14); qqq.Enqueue(1); qqq.Enqueue(662); qqq.Enqueue(909); qqq.Enqueue(112); qqq.Enqueue(5555); Console.WriteLine("QueueElements:"); foreach (var q in qqq) { Console.WriteLine(q); } Console.WriteLine("Dequeue"); Console.WriteLine(qqq.Dequeue()); Console.WriteLine(qqq.Dequeue()); Console.WriteLine("QueueElements:"); foreach (var q in qqq) { Console.WriteLine(q); } Console.WriteLine("Peek:"); Console.WriteLine(qqq.Peek()); Console.WriteLine("QueueElements:"); foreach (var q in qqq) { Console.WriteLine(q); } Console.ReadKey(); }
public void EmptyDequeue_Test() { // ARRANGE var queue = new CustomQueue <int>(); // ACT queue.Dequeue(); }
public void testQueueAddAValue() { CustomQueue<Element> customQueue = new CustomQueue<Element>(); Element e = new Element(1, "A"); customQueue.Enqueue(e); Assert.AreEqual(e.getText(), customQueue.Dequeue().getText()); }
public void Dequeue_Test() { // ARRANGE var queue = new CustomQueue <int>(); // ACT queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); // ASSERT Assert.AreEqual(3, queue.Count); Assert.AreEqual(1, queue.Dequeue()); Assert.AreEqual(2, queue.Dequeue()); Assert.AreEqual(3, queue.Dequeue()); }
private IEnumerator Work() { Working = true; while (workOrderQueue.Count > 0) { var workOrder = workOrderQueue.Peek(); if (workOrder is RecruitmentWorkOrder) { var recruitmentCompleted = false; while (!recruitmentCompleted) { if (populationManager.TryRecruit(workOrder as RecruitmentWorkOrder)) { OnWorkOrderStarted?.Invoke(); yield return(WaitFor(workOrder.duration)); if (!pendingCancel) { Recruit(workOrder as RecruitmentWorkOrder); } else { populationManager.Cancel(workOrder as RecruitmentWorkOrder); } recruitmentCompleted = true; } else { recruitmentProcessStuck = true; while (recruitmentProcessStuck) { yield return(null); } } } } else { OnWorkOrderStarted?.Invoke(); yield return(WaitFor(workOrder.duration)); } if (!pendingCancel) { workOrderQueue.Dequeue(); OnWorkOrderQueueUpdated?.Invoke(workOrderQueue.GetReadonlyList()); } else { pendingCancel = false; } } Working = false; }
public void Dequeue_NormalConditions_Test() { CustomQueue <string> testQueue = new CustomQueue <string>(); testQueue.Enqueue("Test"); testQueue.Enqueue("Test2"); testQueue.Dequeue(); Assert.That(testQueue.Peek(), Is.EqualTo("Test2")); }
public void testQueueAddAValue() { CustomQueue <Element> customQueue = new CustomQueue <Element>(); Element e = new Element(1, "A"); customQueue.Enqueue(e); Assert.AreEqual(e.getText(), customQueue.Dequeue().getText()); }
public void PeekElementFromQueueTest() { CustomQueue<int> myQueue = new CustomQueue<int>(); myQueue.Enqueue(new int[]{2, 12, 52, 82, 4, 2}); myQueue.Dequeue(); int actual = myQueue.Peek(); int expected = 12; Assert.AreEqual(expected, actual); }
private static void ConsumeQueue(object sender, EventArgs e) { object item; while (MyQueue.Count > 0) { item = MyQueue.Dequeue(); //Do something... } }
public void TryingToDequeueBeforePutAnythingInQueueShouldThrowInvalidOperationException() { //Arange var queue = new CustomQueue <string>(); //Act var ex = Assert.ThrowsException <InvalidOperationException>(() => queue.Dequeue()); //Assert Assert.AreEqual(emptyQueue, ex.Message); }
public static void Main() { CustomQueue <int> q = new CustomQueue <int>(); q.Enqueue(5); q.Enqueue(6); q.Enqueue(7); q.Enqueue(8); q.Enqueue(9); Console.WriteLine(q.Contains(9)); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Contains(6)); Console.WriteLine(q.Count); }
public static void Main() { CustomQueue<int> q = new CustomQueue<int>(); q.Enqueue(5); q.Enqueue(6); q.Enqueue(7); q.Enqueue(8); q.Enqueue(9); Console.WriteLine(q.Contains(9)); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Dequeue()); Console.WriteLine(q.Contains(6)); Console.WriteLine(q.Count); }
public void GivenQueueWithFiveItemAndFirstItemIs84_WhenDequeue_ThenTheItemRemovedIsEqualTo84() { var queue = new CustomQueue<int>(); queue.Enqueue(84); queue.Enqueue(77); queue.Enqueue(99); queue.Enqueue(71); queue.Enqueue(18); var result = queue.Dequeue(); Assert.AreEqual(84, result); }
public void PeekTests(IEnumerable <string> collection, string expected) { // Arrange CustomQueue <string> queue = new CustomQueue <string>(collection); // Act var result = queue.Dequeue(); // Assert Assert.AreEqual(expected, result); }
public void DequeueAndEnqueue_FilledWithEnqueueDequeueOneElement_ReturnsExpectedQueue() { var queue = new CustomQueue<int>(new[] { 1, 2, 3, 4, 5 }); var result = new CustomQueue<int>(); result.Enqueue(2); result.Enqueue(3); result.Enqueue(4); result.Enqueue(5); queue.Dequeue(); Assert.AreEqual(result, queue); }
static void Main(string[] args) { WriteLine("Start Queue test"); CustomQueue <int> queue = new CustomQueue <int>(new List <int> { 0, 1, 2, 4, 5, -5, -8, 95 }); WriteLine("\nTest foreach"); foreach (var i in queue) { Write($"{i} .. "); } queue.Enqueue(57); queue.Enqueue(-57); queue.Enqueue(0); WriteLine("\nTest Enqueue /57, -57, 0/"); foreach (var i in queue) { Write($"{i} .. "); } WriteLine("\nTest Error when enumerate and modify"); try { foreach (var i in queue) { Write($"{i} .. "); WriteLine($"Try to dequeue: {queue.Dequeue()}"); } } catch (InvalidOperationException ex) { WriteLine(ex); } WriteLine("\nTest Dequeue 6 elements"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine("\nWrite after dequeue"); foreach (var i in queue) { Write($"{i} .. "); } WriteLine("\nCheck Peek"); WriteLine($"Peek: {queue.Peek()}"); WriteLine("\nTest Clear"); queue.Clear(); WriteLine($"Count: {queue.Count}"); ReadLine(); }
public void Peek_GetFirstItemWithoutReturn_Return10() { queue = new CustomQueue <int>(new int[] { 10, 20, 30 }); // Get first without return: 10 var res = queue.Peek(); Assert.Equal(10, res); // Get first without return: 10 res = queue.Peek(); Assert.Equal(10, res); // Get first and return: 10 res = queue.Dequeue(); Assert.Equal(10, res); // Get first and return: 20 res = queue.Dequeue(); Assert.Equal(20, res); }
public static void Main() { Console.WriteLine("Stack to Queue..."); var queue = new CustomQueue(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); Console.WriteLine(queue.Dequeue()); queue.Enqueue(4); queue.Enqueue(5); Console.WriteLine(queue.Dequeue()); Console.WriteLine(queue.Dequeue()); Console.WriteLine(queue.Dequeue()); Console.ReadLine(); }
public void CheckeReverseQueue() { CustomQueue<double> queue = new CustomQueue<double>(); queue.EnQueue(3.14); queue.EnQueue(8.28); queue.EnQueue(1.1987); queue.EnQueue(5.39); queue.Reverse(); double element = queue.Dequeue(); Assert.AreEqual(5.39, element); }
static void Main() { var testQ = new CustomQueue<int>(); testQ.Enqueue(1); testQ.Enqueue(2); testQ.Enqueue(3); while (testQ.Count > 0) { Console.WriteLine(testQ.Dequeue()); } }
/* Task 13: * Implement the ADT queue as dynamic linked list. * Use generics (LinkedQueue<T>) to allow storing different data types in the queue. */ static void Main(string[] args) { var customQueue = new CustomQueue<int>(); customQueue.Enqueue(15); customQueue.Enqueue(25); customQueue.Enqueue(35); customQueue.Enqueue(45); Console.WriteLine("Custom Queue Count: {0}", customQueue.Count()); Console.WriteLine("Removed element {0}", customQueue.Dequeue()); Console.WriteLine("Custom Queue Count: {0}", customQueue.Count()); }
public void DequeueTests(IEnumerable <sbyte> collection, sbyte value, IEnumerable <sbyte> expected) { // Arrange CustomQueue <sbyte> queue = new CustomQueue <sbyte>(collection); // Act var result = queue.Dequeue(); // Assert Assert.AreEqual(value, result); CollectionAssert.AreEqual(expected.ToArray(), queue.ToArray()); }
public void Dequeue_CorrectParamsSting_CountDecrements() { string[] arr = { "af", "re", "lo" }; CustomQueue <string> queue = new CustomQueue <string>(arr); int expected = 2; queue.Dequeue(); int actual = queue.Count; Assert.AreEqual(expected, actual); }
public void DequeueAndEnqueue_FilledWithEnqueueDequeueOneElement_ReturnsExpectedQueue() { var queue = new CustomQueue <int>(new[] { 1, 2, 3, 4, 5 }); var result = new CustomQueue <int>(); result.Enqueue(2); result.Enqueue(3); result.Enqueue(4); result.Enqueue(5); queue.Dequeue(); Assert.AreEqual(result, queue); }
public void CheckeDequeue() { CustomQueue<double> queue = new CustomQueue<double>(); queue.EnQueue(3.14); queue.EnQueue(8.28); queue.EnQueue(1.1987); queue.EnQueue(5.39); double element = queue.Dequeue(); int length = queue.Length; Assert.AreEqual(3.14, element); Assert.AreEqual(3, length); }
public void Enqueue_GivenSix_ReturnsSixWhenDequeuePreviousElements() { var queue = new CustomQueue <int>(new[] { 1, 2, 3, 4, 5 }); queue.Enqueue(6); for (int i = 0; i < 5; i++) { queue.Dequeue(); } var lastElement = queue.Peek(); Assert.AreEqual(6, lastElement); }
static void Main(string[] args) { CustomQueue<int> userQueue = new CustomQueue<int>(); Console.WriteLine("Was created. Count = "+userQueue.Count); userQueue.Enqueue(1); userQueue.Enqueue(2); userQueue.Enqueue(3); userQueue.Enqueue(4); userQueue.Enqueue(5); foreach (var item in userQueue) { Console.WriteLine(item); } Console.WriteLine("Was enqueued. Count = " + userQueue.Count); Console.WriteLine("\nDequeued: " + userQueue.Dequeue()); Console.WriteLine("Dequeued: " + userQueue.Dequeue()); Console.WriteLine("\n Result:"); foreach (var item in userQueue) { Console.WriteLine(item); } Console.WriteLine("Was dequeued. Count = " + userQueue.Count); Console.WriteLine(userQueue.Peek()); Console.WriteLine("Was peeked. Count = " + userQueue.Count); Console.WriteLine("\nCtor with IEnumerable:"); int[] array = new int[] { 5, 6, 7, 8, 9 }; CustomQueue<int> userQueue2 = new CustomQueue<int>(array); foreach (var item in userQueue2) { Console.WriteLine(item); } Console.ReadLine(); }
public static void Main(string[] args) { CustomQueue<int> queue = new CustomQueue<int>(); queue.Add(5); queue.Add(55); queue.Add(96); queue.Add(123); queue.Add(234); while (queue.Count > 0) { Console.WriteLine(queue.Dequeue()); } }
public void ConstructorWithIEnumerable_Test() { int[] array = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; CustomQueue<int> queue = new CustomQueue<int>(array); bool isCorrect = true; for (int i = 0; i < array.Length; i++) { isCorrect = (queue.Dequeue() == array[i]); if (!isCorrect) break; } Assert.IsTrue(isCorrect); }
public void Dequeue_Test() { int[] array = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; CustomQueue<int> queue = new CustomQueue<int>(array); bool isCorrect = true; for (int i = 0; i < array.Length; i++) { isCorrect = isCorrect && (queue.Dequeue() == array[i]); } isCorrect = isCorrect && (queue.Count == 0); Assert.IsTrue(isCorrect); }
public void CheckeDequeueWhenEmpty() { string s = string.Empty; try { CustomQueue<double> queue = new CustomQueue<double>(); double element = queue.Dequeue(); } catch(System.Exception ex) { s = ex.GetType().ToString(); } Assert.AreEqual("System.InvalidOperationException", s); }
public void testQueueAddMaxValue() { CustomQueue<Element> customQueue = new CustomQueue<Element>(); Element maxElement = new Element(10, "This is max"); customQueue.Enqueue(new Element(1, "This is not max")); customQueue.Enqueue(new Element(5, "This is not max")); customQueue.Enqueue(new Element(4, "This is not max")); customQueue.Enqueue(maxElement); customQueue.Enqueue(new Element(1, "This is not max")); customQueue.Enqueue(new Element(7, "This is not max")); customQueue.Enqueue(new Element(9, "This is not max")); Assert.AreEqual(maxElement.getText(), customQueue.Dequeue().getText()); }
static void Main(string[] args) { WriteLine("Start Queue test"); CustomQueue<int> queue = new CustomQueue<int>(new List<int> { 0, 1, 2, 4, 5, -5, -8, 95 }); WriteLine("\nTest foreach"); foreach(var i in queue) { Write($"{i} .. "); } queue.Enqueue(57); queue.Enqueue(-57); queue.Enqueue(0); WriteLine("\nTest Enqueue /57, -57, 0/"); foreach (var i in queue) { Write($"{i} .. "); } WriteLine("\nTest Error when enumerate and modify"); try { foreach(var i in queue) { Write($"{i} .. "); WriteLine($"Try to dequeue: {queue.Dequeue()}"); } } catch(InvalidOperationException ex) { WriteLine(ex); } WriteLine("\nTest Dequeue 6 elements"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine($"Dequeue: {queue.Dequeue()}"); WriteLine("\nWrite after dequeue"); foreach (var i in queue) { Write($"{i} .. "); } WriteLine("\nCheck Peek"); WriteLine($"Peek: {queue.Peek()}"); WriteLine("\nTest Clear"); queue.Clear(); WriteLine($"Count: {queue.Count}"); ReadLine(); }
public void EnqueueDequeue_ArrayElements_ElementsOrderedByEnterTime() { CustomQueue<int> queue = new CustomQueue<int>(); for (int i = 0; i < 200; i++) { queue.Enqueue(i); } bool isRightOrder = true; for (int i = 0; i < 200; i++) { isRightOrder &= queue.Dequeue() == i; } Assert.IsTrue(isRightOrder); }
public void TestMethodsEnqueuDequeuPeek(int[] expectedArray, int expectedPeek) { CustomQueue<int> customQueue = new CustomQueue<int>(); var customIter = customQueue.GetEnumerator(); Queue<int> queue = new Queue<int>(); customQueue.Enqueue(1); customQueue.Enqueue(2); customQueue.Enqueue(4); customQueue.Enqueue(8); customQueue.Enqueue(9); customQueue.Dequeue(); Assert.AreEqual(customQueue.Peek(), expectedPeek); int[] array = customQueue.ToArray(); CollectionAssert.AreEqual(expectedArray, array); }
static void Main(string[] args) { CustomQueue<int> CQ = new CustomQueue<int>(); CQ.Enqueue(1); CQ.Enqueue(2); CQ.Enqueue(3); CQ.Enqueue(4); CQ.Enqueue(5); Console.WriteLine(CQ.Peek()); int first = CQ.Dequeue(); Console.WriteLine(CQ.Peek()); foreach (int i in CQ) Console.Write(i + " "); Console.WriteLine(); Console.WriteLine(CQ.Peek()); }
public void CustomQueue_DequeueTest() { CustomQueue<int> myQueue = new CustomQueue<int>(); for (int i = 0; i < 10; i++) { myQueue.Enqueue(i); } for (int i = 0; i < 5; i++) { myQueue.Dequeue(); } int expected = 5; Assert.AreEqual(expected, myQueue.Count); }