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);
}
/*
* 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
}
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();
}
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
}
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));
}
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 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()
{
LinkedQueue<int> myQueue = new LinkedQueue<int>();
myQueue.Enqueue(5);
myQueue.Enqueue(6);
Console.WriteLine(myQueue.Dequeue());
Console.WriteLine(myQueue.Dequeue());
}
public void TestCountAfterDequeue()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Dequeue();
queue.Dequeue();
Assert.AreEqual(1, queue.Count);
}
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 TestCount_SeveralElementsWithDequeue_CountTwo()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(50);
queue.Enqueue(60);
queue.Enqueue(70);
queue.Enqueue(int.MaxValue);
queue.Dequeue();
queue.Dequeue();
Assert.AreEqual(2, queue.Count, "Queue count should be 2.");
}
public void Dequeue_Enqueue()
{
LinkedQueue<int> testDequeue = new LinkedQueue<int>();
Assert.AreEqual(0, testDequeue.Count);
testDequeue.Enqueue(3);
Assert.AreEqual(1, testDequeue.Count);
testDequeue.Enqueue(3);
Assert.AreEqual(2, testDequeue.Count);
Assert.AreEqual(3, testDequeue.Dequeue());
Assert.AreEqual(1, testDequeue.Count);
Assert.AreEqual(3, testDequeue.Dequeue());
Assert.AreEqual(0, testDequeue.Count);
}
public void TestDequeue_MultipleElements_ShouldReturnProperElements()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(50);
queue.Enqueue(60);
queue.Enqueue(70);
var elementOne = queue.Dequeue();
var elementTwo = queue.Dequeue();
var elementThree = queue.Dequeue();
Assert.AreEqual(50, elementOne, "First element value should be 50.");
Assert.AreEqual(60, elementTwo, "Second element value should be 60.");
Assert.AreEqual(70, elementThree, "Third element value should be 70.");
}
static void Main()
{
LinkedQueue<int> linkedQueue = new LinkedQueue<int>();
linkedQueue.Enqueue(2);
linkedQueue.Enqueue(3);
linkedQueue.Enqueue(5);
linkedQueue.Enqueue(61);
linkedQueue.Enqueue(57);
linkedQueue.Dequeue();
linkedQueue.Dequeue();
linkedQueue.Dequeue();
}
public static void Main()
{
LinkedQueue<int> list = new LinkedQueue<int>();
list.Enqueue(5);
list.Enqueue(6);
list.Enqueue(7);
list.Enqueue(8);
Console.WriteLine(list.Dequeue());
Console.WriteLine(list.Dequeue());
Console.WriteLine("List count: {0}", list.Count);
}
public static void Main()
{
LinkedQueue<int> myTestLinkedQueue = new LinkedQueue<int>();
myTestLinkedQueue.Enqueue(11);
myTestLinkedQueue.Enqueue(22);
myTestLinkedQueue.Enqueue(33);
myTestLinkedQueue.Enqueue(44);
myTestLinkedQueue.Enqueue(55);
Console.WriteLine("Dequeue test: {0}", myTestLinkedQueue.Dequeue());
Console.WriteLine("Dequeue test: {0}", myTestLinkedQueue.Dequeue());
Console.WriteLine("Dequeue test: {0}", myTestLinkedQueue.Dequeue());
Console.WriteLine("Dequeue test: {0}", myTestLinkedQueue.Dequeue());
Console.WriteLine("Dequeue test: {0}", myTestLinkedQueue.Dequeue());
}
public void TestEnqueueDequeue_ShouldReturnCorrectResultsAndUpdateCounterProperly()
{
var stack = new LinkedQueue<string>();
Assert.IsTrue(stack.Count == 0);
stack.Enqueue("wow");
Assert.IsTrue(stack.Count == 1);
stack.Enqueue("yeah");
Assert.IsTrue(stack.Count == 2);
var element = stack.Dequeue();
Assert.AreEqual("wow", element);
Assert.IsTrue(stack.Count == 1);
element = stack.Dequeue();
Assert.AreEqual("yeah", element);
Assert.IsTrue(stack.Count == 0);
}
static void Main(string[] args)
{
LinkedQueue<int> numbers = new LinkedQueue<int>();
numbers.Enqueue(5);
numbers.Enqueue(6);
numbers.Enqueue(7);
numbers.Enqueue(8);
numbers.Enqueue(2);
Console.WriteLine("Count of numbers: {0}.",numbers.Count);
Console.WriteLine("Remove number: {0}.",numbers.Dequeue());
Console.WriteLine("Remove number: {0}.", numbers.Dequeue());
Console.WriteLine("Count of numbers: {0}.", numbers.Count);
}
static void Main(string[] args)
{
LinkedQueue<int> myQueue = new LinkedQueue<int>();
myQueue.Enqueue(1);
myQueue.Enqueue(2);
myQueue.Enqueue(3);
myQueue.Enqueue(4);
myQueue.Enqueue(5);
Console.WriteLine(myQueue.Peek());
Console.WriteLine(myQueue.Dequeue());
Console.WriteLine(myQueue.Dequeue());
Console.WriteLine(myQueue.Dequeue());
Console.WriteLine(myQueue.Dequeue());
Console.WriteLine(myQueue.Dequeue());
}
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);
}
}
public void DequeueTest_CheckTheExpectedCountAfterDequeue()
{
LinkedQueue<int> queue = new LinkedQueue<int>();
queue.Enqueue(45);
queue.Enqueue(32);
queue.Enqueue(1);
queue.Enqueue(143);
queue.Enqueue(57);
queue.Dequeue();
queue.Dequeue();
queue.Dequeue();
Assert.AreEqual(2, queue.Count, "Count is not the same as expected after the Dequeue");
}
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);
}
}
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 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 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);
}
}
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 DequeueEmptyStack()
{
LinkedQueue<string> testQueue = new LinkedQueue<string>();
Assert.Throws<NullReferenceException>(() =>
{
testQueue.Dequeue();
});
}
static void Main(string[] args)
{
//Implement the ADT queue as dynamic linked list.
//Use generics (LinkedQueue<T>)to allow storing different data types in the queue.
LinkedQueue<int> queue = new LinkedQueue<int>();
Console.WriteLine("Add 1,2,3 in the queue");
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
Console.WriteLine("Dequeue the values");
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
}
public void PopElementFromQueueShouldReturnTheProperElementAndDecreaseCountWithOne()
{
LinkedQueue<int> queue = new LinkedQueue<int>();
queue.Enqueue(5);
int poppedElement = queue.Dequeue();
Assert.AreEqual(5, poppedElement);
Assert.AreEqual(0, queue.Count);
}
public void TestDequeue_SingleElement_ShouldReturnProperElement()
{
var queue = new LinkedQueue<int>();
queue.Enqueue(50);
var element = queue.Dequeue();
Assert.AreEqual(50, element, "Element value should be 50.");
}
public GroupMessage NewMessageDequeue()
{
GroupMessage a;
SNewMessages.WaitOne();
a = NewMessages.Dequeue();
SNewMessages.Release();
return(a);
}
public void Dequeue_EmptyQueue_ThrowsException()
{
var queue = new LinkedQueue <int>();
Assert.Throws <InvalidOperationException>(() =>
{
queue.Dequeue();
});
}
public void DequeueEmptyStack()
{
LinkedQueue <string> testQueue = new LinkedQueue <string>();
Assert.Throws <NullReferenceException>(() =>
{
testQueue.Dequeue();
});
}
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 Dequeue_EmptyQueue_ThrowsException()
{
// Arrange
var queue = new LinkedQueue <int>();
// Act
queue.Dequeue();
// Assert: expect and exception
}
public void ShouldDequeueElementsCorrectly()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i);
}
Assert.AreEqual(queue.Count, 5);
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(queue.Dequeue(), i);
}
Assert.AreEqual(queue.Count, 0);
Assert.ThrowsException <InvalidOperationException>(() => queue.Dequeue());
}
public void TestQueueReturnsExpectedElement()
{
var linkedQueue = new LinkedQueue <int>();
linkedQueue.Enqueue(5);
var element = linkedQueue.Dequeue();
Assert.AreEqual(5, element, "The queue does not contain the element.");
}
public void DequeueElements_ShouldReturn_TheSameCollection()
{
var queue = new LinkedQueue <int>();
int[] numbers = { 1, 2, 3, 4, 5 };
numbers.ToList().ForEach(n => queue.Enqueue(n));
var result = queue.Select(e => queue.Dequeue()).ToList();
CollectionAssert.AreEqual(numbers, result);
}
public void Peek_EnqueueTwoItemsAndDequeue_ReturnsHeadElement()
{
var queue = new LinkedQueue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Dequeue();
Assert.AreEqual(2, queue.Peek());
}
public void LinkedQueue_Dequeue_ReturnsCorrectValue()
{
var queue = new LinkedQueue <string>();
queue.Enqueue("cat");
queue.Enqueue("dog");
queue.Enqueue("catdog");
var e1 = queue.Dequeue();
Assert.AreEqual("cat", e1);
var e2 = queue.Dequeue();
Assert.AreEqual("dog", e2);
var e3 = queue.Dequeue();
Assert.AreEqual("catdog", e3);
}
public void LinkedQueueTest2()
{
int[] input = { 3, 2, 4, 6, 9 };
LinkedQueue <int> queue = new LinkedQueue <int>();
queue.Enqueue(3);
Assert.AreEqual("3 ", IteratorToString(queue));
queue.Enqueue(4);
Assert.AreEqual("3 4 ", IteratorToString(queue));
Assert.AreEqual(3, queue.Dequeue());
Assert.AreEqual(4, queue.Dequeue());
Assert.AreEqual(0, queue.Count, "New queue has zero size");
foreach (int i in input)
{
queue.Enqueue(i);
}
Assert.AreEqual(input.Length, queue.Count);
Assert.AreEqual("3 2 4 6 9 ", IteratorToString(queue));
}
public void TestEnqueueDequeueElement()
{
var queue = new LinkedQueue <int>();
Assert.AreEqual(0, queue.Count);
queue.Enqueue(1);
Assert.AreEqual(1, queue.Count);
queue.Dequeue();
Assert.AreEqual(0, queue.Count);
}
public void EnqueueDequeueOneElement()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
Assert.IsTrue(queue.Count == 0);
queue.Enqueue(15);
Assert.IsTrue(queue.Count == 1);
int actual = queue.Dequeue();
Assert.AreEqual(15, actual);
Assert.IsTrue(queue.Count == 0);
}
public void TestAutoGrouth()
{
LinkedQueue <int> numbers = new LinkedQueue <int>();
Assert.AreEqual(0, numbers.Count);
numbers.Enqueue(10);
Assert.AreEqual(1, numbers.Count);
numbers.Enqueue(100);
Assert.AreEqual(2, numbers.Count);
int number = numbers.Dequeue();
Assert.AreEqual(10, number);
Assert.AreEqual(1, numbers.Count);
number = numbers.Dequeue();
Assert.AreEqual(100, number);
Assert.AreEqual(0, numbers.Count);
}
public void DequeueEnqueueElementCheck()
{
LinkedQueue <int> testQueue = new LinkedQueue <int>();
Assert.IsTrue(0 == testQueue.Count);
int firstNum = 25;
int secondNum = 55;
testQueue.Enqueue(firstNum);
Assert.IsTrue(1 == testQueue.Count);
testQueue.Enqueue(secondNum);
Assert.IsTrue(2 == testQueue.Count);
Assert.AreEqual(testQueue.Dequeue(), firstNum);
Assert.IsTrue(1 == testQueue.Count);
Assert.AreEqual(testQueue.Dequeue(), secondNum);
Assert.IsTrue(0 == testQueue.Count);
}
public void EnqueueAndDequeueReturnsSamePersonReference()
{
LinkedQueue queue = new LinkedQueue();
Person alice = new Person {
Name = "Alice"
};
queue.Enqueue(alice);
Person personFromQueue = queue.Dequeue();
Assert.AreSame(alice, personFromQueue);
}
public void testCountProperty_ShouldStartFromZeroAndGrowAndShrinks()
{
var queue = new LinkedQueue <int>();
Assert.AreEqual(0, queue.Count);
queue.Enqueue(5);
Assert.AreEqual(1, queue.Count);
queue.Dequeue();
Assert.AreEqual(0, queue.Count);
}
public void EnqueueDequeueMoreItems_ShouldWorkCorrectly()
{
var stack = new LinkedQueue <int>();
Assert.AreEqual(0, stack.Count);
stack.Enqueue(10);
Assert.AreEqual(1, stack.Count);
stack.Enqueue(15);
Assert.AreEqual(2, stack.Count);
var element = stack.Dequeue();
Assert.AreEqual(10, element);
Assert.AreEqual(1, stack.Count);
var anotherElement = stack.Dequeue();
Assert.AreEqual(15, anotherElement);
Assert.AreEqual(0, stack.Count);
}
public static void Main()
{
var linkedQueue = new LinkedQueue <int>();
for (int i = 1; i <= 10; i++)
{
linkedQueue.Enqueue(i);
}
int[] toArray = linkedQueue.ToArray();
Console.WriteLine(string.Join(", ", toArray));
Console.WriteLine(linkedQueue.Dequeue());
linkedQueue.Enqueue(50);
Console.WriteLine(linkedQueue.Dequeue());
toArray = linkedQueue.ToArray();
Console.WriteLine(string.Join(", ", toArray));
}
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 EnqueDequeue_ShouldWorkCorrectly()
{
var linkedQueue = new LinkedQueue <int>();
var element = 20;
Assert.AreEqual(0, linkedQueue.Count);
linkedQueue.Enqueue(element);
Assert.AreEqual(1, linkedQueue.Count);
var popElement = linkedQueue.Dequeue();
Assert.AreEqual(element, popElement);
Assert.AreEqual(0, linkedQueue.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_element_should_encrease_the_Count_and_Dequeue_should_decrease_the_Count_and_return_the_same_element()
{
var arr = new LinkedQueue <int>();
arr.Enqueue(5);
Assert.AreEqual(1, arr.Count);
int element = arr.Dequeue();
Assert.AreEqual(0, arr.Count);
Assert.AreEqual(5, element);
}
public void RemoveFirst_Node_Should_Become_Head_string()
{
// arrange
var start_node_value = "abc";
var node = "def";
IQueue <string> TestQueue = new LinkedQueue <string>(start_node_value);
TestQueue.Enqueue(node);
// act
// assert
Assert.AreEqual(start_node_value, TestQueue.Dequeue());
Assert.AreEqual(node, TestQueue.First());
}
public void RemoveFirst_Node_Should_Become_Head_bool()
{
// arrange
var start_node_value = true;
var node = false;
IQueue <bool> TestQueue = new LinkedQueue <bool>(start_node_value);
TestQueue.Enqueue(node);
// act
// assert
Assert.AreEqual(start_node_value, TestQueue.Dequeue());
Assert.AreEqual(node, TestQueue.First());
}
public void EnqueueAndDequeue_QueueWith1Element_ShouldRemoveElement()
{
//Arrange
var queue = new LinkedQueue <string>();
var elementToBeAdded = "An element";
//Act
queue.Enqueue(elementToBeAdded);
var removedElement = queue.Dequeue();
//Assert
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(elementToBeAdded, removedElement);
}
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 void EnqueueAndDequeueTest_ValueType()
{
IQueue <int> queue = new LinkedQueue <int>();
queue.Enqueue(1);
Assert.IsFalse(queue.IsEmpty());
Assert.AreEqual(1, queue.Peek());
Assert.AreEqual(1, queue.Size());
int value = queue.Dequeue();
Assert.IsTrue(queue.IsEmpty());
Assert.AreEqual(0, queue.Size());
Assert.AreEqual(1, value);
}
public void EnqueueAndDequeueTest_ReferenceType()
{
IQueue <String> queue = new LinkedQueue <String>();
queue.Enqueue("1");
Assert.IsFalse(queue.IsEmpty());
Assert.AreEqual("1", queue.Peek());
Assert.AreEqual(1, queue.Size());
String value = queue.Dequeue();
Assert.IsTrue(queue.IsEmpty());
Assert.AreEqual(0, queue.Size());
Assert.AreEqual("1", value);
}
public void EnqueueDeque_ShouldWorkCorrectly()
{
// Arrange
var queue = new LinkedQueue <string>();
var element = "some value";
// Act
queue.Enqueue(element);
var elementFromQueue = queue.Dequeue();
// Assert
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(element, elementFromQueue);
}
