public void CheckClearQueue(int[] array) { var queue = new GenericQueue <int>(array); queue.Clear(); Assert.That(queue.ToArray, Is.EqualTo(new int[] { })); }
public void CheckDequeue(int[] array) { var queue = new GenericQueue <int>(array); var element = queue.Dequeue(); Assert.That(element, Is.EqualTo(array[0])); Assert.That(queue.ToArray(), Is.EqualTo(array[1..]));
public void ClearTest(int[] arg) { GenericQueue <int> queue = new GenericQueue <int>(arg); queue.Clear(); Assert.AreEqual(true, queue.IsEmpty()); }
public int[] CheckAddElementToQueue(int[] array, int element) { var queue = new GenericQueue <int>(array); queue.Enqueue(element); return(queue.ToArray()); }
public void DequeueTest(int[] arg) { GenericQueue <int> queue = new GenericQueue <int>(arg); queue.Dequeue(); queue.Dequeue(); Assert.AreEqual(new int[] { 3, 4 }, queue.ToArray()); }
public void IsEmptyTest() { GenericQueue <int> queue = new GenericQueue <int>(); Assert.AreEqual(true, queue.IsEmpty()); queue.Enqueue(1); Assert.AreEqual(false, queue.IsEmpty()); }
public void PeekTest(int[] arg) { GenericQueue <int> queue = new GenericQueue <int>(arg); queue.Dequeue(); queue.Dequeue(); Assert.AreEqual(3, queue.Peek()); }
public void GenericQueue_Enqueue_Success() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(10); queue.Enqueue(5); int[] expected = { 10, 5 }; CollectionAssert.AreEqual(queue, expected); }
public void Constructor_Collection_Tests(int[] expected) { List <int> test = new List <int>() { 1, 2, 3, 4, 5 }; GenericQueue <int> testQueue = new GenericQueue <int>(test); CollectionAssert.AreEqual(testQueue.ToArray(), expected); }
public void Constructor_Capacity_Test(int capacity, int[] expected) { GenericQueue <int> test = new GenericQueue <int>(capacity); for (int i = 1; i <= 5; i++) { test.Enqueue(i); } CollectionAssert.AreEqual(test.ToArray(), expected); }
public void EnqueTest(int[] arg) { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); Assert.AreEqual(queue.ToArray(), arg); }
public void GenericQueue_Dequeue_Success() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(10); queue.Enqueue(5); int dequeuedItem = queue.Dequeue(); int expected = 10; Assert.AreEqual(expected, dequeuedItem); }
public void GenericQueue_Clear() { GenericQueue <int> queue = new GenericQueue <int>(); GenericQueue <int> empty = new GenericQueue <int>(); queue.Enqueue(10); queue.Enqueue(5); queue.Clear(); CollectionAssert.AreEqual(queue, empty); }
public void EnumeratorTest() { GenericQueue <int> queue = new GenericQueue <int>(Enumerable.Range(1, 1000).ToList()); int i = 1; foreach (int elem in queue) { Assert.AreEqual(i, elem); i++; } }
public void GenericQueueTest() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(10); queue.Enqueue(11); queue.Enqueue(12); Assert.AreEqual(10, queue.Dequeue()); Assert.AreEqual(11, queue.Dequeue()); Assert.AreEqual(12, queue.Dequeue()); }
public void GenericQueue_IEnumerable() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); int[] expected = { 1, 2, 3 }; Assert.AreEqual(expected, queue); }
public void GenericQueue_Enqueue_Success() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(6); int[] expected = { 1, 2, 3, 4, 5, 6 }; NUnit.Framework.CollectionAssert.AreEqual(queue, expected); }
public void Enqueue_And_Dequeue_Tests(int[] data1) { GenericQueue <int> test1 = new GenericQueue <int>(data1); test1.Dequeue(); test1.Dequeue(); GenericQueue <int> test2 = new GenericQueue <int>(10); for (int i = 3; i <= 10; i++) { test2.Enqueue(i); } CollectionAssert.AreEqual(test1, test2); }
public void GenericQueue_Peek() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(10); queue.Enqueue(5); int oldCount = queue.Count(); int result = queue.Peek(); int expected = 10; int newCount = queue.Count(); Assert.AreEqual(expected, result); Assert.AreEqual(oldCount, newCount); }
public static void INP_QUEUE(GenericQueue <int> a) { do { int x; Console.Write("Gia tri (nhap <=0 de ket thuc): "); int.TryParse(Console.ReadLine(), out x); if (x <= 0) { break; } a.Enqueue(x); Console.WriteLine(">> Da Enqueue {0} thanh cong", x); } while (true); }
public void GenericQueue_Clear_Success() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(6); queue.Clear(); int[] expected = { }; NUnit.Framework.Assert.AreEqual(expected, queue); }
public void GenericQueue_GetEnumeratorTest() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(10); queue.Enqueue(11); queue.Enqueue(12); int[] res = { 10, 11, 12 }; int index = 0; foreach (var num in queue) { Assert.AreEqual(res[index], num); index++; } }
static void Main(string[] args) { var queue = new GenericQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(6); queue.Enqueue(7); var t = queue.ToArray(); foreach (var i in queue) { Console.Write(i + " "); } }
public void GenericQueue_Peek_Success() { GenericQueue <int> queue = new GenericQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(6); int[] expected = { 1, 2, 3, 4, 5, 6 }; int peekedItem = queue.Peek(); int expected1 = 1; NUnit.Framework.Assert.AreEqual(expected1, peekedItem); NUnit.Framework.CollectionAssert.AreEqual(queue, expected); }
public void GenericQueue_Dequeue_Success() { GenericQueue <string> queue = new GenericQueue <string>(); queue.Enqueue("a"); queue.Enqueue("b"); queue.Enqueue("c"); queue.Enqueue("d"); queue.Enqueue("e"); queue.Enqueue("f"); string dequeuedItem = queue.Dequeue(); string expected = "a"; string[] expected1 = { "b", "c", "d", "e", "f" }; NUnit.Framework.Assert.AreEqual(expected, dequeuedItem); NUnit.Framework.CollectionAssert.AreEqual(queue, expected1); }
private static void Main() { var list = new List <Person> { new Person { Age = 20, Name = "Billy" }, new Person { Age = 19, Name = "Van" }, new Person { Age = 33, Name = "Kojima" }, new Person { Age = 4, Name = "Kazuma" }, new Person { Age = 12, Name = "Subaru" } }; var sortedListAsc = list.Sort((a, b) => a != null && a.CompareTo(b) > 0); foreach (var item in sortedListAsc) { Console.WriteLine(item.Age + " - " + item.Name); } Console.WriteLine(); Console.WriteLine("root of n degree: " + NewtonMethod.NewtonMethod.Pow(5, 10)); Console.WriteLine(Math.Pow(10, (double)1 / 5)); var q = new GenericQueue <string>(5); q.Enqueue("First item"); q.Enqueue("Second item"); q.Enqueue("Third item"); q.Enqueue("Fourth item"); Console.WriteLine("Deleted: " + q.Dequeue()); Console.WriteLine("Deleted: " + q.Dequeue()); }
static void Main(string[] args) { GenericQueue<int> example = new GenericQueue<int>(); Console.WriteLine(example.QueueEmpty()); example.Enqueue(15); example.Enqueue(25); example.Enqueue(35); example.Enqueue(45); Console.WriteLine(example.QueueEmpty()); Console.WriteLine(example.Dequeue()); Console.WriteLine(example.Dequeue()); example.Enqueue(1); example.Enqueue(1); Console.WriteLine(example.Dequeue()); Console.WriteLine(example.Dequeue()); Console.WriteLine(example.QueueEmpty()); Console.WriteLine(example.Dequeue()); Console.WriteLine(example.Dequeue()); Console.WriteLine(example.QueueEmpty()); Console.WriteLine(example.Dequeue()); }
public void CategorizeByModel() { //Method to categorize droids in the order of Astromech, Janitor, Utility, Protocol GenericStack<IDroid> protocolStack = new GenericStack<IDroid>(); GenericStack<IDroid> utilityStack = new GenericStack<IDroid>(); GenericStack<IDroid> janitorStack = new GenericStack<IDroid>(); GenericStack<IDroid> astromechStack = new GenericStack<IDroid>(); foreach (IDroid droid in droidCollection) { if (droid != null) { switch (droid.GetModel()) { //Go through the droidCollection and separate the droids into stacks by Model case "PROTOCOL": protocolStack.Add(droid); break; case "UTILITY": utilityStack.Add(droid); break; case "JANITOR": janitorStack.Add(droid); break; case "ASTROMECH": astromechStack.Add(droid); break; default: break; } } } //Create the queue and add the stacks to it in the desired order GenericQueue<IDroid> droidQueue = new GenericQueue<IDroid>(); droidQueue.AddStack(astromechStack); droidQueue.AddStack(janitorStack); droidQueue.AddStack(utilityStack); droidQueue.AddStack(protocolStack); droidCollection = new IDroid[droidQueue.Depth]; for (int i = 0; i < droidQueue.Depth; i++) { droidCollection[i] = (IDroid)droidQueue.Retrieve(i + 1).Droid; } }
public void GenericQueue_Empty_InvalidOperationException() { GenericQueue <int> queue = new GenericQueue <int>(); Assert.Throws <InvalidOperationException>(() => queue.Dequeue()); }
public void SortbyModel() { GenericStack<ProtocolDroid> ProtocolStack = new GenericStack<ProtocolDroid>(); GenericStack<UtilityDroid> UtilityStack = new GenericStack<UtilityDroid>(); GenericStack<JanitorDroid> JanitorStack = new GenericStack<JanitorDroid>(); GenericStack<AstromechDroid> AstromechStack = new GenericStack<AstromechDroid>(); GenericQueue<Droid> DroidsQueue = new GenericQueue<Droid>(); foreach (IDroid droid in droidCollection) { if (droid is ProtocolDroid) { ProtocolStack.Push((ProtocolDroid)droid); } else if (droid is UtilityDroid) { UtilityStack.Push((UtilityDroid)droid); } else if (droid is JanitorDroid) { JanitorStack.Push((JanitorDroid)droid); } else if (droid is AstromechDroid) { AstromechStack.Push((AstromechDroid)droid); } } while (ProtocolStack != null) { DroidsQueue.Enqueue(ProtocolStack.Pop()); } while (UtilityStack != null) { DroidsQueue.Enqueue(UtilityStack.Pop()); } while (JanitorStack != null) { DroidsQueue.Enqueue(JanitorStack.Pop()); } while (AstromechStack != null) { DroidsQueue.Enqueue(AstromechStack.Pop()); } while (DroidsQueue != null) { int i =0; droidCollection[i] = DroidsQueue.Dequeue(); i++; } }
public void SortModel() { GenericStack<UtilityDroid> UtilityDroidStack = new GenericStack<UtilityDroid>(); GenericStack<AstromechDroid> AstromechDroidStack = new GenericStack<AstromechDroid>(); GenericStack<ProtocolDroid> ProtocolDroidStack = new GenericStack<ProtocolDroid>(); GenericStack<JanitorDroid> JanitorDroidStack = new GenericStack<JanitorDroid>(); foreach(IDroid droids in droidCollection) { if(droids is UtilityDroid) { UtilityDroidStack.Add((UtilityDroid)droids); } else if (droids is AstromechDroid) { AstromechDroidStack.Add((AstromechDroid)droids); } else if (droids is ProtocolDroid) { ProtocolDroidStack.Add((ProtocolDroid)droids); } else if (droids is JanitorDroid) { JanitorDroidStack.Add((JanitorDroid)droids); } //*****************************************************************************************************************PROBLEM***********************************************************************************************************************************8************************************************* //Error 4 Argument 1: cannot convert from 'cis237assignment4.GenericStack<cis237assignment4.UtilityDroid>' to 'cis237assignment4.IDroid' c:\users\jason\cis237\cis237assignment4\cis237assignment4\droidcollection.cs 174 23 cis237assignment4 //Error 3 The best overloaded method match for 'cis237assignment4.GenericQueue<cis237assignment4.IDroid>.Add(cis237assignment4.IDroid)' has some invalid arguments c:\users\jason\cis237\cis237assignment4\cis237assignment4\droidcollection.cs 175 13 cis237assignment4 /************************************************************************************************************************************************************************************************************************************************/ } GenericQueue<IDroid> Queue = new GenericQueue<IDroid>(); //Queue.Add(AstromechDroidStack); //Queue.Add(UtilityDroidStack); }
//method to organize droids by type public bool Organize() { GenericStack<AstromechDroid> astromechStack = new GenericStack<AstromechDroid>(); GenericStack<JanitorDroid> janitorStack = new GenericStack<JanitorDroid>(); GenericStack<UtilityDroid> utilityStack = new GenericStack<UtilityDroid>(); GenericStack<ProtocolDroid> protocolStack = new GenericStack<ProtocolDroid>(); GenericQueue<IDroid> droidQueue = new GenericQueue<IDroid>(); //Add droids to appropriate stack types for (int i = 0; i < lengthOfCollection; i++) { try { astromechStack.Add((AstromechDroid)droidCollection[i]); } catch { try { janitorStack.Add((JanitorDroid)droidCollection[i]); } catch { try { utilityStack.Add((UtilityDroid)droidCollection[i]); } catch { try { protocolStack.Add((ProtocolDroid)droidCollection[i]); } catch { return false; } } } } } //Add droids in order to the queue while (astromechStack.Head != null) { droidQueue.Add((IDroid)astromechStack.Pop()); } while (janitorStack.Head != null) { droidQueue.Add((IDroid)janitorStack.Pop()); } while (utilityStack.Head != null) { droidQueue.Add((IDroid)utilityStack.Pop()); } while (protocolStack.Head != null) { droidQueue.Add((IDroid)protocolStack.Pop()); } //Dequeue droids back into the array for (int i = 0; droidQueue.Tail != null; i++) { droidCollection[i] = (IDroid)droidQueue.Dequeue(); } return true; }
public void SortByModel() { //Create generic stacks for each model type GenericStack<Droid> protocolStack = new GenericStack<Droid>(); GenericStack<Droid> utilityStack = new GenericStack<Droid>(); GenericStack<Droid> janitorStack = new GenericStack<Droid>(); GenericStack<Droid> astromechStack = new GenericStack<Droid>(); //Create new generic queue GenericQueue<Droid> droidQueue = new GenericQueue<Droid>(); foreach (Droid droid in droidArray) { if (droid != null) { switch (droid.GetModel()) { case "Protocol": protocolStack.Push(droid); break; case "Utility": utilityStack.Push(droid); break; case "Janitor": janitorStack.Push(droid); break; case "Astromech": astromechStack.Push(droid); break; default: break; } } } //Get droids from each stack and enqueue them while (astromechStack.IsNotEmpty()) { droidQueue.Enqueue(astromechStack.Pop()); } while (janitorStack.IsNotEmpty()) { droidQueue.Enqueue(janitorStack.Pop()); } while (utilityStack.IsNotEmpty()) { droidQueue.Enqueue(utilityStack.Pop()); } while (protocolStack.IsNotEmpty()) { droidQueue.Enqueue(protocolStack.Pop()); } int i = 0; while (droidQueue.IsNotEmpty()) { droidArray[i] = droidQueue.Dequeue(); i++; } }
public static void TestQueue() { GenericQueue <int> queue; queue = new GenericQueue <int>(); GenericStack <int> stack; stack = new GenericStack <int>(); var chon = 0; do { chon = MenuQueue(); switch (chon) { case 1: { INP_STACK(stack); Console.WriteLine("STACK : "); stack.print(); if (queue.Count == 0) { Console.WriteLine("Queue : NULL"); } Console.WriteLine("---------Convert Stack to Queue----------"); Console.Write("Queue : "); ConvertStackToQueue.ConverTo(stack, queue); if (stack.Size == 0) { Console.WriteLine("Stack : NULL"); } Console.WriteLine("\nPress any key to terminate..."); break; } case 2: { var queue1 = new GenericQueue <int>(); INP_QUEUE(queue1); Console.WriteLine("queue luc ban dau: " + queue1); Console.WriteLine("queue luc sau khi dao nguoc: " + queue1.Reverse()); break; } case 3: { Console.Write("+ Nhap Chuoi: "); var str = Console.ReadLine(); Console.WriteLine("[Cach lam: chay cai phan tu chuoi tu 0 den het chuoi, \nneu gap phan tu khac rong thi Enqueue. " + "\nsau do cho queue dequeue vao string builder roi in ra]"); Console.WriteLine("Chuoi sau khi loai bo khoang trang: "); Console.WriteLine("=> " + Chuoi.Trim(str)); break; } case 0: { break; } default: { Console.WriteLine("Unexpected Case"); break; } } Console.ReadKey(); Console.Clear(); } while (chon != 0); }
public void Setup() { _genericQueue = new GenericQueue <int>(10); }
public void TearDown() { _genericQueue = null; }
/// <summary> /// public method to Sort the droids into categories using a modified bucket sort /// </summary> public void SortIntoCategories() { //Create a generic stack for each type of droid, and pass in the droid type as the generic that will //come through on the stack class as T. GenericStack<ProtocolDroid> protocolStack = new GenericStack<ProtocolDroid>(); GenericStack<UtilityDroid> utilityStack = new GenericStack<UtilityDroid>(); GenericStack<JanitorDroid> janitorStack = new GenericStack<JanitorDroid>(); GenericStack<AstromechDroid> astromechStack = new GenericStack<AstromechDroid>(); //Create a queue to hold the droids as we pop them off the stack. GenericQueue<IDroid> categorizedDroidQueue = new GenericQueue<IDroid>(); //For each IDroid in the droidCollection foreach (IDroid droid in this.droidCollection) { //if the droid is not null we want to process it. If it is null we will go to the else if (droid != null) { //The testing of the droids must occur in this order. It must be done in the order of //most specific droid to least specific. //If we were to test a droid that IS of type Astromech against Utility BEFORE we test against //Astromech, it would pass and be put into the Utility stack and not the Astromech. That is why it //is important to test from most specific to least. //If the droid is an Astromech, push it on the astromech stack if (droid is AstromechDroid) { astromechStack.Push((AstromechDroid)droid); } //Else if it is a JanitorDroid, push it on the janitor stack else if (droid is JanitorDroid) { janitorStack.Push((JanitorDroid)droid); } //Do for Utility else if (droid is UtilityDroid) { utilityStack.Push((UtilityDroid)droid); } //Do for Protocol else if (droid is ProtocolDroid) { protocolStack.Push((ProtocolDroid)droid); } } //The droid we are trying to consider is null, break out of the loop. else { break; } } //Now that the droids are all in thier respective stacks we can do the work //of poping them off of the stacks and adding them to the queue. //It is required that they be popped off from each stack in this order so that they have //the correct order going into the queue. //This is a primer pop. It gets the first droid off the stack, which could be null if the stack is empty AstromechDroid currentAstromechDroid = astromechStack.Pop(); //While the droid that is popped off is not null while (currentAstromechDroid != null) { //Add the popped droid to the queue. categorizedDroidQueue.Enqueue(currentAstromechDroid); //Pop off the next droid for the loop test currentAstromechDroid = astromechStack.Pop(); } //See above method for Astromech. It is the same except for Janitor JanitorDroid currentJanitorDroid = janitorStack.Pop(); while (currentJanitorDroid != null) { categorizedDroidQueue.Enqueue(currentJanitorDroid); currentJanitorDroid = janitorStack.Pop(); } //See above method for Astromech. It is the same except for Utility UtilityDroid currentUtilityDroid = utilityStack.Pop(); while (currentUtilityDroid != null) { categorizedDroidQueue.Enqueue(currentUtilityDroid); currentUtilityDroid = utilityStack.Pop(); } //See above method for Astromech. It is the same except for Protocol ProtocolDroid currentProtocolDroid = protocolStack.Pop(); while (currentProtocolDroid != null) { categorizedDroidQueue.Enqueue(currentProtocolDroid); currentProtocolDroid = protocolStack.Pop(); } //Now that the droids have all been removed from the stacks and put into the queue //we need to dequeue them all and put them back into the original array. //Set a int counter to 0. int counter = 0; //This is a primer dequeue that will get the first droid out of the queue. IDroid iDroid = categorizedDroidQueue.Dequeue(); //While the dequeued droid is not null. while (iDroid != null) { //Add the droid to the droid collection using the int counter as the index this.droidCollection[counter] = iDroid; //increment the counter counter++; //dequeue the next droid off the queue so it can be used in the while condition iDroid = categorizedDroidQueue.Dequeue(); } //set the lenght of the collection to the value of the counter. It should be the same, but in case it changed. this.lengthOfCollection = counter; }