public void NawArrayOrdered_Add_FillWholeArray_ShouldFit() { // Arrange var expectedSize = 10; var expectedNaws = RandomNawGenerator.NewArray(expectedSize); var array = new NawArrayOrdered(expectedSize); // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; for (int i = 0; i < expectedSize; i++) { try { array.Add(expectedNaws[i]); Assert.AreEqual(i + 1, array.Count, "\n\nNawArrayOrdered.Add(): Het aantal elementen in de array komt niet overeen met het aantal toegevoegde items."); } catch (NawArrayOrderedOutOfBoundsException) { // Assert Assert.Fail("\n\nNawArrayOrdered.Add(): Er konden maar {0} NAW-objecten aan een array die met omvang {1} is geinitialiseerd worden toegevoegd", i, expectedSize); } } Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); }
public void NawArrayUnordered_BubbleSort_ShouldStartWithFirst() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "4"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "0"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "8"; testSet[9].Woonplaats = "9"; // Act array.BubbleSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd()); var swaps = Logger.Instance.RealSwaps.ToList(); // We moeten eerst alles naar achteren schuiven voordat er voor de 0 plaats is. Assert.AreEqual(7, swaps.Count); Assert.AreEqual("0", swaps[6].NewNaw1.Woonplaats); }
public void NawArrayUnordered_BubbleSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "0"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "8"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "4"; testSet[9].Woonplaats = "9"; // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.BubbleSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.IsTrue(array.CheckIsGesorteerd(), "De array is na de bubbleSort niet geordend. De items staan niet op de juiste volgorde."); Assert.AreEqual(7, Logger.Instance.RealSwaps.Count(), "Het aantal swaps dat gemaakt wordt is niet 7."); Assert.AreEqual(0, Logger.Instance.LogItems.Count(li => li.ArrayAction == ArrayAction.SWAP && li.Index1 == li.Index2), "Je zet verschillende items opnieuw met dezelfde waarde. Dit is niet nodig."); }
public void NawArrayUnordered_BubbleSort_ShouldStartWithFirst() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "4"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "0"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "8"; testSet[9].Woonplaats = "9"; // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.BubbleSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.IsTrue(array.CheckIsGesorteerd(), "De array is na de bubbleSort niet geordend. De items staan niet op de juiste volgorde."); var swaps = Logger.Instance.RealSwaps.ToList(); // We moeten eerst alles naar achteren schuiven voordat er voor de 0 plaats is. Assert.AreEqual(7, swaps.Count, "Het aantal swaps dat gemaakt wordt is niet 7."); Assert.AreEqual("0", swaps[6].NewNaw1.Woonplaats, "Het laatste item dat gezet wordt is niet degene op de eerste plaats. Hij bubbelt niet van voor naar achter."); }
public void NawArrayUnordered_BubbleSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "0"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "8"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "4"; testSet[9].Woonplaats = "9"; // Act array.BubbleSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd()); Assert.AreEqual(7, Logger.Instance.RealSwaps.Count()); Assert.AreEqual(0, Logger.Instance.LogItems.Count(li => li.ArrayAction == ArrayAction.SWAP && li.Index1 == li.Index2)); }
public static void WithUniqueOrderedArray(int capacity, int filled, Action <INawArrayOrdered> f) { var testSet = RandomNawGenerator.NewArrayOfUniqueEntries(filled); var arr = OrderedArrayOfSize(capacity, testSet); f(arr); }
public static NawDoublyLinkedList Random(int min, int max, out int count) { var result = new NawDoublyLinkedList(); var r = new Random(); count = r.Next(min, max); DoubleLink prev = null; for (var i = 0; i < count; ++i) { var newLink = new DoubleLink { Naw = RandomNawGenerator.New(10) }; if (prev == null) { result.First = newLink; } else { prev.Next = newLink; } newLink.Previous = prev; prev = newLink; result.Last = prev; } return(result); }
public void NawArrayOrdered_Add_Valid_ShouldAddInOrder() { // Arrange char[] woonplaatsen = "abcde".ToCharArray(); NAW[] testSet = RandomNawGenerator.NewArray(5); testSet[0].Woonplaats = woonplaatsen[3].ToString(); testSet[1].Woonplaats = woonplaatsen[2].ToString(); testSet[2].Woonplaats = woonplaatsen[4].ToString(); testSet[3].Woonplaats = woonplaatsen[0].ToString(); testSet[4].Woonplaats = woonplaatsen[1].ToString(); var array = new NawArrayOrdered(20); Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; for (int i = 0; i < testSet.Length; i++) { // Act array.Add(testSet[i]); // Assert Assert.IsTrue(array.CheckIsGesorteerd(), "NawArrayOrdered.Add(): Na het toevoegen van het element is de array niet langer goed gesorteerd."); } Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); }
public void NawArrayUnordered_InsertionSort_ShouldStartWithFirst() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "4"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "0"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "8"; testSet[9].Woonplaats = "9"; // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.InsertionSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de InsertionSort."); var setters = Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET && li.OldNaw1 != li.NewNaw1).ToList(); // We moeten eerst alles naar achteren schuiven voordat er voor de 0 plaats is. setters.Last().AssertAreEqual(0, "0", "Je moet het gesorteerde deel van voor naar achteren laten opbouwen. Dit gebeurt nu niet."); }
public void SelectionSortNawArray_SelectionSortGeinverteerd_SortedArrayDescending_ShouldHaveRightBounds() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "0"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "8"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "4"; testSet[9].Woonplaats = "9"; // Act array.SelectionSortInverted(); // Assert var realSwaps = Logger.Instance.RealSwaps.ToList(); var logItems = Logger.Instance.LogItems.ToList(); Assert.IsTrue(array.CheckIsGesorteerd()); Assert.AreEqual(1, realSwaps.Count); // We assert to not touch previous touched items. var indexOfSwap = logItems.IndexOf(realSwaps[0]); Assert.IsFalse(logItems.Skip(indexOfSwap + 1).Any(li => li.Index1 >= realSwaps[0].Index2)); }
public void NawArrayUnordered_SelectionSort_SortedArrayDescending_ShouldHaveRightBounds() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "0"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "8"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "4"; testSet[9].Woonplaats = "9"; // Act array.SelectionSort(); // Assert var realSwaps = Logger.Instance.RealSwaps.ToList(); var logItems = Logger.Instance.LogItems.ToList(); Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de SelectionSort"); Assert.AreEqual(1, realSwaps.Count, "Wanneer je de 4 hebt gevonden en ruilt met de 8 zou je daarna geen swaps meer hoeven doen."); // We assert to not touch previous touched items. var indexOfSwap = logItems.IndexOf(realSwaps[0]); Assert.IsFalse(logItems.Skip(indexOfSwap + 1).Any(li => li.Index1 <= realSwaps[0].Index1), "We verwachten dat je geen swaps doet voor index 4."); }
public void NawArrayUnordered_Add_Valid_ShouldAddAtTheEnd() { const int capacity = 10; const int filled = 5; WithUnordenedArray(capacity, filled, arr => { var prevState = new NAW[filled]; WithoutLogging(() => { for (int i = 0; i < filled; ++i) { prevState[i] = arr.Array[i]; } }); WithoutCallingArrayMethods(() => { arr.Add(RandomNawGenerator.New()); }); for (int i = 0; i < filled; ++i) { Assert.AreSame(prevState[i], arr.Array[i], "Jouw Add methode van NAWArrayUnordered doet ook iets met de elementen die al in de array zaten. Dit is niet de bedoeling"); } }); }
public void NawArrayUnordered_Add_Valid_ShouldAddAtTheEnd() { // Arrange NAW[] testSet; var expectedLength = 5; var array = InitializeTestsubject(10, expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.Add(newNaw); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.AreEqual(expectedLength + 1, array.Count, "Na het toevoegen is de ItemCount() niet opgehoogd."); // Niets is overschreven for (var i = 0; i < testSet.Length; i++) { Assert.AreEqual(testSet[i], array.Array[i], "\n\nNawArrayUnordered.Add(): Bij het toevoegen aan de array is item {0} onterecht overschreven.", i); } // Aan het einde toegevoegd Assert.AreEqual(newNaw, array.Array[expectedLength], "\n\nNawArrayUnordered.Add(): Bij het toevoegen aan de array is de nieuwe item niet aan het einde ingevoegd."); }
public void NawArrayOrdered_Add_Valid_ShouldMoveTheRightNumberOfItems() { // Arrange char[] woonplaatsen = "acegi".ToCharArray(); NAW[] testSet = RandomNawGenerator.NewArray(5); testSet[0].Woonplaats = woonplaatsen[3].ToString(); testSet[1].Woonplaats = woonplaatsen[2].ToString(); testSet[2].Woonplaats = woonplaatsen[4].ToString(); testSet[3].Woonplaats = woonplaatsen[0].ToString(); testSet[4].Woonplaats = woonplaatsen[1].ToString(); var array = new NawArrayOrdered(20); for (int i = 0; i < testSet.Length; i++) { // Act array.Add(testSet[i]); } Logger.Instance.ClearLog(); array.Add(new NAW() { Woonplaats = "f" }); var setters = Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET); Assert.AreEqual(3, setters.Count(), "NawArrayOrdered.Add(): Er worden teveel elementen verschoven om ruimte te maken voor het nieuwe element."); Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "f")); Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "g")); Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "i")); // Assert.IsTrue(array.CheckIsGesorteerd()); Wordt al bij andere testcase beoordeeld. }
public void NawArrayUnordered_InsertionSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "0"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "8"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "4"; testSet[9].Woonplaats = "9"; // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.InsertionSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de InsertionSort."); int lowerBound = 4, upperBound = 8; NAW toMoveUp = testSet[lowerBound]; var toMoveUpSetters = (from li in Logger.Instance.LogItems where li.NewNaw1 == toMoveUp && li.ArrayAction == ArrayAction.SET orderby li.Index1 select li).ToArray(); // This one bubbles up slowly. for (int i = lowerBound + 1; i <= upperBound; i++) { Assert.IsTrue(toMoveUpSetters[i - lowerBound - 1].Index1 == i, "Er zouden 4 items verplaatst moeten zijn om ruimte te maken in het geordende deel."); } NAW toBeInsertedDown = testSet[upperBound]; var toBeInsertedDownSetters = (from li in Logger.Instance.LogItems where li.NewNaw1 == toBeInsertedDown && li.ArrayAction == ArrayAction.SET orderby li.Index1 select li).ToArray(); // This one moves down in an insertion way. Assert.AreEqual(1, toBeInsertedDownSetters.Count(), "Meerdere items zijn geïnsert in de sortering, dit had er 1 moeten zijn."); Assert.AreEqual(lowerBound, toBeInsertedDownSetters.First().Index1, "Item met woonplaats 4 zou op de 4e index geïnsert moeten zijn."); // All setters must be in between the bounds. Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET).All(li => li.Index1 >= lowerBound && li.Index1 <= upperBound) , "Je hebt items gezet waarbij de oude index gelijk was aan de nieuwe, dit is niet nodig."); }
public void InsertionSortNawArray_InsertionSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); testSet[0].Woonplaats = "0"; testSet[1].Woonplaats = "1"; testSet[2].Woonplaats = "2"; testSet[3].Woonplaats = "3"; testSet[4].Woonplaats = "8"; testSet[5].Woonplaats = "5"; testSet[6].Woonplaats = "6"; testSet[7].Woonplaats = "7"; testSet[8].Woonplaats = "4"; testSet[9].Woonplaats = "9"; // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.InsertionSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.IsTrue(array.CheckIsGesorteerd()); int lowerBound = 4, upperBound = 8; NAW toMoveUp = testSet[lowerBound]; var toMoveUpSetters = (from li in Logger.Instance.LogItems where li.NewNaw1 == toMoveUp && li.ArrayAction == ArrayAction.SET orderby li.Index1 select li).ToArray(); // This one bubbles up slowly. for (int i = lowerBound + 1; i <= upperBound; i++) { Assert.IsTrue(toMoveUpSetters[i - lowerBound - 1].Index1 == i); } NAW toBeInsertedDown = testSet[upperBound]; var toBeInsertedDownSetters = (from li in Logger.Instance.LogItems where li.NewNaw1 == toBeInsertedDown && li.ArrayAction == ArrayAction.SET orderby li.Index1 select li).ToArray(); // This one moves down in an insertion way. Assert.AreEqual(1, toBeInsertedDownSetters.Count()); Assert.AreEqual(lowerBound, toBeInsertedDownSetters.First().Index1); // All setters must be in between the bounds. Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET).All(li => li.Index1 >= lowerBound && li.Index1 <= upperBound)); }
private static INawArrayUnordered InitializeTestsubject(int maxSize, int initialFilledSize, out NAW[] testSet, int?maxStringLenght = null) { testSet = RandomNawGenerator.NewArray(initialFilledSize); var array = new NawArrayUnordered(maxSize); Array.ForEach(testSet, naw => array.Add(naw)); // We have to clear the log because adding to the array will cause the logger to log as well. Logger.Instance.ClearLog(); return(array); }
public void NawArrayUnordered_SelectionSort_EmptyArray_ShouldNotSort() { // Arrange NAW[] testSet; var expectedLength = 0; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); // Act array.SelectionSort(); // Assert Assert.AreEqual(0, Logger.Instance.LogItems.Count(), "Je controleert items terwijl de array leeg is. Dit is niet nodig."); }
public void NawArrayUnordered_BubbleSort_EmptyArray_ShouldNotSort() { // Arrange NAW[] testSet; var expectedLength = 0; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); // Act array.BubbleSort(); // Assert Assert.AreEqual(0, Logger.Instance.LogItems.Count()); }
public static void WithOrderedArray(int capacity, int filled, Action <INawArrayOrdered> f) { var array = OrderedArrayOfSize(capacity); WithoutLogging(() => { var testSet = RandomNawGenerator.NewArray(filled); foreach (var i in testSet) { array.Add(i); } }); f(array); }
public void SelectionSortNawArray_SelectionSort_SortedArray_ShouldNotSwapAtAll() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderAscending: true); var newNaw = RandomNawGenerator.New(); // Act array.SelectionSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd()); Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength); Assert.AreEqual(0, Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SWAP).Count()); }
public void NawArrayUnordered_Add_OneTooMany_ShouldThrowException() { int[] capacities = { 1, 10, 100 }; foreach (var capacity in capacities) { WithoutCallingArrayMethods(() => { WithUnordenedArray(capacity, capacity, arr => { Assert.Throws <NawArrayUnorderedOutOfBoundsException>( () => arr.Add(RandomNawGenerator.New()), $"Jouw implementatie van de Add methode werpt geen uitzondering op wanneer we een element aan een volle array proberen toe te voegen"); }); }); } }
public void NawArrayUnordered_SelectionSort_SortedArray_ShouldNotSwapDifferentIndexes() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderAscending: true); var newNaw = RandomNawGenerator.New(); // Act array.SelectionSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de SelectionSort"); Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength, "Je bent niet door de hele lijst heen gelopen om te controleren of hij geordend is."); Assert.AreEqual(0, Logger.Instance.RealSwaps.Count(), "De lijst was vooraf al geordend. Toch heb je items geswitched. Dit klopt niet."); }
public void NawArrayOrdered_Add_OneTooMany_ShouldThrowException() { // Arrange NAW[] testSet; var array = InitializeTestsubject(3, 3, out testSet); var oneTooMany = RandomNawGenerator.New(); // Act Alg1.Practica.Utils.Globals.Alg1NawArrayMethodCalled = false; Assert.Throws <NawArrayOrderedOutOfBoundsException>(() => array.Add(oneTooMany), "NawArrayOrdered.Add(): Toevoegen van 11e element aan array met omvang van 10 geeft geen exceptie"); Assert.IsFalse(Alg1.Practica.Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); }
public void NawArrayUnordered_BubbleSort_SortedArrayDescending_ShouldSetAllItemsButOne() { // Arrange NAW[] testSet; var expectedLength = 100; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderDescending: true); var newNaw = RandomNawGenerator.New(); // Act array.BubbleSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd()); var swaps = Logger.Instance.RealSwaps; Assert.AreEqual(expectedLength.SumAllSmallerIncSelf() - expectedLength, swaps.Count()); }
public void NawArrayUnordered_BubbleSort_EmptyArray_ShouldNotSort() { // Arrange NAW[] testSet; var expectedLength = 0; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.BubbleSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.AreEqual(0, Logger.Instance.LogItems.Count(), "Je hebt de array benaderd terwijl deze leeg is. Dit had niet gehoeven omdat je dit al wist door je ItemCount."); }
public void NawArrayUnordered_Add_ShouldNotUseForloop() { const int filled = 5; WithUnordenedArray(10, filled, arr => { WithoutCallingArrayMethods(() => { var toAdd = RandomNawGenerator.New(); arr.Add(toAdd); Console.WriteLine(Logger.Instance.LogItems.FirstOrDefault()); Assert.IsTrue( Logger.Instance.LogItems.SequenceEqual(new LogItem[] { LogItem.SetItem(filled, null, toAdd) }), "Het enige dat Add moet doen is het nieuwe element opslaan in de onderliggende Alg1NawArray. Dat kan direct op de index _used (voordat je hem verhoogt). Je hoeft verder niets met Alg1NawArray te doen." ); }); }); }
public void NawArrayUnordered_SelectionSort_SortedArrayDescending_ShouldSwapAllItems() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderDescending: true); var newNaw = RandomNawGenerator.New(); // Act array.SelectionSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de SelectionSort"); Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength, "Je bent niet door de hele lijst heen gelopen om te controleren of hij geordend is."); // We expect half the length of the array to be swapped. // This occurs because when ordered descending when we swap we coincidentally set two items right. Assert.AreEqual(expectedLength / 2, Logger.Instance.RealSwaps.Count(), "De array was vooraf descending geordend. Met de helft van de lengte aan swaps zou je een geordende array moeten hebben."); }
public void NawArrayUnordered_InsertionSort_EmptyArray_ShouldNotSort() { // Arrange NAW[] testSet; var expectedLength = 0; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet); var newNaw = RandomNawGenerator.New(); // Act Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false; array.InsertionSort(); // Assert Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n"); Assert.AreEqual(0, Logger.Instance.LogItems.Count(), "Je controleert items terwijl de array leeg is. Dit is niet nodig."); }
public void SelectionSortNawArray_SelectionSort_SortedArrayDescending_ShouldSwapAllItems() { // Arrange NAW[] testSet; var expectedLength = 10; var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderDescending: true); var newNaw = RandomNawGenerator.New(); // Act array.SelectionSort(); // Assert Assert.IsTrue(array.CheckIsGesorteerd()); Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength); // We expect half the length of the array to be swapped. // This occurs because when ordered descending when we swap we coincidentally set two items right. Assert.AreEqual(expectedLength / 2, Logger.Instance.RealSwaps.Count()); }