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);
}
private static void CustomQueue_CustomQueueEvent(CustomQueue <HardwareItem> sender, QueueEventArgs eventArgs)
{
Console.Clear();
Console.WriteLine(MainHeading());
Console.WriteLine();
Console.WriteLine(RealTimeUpdateHeading());
if (sender.QueueLength > 0)
{
Console.WriteLine(eventArgs.Message);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(ItemsInQueueHeading());
Console.WriteLine(FieldHeadings());
WriteValuesInQueueToScreen(sender);
if (sender.QueueLength == Batch_Size)
{
ProcessItems(sender);
}
}
else
{
Console.WriteLine("Status: All items have been processed.");
}
}
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);
}
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--;
}
}
private static void WriteValuesInQueueToScreen(CustomQueue <HardwareItem> hardwareItems)
{
foreach (var hardwareItem in hardwareItems)
{
Console.WriteLine($"{hardwareItem.Id,-6}{hardwareItem.Name,-15}{hardwareItem.Type,-20}{hardwareItem.Quantity,10}{hardwareItem.UnitValue,10}");
}
}
public void IsEmpty_NormalConditions_Test()
{
CustomQueue <int> testQueue = new CustomQueue <int>();
var empty = testQueue.IsEmpty();
Assert.That(empty, Is.EqualTo(true));
}
public void Setup()
{
queueInt = new CustomQueue<int> ();
queueInt.Enqueue (1);
queueInt.Enqueue (3);
queueInt.Enqueue (5);
}
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--;
}
}
}
public int TestPush(int[] elements)
{
CustomQueue <int> queue = new CustomQueue <int>(elements);
queue.Push(1);
return(queue.Count());
}
public void CustomQueue_Clear_Int_Test()
{
var customQueue = new CustomQueue <int>();
customQueue.Enqueue(1);
customQueue.Enqueue(2);
customQueue.Enqueue(3);
customQueue.Enqueue(4);
customQueue.Enqueue(5);
customQueue.Enqueue(6);
customQueue.Enqueue(7);
customQueue.Enqueue(1);
customQueue.Enqueue(2);
customQueue.Enqueue(3);
customQueue.Enqueue(4);
customQueue.Enqueue(5);
customQueue.Enqueue(6);
customQueue.Enqueue(7);
Assert.AreEqual(customQueue.Capacity, 16);
Assert.AreEqual(customQueue.Count, 14);
customQueue.Clear();
Assert.AreEqual(customQueue.Capacity, 8);
Assert.AreEqual(customQueue.Count, 0);
}
private static void WriteQueue <T>(CustomQueue <T> queue)
{
foreach (var q in queue)
{
System.Console.WriteLine(q.ToString());
}
}
public void Ctor_GivenEmptyArray_ReturnsEmptyQueue()
{
var queue = new CustomQueue <int>(new int[] {});
var result = new CustomQueue <int>();
Assert.AreEqual(result, queue);
}
public void Peek_GivenArray_ReturnsFirstElementOfGivenQueue()
{
var queue = new CustomQueue <int>(new[] { 1, 2, 3, 4, 5 });
var firstElement = queue.Peek();
Assert.AreEqual(1, firstElement);
}
static void Main(string[] args)
{
var queue = new CustomQueue<string>(new[]
{
"one", "two", "three", "four"
}
);
CustomQueue<string>.CustomIterator iterator = queue.Iterator();
while (iterator.MoveNext())
{
Console.WriteLine(iterator.Current);
}
iterator.Reset();
while (iterator.MoveNext())
{
Console.WriteLine(iterator.Current);
}
var cueueInt = new CustomQueue<int>(new[]
{
1, 2, 3, 4
});
CustomQueue<int>.CustomIterator iterator1 = cueueInt.Iterator();
while (iterator1.MoveNext())
{
Console.WriteLine(iterator1.Current);
}
iterator1.Reset();
Console.ReadLine();
}
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 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());
}
public void TestPeek()
{
var testArray = new int[] { 0, 3, 5, 7, 9 };
var queue = new CustomQueue <int>(testArray);
Assert.AreEqual(testArray[0], queue.Peek());
}
public void QueueAddElementCorrectly()
{
var queue = new CustomQueue <int>();
queue.Enqueue(1);
Assert.Equal(1, queue.Count);
}
static void Main(string[] args)
{
CustomQueue<object> queue = new CustomQueue<object>();
queue.Enqueue("My name is Nataly");
queue.Enqueue("Something else");
queue.Enqueue(312);
CustomQueue<object> queue2 = queue.Clone();
CustomQueue<object> queue3 = queue;
queue.Enqueue(new List<int>());
queue.Enqueue(new DateTime());
foreach (var variable in queue)
{
Console.WriteLine(variable);
}
Console.WriteLine('\n');
foreach (var variable in queue2)
{
Console.WriteLine(variable);
}
Console.WriteLine('\n');
foreach (var variable in queue3)
{
Console.WriteLine(variable);
}
Console.WriteLine('\n');
Console.ReadLine();
}
public void GivenEmptyQueue_WhenEnqueue_ThenTheQueueIsNotEmpty()
{
var queue = new CustomQueue <int>();
queue.Enqueue(1);
Assert.IsNotNull(queue);
}
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 TestBefore()
{
queue = new CustomQueue <string>();
queue.Enqueue("one");
queue.Enqueue("two");
queue.Enqueue("last");
}
public void TestCountAfterCreationWithArray()
{
var testArray = new int[] { 0, 3, 5, 7, 9 };
var queue = new CustomQueue <int>(testArray);
Assert.AreEqual(testArray.Length, queue.Count());
}
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);
}
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 QueueRemoveSecondElementTest(CustomQueue <int> input, CustomQueue <int> expected)
{
input.MoveNext();
input.MoveNext();
input.RemoveCurrent();
Assert.AreEqual(expected.QueueList, input.QueueList);
}
public void CustomQueue_Constructor_Int_Test()
{
var customQueue = new CustomQueue <int>();
Assert.AreEqual(customQueue.Capacity, 8);
Assert.AreEqual(customQueue.Count, 0);
}
public void Enqueue_Int_AddsToQueue()
{
CustomQueue<int> queue = new CustomQueue<int>();
queue.Enqueue(5);
Assert.AreEqual(5, queue.Peek());
}
public void GivenEmptyQueue_WhenEnqueue_ThenTheCountOfTheQueueIsEqualToOne()
{
var queue = new CustomQueue <int>();
queue.Enqueue(1);
Assert.AreEqual(1, queue.Count);
}
public void Peek_SecondTime_ReturnsFirstElementFromBegining()
{
CustomQueue<int> queue = new CustomQueue<int>( new int[]{5, 11, 6, 5, 9});
queue.Peek();
Assert.AreEqual(5, queue.Peek());
}
public void Constructor_IncorrectParams_ThrowsExeption()
{
string[] arr = new string[10];
CustomQueue <int> queue = new CustomQueue <int>();
Assert.Throws <ArgumentException>(() => queue.CopyTo(arr, 0));
}
public void TestDequeueAfterCreationWithArray()
{
var testArray = new int[] { 0, 3, 5, 7, 9 };
var queue = new CustomQueue <int>(testArray);
Assert.AreEqual(testArray[0], queue.Dequeue());
}
public void TestToArray_EmptyQueue()
{
CustomQueue <int> queue = new CustomQueue <int>();
int[] arr = queue.ToArray();
Assert.AreEqual(0, arr.Length);
}
public void CustomQueue_UsualDate_EnqueueTest()
{
CustomQueue<int> queue = new CustomQueue<int>(1);
queue.Enqueue(1);
queue.Enqueue(2);
Assert.AreEqual(2, queue.Count);
}
public void QueueRemoveElementCorrectly()
{
var queue = new CustomQueue <int>();
queue.Enqueue(1);
queue.Dequeue();
Assert.Equal(0, queue.Count);
}
public void TestClear_EmptyQueue()
{
CustomQueue <int> queue = new CustomQueue <int>();
queue.Clear();
Assert.AreEqual(0, queue.Count);
}
public int TestPeek(int[] elements)
{
CustomQueue <int> queue = new CustomQueue <int>(elements);
queue.Pop();
queue.Push(1);
return(queue.Peek());
}
public void Enqueue_NormalConditions_Test()
{
CustomQueue <string> testQueue = new CustomQueue <string>();
testQueue.Enqueue("Test");
testQueue.Enqueue("Test2");
Assert.That(testQueue.Peek(), Is.EqualTo("Test"));
}
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 QueueEnumerator(CustomQueue <T> queue)
{
this.queue = queue;
this.values = queue.values;
this.size = queue.count;
this.version = queue.version;
this.iteratorPointer = -1;
}
public void CheckEnqueue()
{
CustomQueue<int> queue = new CustomQueue<int>();
queue.EnQueue(2);
int length = queue.Length;
int element = queue.Peek();
Assert.AreEqual(length, 1);
Assert.AreEqual(2, element);
}
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 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);
}
public void Peek_FromThreeIntQueue_ReturnsFirstOne()
{
CustomQueue<int> queue = new CustomQueue<int>();
queue.Enqueue(5);
queue.Enqueue(6);
queue.Enqueue(11);
Assert.AreEqual(5, queue.Peek());
}
public void Peek_Test()
{
int[] array = new int[] { 0, 1, 2, 3, 4 };
CustomQueue<int> queue = new CustomQueue<int>(array);
int actual = queue.Peek();
int expected = 0;
Assert.AreEqual(expected, actual);
}
public void Iterator_GivenQueue_ListsAllElements()
{
var queue = new CustomQueue<int>(new[] { 1, 2, 3, 4, 5, 6 });
var queueElements = new List<int> {};
foreach (var element in queue)
{
queueElements.Add(element);
}
Assert.AreEqual(queueElements.Count, queue.ElementsCount);
}
public void CustomQueue_Peek_Test()
{
CustomQueue<int> queue = new CustomQueue<int>(1);
queue.Enqueue(1);
queue.Enqueue(2);
var item = queue.Peek();
Assert.AreEqual(1, item);
}
static void Main(string[] args)
{
CustomQueue<int> queue = new CustomQueue<int>();
for (int i = 0; i < 10; i++)
queue.Enqueue(i * i);
foreach (var item in queue)
{
System.Console.WriteLine(item);
}
System.Console.ReadLine();
}
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 CustomQueue_ContainsTrueTest()
{
CustomQueue<int> myQueue = new CustomQueue<int>();
for (int i = 0; i < 10; i++)
{
myQueue.Enqueue(i);
}
Assert.IsTrue(myQueue.Contains(3));
}
static void Main(string[] args)
{
CustomQueue<int> myQueue = new CustomQueue<int>();
myQueue.Enqueue(new int[]{2,5,12,53,24,1});
Console.WriteLine("First Call");
foreach (var i in myQueue)
{
Console.Write("{0}\t",i);
}
Console.ReadKey(true);
}
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 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 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);
}
public void EnqueueCollection()
{
CustomQueue<int> myQueue = new CustomQueue<int>();
List<int> expected = new List<int>() { 2, 12, 52, 82, 4, 2 };
myQueue.Enqueue(expected);
List<int> actual = new List<int>();
foreach (int i in myQueue)
{
actual.Add(i);
}
CollectionAssert.AreEqual(expected,actual);
}
public void CustomQueue_Foreach_Test()
{
CustomQueue<int> queue = new CustomQueue<int>(1);
queue.Enqueue(1);
queue.Enqueue(2);
int count = 0;
foreach (var item in queue)
{
count++;
}
Assert.AreEqual(2, count);
}
public void GrowArray_200Elements_Capacity320()
{
CustomQueue<int> queue = new CustomQueue<int>();
int expected = 320;
for (int i = 0; i < 200; i++)
{
queue.Enqueue(i);
}
int actual = queue.Capacity;
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
CustomQueue<int> queue = new CustomQueue<int>();
queue.Enqueue(12);
queue.Enqueue(1);
queue.Enqueue(1111);
foreach(var a in queue)
{
Console.WriteLine($"{a}");
}
Console.Read();
}
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());
}
}
