From 09e85e9945dc39705daba2af992283d0ceb59146 Mon Sep 17 00:00:00 2001 From: schneefux Date: Sat, 29 Sep 2018 21:30:09 +0200 Subject: test --- .../algo/ws18/s1/test/ManagementTestS1.java | 397 +++++++++++++++++++++ 1 file changed, 397 insertions(+) create mode 100644 src/de/ostfalia/algo/ws18/s1/test/ManagementTestS1.java (limited to 'src/de/ostfalia/algo/ws18/s1/test/ManagementTestS1.java') diff --git a/src/de/ostfalia/algo/ws18/s1/test/ManagementTestS1.java b/src/de/ostfalia/algo/ws18/s1/test/ManagementTestS1.java new file mode 100644 index 0000000..e9eb46e --- /dev/null +++ b/src/de/ostfalia/algo/ws18/s1/test/ManagementTestS1.java @@ -0,0 +1,397 @@ +package de.ostfalia.algo.ws18.s1.test; + +import static org.junit.Assert.assertFalse; + +import java.util.Arrays; + +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.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 ManagementTestS1 { + + 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); + + /** + * Datensatz mit 10 Eintraegen als Testdaten fuer die JUnit-Tests. + */ + public String[] data10 = {"Hueber, Uta, 1922-10-15, F, HANDBALL", //[0] + "Muller, Ursula, 1964-01-28, F, HANDBALL", //[1] + "Fried, Heike, 1997-12-14, F, RUDERN", //[2] + "Meyer, Tanja, 1946-04-16, F, HANDBALL", //[3] + "Brauer, Mandy, 1933-07-21, F, FUSSBALL", //[4] + "Weiss, Ulrich, 1987-06-09, M, FUSSBALL", //[5] + "Bohm, Stephanie, 1931-10-22, F, HANDBALL", //[6] + "Huber, Annett, 1936-11-19, F, RUDERN", //[7] + "Hertz, Thomas, 1946-10-01, M, HANDBALL", //[8] + "Scholz, Anja, 1933-01-12, F, RUDERN"}; //[9] + + /** + * Schluesselwerte fuer den Datensatz data (10 Eintraege). + */ + public long[] keys10 = {82115101922L, 132128011964L, 60814121997L, 132016041946L, + 21321071933L, 232109061987L, 21922101931L, 80119111936L, + 82001101946L, 190112011933L}; + + int[] all = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; + int[] ofs = {-1, +1}; + + @Before + public void setUp() throws Exception { + } + + /** + * + */ + @Test (timeout = 1000) + @TestDescription("Testen des Kontruktors().") + public void testKonstruktorOhneParameter() { + trace.add("Konstruktoraufruf Management()"); + IManagement mgnt = new Management(); + evaluate(mgnt); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorOhneParameter") + @TestDescription("Testen des Kontruktors(String[]) mit einem Datensatz.") + public void testKonstruktorEinDatensatz() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(Arrays.copyOf(data10, 1)); + evaluate(mgnt, 0); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorEinDatensatz") + @TestDescription("Testen des Kontruktors(String[]) mit 10 Datensaetzen.") + public void testKonstruktorZehnDatensaetze() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + @TestDescription("Testen der insert(IMember)-Methode mit 10 Datensaetzen.") + public void testInsert() { + trace.add("Konstruktoraufruf Management()"); + IManagement mgnt = new Management(); + evaluate(mgnt); + + String msg = "Falscher Rueckgabe beim Einfuegen errhalten."; + for (int i = 0; i < data10.length; i++) { + trace.add("Datensatz \"%s\" hinzufuegen.", data10[i]); + IMember member = new Member(data10[i]); + trace.addInfo("Aufruf von insert(%s).", member); + trace.addInfo(PassTrace.ifTrue(msg, mgnt.insert(member))); + } + evaluate(mgnt, all); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + @TestDescription("Testen der search(long)-Methode mit 10 Datensaetzen.") + public void testSearchLong() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + + String msg = "Falscher Datensatz bei der Suche nach %d geliefert."; + for (int i = 0; i < data10.length; i++) { + trace.add("Aufruf von search(%d)", keys10[i]); + String exp = concat(i); + IMember got = mgnt.search(keys10[i]); + trace.addInfo(PassTrace.ifEquals(msg, exp, got, keys10[i])); + } + assertFalse("Methode search(long) liefert falschen Datensatz.", + trace.hasOccurrences()); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + @TestDescription("Methode search(long) muss bei nicht vorhandenen Schluesseln null liefern.") + public void testSearchNotExist() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + + String msg = "Nicht vorhandener Schluessel %d geliefert ungueltigen Datensatz."; + for (int i = 0; i < data10.length; i++) { + for (int j = 0; j < ofs.length; j++) { + long key = keys10[i] + ofs[j]; + trace.add("Aufruf von search(%d)", key); + IMember got = mgnt.search(key); + trace.addInfo(PassTrace.ifEquals(msg, null, got, key)); + } + } + assertFalse("Methode search(long) liefert falschen Datensatz.", + trace.hasOccurrences()); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + @TestDescription("Testen der search(String, String)-Methode mit 10 Datensaetzen.") + public void testSearchName() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + + String msg = "Falscher Datensatz bei der Suche nach \"%s, %s\" geliefert."; + for (int i = 0; i < data10.length; i++) { + String[] parts = data10[i].split(","); + trace.add("Aufruf von search(\"%s, %s\")", parts[0], parts[1]); + String exp = concat(i); + IMember got = mgnt.search(parts[0].trim(), parts[1].trim()); + trace.addInfo(PassTrace.ifEquals(msg, exp, got, parts[0], parts[1])); + } + assertFalse("Methode search(String, String) liefert falschen Datensatz.", + trace.hasOccurrences()); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + @TestDescription("Methode search(String, String) nuss bei unbekannen Namen null liefern.") + public void testSearchUnknown() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + + String msg = "Ungueltiger Datensatz bei der Suche nach \"%s, %s\" geliefert."; + for (int i = 0; i < data10.length; i++) { + String[] parts = data10[i].split(","); + String unknown = parts[0] + "s"; + trace.add("Aufruf von search(\"%s, %s\")", unknown, parts[1]); + IMember got = mgnt.search(unknown.trim(), parts[1].trim()); + trace.addInfo(PassTrace.ifEquals(msg, null, got, unknown, parts[1])); + } + assertFalse("Methode search(String, String) liefert falschen Datensatz.", + trace.hasOccurrences()); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + @TestDescription("Testen der size(KindOfSport)-Methode mit 10 Datensaetzen.") + public void testSizeKindOfSport() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + + String msg = "Falsche Anzahl der Mitglieder fuer die Sportarten %s erhalten."; + + KindOfSport sport = KindOfSport.HANDBALL; + trace.add("Aufruf von size(%s).", sport); + trace.addInfo(PassTrace.ifEquals(msg, 5, mgnt.size(sport), sport)); + + sport = KindOfSport.RUDERN; + trace.add("Aufruf von size(%s).", sport); + trace.addInfo(PassTrace.ifEquals(msg, 3, mgnt.size(sport), sport)); + + sport = KindOfSport.FUSSBALL; + trace.add("Aufruf von size(%s).", sport); + trace.addInfo(PassTrace.ifEquals(msg, 2, mgnt.size(sport), sport)); + + sport = KindOfSport.REITEN; + trace.add("Aufruf von size(%s).", sport); + trace.addInfo(PassTrace.ifEquals(msg, 0, mgnt.size(sport), sport)); + + assertFalse("Methode size(KindOfSport) liefert falsches Ergebnis.", + trace.hasOccurrences()); + } + + /** + * + */ + @Test (timeout = 1000) + @AfterMethod("testKonstruktorZehnDatensaetze") + public void testDiscipline() { + trace.add("Konstruktoraufruf Management(String[])"); + IManagement mgnt = new Management(data10); + evaluate(mgnt, all); + + KindOfSport sport = KindOfSport.HANDBALL; + trace.add("Aufruf von discipline(%s).", sport); + evaluate(mgnt.discipline(sport), 8, 6, 3, 1, 0); + + sport = KindOfSport.RUDERN; + trace.add("Aufruf von discipline(%s).", sport); + evaluate(mgnt.discipline(sport), 9, 7, 2); + + sport = KindOfSport.FUSSBALL; + trace.add("Aufruf von discipline(%s).", sport); + evaluate(mgnt.discipline(sport), 5, 4); + + sport = KindOfSport.REITEN; + trace.add("Aufruf von discipline(%s).", sport); + evaluate(mgnt.discipline(sport)); + + assertFalse("Methode discipline(KindOfSport) liefert falsches Ergebnis.", + trace.hasOccurrences()); + } + + //----------------------------------------------------------------- + + /** + * Ueberpruefung der durch die Methode toArray() der Mitgilderverwaltung + * zurueckgelieferten Datensaetze. + * @param mgnt - Mitgliederverwaltung: IManagement. + * @param elements - Indizes der erwarteten Testdatensaetze: int... + */ + private void evaluate(IManagement mgnt, int... elements) { + evaluate(mgnt.toArray(), elements); + } + + /** + * Ueberpruefung der uebergebenen Datensaetze anhand der Indizes der + * erwarteten Testdatensaetze. + * @param members - Array mit Datensaetze: IMember[]. + * @param elements - Indizes der erwarteten Testdatensaetze: int... + */ + private void evaluate(IMember[] members, int... elements) { + trace.addInfo(PassTrace.ifEquals("Anzahl der Mitglieder nicht korrekt.", + elements.length, members.length)); + int length = Integer.min(elements.length, members.length); + for (int i = 0; i < length; i++) { + int index = elements[i]; + String exp = concat(index); + trace.addInfo(PassTrace.ifEquals("Fehler im Datensatz %d.", + exp, members[i], i + 1)); + } + assertFalse("Fehlerhafte Datensaetze in der Mitgliederverwaltung.", + trace.hasOccurrences()); + } + + /** + * Zusammenfuegen eines Schluesselwerts mit dem zuhegoerigen Datensatz + * entsprechend ihrem Index in den Testdatensaetzen. + * @param element - Index im Datensatz: int. + * @return Schluesselwert mit dem zuhegoerigen Datensatz: String. + */ + private String concat(int element) { + return keys10[element] + ", " + data10[element]; + } + +} -- cgit v1.3.1