From 09e85e9945dc39705daba2af992283d0ceb59146 Mon Sep 17 00:00:00 2001 From: schneefux Date: Sat, 29 Sep 2018 21:30:09 +0200 Subject: test --- src/de/ostfalia/algo/ws18/s1/test/LageTestS1.java | 365 ++++++++++++++++++++++ 1 file changed, 365 insertions(+) create mode 100644 src/de/ostfalia/algo/ws18/s1/test/LageTestS1.java (limited to 'src/de/ostfalia/algo/ws18/s1/test/LageTestS1.java') diff --git a/src/de/ostfalia/algo/ws18/s1/test/LageTestS1.java b/src/de/ostfalia/algo/ws18/s1/test/LageTestS1.java new file mode 100644 index 0000000..63078cc --- /dev/null +++ b/src/de/ostfalia/algo/ws18/s1/test/LageTestS1.java @@ -0,0 +1,365 @@ +package de.ostfalia.algo.ws18.s1.test; + +import static org.junit.Assert.assertFalse; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; + +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.RuleChain; +import org.junit.rules.TestRule; +import org.junit.runner.RunWith; + +import de.ostfalia.algo.ws18.base.IManagement; +import de.ostfalia.algo.ws18.base.IMember; +import de.ostfalia.algo.ws18.base.KindOfSport; +import de.ostfalia.algo.ws18.base.Member; +import de.ostfalia.algo.ws18.s1.Management; +import de.ostfalia.junit.annotations.AfterMethod; +import de.ostfalia.junit.annotations.TestDescription; +import de.ostfalia.junit.base.IMessengerRules; +import de.ostfalia.junit.base.ITraceRules; +import de.ostfalia.junit.conditional.Natural; +import de.ostfalia.junit.conditional.PassTrace; +import de.ostfalia.junit.rules.MessengerRule; +import de.ostfalia.junit.rules.RuleControl; +import de.ostfalia.junit.rules.TraceRule; +import de.ostfalia.junit.runner.TopologicalSortRunner; + +@RunWith(TopologicalSortRunner.class) +public class LageTestS1 { + + public boolean evalOperations = true; + public RuleControl opt = RuleControl.NONE; + public IMessengerRules messenger = MessengerRule.newInstance(opt); + public ITraceRules trace = TraceRule.newInstance(opt); + + + @Rule + public TestRule chain = RuleChain + .outerRule(trace) + .around(messenger); + + private int fileLength = 10000; + /** + * Datei mit 10000 Datensaetze fuer die JUnit-Tests. + */ + public String fileName = "Materialien/Mitglieder10000.txt"; + + private FileReader fileReader; + private BufferedReader bufferedReader; + + @Before + public void setUp() throws Exception { + fileReader = new FileReader(new File(fileName)); + bufferedReader = new BufferedReader(fileReader); + } + + @After + public void after() throws Exception { + if (bufferedReader != null) bufferedReader.close(); + if (fileReader != null) fileReader.close(); + } + + /** + * + * @throws IOException + * wird ausgeloest, wenn ein E/A-Fehler auftritt, also das Lesen aus + * der Datensatzdatei fehlschlaegt. + */ + @Test + @TestDescription("Testen des Kontruktors(String).") + public void testKonstruktorString() throws IOException { + trace.add("Konstruktoraufruf Management(\"%s\")", fileName); + IManagement mgnt = new Management(fileName); + int count = mgnt.numberOfOperations(); + trace.add("Aufruf der Methode toArray()."); + IMember[] members = mgnt.toArray(); + + evaluate(members, mgnt.size(), fileLength); + evaluate(members, fileLength); + evaluate(count, 10000, 1000); + } + + /** + * + * @throws IOException + * wird ausgeloest, wenn ein E/A-Fehler auftritt, also das Lesen aus + * der Datensatzdatei fehlschlaegt. + */ + @Test + @AfterMethod ("testKonstruktorString") + @TestDescription("Testen der Insert-Methode.") + public void testEinfuegen() throws IOException { + trace.add("Konstruktoraufruf Management()"); + IManagement mgnt = new Management(); + trace.add("Aufruf der Methode toArray()."); + IMember[] members = mgnt.toArray(); + + evaluate(members, mgnt.size(), 0); + + trace.add("Einfuegen der Datensaetze in die Mitgliederverwaltung."); + String line; + int count = 0; + while ((line = bufferedReader.readLine()) != null) { + trace.addInfo(PassTrace.ifTrue("Einfuegen von Datensatz \"%s\".", + mgnt.insert(new Member(line)), line)); + count += mgnt.numberOfOperations(); + } + assertFalse("Datensatz/-saetze konnten nicht eingefügt werden.", + trace.hasOccurrences()); + trace.add("Aufruf der Methode toArray() nach dem Einfuegen."); + members = mgnt.toArray(); + + evaluate(members, mgnt.size(), fileLength); + evaluate(members, fileLength); + evaluate(count, 10000, 1000); + } + + /** + * + * @throws IOException + * wird ausgeloest, wenn ein E/A-Fehler auftritt, also das Lesen aus + * der Datensatzdatei fehlschlaegt. + */ + @Test + @AfterMethod("testKonstruktorString") + @TestDescription("Testen der search(long)-Methode.") + public void testSuchen() throws IOException { + trace.add("Konstruktoraufruf Management(%s)", fileName); + IManagement mgnt = new Management(fileName); + trace.add("Aufruf der Methode toArray()."); + IMember[] members = mgnt.toArray(); + + evaluate(members, mgnt.size(), fileLength); + + trace.add("Suchen nach Datensaetze in die Mitgliederverwaltung."); + String line; + int count = 0; + while ((line = bufferedReader.readLine()) != null) { + IMember exp = new Member(line); + IMember got = mgnt.search(exp.getKey()); + trace.addInfo(PassTrace.ifEquals("Suchen nach Schluessel \"%d\".", + exp, got, exp.getKey())); + count += mgnt.numberOfOperations(); + } + assertFalse("Fehlerhafte / fehlende Datensaetze in der Mitgliederverwaltung.", + trace.hasOccurrences()); + evaluate(count, 50005000, fileLength); + } + + /** + * + * @throws IOException + * wird ausgeloest, wenn ein E/A-Fehler auftritt, also das Lesen aus + * der Datensatzdatei fehlschlaegt. + */ + @Test + @AfterMethod("testKonstruktorString") + @TestDescription("Testen der size(KindOfSport)-Methode.") + public void testTraversieren() throws IOException { + final int[] exp = {985, 989, 1037, 973, 1000, 985, 1033, 996, 992, 1010}; + + trace.add("Konstruktoraufruf Management(%s)", fileName); + IManagement mgnt = new Management(fileName); + + String msg = "Falsche Anzahl der Mitglieder fuer die Sportarten %s erhalten."; + int index = 0, count = 0; + for (KindOfSport sport : KindOfSport.values()) { + trace.add("Aufruf von size(%s).", sport); + trace.addInfo(PassTrace.ifEquals(msg, exp[index++], mgnt.size(sport), sport)); + count += mgnt.numberOfOperations(); + } + assertFalse("Methode size(KindOfSport) liefert falsches Ergebnis.", + trace.hasOccurrences()); + evaluate(count, 10 * 10000, 10000); + } + + /** + * + * @throws IOException + * wird ausgeloest, wenn ein E/A-Fehler auftritt, also das Lesen aus + * der Datensatzdatei fehlschlaegt. + */ + @Test + @AfterMethod("testKonstruktorString") + @TestDescription("Testen der discipline(KindOfSport)-Methode.") + public void testTraversieren2() throws IOException { + final int[] exp = {985, 989, 1037, 973, 1000, 985, 1033, 996, 992, 1010}; + final long[] chk = {225236503928L, 173758233713L, 183013252630L, 161145468810L, + 152686351492L, 257673959686L, 90525160369L, 266557207632L, + 74094229376L, 58704317911L}; + + trace.add("Konstruktoraufruf Management(%s)", fileName); + IManagement mgnt = new Management(fileName); + + String msg = "Anzahl der Mitglieder fuer die Sportarten %s."; + int index = 0; + for (KindOfSport sport : KindOfSport.values()) { + trace.add("Aufruf von discipline(%s).", sport); + IMember[] got = mgnt.discipline(sport); + trace.addInfo(PassTrace.ifEquals(msg, exp[index], got.length, sport)); + trace.add("Alle Eintraege muessen der Sportart %s entprechen.", sport); + int idx = 0; + long chkSum = 0; + for (IMember member : got) { + trace.addInfo(PassTrace.ifEquals("[%d] Unerwartete Sportart %s.", + sport, member.getKindOfSport(), idx++, sport)); + chkSum ^= member.getKey(); + } + trace.add("Pruefsumme fuer die Sportart %s.", sport); + trace.addInfo(PassTrace.ifEquals("Unerwartete Pruefsumme.", chk[index], chkSum)); + index++; + } + assertFalse("Methode discipline(KindOfSport) liefert falsches Ergebnis.", + trace.hasOccurrences()); + } + + //----------------------------------------------------------------- + + /** + * Ueberpruefung der Anzahl Mitglieder in der Mitgliederverwaltung. + * @param members - Mitglieder in der Mitgliederverwaltung: IMember[]. + * @param size - erhaltene Anzahl der Mitglieder: int. + * @param exp - erwartete Anzahl der Mitglieder: int. + */ + private void evaluate(IMember[] members, int size, int exp) { + trace.add(PassTrace + .ifEquals("Anzahl der Datensaetze muss %d betragen.", exp, size, exp)); + trace.add(PassTrace + .ifEquals("toArray().length muss %d liefern.", exp, members.length, exp)); + assertFalse("Fehlerhafte Anzahl von Datensaetze in der Mitgliederverwaltung.", + trace.hasOccurrences()); + } + + /** + * Ueberpueft die Datensaetze in der Mitgliederverwaltung mit den Datensaetzen + * in der eingelesenen Datei. + * @param members - Mitglieder in der Mitgliederverwaltung: IMember[]. + * @param lines - Anzahl Zeilen (Datensaetze) in der eingelesenen Datei: int. + * @throws IOException + */ + private void evaluate(IMember[] members, int lines) throws IOException { + int index = lines; + String line; + FileReader fr = new FileReader(new File(fileName)); + BufferedReader br = new BufferedReader(fr); + while ((line = bufferedReader.readLine()) != null) { + IMember member = new Member(line); + trace.addInfo(PassTrace.ifEquals("Ungueltiger Datensatz [%d], Dateizeile %d", + member, members[--index], index, lines - index)); + } + fr.close(); + br.close(); + int errors = trace.getOccurrences(); + assertFalse(errors + " fehlerhafte Datensaetze in der Mitgliederverwaltung.", + trace.hasOccurrences()); + } + + /** + * Ueberpruefung der Anzahl der Operationen. + * @param count - erhaltene Anzahl der Operationen: int. + * @param exp - erwartete Anzahl der Operationen: int. + * @param range - gueltiger Bereich um den erwarteten Wert: int. + */ + private void evaluate(int count, int exp, int range) { + if (evalOperations) { + int min = exp - range; + int max = exp + range; + Natural got = Natural.format(count); + trace.add(PassTrace.ifTrue( + "Anzahl Operationen muss im Bereich %d..%d liegen. Erhalten %d.", + got.rangeOf(min, max), min, max, count) + ); + assertFalse("Fehlerhafte Anzahl Operationen.", trace.hasOccurrences()); + } else { + System.err.println("Evaluate Operations disabled!"); + } + } + +} -- cgit v1.3.1