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);
}
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);
}
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());
}
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 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);
}
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);
}
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);
}
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 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 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 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);
}
}
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);
}
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()
{
// 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 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);
}
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);
}
}
static void Main()
{
LinkedQueue<int> myQueue = new LinkedQueue<int>();
myQueue.Enqueue(5);
myQueue.Enqueue(6);
Console.WriteLine(myQueue.Dequeue());
Console.WriteLine(myQueue.Dequeue());
}
public void TestCountAfterEnqueue()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
Assert.AreEqual(3, queue.Count);
}
public void Setup()
{
LinkedQueue2 = new LinkedQueue <string>();
LinkedQueue2.Enqueue("Phil");
LinkedQueue2.Enqueue("Bob");
LinkedQueue2.Enqueue("Marry");
LinkedQueue2.Enqueue("Bobby");
}
public void EnqueueTest()
{
for (int i = 0; i < 4; i++)
{
queue.Enqueue(i);
}
Assert.AreEqual("{0, 1, 2, 3}", queue.ToString());
}
public void Enqueue_OnValidParam_ContainsEnqueuedItems(int[] expectedItems)
{
foreach (var item in expectedItems)
{
_queue.Enqueue(item);
}
Assert.Equal(expectedItems, _queue);
}
public void TestCountAfterEnqueue()
{
var queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
Assert.AreEqual(3, queue.Count);
}
public void Dequeue_ShouldDecrementCount()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(5);
queue.Enqueue(7);
queue.Dequeue();
Assert.AreEqual(1, queue.Count, "Dequeue isn't working correctly.");
}
static void Main(string[] args)
{
var linkedQueue = new LinkedQueue<int>();
linkedQueue.Dequeue();
linkedQueue.Enqueue(5);
linkedQueue.Enqueue(6);
linkedQueue.Enqueue(7);
Console.WriteLine(string.Join(" ",linkedQueue.ToArray()));
}
public void Peek_EnqueueTwoItems_ReturnsHeadItem()
{
var queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
Assert.AreEqual(1, queue.Peek());
}
public static void Main()
{
LinkedQueue<int> sue = new LinkedQueue<int>();
sue.Enqueue(5);
sue.Enqueue(1);
sue.Enqueue(7);
sue.Dequeue();
}
public void DequeueElementFromLinkedStackShouldReturnTheLastElement()
{
LinkedQueue<int> arrayStack = new LinkedQueue<int>();
arrayStack.Enqueue(1);
arrayStack.Enqueue(2);
arrayStack.Enqueue(3);
var lastElement = arrayStack.Dequeue();
Assert.AreEqual(3, lastElement);
}
public void To_Array()
{
var nums = new LinkedQueue<int>();
nums.Enqueue(3);
nums.Enqueue(5);
nums.Enqueue(-2);
nums.Enqueue(7);
int[] arrTest = { 3, 5, -2, 7 };
CollectionAssert.AreEqual(arrTest, nums.ToArray());
}
public void Enqueue_OnValidParam_ContainsEnqueuedItems(int[] expectedItems)
{
//Act
foreach (var item in expectedItems)
{
_queue.Enqueue(item);
}
//Assert
CollectionAssert.AreEquivalent(expectedItems, _queue);
}
public static void Main()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
queue.Enqueue(4);
queue.Enqueue(3);
Console.WriteLine(string.Join(" ", queue.ToArray()));
Console.WriteLine(queue.Dequeue());
}
public void DequeueTest_CheckTheExpectedCount()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
queue.Enqueue(45);
queue.Enqueue(32);
queue.Enqueue(1);
Assert.AreEqual(3, queue.Count, "Count is not the same as expected after the Enqueue");
}
public void LinkedQueue_Enqueue_AddsElementAtFront()
{
var queue = new LinkedQueue <string>();
queue.Enqueue("cat");
queue.Enqueue("dog");
queue.Enqueue("catdog");
Assert.AreEqual(3, queue.Size);
Assert.AreEqual("cat", queue.Front);
}
public void DequeueTest_CheckTheExpectedCount()
{
LinkedQueue<int> queue = new LinkedQueue<int>();
queue.Enqueue(45);
queue.Enqueue(32);
queue.Enqueue(1);
Assert.AreEqual(3, queue.Count, "Count is not the same as expected after the Enqueue");
}
public void TestCount_SingleElement_CountOne()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(50);
queue.Enqueue(60);
queue.Enqueue(70);
queue.Enqueue(int.MaxValue);
Assert.AreEqual(4, queue.Count, "Queue count should be 4.");
}
public void TestToArray_ShouldReturnCorrectResult()
{
var stack = new LinkedQueue<int>();
stack.Enqueue(3);
stack.Enqueue(5);
stack.Enqueue(-2);
stack.Enqueue(7);
var toArray = stack.ToArray();
var expected = new int[] { 3, 5, -2, 7 };
CollectionAssert.AreEqual(expected, toArray);
}
public void Peek_EnqueueTwoItemsAndDequeue_ReturnsHeadElement()
{
var queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Dequeue();
Assert.AreEqual(2, queue.Peek());
}
public static void Main()
{
LinkedQueue<int> numbers = new LinkedQueue<int>();
numbers.Enqueue(1);
numbers.Enqueue(2);
numbers.Enqueue(3);
numbers.Enqueue(4);
numbers.Enqueue(5);
Console.WriteLine(string.Join(" ", numbers.ToArray()));
}
public void TestLinkedQueue() {
var queue = new LinkedQueue<string>();
queue.Enqueue("Hello");
queue.Enqueue("World");
queue.Enqueue("how");
queue.Enqueue("are");
queue.Enqueue("you");
foreach (var item in queue) {
Console.WriteLine(item);
}
}
public static void Main(string[] args)
{
LinkedQueue <int> node = new LinkedQueue <int>();
node.Enqueue(3);
node.Enqueue(5);
node.Enqueue(7);
node.Enqueue(9);
Console.WriteLine(string.Join(" ", node.ToArray()));
}
public void ToArrayMethodShouldReturnArrayWithTheElementsOfLinkedQueue()
{
LinkedQueue<int> arrayStack = new LinkedQueue<int>();
arrayStack.Enqueue(3);
arrayStack.Enqueue(5);
arrayStack.Enqueue(-2);
arrayStack.Enqueue(7);
int[] array = arrayStack.ToArray();
Assert.AreEqual(7, array[0]);
}
public void LinkedQueueToArray()
{
var linkedQueue = new LinkedQueue<int>();
linkedQueue.Enqueue(1);
linkedQueue.Enqueue(2);
linkedQueue.Enqueue(3);
linkedQueue.Enqueue(4);
var testArr = new int[] {1, 2, 3, 4};
CollectionAssert.AreEqual(testArr, linkedQueue.ToArray());
}
public static void Main()
{
var linkedQueue = new LinkedQueue<int>();
linkedQueue.Enqueue(42);
linkedQueue.Enqueue(666);
linkedQueue.Enqueue(1337);
while (linkedQueue.Count > 0)
{
Console.WriteLine(linkedQueue.Dequeue());
}
}
public void ConvertToArray()
{
LinkedQueue<int> queue = new LinkedQueue<int>();
int[] expected = { 3, 5, -2, 7 };
queue.Enqueue(3);
queue.Enqueue(5);
queue.Enqueue(-2);
queue.Enqueue(7);
int[] actual = queue.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public static void Main()
{
LinkedQueue<int> numbers = new LinkedQueue<int>();
numbers.Enqueue(4);
numbers.Enqueue(5);
numbers.Enqueue(6);
int countOfElements = numbers.Count;
for (var i = 0; i < countOfElements; i++)
{
Console.WriteLine(numbers.Dequeue());
}
}
public void ToArray_ShouldWorkCorrectly()
{
var stack = new LinkedQueue<int>();
stack.Enqueue(3);
stack.Enqueue(5);
stack.Enqueue(-2);
stack.Enqueue(7);
var arr = stack.ToArray();
var str = string.Join(" ", arr);
Assert.AreEqual("3 5 -2 7", str);
}
static void Main(string[] args)
{
LinkedQueue <int> q = new LinkedQueue <int>();
q.Enqueue(1);
q.Enqueue(2);
Console.WriteLine(q.Dequeue());
Console.WriteLine(q.Dequeue());
// Console.WriteLine(q.Dequeue());
}
public void EnqueueElementsToLinkedQueue()
{
LinkedQueue<int> arrayStack = new LinkedQueue<int>();
Assert.AreEqual(0, arrayStack.Count);
arrayStack.Enqueue(1);
arrayStack.Enqueue(2);
arrayStack.Enqueue(3);
arrayStack.Enqueue(4);
Assert.AreEqual(4, arrayStack.Count);
}
public static void Main()
{
var testQeue = new LinkedQueue<int>();
testQeue.Enqueue(1);
testQeue.Enqueue(2);
testQeue.Enqueue(3);
while (testQeue.Count > 0)
{
Console.WriteLine(testQeue.Dequeue());
}
}
public void EnqueueSomeElements_ShouldReturn_TheSameCount()
{
var queue = new LinkedQueue <int>();
queue.Enqueue(5);
queue.Enqueue(5);
queue.Enqueue(5);
queue.Enqueue(5);
queue.Enqueue(5);
Assert.AreEqual(5, queue.Count);
}
public void Enqueue_AddFiveElements()
{
LinkedQueue<int> queue = new LinkedQueue<int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
queue.Enqueue(13);
queue.Enqueue(14);
Assert.IsTrue(queue.Count == 5);
}
public void ToArray_ShouldReturnArray()
{
var stack = new LinkedQueue <int>();
stack.Enqueue(3);
stack.Enqueue(5);
stack.Enqueue(-2);
stack.Enqueue(7);
var arr = stack.ToArray();
CollectionAssert.AreEqual(new int[] { 3, 5, -2, 7 }, arr);
}
public void ToArrayTest()
{
LinkedQueue <int> numbersStack = new LinkedQueue <int>();
numbersStack.Enqueue(3);
numbersStack.Enqueue(5);
numbersStack.Enqueue(-2);
numbersStack.Enqueue(7);
int[] array = new int[] { 3, 5, -2, 7 };
int[] resultArray = numbersStack.ToArray();
CollectionAssert.AreEqual(array, resultArray);
}
public void Clear_ShouldRemove_AllElements()
{
var queue = new LinkedQueue<int>();
int expectedLinkedQueueCount = 0;
queue.Enqueue(3);
queue.Enqueue(5);
queue.Enqueue(7);
queue.Clear();
Assert.AreEqual(expectedLinkedQueueCount, queue.Count, "Clear isn't working correctly.");
}
static void Main(string[] args)
{
LinkedQueue <int> linkedQ = new LinkedQueue <int>();
linkedQ.Enqueue(10);
linkedQ.Dequeue();
linkedQ.Enqueue(1);
foreach (var item in linkedQ)
{
Console.WriteLine(item);
}
Console.WriteLine(linkedQ.Count);
}
public void Peak_ShouldWorkCorrectly()
{
// Arrange
// Act
var queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(69);
queue.Dequeue();
// Assert
Assert.AreEqual(69, queue.Peak());
}
public void Enqueue_Dequeue_Elements()
{
var nums = new LinkedQueue<int>();
Assert.AreEqual(0, nums.Count);
nums.Enqueue(15);
Assert.AreEqual(1, nums.Count);
nums.Enqueue(12);
Assert.AreEqual(2, nums.Count);
Assert.AreEqual(15, nums.Dequeue());
Assert.AreEqual(1, nums.Count);
Assert.AreEqual(12, nums.Dequeue());
Assert.AreEqual(0, nums.Count);
}
public void ConvertToArray()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
int[] expected = { 3, 5, -2, 7 };
queue.Enqueue(3);
queue.Enqueue(5);
queue.Enqueue(-2);
queue.Enqueue(7);
int[] actual = queue.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void TestLinkedQueue()
{
var queue = new LinkedQueue <string>();
queue.Enqueue("Hello");
queue.Enqueue("World");
queue.Enqueue("how");
queue.Enqueue("are");
queue.Enqueue("you");
foreach (var item in queue)
{
Console.WriteLine(item);
}
}
public static void Main(string[] args)
{
var queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Dequeue();
Console.WriteLine(queue.Peek());
}
public static void Main(string[] args)
{
LinkedQueue <int> queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
int toRemove = queue.Dequeue();
Console.WriteLine("---" + toRemove + "---");
int[] arr = queue.ToArray();
Console.WriteLine(string.Join(" ", arr));
}
