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 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 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");
}
private static void week2_Testaanroepen()
{
// >>>> Testaanroepen week 2 - Ordered Array - AddBinary <<<<
// Aanmaken testarray:
NawArrayOrdered orderedArray = new NawArrayOrdered(20);
orderedArray.Add(new NAW("Persoon 1", "Adres 1", "Woonplaats 1"));
orderedArray.Add(new NAW("Persoon 2", "Adres 2", "Woonplaats 2"));
orderedArray.Add(new NAW("Persona non grata", "Adres 3", "Woonplaats 3"));
orderedArray.Add(new NAW("Persoon 4", "Adres 4", "Woonplaats 2"));
orderedArray.Add(new NAW("Persoon 1", "Adres 5", "Woonplaats 1"));
orderedArray.Add(new NAW("Persoon 2", "Adres 6", "Woonplaats 2"));
orderedArray.Add(new NAW("Persona non grata", "Adres 7", "Woonplaats 3"));
orderedArray.Add(new NAW("Persoon 2", "Adres 8", "Woonplaats 2"));
orderedArray.Add(new NAW("Persoon 9", "Adres 9", "Woonplaats 1"));
orderedArray.Add(new NAW("Persoon 10", "Adres 10", "Woonplaats 2"));
System.Console.WriteLine("\n\nDe geordende array na initialisatie maar voor bewerkingen is:");
orderedArray.Show();
// Testaanroep AddBinary:
/*
* NAW toeTeVoegenNaw = new NAW("Persoon 5", "Adres 4", "Woonplaats 2");
* orderedArray.AddBinary(toeTeVoegenNaw);
* System.Console.WriteLine("\n\nDe geordende array na aanroep AddBinary is:");
* orderedArray.Show();
*/
// >>>> Testaanroepen week 2 - Unordered Array - BubbleSortInverted <<<<
// Aanmaken testarray:
NawArrayUnordered unorderedArray = new NawArrayUnordered(20);
unorderedArray.Add(new NAW("Persoon 1", "Adres 1", "Woonplaats 1"));
unorderedArray.Add(new NAW("Persoon 2", "Adres 2", "Woonplaats 2"));
unorderedArray.Add(new NAW("Persona non grata", "Adres 3", "Woonplaats 3"));
unorderedArray.Add(new NAW("Persoon 4", "Adres 4", "Woonplaats 2"));
unorderedArray.Add(new NAW("Persoon 1", "Adres 5", "Woonplaats 1"));
unorderedArray.Add(new NAW("Persoon 2", "Adres 6", "Woonplaats 2"));
unorderedArray.Add(new NAW("Persona non grata", "Adres 7", "Woonplaats 3"));
unorderedArray.Add(new NAW("Persoon 2", "Adres 8", "Woonplaats 2"));
unorderedArray.Add(new NAW("Persoon 9", "Adres 9", "Woonplaats 1"));
unorderedArray.Add(new NAW("Persoon 10", "Adres 10", "Woonplaats 2"));
System.Console.WriteLine("\n\nDe ongeordende array na initialisatie maar voor bewerkingen is:");
unorderedArray.Show();
// Testaanroep BubbleSortInverted:
/*
* unorderedArray.BubbleSortInverted();
* System.Console.WriteLine("\n\nDe ongeordende array na aanroep BubbleSortInverted is:");
* unorderedArray.Show();
*/
}
public void NawArrayOrdered_Constructor_Size1000001_ThrowsException()
{
try
{
INawArrayOrdered array = new NawArrayOrdered(1000001);
Assert.Fail("\n\nNawArrayOrdered: De constructor accepteert ten onrechte een te grote initialSize.\nTIP: De maximale grootte waarop de NawArrayOrdered geinitialiseerd mag worden zou 1.000.000 moeten zijn.\n");
}
catch (NawArrayOrderedInvalidSizeException) { }
}
public INawArrayOrdered ToNawArrayOrdered()
{
NawArrayOrdered nawArray = new NawArrayOrdered(_used);
for (int i = 0; i < _used; i++)
{
nawArray.Add(_nawArray[i]);
}
return(nawArray);
}
public INawArrayOrdered ToNawArrayOrdered()
{
NawArrayOrdered array = new NawArrayOrdered(_size);
for (int i = 0; i < _used; i++)
{
array.Add(_nawArray[i]);
}
return(array);
}
public INawArrayOrdered ToNawArrayOrdered()
{
NawArrayOrdered ordered = new NawArrayOrdered(_size);
for (int i = 0; i < _used; i++)
{
ordered.Add(_nawArray[i]);
}
return(ordered);
}
private static NawArrayOrdered InitializeTestsubject(int maxSize, int initialFilledSize, out NAW[] testSet, int?maxStringLenght = null)
{
testSet = RandomNawGenerator.NewArray(initialFilledSize).OrderAscending();
var array = new NawArrayOrdered(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 static int FindLinear(this NawArrayOrdered array, NAW item, int maxIndex)
{
// doorzoek array
for (int i = 0; i < maxIndex; i++)
{
if (array.Array[i].CompareTo(item) == 0)
{
return(i);
}
}
return(-1);
}
private static void week1_OrderedArray_Testaanroepen()
{
// >>>> Testaanroepen week 1 - Ordered Array <<<<
// Testaanroep constructor:
NawArrayOrdered orderedArray = new NawArrayOrdered(20);
// Testaanroepen Add:
orderedArray.Add(new NAW("Persoon 1", "Adres 1", "Woonplaats 1"));
orderedArray.Add(new NAW("Persoon 2", "Adres 2", "Woonplaats 2"));
orderedArray.Add(new NAW("Persona non grata", "Adres 3", "Woonplaats 3"));
orderedArray.Add(new NAW("Persoon 4", "Adres 4", "Woonplaats 2"));
orderedArray.Add(new NAW("Persoon 1", "Adres 5", "Woonplaats 1"));
orderedArray.Add(new NAW("Persoon 2", "Adres 6", "Woonplaats 2"));
orderedArray.Add(new NAW("Persona non grata", "Adres 7", "Woonplaats 3"));
orderedArray.Add(new NAW("Persoon 2", "Adres 8", "Woonplaats 2"));
orderedArray.Add(new NAW("Persoon 9", "Adres 9", "Woonplaats 1"));
orderedArray.Add(new NAW("Persoon 10", "Adres 10", "Woonplaats 2"));
System.Console.WriteLine("\n\nDe geordende array na initialisatie maar voor bewerkingen is:");
orderedArray.Show();
// Activeer onderstaande testaanroepen wanneer je de bijhorende methode hebt geimplementeerd door de commentaarhaken weg te halen.
// Testaanroepen Find:
/*
* NAW gezochteNAW = new NAW("Persoon 4", "Adres 4", "Woonplaats 2");
* NAW nietbestaandeNAW = new NAW("Onbekende Persoon", "Adres 3", "Woonplaats 1");
*
* int gezochteNAWIndex = orderedArray.Find(gezochteNAW);
* System.Console.WriteLine("\nPersoon 4 gevonden op index {0}:", gezochteNAWIndex);
*
* int gezochteNAWIndex2 = orderedArray.Find(nietbestaandeNAW);
* System.Console.WriteLine("\nOnbekende Persoon gevonden op index {0}:", gezochteNAWIndex2);
*/
// Testaanroep Update:
/*
* orderedArray.Update(gezochteNAW, nietbestaandeNAW);
* System.Console.WriteLine("\n\nDe geordende array na update van persoon 4:");
* orderedArray.Show();
*/
}
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);
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.");
}
}
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);
Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;
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(), "\n\nNawArrayOrdered.Add(): Er worden te veel of te weinig elementen verschoven ({0}, i.p.v. {1}) om ruimte te maken voor het nieuwe element.", setters.Count(), 3);
Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "f"), "Naw met woonplaats f had verplaatst moeten worden, dit is niet gebeurd.");
Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "g"), "Naw met woonplaats g had verplaatst moeten worden, dit is niet gebeurd.");
Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "i"), "Naw met woonplaats i had verplaatst moeten worden, dit is niet gebeurd.");
// Assert.IsTrue(array.CheckIsGesorteerd()); Wordt al bij andere testcase beoordeeld.
Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");
}
