diff options
Diffstat (limited to 'src/de/ostfalia/algo/ws18/s2/test/ManagementTestS2.java')
| -rw-r--r-- | src/de/ostfalia/algo/ws18/s2/test/ManagementTestS2.java | 424 |
1 files changed, 424 insertions, 0 deletions
diff --git a/src/de/ostfalia/algo/ws18/s2/test/ManagementTestS2.java b/src/de/ostfalia/algo/ws18/s2/test/ManagementTestS2.java new file mode 100644 index 0000000..0e539e4 --- /dev/null +++ b/src/de/ostfalia/algo/ws18/s2/test/ManagementTestS2.java @@ -0,0 +1,424 @@ +package de.ostfalia.algo.ws18.s2.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.s2.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 ManagementTestS2 {
+
+ 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 = {4, 6, 2, 7, 8, 0, 3, 1, 9, 5};
+ int[] ofs = {-1, +1};
+
+ @Before
+ public void setUp() throws Exception {
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Standard-Konstruktoraufruf Management().<br>
+ * Nach Aufruf des Standard-Konstruktors duerfen sich keine Datensaetze
+ * in der Mitgliederverwaltung befinden.</li>
+ * <li>Erwartet: Anzahl der Datensaetze = 0.</li>
+ * </ul>
+ */
+ @Test
+ @TestDescription("Testen des Kontruktors().")
+ public void testKonstruktorOhneParameter() {
+ trace.add("Konstruktoraufruf Management()");
+ IManagement mgnt = new Management();
+ evaluate(mgnt);
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit einem Datensatz.<br>
+ * Nach Aufruf Konstruktors muss sich genau ein Datensatz (data10[0])
+ * in der Mitgliederverwaltung befinden.</li>
+ * <li>Erwartet: data10[0] in der Mitgliederverwaltung.</li>
+ * </ul>
+ */
+ @Test
+ @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);
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen.<br>
+ * Nach Aufruf Konstruktors mussen sich alle 10 Datensaetze in der
+ * Mitgliederverwaltung befinden.</li>
+ * <li>Erwartet: data10[0] bis data10[9] in der Mitgliederverwaltung.</li>
+ * </ul>
+ */
+ @Test
+ @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);
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Standard-Konstruktoraufruf Management() und anschliessendes
+ * Einfuegen von 10 Datensaetzen.<br>
+ * Alle Datensaetze muessen in die Mitgliederverwaltung eingefuegt
+ * werden koennen.</li>
+ * <li>Erwartet: data10[0] bis data10[9] in der Mitgliederverwaltung.</li>
+ * </ul>
+ */
+ @Test
+ @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);
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Standard-Konstruktoraufruf Management() und anschliessendes
+ * Einfuegen von 10 Datensaetzen in umgekehrter Reihenfolge.<br>
+ * Alle Datensaetze muessen in die Mitgliederverwaltung eingefuegt
+ * werden koennen.</li>
+ * <li>Erwartet: data10[0] bis data10[9] in der Mitgliederverwaltung.</li>
+ * </ul>
+ */
+ @Test
+ @AfterMethod("testKonstruktorZehnDatensaetze")
+ @TestDescription("Testen der insert(IMember)-Methode mit 10 Datensaetzen.")
+ public void testInsertReverse() {
+ trace.add("Konstruktoraufruf Management()");
+ IManagement mgnt = new Management();
+ evaluate(mgnt);
+
+ String msg = "Falscher Rueckgabe beim Einfuegen errhalten.";
+ for (int i = data10.length ; i > 0; i--) {
+ trace.add("Datensatz \"%s\" hinzufuegen.", data10[i - 1]);
+ IMember member = new Member(data10[i - 1]);
+ trace.addInfo("Aufruf von insert(%s).", member);
+ trace.addInfo(PassTrace.ifTrue(msg, mgnt.insert(member)));
+ }
+ evaluate(mgnt, all);
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen
+ * und anschliessendes Suchen nach den Schuesselwerten in der
+ * Mitgliederverwaltung.</li>
+ * <li>Erwartet: Alle Schuesselwerten muessen in der Mitgliederverwaltung
+ * gefunden werden. Die Methode search(long) muss den zugehoerigen
+ * Datensatz zurueckliefern.</li>
+ * </ul>
+ */
+ @Test
+ @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());
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen
+ * und anschliessendes Suchen nach Schuesselwerten, die nicht in der
+ * Mitgliederverwaltung existieren.</li>
+ * <li>Erwartet: Kein Schuesselwert darf in der Mitgliederverwaltung
+ * gefunden werden. Methode search(long) muss null liefern.</li>
+ * </ul>
+ */
+ @Test
+ @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());
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen
+ * und anschliessendes Suchen nach dem Nach- und Vornamen in der
+ * Mitgliederverwaltung.</li>
+ * <li>Erwartet: Alle Namen muessen in der Mitgliederverwaltung
+ * gefunden. Die Methode search(String, String) muss den zugehoerigen
+ * Datensatz zurueckliefern.</li>
+ * </ul>
+ */
+ @Test
+ @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());
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen
+ * und anschliessendes Suchen nach dem Nach- und Vornamen in der
+ * Mitgliederverwaltung, wobei der Nachname nicht exsistiert.</li>
+ * <li>Erwartet: Kein Namen darf in der Mitgliederverwaltung
+ * gefunden werden. Die Methode search(String, String) muss null liefern.</li>
+ * </ul>
+ */
+ @Test
+ @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());
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen
+ * und anschliessendes Ermitteln der Anzahl der Eintraege fuer die
+ * Sportarten HANDBALL, RUDERN, FUSSBALL und REITEN in der
+ * Mitgliederverwaltung.</li>
+ * <li>Erwartet: Die Methode size(KindOfSport) muss folgende Werte liefern:
+ * <ul>
+ * <li>HANDBALL: 5</li>
+ * <li>RUDERN: 3</li>
+ * <li>FUSSBALL: 2</li>
+ * <li>REITEN: 0</li>
+ * </ul>
+ * </li>
+ * </ul>
+ */
+ @Test
+ @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());
+ }
+
+ /**
+ * <ul>
+ * <li>Testfall: Konstruktoraufruf Management(String[]) mit 10 Datensaetzen
+ * und anschliessendes Ermitteln der Eintraege fuer die Sportarten
+ * HANDBALL, RUDERN, FUSSBALL und REITEN in der Mitgliederverwaltung.</li>
+ * <li>Erwartet:<br>
+ * Die Methode discipline(KindOfSport) muss folgende Datensaetze
+ * liefern (angegeben ist jeweils der Index im Datensatz data10):
+ * <ul>
+ * <li>HANDBALL: [6], [8], [0], [3], [1]</li>
+ * <li>RUDERN: [2], [7], [9]</li>
+ * <li>FUSSBALL: [4], [5]</li>
+ * <li>REITEN: nicht im Datensatz vorhanden</li>
+ * </ul>
+ * </li>
+ * </ul>
+ */
+ @Test
+ @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), 6, 8, 0, 3, 1);
+
+ sport = KindOfSport.RUDERN;
+ trace.add("Aufruf von discipline(%s).", sport);
+ evaluate(mgnt.discipline(sport), 2, 7, 9);
+
+ sport = KindOfSport.FUSSBALL;
+ trace.add("Aufruf von discipline(%s).", sport);
+ evaluate(mgnt.discipline(sport), 4, 5);
+
+ 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];
+ }
+
+}
|