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