static void Main() { LinkedQueue<int> linkedQueue = new LinkedQueue<int>(); LinkedQueue<string> anotherLinkedQueue = new LinkedQueue<string>( new List<string> { "pesho", "gosho", "sasho", "misho" }); Console.WriteLine(anotherLinkedQueue); Console.WriteLine("First: " + anotherLinkedQueue.First.Value); Console.WriteLine("Last: " + anotherLinkedQueue.Last.Value); Console.WriteLine(); linkedQueue.Enqueue(15); linkedQueue.Enqueue(20); Console.WriteLine(linkedQueue); linkedQueue.Enqueue(50); linkedQueue.Enqueue(100); Console.WriteLine(linkedQueue); anotherLinkedQueue.Dequeue(); Console.WriteLine(anotherLinkedQueue); linkedQueue.Dequeue(); Console.WriteLine(linkedQueue); Console.WriteLine(linkedQueue.Peek()); anotherLinkedQueue.Clear(); Console.WriteLine(anotherLinkedQueue.Count == 0 && anotherLinkedQueue.First == null && anotherLinkedQueue.Last == null); }
static void Main() { // TODO: Epxlain the tests Console.WriteLine("Testing custom queue class."); Console.WriteLine("Class features:"); Console.WriteLine(" - linked list implementation"); Console.WriteLine(" - methods Enqueue, Dequeue, Peek, Contains and property Count."); Console.WriteLine(); Console.WriteLine("Creating a LinkedQueue."); LinkedQueue <int> queue = new LinkedQueue <int>(); Console.WriteLine("DONE!" + Environment.NewLine); Console.WriteLine("Enqueuing numbers from 1 to 10"); for (int i = 1; i <= 10; i++) { queue.Enqueue(i); } Console.WriteLine("DONE!" + Environment.NewLine); Console.WriteLine("Printing queue using custom enumerator:"); Print(queue); Console.WriteLine("Peeking: " + queue.Peek()); Console.WriteLine(); Console.WriteLine("Dequeuing 7 elements"); for (int i = 0; i < 7; i++) { queue.Dequeue(); } Console.Write("Press any key to continue testing."); Console.ReadKey(); Console.WriteLine(); Console.WriteLine("Printing queue:"); Print(queue); Console.WriteLine("Enqueuing numbers from 1 to 10"); for (int i = 1; i <= 10; i++) { queue.Enqueue(i); } Console.WriteLine("Peeking: " + queue.Peek()); Console.WriteLine(); Console.WriteLine("Printing queue:"); Print(queue); Console.WriteLine("Cheking if queue contains the number 5: " + queue.Contains(5)); Console.WriteLine("Cheking if queue contains the number -15: " + queue.Contains(-15)); Console.WriteLine(); Console.WriteLine("Clearing the queue"); queue.Clear(); Console.WriteLine("Cleared"); Console.WriteLine(); Console.WriteLine("Printing queue:"); Print(queue); try { Console.WriteLine("Peeking: "); queue.Peek(); } catch (Exception e) { Console.WriteLine(e.Message); } }
public void CircularQueue_EnqueueDequeueManyChunks_ShouldWorkCorrectly() { // Arrange var queue = new LinkedQueue<int>(); int chunks = 100; // Act & Assert in a loop int value = 1; for (int i = 0; i < chunks; i++) { Assert.AreEqual(0, queue.Count); var chunkSize = i + 1; for (int counter = 0; counter < chunkSize; counter++) { Assert.AreEqual(value - 1, queue.Count); queue.Enqueue(value); Assert.AreEqual(value, queue.Count); value++; } for (int counter = 0; counter < chunkSize; counter++) { value--; Assert.AreEqual(value, queue.Count); queue.Dequeue(); Assert.AreEqual(value - 1, queue.Count); } Assert.AreEqual(0, queue.Count); } }
public void CountIsMaintainedWhenPersonIsEnqueuedAndDequeued() { LinkedQueue queue = new LinkedQueue(); Person alice = new Person { Name = "Alice" }; Person bob = new Person { Name = "Bob" }; Person charlie = new Person { Name = "Charlie" }; // Enqueue all and assert Count queue.Enqueue(alice); Assert.AreEqual(1, queue.Count()); queue.Enqueue(bob); Assert.AreEqual(2, queue.Count()); queue.Enqueue(charlie); Assert.AreEqual(3, queue.Count()); // Dequeue all and assert Count Person personFromQueue1 = queue.Dequeue(); Assert.AreEqual(2, queue.Count()); Person personFromQueue2 = queue.Dequeue(); Assert.AreEqual(1, queue.Count()); Person personFromQueue3 = queue.Dequeue(); Assert.AreEqual(0, queue.Count()); }
public void TestEmptyQueueToArray_ShouldReturnEmptyArray() { var linkedQueue = new LinkedQueue<int>(); var queueToArray = linkedQueue.ToArray(); Assert.AreEqual(0, queueToArray.Length); }
[TestMethod] // получение первого элемента public void TakeTest() { LinkedQueue<object> data = new LinkedQueue<object>(); data.Add(8); data.Add(6); data.Take(); }
public void ConvertingQueueToArray() { var queue = new LinkedQueue <int>(); int itemCount = 500000; for (int i = 0; i < itemCount; i++) { queue.Enqueue(i); } var array = queue.ToArray(); int trueCount = 0; for (int i = 0; i < itemCount; i++) { if (array[i] != i) { Assert.Fail(); } trueCount++; } Assert.IsTrue(queue.Count == itemCount && queue.Count == trueCount); }
public static void Main() { var q = new LinkedQueue<int>(); q.Enqueue(1); Console.WriteLine(q.Peek()); }
public void ClearAll() { _normQueue_int = new Queue <int>(); _normQueue_string = new Queue <string>(); _custQueue_int = new LinkedQueue <int>(); _custQueue_string = new LinkedQueue <string>(); }
static void Main(string[] args) { LinkedQueue <int> nums = new LinkedQueue <int>(); nums.Enqueue(1); nums.Enqueue(2); nums.Enqueue(3); nums.Enqueue(4); foreach (var item in nums) { Console.WriteLine(item); } Console.WriteLine(string.Join(" ", nums.ToArray())); Console.WriteLine(nums.Count); nums.Dequeue(); Console.WriteLine(nums.Count); Console.WriteLine(nums.Dequeue()); Console.WriteLine(nums.Dequeue()); Console.WriteLine(nums.Dequeue()); Console.WriteLine(nums.Count); }
private static void Main(string[] args) { ConsoleMio.Setup(); while ((maze = TestMazeFactory.GetNext()) != null) { ConsoleMio.PrintHeading("Task 14 Minimal Distances In The Labyrinth Of Doom"); ConsoleMio.WriteLine("Labyrinth Before: ", DarkCyan); PrintLabyrinth(maze); ConsoleMio.WriteLine(); unexploredPositions = new LinkedQueue <MatrixPosition>(); DoNextLabyrinth(); ConsoleMio.WriteLine("Labyrinth After: ", DarkGreen); PrintLabyrinth(maze); ConsoleMio.WriteLine(); ConsoleMio.WriteLine("Press a key to test the next labyrinth...", DarkRed); Console.ReadKey(true); Console.Clear(); } ConsoleMio.WriteLine( "Completed!!! Thank you very much for looking all the tasks!", DarkGreen); }
static void Main() { var lq = new LinkedQueue <int>(); lq.Enqueue(5); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); var p = lq.Peek(); lq.Enqueue(55); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); lq.Enqueue(55); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); lq.Enqueue(55); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); }
public void ToArrayEmpty() { LinkedQueue <int> testQueue = new LinkedQueue <int>(); int[] result = testQueue.ToArray(); CollectionAssert.AreEqual(result, new int[0]); }
/// <summary> /// Print the binary representation of all numbers from 1 up to n. /// This is accomplished by using a FIFO queue to perform a level /// order(i.e.BFS) traversal of a virtual binary tree that /// looks like this: /// 1 /// / \ /// 10 11 /// / \ / \ /// 100 101 110 111 etc. ///and then storing each "value" in a list as it is "visited". /// </summary> /// <param name="n">int</param> /// <returns>output</returns> static LinkedList <string> GenerateBinaryRepresentationList(int n) { LinkedQueue <StringBuilder> q = new LinkedQueue <StringBuilder>(); LinkedList <string> output = new LinkedList <string>(); if (n < 1) { return(output); } q.Push(new StringBuilder("1")); while (n-- > 0) { StringBuilder sb = q.Pop(); output.AddLast(sb.ToString()); StringBuilder sbc = new StringBuilder(sb.ToString()); sb.Append('0'); q.Push(sb); sbc.Append('1'); q.Push(sbc); } return(output); }
public void TestEmptyStackToArray_ShouldReturnEmptyArray() { var stack = new LinkedQueue<DateTime>(); var array = stack.ToArray(); var expected = new DateTime[0]; CollectionAssert.AreEqual(expected, array); }
public void CircularQueue_EnqueueDequeueManyChunks_ShouldWorkCorrectly() { // Arrange var queue = new LinkedQueue <int>(); int chunks = 100; // Act & Assert in a loop int value = 1; for (int i = 0; i < chunks; i++) { Assert.AreEqual(0, queue.Count); var chunkSize = i + 1; for (int counter = 0; counter < chunkSize; counter++) { Assert.AreEqual(value - 1, queue.Count); queue.Enqueue(value); Assert.AreEqual(value, queue.Count); value++; } for (int counter = 0; counter < chunkSize; counter++) { value--; Assert.AreEqual(value, queue.Count); queue.Dequeue(); Assert.AreEqual(value - 1, queue.Count); } Assert.AreEqual(0, queue.Count); } }
/* * 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) { ILinkedQueue<int> sample = new LinkedQueue<int>(); sample.Enqueue(1); sample.Enqueue(2); sample.Enqueue(3); int[] sampleAsArray = sample.ToArray(); Console.WriteLine("Queue as array:"); for (int index = 0; index < sampleAsArray.Length; index++) { Console.WriteLine(sampleAsArray[index]); } Console.WriteLine("Dequeue + Peek"); Console.WriteLine(sample.Dequeue() + " Dequeue"); Console.WriteLine(sample.Dequeue() + " Dequeue"); Console.WriteLine(sample.Peek() + " Peek"); Console.WriteLine(sample.Dequeue() + " Dequeue"); sample.Enqueue(4); Console.WriteLine("Does Contains 4? " + sample.Contains(4)); sample.Enqueue(5); sample.Enqueue(6); sample.Clear(); Console.WriteLine("Count after clear: " + sample.Count); // Console.WriteLine(sample.Dequeue()); // exception expected }
public void EnqueuingAfterClearingCollection() { var stack = new LinkedQueue <int>(); int itemCount = 500000; for (int i = 0; i < itemCount; i++) { stack.Enqueue(i); } stack.Clear(); for (int i = 0; i < itemCount; i++) { stack.Enqueue(i); } int trueCount = 0; int lastItem = int.MinValue; foreach (var item in stack) { if (lastItem > item) { Assert.Fail(); } lastItem = item; trueCount++; } Assert.IsTrue(stack.Count == itemCount && stack.Count == trueCount); }
public static void Main() { var queue = new LinkedQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); //Console.WriteLine(queue.Dequeue()); //Console.WriteLine(queue.Dequeue()); //Console.WriteLine(queue.Dequeue()); //Console.WriteLine(queue.Dequeue()); Console.WriteLine(string.Join(" ", queue.ToArray())); //var realQueue = new Queue<int>(); //realQueue.Enqueue(1); //realQueue.Enqueue(2); //realQueue.Enqueue(3); //realQueue.Enqueue(4); //Console.WriteLine(string.Join(" ", realQueue.ToArray())); }
public void DequeuingAllExceptOne() { var queue = new LinkedQueue <int>(); int itemCount = 500000; for (int i = 0; i < itemCount; i++) { queue.Enqueue(i); } int lastItem = int.MinValue; for (int i = 0; i < itemCount - 1; i++) { if (lastItem > queue.Dequeue()) { Assert.Fail(); } } int trueCount = 0; foreach (var item in queue) { trueCount++; } Assert.IsTrue(queue.Count == 1 && trueCount == 1); }
public void TestPushAndPopThousandElements() { LinkedQueue <string> elements = new LinkedQueue <string>(); // asserts Count == 0 Assert.AreEqual(0, elements.Count, MESSAGE_COUNTNOTMATCHING); for (int i = 0; i < 1000; i++) { elements.Enqueue("asdf" + i); // asserts correct count Assert.AreEqual(i + 1, elements.Count, MESSAGE_COUNTNOTMATCHING); } for (int i = 0, j = 999; i < 1000; i++, j--) { string dequeuedElement = elements.Dequeue(); // asserts the poped and the pushed elements are the same Assert.AreEqual("asdf" + i, dequeuedElement, MESSAGE_NOTEQUALNUMBERS); // asserts correct count Assert.AreEqual(j, elements.Count, MESSAGE_COUNTNOTMATCHING); } }
[TestMethod] // IEnumerable public void EnumerableTest() { LinkedQueue<object> data = new LinkedQueue<object>(); data.Add(8); data.Add(13); data.GetEnumerator(); }
public void TestEmptyQueueToArray() { var queue = new LinkedQueue<DateTime>(); DateTime[] array = queue.ToArray(); Assert.AreEqual(0, array.Length); }
public void EnqueueAndDequeueReturnsCorrectOrderOfPersonReferences() { LinkedQueue queue = new LinkedQueue(); Person alice = new Person { Name = "Alice" }; Person bob = new Person { Name = "Bob" }; Person charlie = new Person { Name = "Charlie" }; // Enqueue all queue.Enqueue(alice); queue.Enqueue(bob); queue.Enqueue(charlie); // Dequeue all Person personFromQueue1 = queue.Dequeue(); Person personFromQueue2 = queue.Dequeue(); Person personFromQueue3 = queue.Dequeue(); // Assert that order is the same Assert.AreSame(alice, personFromQueue1); Assert.AreSame(bob, personFromQueue2); Assert.AreSame(charlie, personFromQueue3); }
/// <summary> Create a FJTaskRunnerGroup with the indicated number /// of FJTaskRunner threads. Normally, the best size to use is /// the number of CPUs on the system. /// <p> /// The threads in a FJTaskRunnerGroup are created with their /// isDaemon status set, so do not normally need to be /// shut down manually upon program termination. /// </p> /// </summary> public FJTaskRunnerGroup(int groupSize) { entryQueue = new LinkedQueue(); threads = new FJTaskRunner[groupSize]; InitializeThreads(); initTime = Utils.CurrentTimeMillis; }
public void EnqueueAndDequeueMultipleTimesReturnsCorrectPersonReferences() { LinkedQueue queue = new LinkedQueue(); Person alice = new Person { Name = "Alice" }; Person bob = new Person { Name = "Bob" }; Person charlie = new Person { Name = "Charlie" }; // Alice queue.Enqueue(alice); Person personFromQueue1 = queue.Dequeue(); Assert.AreSame(alice, personFromQueue1); // Bob queue.Enqueue(bob); Person personFromQueue2 = queue.Dequeue(); Assert.AreSame(bob, personFromQueue2); // Charlie queue.Enqueue(charlie); Person personFromQueue3 = queue.Dequeue(); Assert.AreSame(charlie, personFromQueue3); }
// Level Order: like LILO public IEnumerable <BiTreeNode <T> > LevelOrder(BiTreeNode <T> root) { if (root == null) { yield break; } var queue = new LinkedQueue <BiTreeNode <T> >(); queue.In(root); while (!queue.IsEmpty()) { var node = queue.Out(); yield return(node); if (node.LeftChild != null) { queue.In(node.LeftChild); } if (node.RightChild != null) { queue.In(node.RightChild); } } }
public void Push_Pop_Two() { var ints = new LinkedQueue<int> (); Assert.AreEqual (0, ints.Count); int element1 = 1; ints.Enqueue (element1); Assert.AreEqual (1, ints.Count); int element2 = 2; ints.Enqueue (element2); Assert.AreEqual (2, ints.Count); { int poppedEl = ints.Dequeue (); Assert.AreEqual (poppedEl, element1); Assert.AreEqual (1, ints.Count); } { int poppedEl = ints.Dequeue (); Assert.AreEqual (poppedEl, element2); Assert.AreEqual (0, ints.Count); } }
public void Test_Enqueue_Dequeue() { LinkedQueue<int> roo = new LinkedQueue<int>(); Assert.AreEqual(0, roo.Count); roo.Enqueue(9); Assert.AreEqual(1, roo.Count); Assert.AreEqual(9, roo.Dequeue()); Assert.AreEqual(0, roo.Count); LinkedQueue<string> testEnqueue = new LinkedQueue<string>(); Assert.AreEqual(0, testEnqueue.Count); for (int i = 1; i <= 1000; i++) { testEnqueue.Enqueue("as" + i); Assert.AreEqual(i, testEnqueue.Count); } for (int i = 1; i <= 1000; i++) { Assert.AreEqual("as" + i, testEnqueue.Dequeue()); Assert.AreEqual(1000-i, testEnqueue.Count); } }
static void Main() { try { LinkedQueue<string> queue = new LinkedQueue<string>(); queue.Enqueue("Message One"); queue.Enqueue("Message Two"); queue.Enqueue("Message Three"); queue.Enqueue("Message Four"); Console.WriteLine(queue.Peek()); Console.WriteLine(queue.Contains("Message Three")); var array = queue.ToArray(); Console.WriteLine(string.Join(", ", array)); while (queue.Count > 0) { string message = queue.Dequeue(); Console.WriteLine(message); } queue.Dequeue(); } catch (IndexOutOfRangeException iex) { Console.WriteLine(iex.TargetSite + " -> " + iex.Message); } catch (NullReferenceException nex) { Console.WriteLine(nex.TargetSite + " -> " + nex.Message); } }
public void ConvertEmptyQueueToArray() { LinkedQueue<int> queue = new LinkedQueue<int>(); int[] expected = new int[0]; int[] actual = queue.ToArray(); CollectionAssert.AreEqual(expected, actual); }
static void Main() { LinkedQueue<int> collection = new LinkedQueue<int>(); collection.Enqueue(1); collection.Enqueue(2); collection.Enqueue(3); collection.Enqueue(4); collection.Enqueue(5); collection.Enqueue(6); collection.Enqueue(7); collection.Enqueue(8); collection.Enqueue(9); Console.WriteLine("Total elements: " + collection.Count); Console.WriteLine(collection.Dequeue()); Console.WriteLine(collection.Dequeue()); Console.WriteLine(collection.Dequeue()); Console.WriteLine(collection.Dequeue()); Console.WriteLine("Total elements: " + collection.Count); collection.Enqueue(10); collection.Enqueue(11); Console.WriteLine(collection.Dequeue()); Console.WriteLine("Total elements: " + collection.Count); var array = collection.ToArray(); Console.WriteLine(string.Join(", ", array)); }
private static void TestLinkedQueue() { ILinkedQueue<int> linkedQueue = new LinkedQueue<int>(); // Should return true var isEmpty = linkedQueue.IsEmpty(); linkedQueue.Enqueue(1); linkedQueue.Enqueue(2); linkedQueue.Enqueue(3); linkedQueue.Enqueue(4); // Should have 4 elements // Should remove first added element - (1) and return it var removedElement = linkedQueue.Dequeue(); // Should return first element - (2) var firstElement = linkedQueue.Peek(); // Should return 3 var count = linkedQueue.Count; // Should return false isEmpty = linkedQueue.IsEmpty(); }
public void EnqueueDequeueElement() { LinkedQueue<int> testQueue = new LinkedQueue<int>(); Assert.AreEqual(0, testQueue.Count); testQueue.Enqueue(1); Assert.AreEqual(1, testQueue.Count); }
public void Enqueue_and_Dequeue_element_should_encrease_and_decrease_Count_and_return_correct_element() { var arr = new LinkedQueue <String>(); var s = ""; Assert.AreEqual(0, arr.Count); arr.Enqueue("Pesho"); Assert.AreEqual(1, arr.Count); arr.Enqueue("Gosho"); Assert.AreEqual(2, arr.Count); s = arr.Dequeue(); Assert.AreEqual("Pesho", s); Assert.AreEqual(1, arr.Count); s = arr.Dequeue(); Assert.AreEqual("Gosho", s); Assert.AreEqual(0, arr.Count); }
public void EnqueuingItemsOneByOne() { var queue = new LinkedQueue <int>(); int itemCount = 500000; for (int i = 0; i < itemCount; i++) { queue.Enqueue(i); } int trueCount = 0; int lastItem = int.MinValue; foreach (var item in queue) { if (lastItem > item) { Assert.Fail(); } lastItem = item; trueCount++; } Assert.IsTrue(queue.Count == itemCount && queue.Count == trueCount); }
public static IQueue <UserPost> MergeQueue(IQueue <UserPost> queue1, IQueue <UserPost> queue2) { LinkedQueue <UserPost> newPosts = new LinkedQueue <UserPost>(); while (!(queue1.IsEmpty && queue2.IsEmpty)) { if (queue1.IsEmpty) { newPosts.Enqueue(queue2.Dequeue()); continue; } else if (queue2.IsEmpty) { newPosts.Enqueue(queue1.Dequeue()); continue; } else if (queue1.Front().ID == queue2.Front().ID) { newPosts.Enqueue(queue1.Dequeue()); queue2.Dequeue(); } else if (queue1.Front().DatePosted > queue2.Front().DatePosted) { newPosts.Enqueue(queue1.Dequeue()); } else if (queue2.Front().DatePosted > queue1.Front().DatePosted) { newPosts.Enqueue(queue2.Dequeue()); } else { newPosts.Enqueue(queue1.Dequeue()); newPosts.Enqueue(queue2.Dequeue()); } } return(newPosts); }
public void EnqueuingItemsAndCheckingIfIteratedInCorrectly() { var queue = new LinkedQueue <int>(); int itemCount = 500000; for (int i = 0; i < itemCount; i++) { queue.Enqueue(i); } int trueCount = 0; int itemNum = 0; foreach (var item in queue) { if (itemNum++ != item) { Assert.Fail(); } trueCount++; } Assert.IsTrue(queue.Count == itemCount && queue.Count == trueCount); }
private static void Main(string[] args) { ConsoleMio.Setup(); while ((maze = TestMazeFactory.GetNext()) != null) { ConsoleMio.PrintHeading("Task 14 Minimal Distances In The Labyrinth Of Doom"); ConsoleMio.WriteLine("Labyrinth Before: ", DarkCyan); PrintLabyrinth(maze); ConsoleMio.WriteLine(); unexploredPositions = new LinkedQueue<MatrixPosition>(); DoNextLabyrinth(); ConsoleMio.WriteLine("Labyrinth After: ", DarkGreen); PrintLabyrinth(maze); ConsoleMio.WriteLine(); ConsoleMio.WriteLine("Press a key to test the next labyrinth...", DarkRed); Console.ReadKey(true); Console.Clear(); } ConsoleMio.WriteLine( "Completed!!! Thank you very much for looking all the tasks!", DarkGreen); }
public void InitializingArrayQueueWithCollection() { var queue = new LinkedQueue <int>(); int itemCount = 500000; for (int i = 0; i < itemCount; i++) { queue.Enqueue(i); } var queue2 = new LinkedQueue <int>(queue); int trueCount = 0; int lastItem = int.MinValue; foreach (var item in queue2) { if (lastItem > item) { Assert.Fail(); } lastItem = item; trueCount++; } Assert.IsTrue(queue.Count == itemCount && queue2.Count == itemCount && queue2.Count == trueCount); }
public void dequeuing_the_only_item_in_the_queue_empties_the_queue() { var q = new LinkedQueue <Waiter>(); var win = new Waiter(); Queue.Enqueue(ref q, win); var wout = Queue.Dequeue(ref q); if (win != wout) { Assert.Fail("dequeue item is wrong"); } if (q.Head != null) { Assert.Fail("Head is " + q.Head); } if (q.Tail != null) { Assert.Fail("Tail is " + q.Tail); } if (win.Next != null) { Assert.Fail("win1.Next is " + win.Next); } }
[TestMethod] // Тест заполнения очереди public void AddTest() { LinkedQueue<object> data = new LinkedQueue<object>(); data.Add(8); data.Add(6); data.Add(10); }
public void dequeuing_one_item_from_a_queue_of_two_sets_the_head_and_tail_to_the_remaining_item() { var q = new LinkedQueue <Waiter>(); var win1 = new Waiter(); var win2 = new Waiter(); Queue.Enqueue(ref q, win1); Queue.Enqueue(ref q, win2); var wout = Queue.Dequeue(ref q); if (win1 != wout) { Assert.Fail("dequeue item is wrong"); } if (q.Head != win2) { Assert.Fail("Head is " + q.Head); } if (q.Tail != win2) { Assert.Fail("Tail is " + q.Tail); } if (win1.Next != null) { Assert.Fail("win1.Next is " + win1.Next); } }
[TestMethod] // ICloneable public void CloneTest() { LinkedQueue<object> data = new LinkedQueue<object>(); data.Add(8); data.Add(10); data.Clone(); }
public void EnqueueAndDequeueSeveralElements1ShouldWorkCorrectly() { //Arrange var queue = new LinkedQueue<int>(); //Assert Assert.AreEqual(0, queue.Count); //Act queue.Enqueue(5); //Assert Assert.AreEqual(1, queue.Count); //Act queue.Enqueue(6); //Assert Assert.AreEqual(2, queue.Count); //Act var element = queue.Dequeue(); //Assert Assert.AreEqual(5, element); Assert.AreEqual(1, queue.Count); //Act element = queue.Dequeue(); //Assert Assert.AreEqual(6, element); Assert.AreEqual(0, queue.Count); }
[TestMethod] //IDisposable public void DisposeTest() { LinkedQueue<object> data = new LinkedQueue<object>(); data.Add(10); data.Add(3); data.Dispose(); }
static void Main() { var test = new LinkedQueue<int>(); test.Enqueue(1); Console.WriteLine(string.Join(" ", test.ToArray())); test.Enqueue(2); Console.WriteLine(string.Join(" ", test.ToArray())); test.Enqueue(3); Console.WriteLine(string.Join(" ", test.ToArray())); test.Enqueue(4); Console.WriteLine(string.Join(" ", test.ToArray())); test.Enqueue(5); Console.WriteLine(string.Join(" ", test.ToArray())); test.Enqueue(6); Console.WriteLine(string.Join(" ", test.ToArray())); test.Enqueue(7); Console.WriteLine(string.Join(" ", test.ToArray())); Console.WriteLine("The queue count: {0}", test.Count); test.Dequeue(); test.Dequeue(); Console.WriteLine(string.Join(" ", test.ToArray())); Console.WriteLine("The queue count: {0}", test.Count); Console.WriteLine(test.Peek()); Console.WriteLine(string.Join(" ", test.ToArray())); Console.WriteLine("The queue count: {0}", test.Count); test.Clear(); Console.WriteLine(string.Join(" ", test.ToArray())); Console.WriteLine("The queue count: {0}", test.Count); //test.Dequeue(); //if uncommented this line should throw exception }
public void Constructor_IEnumerable(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements) { var enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, numberOfDuplicateElements); var queue = new LinkedQueue <T>(enumerable); Assert.Equal(enumerable, queue); }
public static void Main() { var queue = new LinkedQueue <int>(); for (int i = 1; i <= 5; i++) { queue.Enqueue(i); } Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine($"Count {queue.Count}"); Console.WriteLine("=============="); for (int i = 1; i <= 7; i++) { try { Console.WriteLine($"Removed {queue.Dequeue()}"); } catch (Exception e) { Console.WriteLine($"Error {e.Message}"); } Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine($"Count {queue.Count}"); Console.WriteLine("=============="); } }
public void To_Array_Empty() { var dates = new LinkedQueue<DateTime>(); var arrTest = new DateTime[0]; CollectionAssert.AreEqual(arrTest, dates.ToArray()); }
public void EnqueueAndDequeue(int capacity, int items) { var seed = 53134; var q = new LinkedQueue <T>(); Assert.Empty(q); // Enqueue some values and make sure the count is correct var source = (List <T>)CreateEnumerable(EnumerableType.List, null, items, 0, 0); foreach (var val in source) { q.Enqueue(val); } Assert.Equal(source, q); // Dequeue to make sure the values are removed in the right order and the count is updated for (var i = 0; i < items; i++) { var itemToRemove = source[0]; source.RemoveAt(0); Assert.Equal(itemToRemove, q.Dequeue()); Assert.Equal(items - i - 1, q.Count); } // Can't dequeue when empty Assert.Throws <InvalidOperationException>(() => q.Dequeue()); // But can still be used after a failure and after bouncing at empty var itemToAdd = CreateT(seed++); q.Enqueue(itemToAdd); Assert.Equal(itemToAdd, q.Dequeue()); }
public static void Main(string[] args) { var testQue = new LinkedQueue<int>(); testQue.Enqueue(1); testQue.Enqueue(2); testQue.Enqueue(3); testQue.Enqueue(4); Console.WriteLine(); var testArr = testQue.ToArray(); foreach (var i in testArr) { Console.WriteLine(i); } Console.WriteLine(); Console.WriteLine(testQue.Dequeue()); Console.WriteLine(); testQue.Enqueue(100); Console.WriteLine(testQue.Dequeue()); Console.WriteLine(); testArr = testQue.ToArray(); foreach (var i in testArr) { Console.WriteLine(i); } }
static void Main() { var lq = new LinkedQueue<int>(); lq.Enqueue(5); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); var p = lq.Peek(); lq.Enqueue(55); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); lq.Enqueue(55); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); lq.Enqueue(55); lq.Enqueue(11); lq.Enqueue(22); lq.Enqueue(33); lq.Enqueue(44); lq.Dequeue(); }
public void EmptyLinkedQueueToArray() { var linkedQueue = new LinkedQueue<DateTime>(); var testArr = new DateTime[0]; CollectionAssert.AreEqual(testArr, linkedQueue.ToArray()); }
private static void Main(string[] args) { var myQueue = new LinkedQueue<int>(); myQueue.Enqueue(1); myQueue.Enqueue(2); myQueue.Enqueue(3); foreach (var val in myQueue) { Console.WriteLine(val); } Console.WriteLine("------------------------"); var num = myQueue.Dequeue(); Console.WriteLine("Dequeued value: " + num); Console.WriteLine("------------------------"); foreach (var val in myQueue) { Console.WriteLine(val); } var arr = myQueue.ToArray(); Console.WriteLine("To Array:\n" + string.Join(",", arr)); myQueue.Clear(); Console.WriteLine("-------------Cleared-------------"); myQueue.Enqueue(5); myQueue.Enqueue(6); myQueue.Enqueue(7); myQueue.Enqueue(8); foreach (var val in myQueue) { Console.WriteLine(val); } }
public void ToArrayOnEmptyQueueShouldReturnEmptyArray() { LinkedQueue<int> stack = new LinkedQueue<int>(); var resultArray = stack.ToArray(); Assert.AreEqual(0, resultArray.Length); }
public static void Remove <T>(ref LinkedQueue <T> q, T item) where T : class, INext <T> { if (q.Head == item) { q.Head = item.Next; if (q.Head == null) { q.Tail = null; } } else { for (var val = q.Head; val != null; val = val.Next) { if (val.Next == item) { val.Next = item.Next; item.Next = null; if (q.Tail == item) { q.Tail = val; } break; } } } }
static void Main() { // TODO: Epxlain the tests Console.WriteLine("Testing custom queue class."); Console.WriteLine("Class features:"); Console.WriteLine(" - linked list implementation"); Console.WriteLine(" - methods Enqueue, Dequeue, Peek, Contains and property Count."); Console.WriteLine(); Console.WriteLine("Creating a LinkedQueue."); LinkedQueue<int> queue = new LinkedQueue<int>(); Console.WriteLine("DONE!" + Environment.NewLine); Console.WriteLine("Enqueuing numbers from 1 to 10"); for (int i = 1; i <= 10; i++) { queue.Enqueue(i); } Console.WriteLine("DONE!" + Environment.NewLine); Console.WriteLine("Printing queue using custom enumerator:"); Print(queue); Console.WriteLine("Peeking: " + queue.Peek()); Console.WriteLine(); Console.WriteLine("Dequeuing 7 elements"); for (int i = 0; i < 7; i++) { queue.Dequeue(); } Console.Write("Press any key to continue testing."); Console.ReadKey(); Console.WriteLine(); Console.WriteLine("Printing queue:"); Print(queue); Console.WriteLine("Enqueuing numbers from 1 to 10"); for (int i = 1; i <= 10; i++) { queue.Enqueue(i); } Console.WriteLine("Peeking: " + queue.Peek()); Console.WriteLine(); Console.WriteLine("Printing queue:"); Print(queue); Console.WriteLine("Cheking if queue contains the number 5: " + queue.Contains(5)); Console.WriteLine("Cheking if queue contains the number -15: " + queue.Contains(-15)); Console.WriteLine(); Console.WriteLine("Clearing the queue"); queue.Clear(); Console.WriteLine("Cleared"); Console.WriteLine(); Console.WriteLine("Printing queue:"); Print(queue); try { Console.WriteLine("Peeking: "); queue.Peek(); } catch (Exception e) { Console.WriteLine(e.Message); } }
public void Constructor_int(int count) { var queue = new LinkedQueue <T>(); Assert.Equal(new T[0], queue.ToArray()); queue.Clear(); Assert.Equal(new T[0], queue.ToArray()); }
public void Enqueue_AddSingleElement() { LinkedQueue<int> queue = new LinkedQueue<int>(); queue.Enqueue(1); Assert.IsTrue(queue.Count == 1); }