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