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