*************************************************************************** Diese Datei pr1_AlleUebProgs ergaenzt die Datei Uebungen.odt und enthaelt die Uebungen, die sich besser durch eine Java-Klasse darstellen lassen als durch einen Text. Die Klassen, deren Namen Mit '_Jut' enden sind JUnit-Testprogramme. Die anderen Klassen enthalten Probleme, die man loesen und dann mit einem der Test- Programme testen sollte. Einige der Klassen sind dazu gedacht, mit 'Papier und Bleistift' ausgefuehrt zu werden. Die einzelnen Klassen sind durch Sternchen-Zeilen '*****...*****' voneinander getrennt. *************************************************************************** // Datei UebIfA.java /* ------------------------------------------------------------------------ Verschiedene Varianten der if-Anweisung (if, if-else, if-else-if ...). Dieses Programm soll dreimal mit "Papier und Bleistift" ausgefuehrt werden. Dabei soll angenommen werden, dass der Benutzer (fuer den Lesebefehl EM.liesInt()) jeweils eine der folgenden Ganzzahlen eingibt: 6, -9, 10. ------------------------------------------------------------------------ */ class UebIfA { // --------------------------------------------------------------------- static public void main(String[] sr) { pln("-------------------------------"); p ("A UebIfA: Eine Ganzzahl n? "); int n = EM.liesInt(); // if-Anweisunge mit und ohne geschweifte Klammern: if (n > 0) pln("B n ist positiv!"); if (n < 0) {pln("C n ist negativ!");} // if-Anweisung mit mehreren Anweisungen darin: if ((-9 <= n) && (n <= +9)) { n = 2 * n; pln("D n war einstellig und wurde"); pln("E verdoppelt zu " + n); } // if-else-Anweisung: if (n % 2 == 0) { pln("F n ist eine gerade Zahl!"); } else { pln("G n ist eine ungerade Zahl!"); } // if-else-if-else-Anweisung: if (n % 3 == 0) { pln("H n ist durch 3 teilbar!"); } else if (n % 4 == 0) { pln("I n ist durch 4 teilbar!"); } else if (n % 5 == 0) { pln("J n ist durch 5 teilbar!"); } else { pln("K n ist nicht durch 3, 4 oder 5 teilbar!"); } // Manchmal geht es einfacher ohne if-Anweisungen: boolean nIstEinstellig = ( -9 <= n) && (n <= +9); boolean nIstZweistellig = (-99 <= n) && (n <= +99) && !nIstEinstellig; pln("L Ist n einstellig? " + nIstEinstellig); pln("M Ist n zweistellig? " + nIstZweistellig); pln("N UebIfA: Das war's erstmal!"); pln("-------------------------------"); } // main // --------------------------------------------------------------------- // Mehrere Methoden mit kurzen Namen: static void pln(Object ob) {System.out.println(ob);} static void p (Object ob) {System.out.print (ob);} static void pln() {System.out.println(); } // --------------------------------------------------------------------- } // class UebIfA *************************************************************************** // Datei UebIfB.java /* ------------------------------------------------------------------------ In diese Klasse UebIfB kann man Ruempfe fuer bestimmte Methoden eintragen und dann mit dem Testprogramm UebIfB_Jut testen. ACHTUNG: In dieser Klasse sollen alle Berechnungen mit Ganzzahlen (vom Typ int) durchgefuehrt werden (nicht mit Bruchzahlen der Typen float, double oder BigDecimal!). ------------------------------------------------------------------------ */ public class UebIfB { // --------------------------------------------------------------------- static public int ta01(int n1) { // Falls die Variable n1 einen negativen Wert enthaelt, soll ihr der // Wert 0 zugewiesen werden // HIER SOLLTEN SIE ETWAS EINFUEGEN return n1; } // ta01 // --------------------------------------------------------------------- static public int ta02(int n1) { // Falls die Variable n1 einen positiven Wert enthaelt, soll ihr Wert // um 13 Prozent erhoeht werden (mit Ganzzahlrechnung!). // HIER SOLLTEN SIE ETWAS EINFUEGEN return n1; } // ta02 // --------------------------------------------------------------------- static public int ta03(int n1) { // Falls die Variable n1 einen geraden Wert enthaelt, soll ihr Wert // halbiert werden. Sonst soll ihr Wert verdoppelt werden. Um fest- // zustellen, ob n1 gerade ist oder nicht, sollten Sie die Rest- // operation (Modulo-Operation) % verwenden. // HIER SOLLTEN SIE ETWAS EINFUEGEN return n1; } // ta03 // --------------------------------------------------------------------- static public int ta04(int n1) { // Falls die Variable n1 einen geraden Wert enthaelt, soll ihr Wert // halbiert werden. Sonst soll ihr Wert verdoppelt werden. Diesmal // sollen Sie ohne die Restoperation % feststellen, ob n1 gerade ist // oder nicht (nur mit den Operationen +, -, *, / und ==). // Wie ist der Rest einer Ganzzahldivision eigentlich definiert? // HIER SOLLTEN SIE ETWAS EINFUEGEN return n1; } // ta04 // --------------------------------------------------------------------- static public boolean ta05(int n1) { // Falls die Variable n1 einen ungeraden Wert enthaelt (z.B. 3 oder // -5 etc.), soll true geliefert werden, und sonst false. // Um festzustellen, ob n1 ungerade ist oder nicht, sollen Sie // die Restoperation (Modulo-Operation) % verwenden. return false; // SOLLTE ERSETZT WERDEN } // ta05 // --------------------------------------------------------------------- static public int ta06(int n1) { // Falls die Variable n1 den Wert 0 enthaelt, soll sie unveraendert // bleiben. Sonst soll ihr Wert in Richtung 0 um 1 veraendert werden // (z.B. soll der Wert -5 durch -4 ersetzt werden oder +7 durch +6). // HIER SOLLTEN SIE ETWAS EINFUEGEN return n1; } // ta06 // --------------------------------------------------------------------- static public int ta07(int n1) { // Falls die Variable n1 den Wert 0 enthaelt, soll sie unveraendert // bleiben. Sonst soll ihr Wert um 1 vermindert werden (z.B. soll // der Wert -5 durch -6 ersetzt werden oder +7 durch +6). // HIER SOLLTEN SIE ETWAS EINFUEGEN return n1; } // ta07 // --------------------------------------------------------------------- static public int ta08(int n1, int n2) { // Die groesste der zwei Zahlen n1 und n2 soll der Variablen max // zugewiesen werden. int max = -999; // DIESE ZEILE SOLL ERSETZT WERDEN return max; } // ta08 // --------------------------------------------------------------------- static public int ta09(int n1, int n2, int n3) { // Die groesste der drei Zahlen n1 bis n3 soll der Variablen max // zugewiesen werden. Versuchen Sie, eine einfache Loesung fuer diese // Aufgabe zu finden, ehe Sie die folgende Aufgabe in Angriff nehmen. int max = -999; // DIESE ZEILE SOLL ERSETZT WERDEN return max; } // ta09 // --------------------------------------------------------------------- static public int ta10(int n1, int n2, int n3, int n4, int n5) { // Die groesste der fuenf Zahlen n1 bis n5 soll der Variablen max // zugewiesen werden. int max = -999; // DIESE ZEILE SOLL ERSETZT WERDEN return max; } // ta10 // --------------------------------------------------------------------- static public int ta11(int n1) { // Angenommen, die Variable n1 enthaelt einen Rechnungsbetrag. // Falls dieser Betrag groesser als 100 (aber nicht groesser als 500) // ist, soll er um 3 Prozent (Rabatt) vermindert werden. // Falls der Betrag groesser als 500 (aber nicht groesser als 1000) ist, // soll er um 5 Prozent vermindert werden. // Falls der Betrag groesser als 1000 ist, soll er um 6 Prozent ver- // mindert werden. // Gestalten Sie Ihre Loesung moeglichst so, dass der Kollege2 sie // leicht um zusaetzliche Rabattstufen erweitern kann (z.B. 8 Prozent // fuer Betraege ueber 10.000,- DM etc.). return n1; // DIESE ZEILE SOLL ERSETZT WERDEN } // ta11 // --------------------------------------------------------------------- static public void main(String [] sonja) { printf("-------------------------------------------------%n"); printf("Diese Klasse UebIfB kann man testen mit dem%n"); printf("Testprogramm UebIfB_Jut.java !%n"); printf("-------------------------------------------------%n"); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebIfB *************************************************************************** // Datei UebIfB_Jut.java /* ------------------------------------------------------------------------ Ein Programm zum Testen der Klassen UebIfB und UebIfB_Loes. Erstellt mit und fuer JUnit Version 3.8. ------------------------------------------------------------------------ */ import junit.framework.Test; // Eine Schnittstelle import junit.framework.TestCase; // Eine Test-Klasse import junit.framework.TestSuite; // Eine Test-Klasse import java.lang.reflect.Method; public class UebIfB_Jut extends TestCase { // --------------------------------------------------------------------- // Welche Klasse soll getestet werden, UebIfB oder UebIfB_Loes? static String KLASSEN_NAME = "UebIfB"; static Class kob; static { // Dies ist ein Klassen-Initialisierer try { kob = Class.forName(KLASSEN_NAME); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } } // --------------------------------------------------------------------- public void test_ta01() { try { Method m = kob.getDeclaredMethod("ta01", Integer.TYPE); assertEquals("Arg -17,", 0, m.invoke(null, -17)); assertEquals("Arg -1,", 0, m.invoke(null, -1)); assertEquals("Arg 0,", 0, m.invoke(null, 0)); assertEquals("Arg 1,", 1, m.invoke(null, 1)); assertEquals("Arg 17,", 17, m.invoke(null, 17)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta01", ex); } } // test_ta01 // --------------------------------------------------------------------- public void test_ta02() { try { Method m = kob.getDeclaredMethod("ta02", Integer.TYPE); assertEquals("Arg 100,", 113, m.invoke(null, 100)); assertEquals("Arg 10,", 11, m.invoke(null, 10)); assertEquals("Arg 9,", 10, m.invoke(null, 9)); assertEquals("Arg 0,", 0, m.invoke(null, 0)); assertEquals("Arg -100,", -100, m.invoke(null,-100)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta02", ex); } } // test_ta02 // --------------------------------------------------------------------- public void test_ta03() { try { Method m = kob.getDeclaredMethod("ta03", Integer.TYPE); assertEquals("Arg 2,", 1, m.invoke(null, 2)); assertEquals("Arg -2,", -1, m.invoke(null, -2)); assertEquals("Arg 3,", 6, m.invoke(null, 3)); assertEquals("Arg -3,", -6, m.invoke(null, -3)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta03", ex); } } // test_ta03 // --------------------------------------------------------------------- public void test_ta04() { try { Method m = kob.getDeclaredMethod("ta04", Integer.TYPE); assertEquals("Arg 2,", 1, m.invoke(null, 2)); assertEquals("Arg -2,", -1, m.invoke(null, -2)); assertEquals("Arg 3,", 6, m.invoke(null, 3)); assertEquals("Arg -3,", -6, m.invoke(null, -3)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta04", ex); } } // test_ta04 // --------------------------------------------------------------------- public void test_ta05() { try { Method m = kob.getDeclaredMethod("ta05", Integer.TYPE); assertEquals("Arg 2,", false, m.invoke(null, 2)); assertEquals("Arg -2,", false, m.invoke(null, -2)); assertEquals("Arg 3,", true, m.invoke(null, 3)); assertEquals("Arg -3,", true, m.invoke(null, -3)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta05", ex); } } // test_ta05 // --------------------------------------------------------------------- public void test_ta06() { try { Method m = kob.getDeclaredMethod("ta06", Integer.TYPE); assertEquals("Arg 0,", 0, m.invoke(null, 0)); assertEquals("Arg -1,", 0, m.invoke(null, -1)); assertEquals("Arg +1,", 0, m.invoke(null, +1)); assertEquals("Arg -7,", -6, m.invoke(null, -7)); assertEquals("Arg +7,", +6, m.invoke(null, +7)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta06", ex); } } // test_ta06 // --------------------------------------------------------------------- public void test_ta07() { try { Method m = kob.getDeclaredMethod("ta07", Integer.TYPE); assertEquals("Arg 0,", 0, m.invoke(null, 0)); assertEquals("Arg -1,", -2, m.invoke(null, -1)); assertEquals("Arg +1,", 0, m.invoke(null, +1)); assertEquals("Arg -7,", -8, m.invoke(null, -7)); assertEquals("Arg +7,", +6, m.invoke(null, +7)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta07", ex); } } // test_ta07 // --------------------------------------------------------------------- public void test_ta08() { try { Method m = kob.getDeclaredMethod("ta08", Integer.TYPE, Integer.TYPE); assertEquals("Args 3, 5,", 5, m.invoke(null, 3, 5)); assertEquals("Args 5, 3,", 5, m.invoke(null, 5, 3)); assertEquals("Args -3, -5,", -3, m.invoke(null, -3, -5)); assertEquals("Args -5, -3,", -3, m.invoke(null, -5, -3)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta08", ex); } } // test_ta08 // --------------------------------------------------------------------- public void test_ta09() { try { Method m = kob.getDeclaredMethod("ta09", Integer.TYPE, Integer.TYPE, Integer.TYPE); assertEquals("Args 2, 5, 8,", 8, m.invoke(null, 2, 5, 8)); assertEquals("Args 8, 5, 2,", 8, m.invoke(null, 8, 5, 2)); assertEquals("Args -2, -5, -8,", -2, m.invoke(null,-2,-5,-8)); assertEquals("Args -5, -5, -5,", -5, m.invoke(null,-5,-5,-5)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta09", ex); } } // test_ta09 // --------------------------------------------------------------------- public void test_ta10() { try { Method m = kob.getDeclaredMethod("ta10", Integer.TYPE, Integer.TYPE, Integer.TYPE, Integer.TYPE, Integer.TYPE); assertEquals("Args 1, 3, 4, 7, 8,", 8, m.invoke(null, 1, 3, 4, 7, 8)); assertEquals("Args 1, 8, 4, 7, 3,", 8, m.invoke(null, 1, 8, 4, 7, 3)); assertEquals("Args -1, -8, -4, -7, -3,", -1, m.invoke(null,-1,-8,-4,-7,-3)); assertEquals("Args -4, -4, -4, -2, -2,", -2, m.invoke(null,-4,-4,-4,-2,-2)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta10", ex); } } // test_ta10 // --------------------------------------------------------------------- public void test_ta11() { try { Method m = kob.getDeclaredMethod("ta11", Integer.TYPE); assertEquals("Arg 100,", 100, m.invoke(null, 100)); assertEquals("Arg 101,", 97, m.invoke(null, 101)); assertEquals("Arg 110,", 106, m.invoke(null, 110)); assertEquals("Arg 500,", 485, m.invoke(null, 500)); assertEquals("Arg 501,", 475, m.invoke(null, 501)); assertEquals("Arg 550,", 522, m.invoke(null, 550)); assertEquals("Arg 1000,", 950, m.invoke(null, 1000)); assertEquals("Arg 1001,", 940, m.invoke(null, 1001)); assertEquals("Arg 1100,", 1034, m.invoke(null, 1100)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta11", ex); } } // test_ta11 // --------------------------------------------------------------------- static public void main(String... sonja) throws Exception { printf("Getestet wird die Klasse %s%n", KLASSEN_NAME); junit.awtui.TestRunner.run(UebIfB_Jut.class); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebIfB_Jut *************************************************************************** // Datei UebSchleifenA.java /* ------------------------------------------------------------------------ Dieses Programm UebSchleifenA enthaelt mehrere Schleifen, die "mit Papier und Bleistift" ausgefuehrt werden sollen. Als Ergebnis der Ausfuehrung sollen die von der betreffenden Schleife zum Bildschirm ausgegebenen Zeichen und Zeilen moeglichst genau (einigermassen "spaltengetreu") aufgeschrieben werden. Leerzeichen sollen dabei z.B. durch kleine Rechtecke oder ähnlich (auf jeden Fall aber "klar erkennbar und zaehlbar") dargestellt werden. ------------------------------------------------------------------------ */ import java.util.ArrayList; class UebSchleifenA { // --------------------------------------------------------------------- static public void main(String [] sonja) { printf("UebSchleifenA: Jetzt geht es los!%n"); printf("-------------------------------------%n"); printf("Ausgabe der anna-Schleife:%n%n"); int anna = 7; while (anna > 0) { p(anna + " "); anna /= 2; } pln(); printf("-------------------------------------%n"); printf("Ausgabe der berta-Schleife:%n%n"); int berta = 7; do { berta /= 2; p(" -> " + berta); } while (berta > 0); pln(); printf("-------------------------------------%n"); printf("Ausgabe der celia-Schleife:%n%n"); for (int celia = -3; celia < 5; celia += 2) { p(2 * celia + 4 + " "); } pln(); printf("-------------------------------------%n"); printf("Ausgabe der dora-Schleife:%n%n"); for (int dora = 3; 2*dora > -3; dora--) { p(dora + " "); } pln(); printf("-------------------------------------%n"); printf("Ausgabe der MAX1-Schleife:%n%n"); final int MAX1 = 3; for (int i1 = 1; i1 <= MAX1; i1++) { for (int i2 = 1; i2 <= 2*MAX1; i2++) { p("*"); } pln(); } printf("-------------------------------------%n"); printf("Ausgabe der MAX2-Schleife:%n%n"); final int MAX2 = 5; for (int i1 = 1; i1 <= MAX2; i1++) { for (int i2 = 1; i2 <= i1; i2++) { p("++"); } pln(); } printf("-------------------------------------%n"); printf("UebSchleifenA: Das war's erstmal!%n"); } // main // --------------------------------------------------------------------- static String toString(ArrayList als) { StringBuilder sb = new StringBuilder(); for (String s: als) sb.append(s); als.clear(); return sb.toString(); } // --------------------------------------------------------------------- // Mehrere Methoden mit kurzen Namen: static void pln(Object ob) {System.out.println(ob);} static void p (Object ob) {System.out.print (ob);} static void pln() {System.out.println(); } static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebSchleifenA *************************************************************************** // Datei UebSchleifenB.java /* ------------------------------------------------------------------------ In diese Klasse UebSchleifenB kann man Ruempfe fuer bestimmte Methoden eintragen und und dann mit dem Testprogramm UebSchleifenB_Jut testen. ACHTUNG: Fuer die Methoden ta01 bis ta14 gilt: 1. Alle Ausgaben sollen mit dem Befehl p durchgefuehrt werden. Der Befehl pln oder andere Ausgabebefehle sollen dort NICHT benutzt werden. Ausgaben sollen NICHT mit einem Zeilenwechsel abgeschlossen werden. 2. Beim Ausgeben von Zahlenfolgen soll nach jeder Zahl ein Blank-Zeichen (Leerzeichen, engl. space character) ausgegeben werden. 3. Einige der Probleme "haengen zusammen", d.h. die Loesung zu einem Problem kann zu einer Loesungen eines anderen Problem "erweitert" oder "umgebaut" werden. In der main-Methode koennen Sie alle Ausgabebefehle (p, pln, printf) benutzen, ganz wie Sie wollen. ------------------------------------------------------------------------ */ public class UebSchleifenB { // --------------------------------------------------------------------- static public void ta01() { // Gibt die Zahlenfolge 1 2 3 4 5 6 7 8 9 10 aus. p("Noch nicht fertig 01!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta01 // --------------------------------------------------------------------- static public void ta02() { // Gibt alle durch 3 teilbaren Ganzzahlen zwischen 10 und 40 // (einschliessliche) aus. p("Noch nicht fertig 02!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta02 // --------------------------------------------------------------------- // ACHTUNG: Bevor Sie weitermachen, sollten Sie Ihre Loesung fuer ta02 // dem Betreuer Ihrer Uebungsgruppe zeigen. Moeglicherweise hat er noch // einen wichtigen Verbesserungsvorschlag dafuer. // --------------------------------------------------------------------- static public void ta03() { // Gibt die Zahlenfolge -5 -2 1 4 7 10 13 16 19 aus. p("Noch nicht fertig 03!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta03 // --------------------------------------------------------------------- static public void ta04() { // Gibt die Zahlenfolge 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 // aus. p("Noch nicht fertig 04!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta04 // --------------------------------------------------------------------- static public void ta05() { // Gibt die Zahlenfolge 3 4 6 10 18 34 66 130 258 514 1026 2050 4098 // aus. p("Noch nicht fertig 05!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta05 // --------------------------------------------------------------------- static public void ta06() { // Gibt die Zahlenfolge 1 2 4 7 11 16 22 29 37 46 56 67 79 92 aus. p("Noch nicht fertig 06!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta06 // --------------------------------------------------------------------- // ACHTUNG: In den folgenden 3 Methoden (ta07 bis ta09) geht es nur // um positive ganze Zahlen (1, 2, 3, ...). Jede solche Zahl n ist // durch 1 und durch sich selbst teilbar. Man bezeichnet 1 und n auch // als *unechte Teiler von n". Falls n auch noch weitere Teiler hat, // bezeichnet man die als *echte Teiler von n". // Beispiel: Die Zahl 12 hat die Teiler 1, 2, 3, 4, 6, 12 (und davon // sind 2, 3, 4, 6 echte Teiler) // Die Zahl 17 hat nur die (unechten) Teiler 1 und 17. // --------------------------------------------------------------------- static public void ta07(int norbert) { // Verlaesst sich darauf, dass norbert groesser als 1 ist. // Gibt den groessten echten Teiler von norbert aus (wenn norbert // echte Teiler hat) und gibt sonst 1 aus. p("Noch nicht fertig 07!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta07 // --------------------------------------------------------------------- static public void ta08(int norbert) { // Verlaesst sich darauf, dass norbert groesser als 1 ist. // Gibt den kleinsten echten Teiler von norbert aus (wenn norbert // echte Teiler hat) und gibt sonst norbert aus. p("Noch nicht fertig 08!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta08 // --------------------------------------------------------------------- static public void ta09(int norbert) { // Verlaesst sich darauf, dass norbert groesser als 1 ist. // Gibt true aus, wenn norbert prim ist und gibt sonst false aus. p("Noch nicht fertig 09!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta09 // --------------------------------------------------------------------- static public void ta10(String sara) { // Wie oft kommt 'x' in sara vor? // Diese Anzahl wird ausgegeben. p("Noch nicht fertig 10!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta10 // --------------------------------------------------------------------- static public void ta11(String sara) { // Wie viele Ziffern kommen in sara vor? // Diese Anzahl wird ausgegeben. p("Noch nicht fertig 11!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta11 // --------------------------------------------------------------------- static public void ta12(String sara) { // Wie viele Buchstaben ('A' bis 'Z' und 'a' bis 'z') kommen // in sara vor? Diese Anzahl wird ausgegeben. p("Noch nicht fertig 12!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta12 // --------------------------------------------------------------------- static public void ta13(String sara) { // Mit wie vielen fuehrenden Nullen beginnt sara? // Diese Anzahl wird ausgegeben. p("Noch nicht fertig 13!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta13 // --------------------------------------------------------------------- static public void ta14(String sara) { // Wie oft kommt in sara ein 'A' vor einem 'B' vor? // Diese Anzahl wird ausgegeben. p("Noch nicht fertig 14!"); // DIESE ZEILE SOLL ERSETZT WERDEN } // ta14 // ===================================================================== // Der StringBuilder bildschirm taeuscht einen zweiten Bildschirm vor: // Die Methoden namens p und pln geben ihre Daten voreingestellt zur // Standardausgabe (Bildschirm) aus. Nur wenn das Attribut zum_bildschirm // auf true gesetzt wurde (z.B. mit der Methode set_zum_bildschirm), // "geben sie zum bildschirm aus" (und nicht zum Bildschirm!). // Das Testprogramm UebSchleifenB_Jut setzt zum_bildschirm auf true. static boolean zum_bildschirm = false; static StringBuilder bildschirm = new StringBuilder(); static void p (Object ob) { if (zum_bildschirm) { bildschirm.append(ob.toString()); // gib zum bildschirm aus } else { System.out.print(ob); // gib zum Bildschirm aus } } static void pln(Object ob) { if (zum_bildschirm) { bildschirm.append(ob.toString() + "\n"); } else { System.out.println(ob); } } static void pln() { if (zum_bildschirm) { bildschirm.append("\n"); } else { System.out.println(); } } // --------------------------------------------------------------------- static void set_zum_bildschirm(boolean b) {zum_bildschirm=b;} // --------------------------------------------------------------------- static String holeUndLoescheBildschirmInhalt() { String erg = bildschirm.toString(); // Inhalt holen bildschirm.delete(0, bildschirm.length()); // bildschirm loeschen return erg; } // holeUndLoescheBildschirmInhalt // --------------------------------------------------------------------- static public void main(String [] sonja) { printf("---------------------------------------------------%n"); printf("Diese Klasse UebSchleifenB kann man testen mit %n"); printf("dem Testprogramm UebSchleifenB_Jut.java !%n"); printf("---------------------------------------------------%n"); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen (gibt zum realen Bildschirm aus, // nicht zum internen Bildschirm MethodTest.iScreen): static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebSchleifenB *************************************************************************** // Datei UebSchleifenB_Jut.java /* ------------------------------------------------------------------------ Ein Programm zum Testen der Klassen UebSchleifenB und UebSchleifenB_Loes. Erstellt mit und fuer JUnit Version 3.8. ------------------------------------------------------------------------ */ import junit.framework.Test; // Eine Schnittstelle import junit.framework.TestCase; // Eine Test-Klasse import junit.framework.TestSuite; // Eine Test-Klasse import java.lang.reflect.Method; import java.util.Arrays; import static java.lang.String.format; public class UebSchleifenB_Jut extends TestCase { // --------------------------------------------------------------------- // Welche Klasse soll getestet werden, // UebSchleifenB oder UebSchleifenB_Loes? static String KLASSEN_NAME = "UebSchleifenB"; static Class kob; static { // Dies ist ein Klassen-Initialisierer (static initialiser) try { kob = Class.forName(KLASSEN_NAME); Method set =kob.getDeclaredMethod("set_zum_bildschirm", Boolean.TYPE); set.invoke(null, true); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } catch (Exception ex) { printf("-------------------------------------------------%n"); printf("Kann %s.set_zum_bildschirm nicht aufrufen!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-2); } } // Klassen-Initialisierer // --------------------------------------------------------------------- public void test_ta01() { try { Method m = kob.getDeclaredMethod("ta01"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL = "1 2 3 4 5 6 7 8 9 10 "; m.invoke(null); String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_ta01", ex); } } // test_ta01 // --------------------------------------------------------------------- public void test_ta02() { try { Method m = kob.getDeclaredMethod("ta02"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL = "12 15 18 21 24 27 30 33 36 39 "; m.invoke(null); String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_ta02", ex); } } // test_ta02 // --------------------------------------------------------------------- public void test_ta03() { try { Method m = kob.getDeclaredMethod("ta03"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL = "-5 -2 1 4 7 10 13 16 19 "; m.invoke(null); String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_ta03", ex); } } // test_ta03 // --------------------------------------------------------------------- public void test_ta04() { try { Method m = kob.getDeclaredMethod("ta04"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL = "1 2 4 8 16 32 64 128 256 512 1024 2048 4096 "; m.invoke(null); String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_ta04", ex); } } // test_ta04 // --------------------------------------------------------------------- public void test_ta05() { try { Method m = kob.getDeclaredMethod("ta05"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL = "3 4 6 10 18 34 66 130 258 514 1026 2050 4098 "; m.invoke(null); String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_ta05", ex); } } // test_ta05 // --------------------------------------------------------------------- public void test_ta06() { try { Method m = kob.getDeclaredMethod("ta06"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL = "1 2 4 7 11 16 22 29 37 46 56 67 79 92 "; m.invoke(null); String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_ta06", ex); } } // test_ta06 // --------------------------------------------------------------------- public void test_ta07() { try { Method m = kob.getDeclaredMethod("ta07", Integer.TYPE); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, 2); assertEquals( "1", (String)h.invoke(null)); m.invoke(null, 3); assertEquals( "1", (String)h.invoke(null)); m.invoke(null, 4); assertEquals( "2", (String)h.invoke(null)); m.invoke(null, 5); assertEquals( "1", (String)h.invoke(null)); m.invoke(null, 6); assertEquals( "3", (String)h.invoke(null)); m.invoke(null, 12); assertEquals( "6", (String)h.invoke(null)); m.invoke(null, 17); assertEquals( "1", (String)h.invoke(null)); m.invoke(null, 99); assertEquals( "33", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta07", ex); } } // test_ta07 // --------------------------------------------------------------------- public void test_ta08() { try { Method m = kob.getDeclaredMethod("ta08", Integer.TYPE); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, 2); assertEquals( "2", (String)h.invoke(null)); m.invoke(null, 3); assertEquals( "3", (String)h.invoke(null)); m.invoke(null, 4); assertEquals( "2", (String)h.invoke(null)); m.invoke(null, 5); assertEquals( "5", (String)h.invoke(null)); m.invoke(null, 6); assertEquals( "2", (String)h.invoke(null)); m.invoke(null, 12); assertEquals( "2", (String)h.invoke(null)); m.invoke(null, 17); assertEquals( "17", (String)h.invoke(null)); m.invoke(null, 99); assertEquals( "3", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta08", ex); } } // test_ta08 // --------------------------------------------------------------------- public void test_ta09() { try { Method m = kob.getDeclaredMethod("ta09", Integer.TYPE); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, 2); assertEquals("true" , (String)h.invoke(null)); m.invoke(null, 3); assertEquals("true" , (String)h.invoke(null)); m.invoke(null, 4); assertEquals("false", (String)h.invoke(null)); m.invoke(null, 5); assertEquals("true" , (String)h.invoke(null)); m.invoke(null, 6); assertEquals("false", (String)h.invoke(null)); m.invoke(null, 12); assertEquals("false", (String)h.invoke(null)); m.invoke(null, 17); assertEquals("true" , (String)h.invoke(null)); m.invoke(null, 99); assertEquals("false", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta09", ex); } } // test_ta09 // --------------------------------------------------------------------- public void test_ta10() { try { Method m = kob.getDeclaredMethod("ta10", String.class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, "axbxcxd" ); assertEquals("3", (String)h.invoke(null)); m.invoke(null, "axbxcxdx"); assertEquals("4", (String)h.invoke(null)); m.invoke(null, "xxxxxxxx"); assertEquals("8", (String)h.invoke(null)); m.invoke(null, "aaaaaa" ); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "aaxxaaxx"); assertEquals("4", (String)h.invoke(null)); m.invoke(null, "" ); assertEquals("0", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta10", ex); } } // test_ta10 // --------------------------------------------------------------------- public void test_ta11() { try { Method m = kob.getDeclaredMethod("ta11", String.class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, "a1b2c3d" ); assertEquals("3", (String)h.invoke(null)); m.invoke(null, "a1b2c3d4"); assertEquals("4", (String)h.invoke(null)); m.invoke(null, "11223344"); assertEquals("8", (String)h.invoke(null)); m.invoke(null, "abcdabcd"); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "" ); assertEquals("0", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta11", ex); } } // test_ta11 // --------------------------------------------------------------------- public void test_ta12() { try { Method m = kob.getDeclaredMethod("ta12", String.class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, "a1b2c3d" ); assertEquals("4", (String)h.invoke(null)); m.invoke(null, "a1b2c3d4"); assertEquals("4", (String)h.invoke(null)); m.invoke(null, "11223344"); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "abcdabcd"); assertEquals("8", (String)h.invoke(null)); m.invoke(null, "" ); assertEquals("0", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta12", ex); } } // test_ta12 // --------------------------------------------------------------------- public void test_ta13() { try { Method m = kob.getDeclaredMethod("ta13", String.class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, "1234567" ); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "1" ); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "00012345"); assertEquals("3", (String)h.invoke(null)); m.invoke(null, "00000000"); assertEquals("8", (String)h.invoke(null)); m.invoke(null, "0" ); assertEquals("1", (String)h.invoke(null)); m.invoke(null, "00" ); assertEquals("2", (String)h.invoke(null)); m.invoke(null, "" ); assertEquals("0", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta13", ex); } } // test_ta13 // --------------------------------------------------------------------- public void test_ta14() { try { Method m = kob.getDeclaredMethod("ta14", String.class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null, "ABABABAB"); assertEquals("4", (String)h.invoke(null)); m.invoke(null, "ABAXABAX"); assertEquals("2", (String)h.invoke(null)); m.invoke(null, "XXABXXXX"); assertEquals("1", (String)h.invoke(null)); m.invoke(null, "ABXXXXAB"); assertEquals("2", (String)h.invoke(null)); m.invoke(null, "AB" ); assertEquals("1", (String)h.invoke(null)); m.invoke(null, "A" ); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "B" ); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "C" ); assertEquals("0", (String)h.invoke(null)); m.invoke(null, "" ); assertEquals("0", (String)h.invoke(null)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta14", ex); } } // test_ta14 // --------------------------------------------------------------------- static public void main(String... sonja) throws Exception { printf("Getestet wird die Klasse %s%n", KLASSEN_NAME); junit.awtui.TestRunner.run(UebSchleifenB_Jut.class); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebSchleifenB_Jut *************************************************************************** // Datei UebSchleifenC.java /* ------------------------------------------------------------------------ In diese Klasse UebSchleifenC kann man Ruempfe fuer bestimmte Methoden eintragen und und dann mit dem Testprogramm UebSchleifenC_Jut testen. In der main-Methode koennen Sie alle Ausgabebefehle (p, pln, printf) benutzen, ganz wie Sie wollen. ------------------------------------------------------------------------ */ import java.util.Arrays; class UebSchleifenC { // --------------------------------------------------------------------- static public boolean enthaeltGleiche(int[] ir) { // Liefert true wenn mindestens zwei int-Werte in ir gleich sind, // und sonst false. // // Beispiele: // int[] ir01 = {10,20,10,30}; // int[] ir02 = {10,20,30,40,50,20,60}; // int[] ir03 = {10,20,30,40}; // int[] ir04 = {50}; // int[] ir05 = {}; // // enthaeltGleiche(ir01) ist gleich true // enthaeltGleiche(ir02) ist gleich true // enthaeltGleiche(ir03) ist gleich false // enthaeltGleiche(ir04) ist gleich false // enthaeltGleiche(ir05) ist gleich false return false; // DIESE ZEILE SOLL ERSETZT WERDEN } // enthaeltGleiche // Frage: for-each-Schleifen oder for-i-Schleifen? // --------------------------------------------------------------------- static public int anzahlVerschiedene(int[] ir) { // Liefert die Anzahl der verschiedenen int-Werte von ir. // // Beispiele: // int[] ir01 = {10,20,30,40,50}; // int[] ir02 = {10,20,20,10,50}; // int[] ir03 = {10,10,10}; // int[] ir04 = {10}; // int[] ir05 = {}; // // anzahlVerschiedene(ir01) ist gleich 5 // anzahlVerschiedene(ir02) ist gleich 3 // anzahlVerschiedene(ir03) ist gleich 1 // anzahlVerschiedene(ir04) ist gleich 1 // anzahlVerschiedene(ir05) ist gleich 0 return -999; // DIESE ZEILE SOLL ERSETZT WERDEN } // anzahlVerschiedene // Frage: for-each-Schleifen oder for-i-Schleifen? // --------------------------------------------------------------------- static public boolean enthaelt(int[] irA, int[] irB) { // Liefert true wenn irB in irA enthalten ist d.h. wenn jeder // int-Wert, der (mind. einmal) in irB vorkommt auch (mind. einmal) // in irA vorkommt). // // Beispiele: // int[] ir01 = {10,20,30,40,50}; // int[] ir02 = {50,10,50,10,50}; // int[] ir03 = {30,20,10}; // int[] ir04 = {10,60,10}; // int[] ir05 = {40}; // int[] ir06 = {60}; // int[] ir07 = {}; // // enthaelt(ir01, ir02) ist gleich true // enthaelt(ir01, ir03) ist gleich true // enthaelt(ir01, ir04) ist gleich false // enthaelt(ir01, ir05) ist gleich true // enthaelt(ir01, ir06) ist gleich false // enthaelt(ir01, ir07) ist gleich true // enthaelt(ir02, ir01) ist gleich false // enthaelt(ir06, ir07) ist gleich true // enthaelt(ir07, ir07) ist gleich true return false; // DIESE ZEILE SOLL ERSETZT WERDEN } // enthaelt // Frage: for-each-Schleifen oder for-i-Schleifen? // --------------------------------------------------------------------- static public int[] vereinigung(int[] irA, int[] irB) { // Verlaesst sich darauf, dass irA und irB Mengen repraesentieren // (d.h. keine Doppelgaenger enthalten). Liefert die Vereinigung // von irA und irB (d.h. die int-Werte, die in irA oder in irB // (oder in beiden) enthalten sind). // // Beispiele: // int[] ir01 = {10, 30, 50, 70}; // int[] ir02 = {10,20, 40,50,60,70}; // int[] ir03 = { 20, 50, 70}; // int[] ir04 = {10,20,30,40,50,60,70}; // int[] ir05 = { 20, 40, 60 }; // int[] ir06 = { }; // // int[] er01 = {10,20,30,40,50,60,70}; // int[] er02 = {10,20, 40,50,60,70}; // int[] er03 = {10,20,30,40,50,60,70}; // int[] er04 = {10,20,30,40,50,60,70}; // int[] er05 = { 20, 40, 60 }; // // vereinigung(ir01, ir02) ist gleich er01 // vereinigung(ir02, ir03) ist gleich er02 // vereinigung(ir03, ir04) ist gleich er03 // vereinigung(ir04, ir05) ist gleich er04 // vereinigung(ir05, ir06) ist gleich er05 return new int[]{-999, -999}; // DIESE ZEILE SOLL ERSETZT WERDEN } // vereinigung // Frage: for-each-Schleifen oder for-i-Schleifen? // --------------------------------------------------------------------- static public int[] durchschnitt(int[] irA, int[] irB) { // Verlaesst sich darauf, dass irA und irB Mengen repraesentieren // (d.h. keine Doppelgaenger enthalten). Liefert den Durchschnitt // von irA und irB (d.h. die int-Werte, die in irA und in irB // enthalten sind). // // Beispiele: // int[] ir01 = {10, 30, 50, 70}; // int[] ir02 = {10,20, 40,50,60,70}; // int[] ir03 = { 20, 50, 70}; // int[] ir04 = {10,20,30,40,50,60,70}; // int[] ir05 = { 20, 40, 60 }; // int[] ir06 = { }; // // int[] er01 = {10, 50, 70}; // int[] er02 = { 20, 50, 70}; // int[] er03 = { 20, 50, 70}; // int[] er04 = { 20, 40, 60 }; // int[] er05 = { }; // // durchschnitt(ir01, ir02) ist gleich er01 // durchschnitt(ir02, ir03) ist gleich er02 // durchschnitt(ir03, ir04) ist gleich er03 // durchschnitt(ir04, ir05) ist gleich er04 // durchschnitt(ir05, ir06) ist gleich er05 return new int[]{-999, -999}; // DIESE ZEILE SOLL ERSETZT WERDEN } // durchschnitt // Frage: for-each-Schleifen oder for-i-Schleifen? // --------------------------------------------------------------------- static public int[] differenz(int[] irA, int[] irB) { // Verlaesst sich darauf, dass irA und irB Mengen repraesentieren // (d.h. keine Doppelgaenger enthalten). Liefert die (Mengen-) // Differenz irA minus irB (d.h. alle int-Werte, die in irA, // aber nicht in irB enthalten sind). // // Beispiele: // int[] ir01 = {10 ,30, 50, 70}; // int[] ir02 = {10,20, 40,50,60,70}; // int[] ir03 = { 20, 50, 70}; // int[] ir04 = {10,20,30,40,50,60,70}; // int[] ir05 = { 20, 40, 60 }; // int[] ir06 = { }; // // int[] er01 = { 30 }; // int[] er02 = {10, 40, 60 }; // int[] er03 = { }; // int[] er04 = {10, 30, 50, 70}; // int[] er05 = { 20, 40, 60 }; // // differenz(ir01, ir02) ist gleich er01 // differenz(ir02, ir03) ist gleich er02 // differenz(ir03, ir04) ist gleich er03 // differenz(ir04, ir05) ist gleich er04 // differenz(ir05, ir06) ist gleich er05 return new int[]{-999, -999}; // DIESE ZEILE SOLL ERSETZT WERDEN } // differenz // Frage: for-each-Schleifen oder for-i-Schleifen? // --------------------------------------------------------------------- static public int[] symmetrischeDifferenz(int[] irA, int[] irB) { // Verlaesst sich darauf, dass irA und irB Mengen repraesentieren // (d.h. keine Doppelgaenger enthalten). Liefert die symmetrische // Differenz von irA und irB (d.h. alle int-Werte, die nur in einer // der beiden Mengen enthalten ist, aber nicht in beiden). // // Beispiele: // ir01 = {10 ,30, 50, 70}; // ir02 = {10,20, 40,50,60,70}; // ir03 = { 20, 50, 70}; // ir04 = {10,20,30,40,50,60,70}; // ir05 = { 20, 40, 60 }; // ir06 = { }; // // er01 = { 20,30,40, 60 }; // er02 = {10, 40, 60 }; // er03 = {10, 30,40, 60 }; // er04 = {10, 30, 50, 70}; // er05 = { 20, 40, 60 }; // // symmetrischeDifferenz(ir01, ir02) ist gleich er01 // symmetrischeDifferenz(ir02, ir03) ist gleich er02 // symmetrischeDifferenz(ir03, ir04) ist gleich er03 // symmetrischeDifferenz(ir04, ir05) ist gleich er04 // symmetrischeDifferenz(ir05, ir06) ist gleich er05 return new int[]{-999, -999}; // DIESE ZEILE SOLL ERSETZT WERDEN } // symmetrischeDifferenz // Frage: for-each-Schleifen oder for-i-Schleifen? // ===================================================================== // Der StringBuilder bildschirm taeuscht einen zweiten Bildschirm vor: // Die Methoden namens p und pln geben ihre Daten voreingestellt zur // Standardausgabe (Bildschirm) aus. Nur wenn das Attribut zum_bildschirm // auf true gesetzt wurde (z.B. mit der Methode set_zum_bildschirm), // "geben sie zum bildschirm aus" (und nicht zum Bildschirm!). // Das Testprogramm UebReihung1Jut setzt zum_bildschirm auf true. static boolean zum_bildschirm = false; static StringBuilder bildschirm = new StringBuilder(); static void p (Object ob) { if (zum_bildschirm) { bildschirm.append(ob.toString()); // gib zum bildschirm aus } else { System.out.print(ob); // gib zum Bildschirm aus } } static void pln(Object ob) { if (zum_bildschirm) { bildschirm.append(ob.toString() + "\n"); } else { System.out.println(ob); } } static void pln() { if (zum_bildschirm) { bildschirm.append("\n"); } else { System.out.println(); } } // --------------------------------------------------------------------- static void set_zum_bildschirm(boolean b) {zum_bildschirm=b;} // --------------------------------------------------------------------- static String holeUndLoescheBildschirmInhalt() { String erg = bildschirm.toString(); // Inhalt holen bildschirm.delete(0, bildschirm.length()); // bildschirm loeschen return erg; } // holeUndLoescheBildschirmInhalt // --------------------------------------------------------------------- static public void main(String [] sonja) { printf("---------------------------------------------------%n"); printf("Diese Klasse UebSchleifenC kann man testen mit dem %n"); printf("Testprogramm UebSchleifenC_Jut.java !%n"); printf("---------------------------------------------------%n"); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebSchleifenC *************************************************************************** // Datei UebSchleifenC_Jut.java /* ------------------------------------------------------------------------ Ein Programm zum Testen der Klasse UebSchleifenC und UebSchleifenC_Loes. Erstellt mit und fuer JUnit Version 3.8. ------------------------------------------------------------------------ */ import junit.framework.Test; // Eine Schnittstelle import junit.framework.TestCase; // Eine Test-Klasse import junit.framework.TestSuite; // Eine Test-Klasse import java.lang.reflect.Method; import java.util.Arrays; import static java.lang.String.format; public class UebSchleifenC_Jut extends TestCase { // --------------------------------------------------------------------- // Welche Klasse soll getestet werden, // UebSchleifenC oder UebSchleifenC_Loes? static String KLASSEN_NAME = "UebSchleifenC"; static Class kob; static { // Dies ist ein Klassen-Initialisierer (static initialiser) try { kob = Class.forName(KLASSEN_NAME); Method set =kob.getDeclaredMethod("set_zum_bildschirm", Boolean.TYPE); set.invoke(null, true); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } catch (Exception ex) { printf("-------------------------------------------------%n"); printf("Kann %s.set_zum_bildschirm nicht aufrufen!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-2); } } // Klassen-Initialisierer // --------------------------------------------------------------------- public void test_enthaeltGleiche() { try { Method m = kob.getDeclaredMethod("enthaeltGleiche", int[].class); int[] ir01 = {1,2,1,3}; int[] ir02 = {1,2,3,4,5,2,6}; int[] ir03 = {1,2,3,4}; int[] ir04 = {5}; int[] ir05 = {}; assertEquals(true, (boolean) m.invoke(null, ir01)); assertEquals(true, (boolean) m.invoke(null, ir02)); assertEquals(false, (boolean) m.invoke(null, ir03)); assertEquals(false, (boolean) m.invoke(null, ir04)); assertEquals(false, (boolean) m.invoke(null, ir05)); } catch (Exception ex) { throw new Error("Ausnahme in test_enthaeltGleiche", ex); } } // test_enthaeltGleiche // --------------------------------------------------------------------- public void test_anzahlVerschiedene() { try { Method m = kob.getDeclaredMethod("anzahlVerschiedene", int[].class); int[] ir01 = {10,20,30,40,50}; int[] ir02 = {10,20,20,10,50}; int[] ir03 = {10,10,10}; int[] ir04 = {10}; int[] ir05 = {}; assertEquals(5, (int) m.invoke(null, ir01)); assertEquals(3, (int) m.invoke(null, ir02)); assertEquals(1, (int) m.invoke(null, ir03)); assertEquals(1, (int) m.invoke(null, ir04)); assertEquals(0, (int) m.invoke(null, ir05)); } catch (Exception ex) { throw new Error("Ausnahme in test_anzahlVerschiedene", ex); } } // test_anzahlVerschiedene // --------------------------------------------------------------------- public void test_enthaelt() { try { Method m = kob.getDeclaredMethod("enthaelt", int[].class, int[].class); int[] ir01 = {10,20,30,40,50}; int[] ir02 = {50,10,50,10,50}; int[] ir03 = {30,20,10}; int[] ir04 = {10,60,10}; int[] ir05 = {40}; int[] ir06 = {60}; int[] ir07 = {}; assertEquals(true , (boolean) m.invoke(null, ir01, ir02)); assertEquals(true , (boolean) m.invoke(null, ir01, ir03)); assertEquals(false, (boolean) m.invoke(null, ir01, ir04)); assertEquals(true , (boolean) m.invoke(null, ir01, ir05)); assertEquals(false, (boolean) m.invoke(null, ir01, ir06)); assertEquals(true , (boolean) m.invoke(null, ir01, ir07)); assertEquals(false, (boolean) m.invoke(null, ir02, ir01)); assertEquals(true , (boolean) m.invoke(null, ir06, ir07)); assertEquals(true , (boolean) m.invoke(null, ir07, ir07)); } catch (Exception ex) { throw new Error("Ausnahme in test_enthaelt", ex); } } // test_enthaelt // --------------------------------------------------------------------- public void test_vereinigung() { try { Method m = kob.getDeclaredMethod("vereinigung", int[].class, int[].class); int[] ir01 = {10, 30, 50, 70}; int[] ir02 = {10,20, 40,50,60,70}; int[] ir03 = { 20, 50, 70}; int[] ir04 = {10,20,30,40,50,60,70}; int[] ir05 = { 20, 40, 60 }; int[] ir06 = { }; int[] er01 = {10,20,30,40,50,60,70}; int[] er02 = {10,20, 40,50,60,70}; int[] er03 = {10,20,30,40,50,60,70}; int[] er04 = {10,20,30,40,50,60,70}; int[] er05 = { 20, 40, 60 }; assertEqualsIR(er01, (int[]) m.invoke(null, ir01, ir02)); assertEqualsIR(er02, (int[]) m.invoke(null, ir02, ir03)); assertEqualsIR(er03, (int[]) m.invoke(null, ir03, ir04)); assertEqualsIR(er04, (int[]) m.invoke(null, ir04, ir05)); assertEqualsIR(er05, (int[]) m.invoke(null, ir05, ir06)); } catch (Exception ex) { throw new Error("Ausnahme in test_vereinigung", ex); } } // test_vereinigung // --------------------------------------------------------------------- public void test_durchschnitt() { try { Method m = kob.getDeclaredMethod("durchschnitt", int[].class, int[].class); int[] ir01 = {10, 30, 50, 70}; int[] ir02 = {10,20, 40,50,60,70}; int[] ir03 = { 20, 50, 70}; int[] ir04 = {10,20,30,40,50,60,70}; int[] ir05 = { 20, 40, 60 }; int[] ir06 = { }; int[] er01 = {10, 50, 70}; int[] er02 = { 20, 50, 70}; int[] er03 = { 20, 50, 70}; int[] er04 = { 20, 40, 60 }; int[] er05 = { }; assertEqualsIR(er01, (int[]) m.invoke(null, ir01, ir02)); assertEqualsIR(er02, (int[]) m.invoke(null, ir02, ir03)); assertEqualsIR(er03, (int[]) m.invoke(null, ir03, ir04)); assertEqualsIR(er04, (int[]) m.invoke(null, ir04, ir05)); assertEqualsIR(er05, (int[]) m.invoke(null, ir05, ir06)); } catch (Exception ex) { throw new Error("Ausnahme in test_durchschnitt", ex); } } // test_durchschnitt // --------------------------------------------------------------------- public void test_differenz() { try { Method m = kob.getDeclaredMethod("differenz", int[].class, int[].class); int[] ir01 = {10 ,30, 50, 70}; int[] ir02 = {10,20, 40,50,60,70}; int[] ir03 = { 20, 50, 70}; int[] ir04 = {10,20,30,40,50,60,70}; int[] ir05 = { 20, 40, 60 }; int[] ir06 = { }; int[] er01 = { 30 }; int[] er02 = {10, 40, 60 }; int[] er03 = { }; int[] er04 = {10, 30, 50, 70}; int[] er05 = { 20, 40, 60 }; assertEqualsIR(er01, (int[]) m.invoke(null, ir01, ir02)); assertEqualsIR(er02, (int[]) m.invoke(null, ir02, ir03)); assertEqualsIR(er03, (int[]) m.invoke(null, ir03, ir04)); assertEqualsIR(er04, (int[]) m.invoke(null, ir04, ir05)); assertEqualsIR(er05, (int[]) m.invoke(null, ir05, ir06)); // int[] ir01 = {10,20,30,40}; // int[] ir02 = {10,20,50}; // int[] ir03 = {20,50}; // int[] ir04 = {20}; // int[] ir05 = {}; // int[] ir06 = {10,20,30,40}; // // int[] er02 = {30,40}; // int[] er03 = {10,30,40}; // int[] er04 = {10,30,40}; // int[] er05 = {10,20,30,40}; // int[] er06 = {}; // // assertEqualsIR(er02, (int[]) m.invoke(null, ir01, ir02)); // assertEqualsIR(er03, (int[]) m.invoke(null, ir01, ir03)); // assertEqualsIR(er04, (int[]) m.invoke(null, ir01, ir04)); // assertEqualsIR(er05, (int[]) m.invoke(null, ir01, ir05)); // assertEqualsIR(er06, (int[]) m.invoke(null, ir05, ir06)); } catch (Exception ex) { throw new Error("Ausnahme in test_differenz", ex); } } // test_differenz // --------------------------------------------------------------------- public void test_symmetrischeDifferenz() { try { Method m = kob.getDeclaredMethod("symmetrischeDifferenz", int[].class, int[].class); int[] ir01 = {10 ,30, 50, 70}; int[] ir02 = {10,20, 40,50,60,70}; int[] ir03 = { 20, 50, 70}; int[] ir04 = {10,20,30,40,50,60,70}; int[] ir05 = { 20, 40, 60 }; int[] ir06 = { }; int[] er01 = { 20,30,40, 60 }; int[] er02 = {10, 40, 60 }; int[] er03 = {10, 30,40, 60 }; int[] er04 = {10, 30, 50, 70}; int[] er05 = { 20, 40, 60 }; assertEqualsIR(er01, (int[]) m.invoke(null, ir01, ir02)); assertEqualsIR(er02, (int[]) m.invoke(null, ir02, ir03)); assertEqualsIR(er03, (int[]) m.invoke(null, ir03, ir04)); assertEqualsIR(er04, (int[]) m.invoke(null, ir04, ir05)); assertEqualsIR(er05, (int[]) m.invoke(null, ir05, ir06)); assertEqualsIR(er01, (int[]) m.invoke(null, ir02, ir01)); assertEqualsIR(er02, (int[]) m.invoke(null, ir03, ir02)); assertEqualsIR(er03, (int[]) m.invoke(null, ir04, ir03)); assertEqualsIR(er04, (int[]) m.invoke(null, ir05, ir04)); assertEqualsIR(er05, (int[]) m.invoke(null, ir06, ir05)); } catch (Exception ex) { throw new Error("Ausnahme in test_symmetrischeDifferenz", ex); } } // test_symmetrischeDifferenz // --------------------------------------------------------------------- void assertEqualsIR(int[] soll, int[] ist) { // Dieser assert-Befehl gelingt, wenn die Variablen soll und ist // beide den Wert null haben oder // auf zwei Reihungen zeigen, die gleich lang sind und // gleiche Komponenten (eventuell in unterschiedlichen Reihenfolgen) // enthalten. if (soll==null && ist==null) return; String msg1 = format("Expected <%s> but was <%s>", soll, ist); if (soll==null || ist==null) fail(msg1); String msg2 = format("Expected array length <%d> but was <%d>", soll.length, ist.length); if (soll.length != ist.length) fail(msg2); String msg3 = format("Expected <%s> but was <%s>", Arrays.toString(soll), Arrays.toString(ist)); // Die "Reihenfolge normieren": Arrays.sort(soll); Arrays.sort(ist); for (int i=0; i kob; static { // Dies ist ein Klassen-Initialisierer (static initialiser) try { kob = Class.forName(KLASSEN_NAME); Method set =kob.getDeclaredMethod("set_zum_bildschirm", Boolean.TYPE); set.invoke(null, true); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } catch (Exception ex) { printf("-------------------------------------------------%n"); printf("Kann %s.set_zum_bildschirm nicht aufrufen!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-2); } } // Klassen-Initialisierer // --------------------------------------------------------------------- // Globale Variablen, die in setUp initialisiert werden: int [] ir00; int [] ir01; int [] ir02; int [] ir03; String[] sr00; String[] sr01; String[] sr02; String[] sr03; // --------------------------------------------------------------------- public void setUp() { ir00 = null; ir01 = new int[0]; ir02 = new int[]{10, 20, 30}; sr00 = null; sr01 = new String[0]; sr02 = new String[]{"AA", "B", "CCC"}; sr03 = new String[]{null, "AA", null}; try { Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); h.invoke(null); } catch (Exception ex) { throw new Error("Ausnahme in setUp", ex); } } // --------------------------------------------------------------------- public void test_printRI() { try { Method m = kob.getDeclaredMethod("printR", int[].class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL00 = "null"; final String SOLL01 = "[]"; final String SOLL02 = "[10, 20, 30]"; m.invoke(null, ir00); final String IST00 = (String) h.invoke(null); assertEquals(SOLL00, IST00); m.invoke(null, ir01); final String IST01 = (String) h.invoke(null); assertEquals(SOLL01, IST01); m.invoke(null, ir02); final String IST02 = (String) h.invoke(null); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_printRI", ex); } } // test_printRI // --------------------------------------------------------------------- public void test_min() { try { Method m = kob.getDeclaredMethod("min", int[].class); final Integer SOLL00 = Integer.MAX_VALUE; final Integer SOLL01 = Integer.MAX_VALUE; final Integer SOLL02 = 10; Integer IST00 = (Integer) m.invoke(null, ir00); assertEquals(SOLL00, IST00); Integer IST01 = (Integer) m.invoke(null, ir01); assertEquals(SOLL01, IST01); Integer IST02 = (Integer) m.invoke(null, ir02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_min", ex); } } // test_min // --------------------------------------------------------------------- public void test_mindEineGerade() { try { Method m = kob.getDeclaredMethod("mindEineGerade", int[].class); assertEquals(false, m.invoke(null, ir00)); assertEquals(false, m.invoke(null, ir01)); assertEquals(true, m.invoke(null, ir02)); int[] ir10 = {-17, 3, 0, 5, -7}; int[] ir11 = { 17, -3, 1, -5, 7}; assertEquals(true, m.invoke(null, ir10)); assertEquals(false, m.invoke(null, ir11)); } catch (Exception ex) { throw new Error("Ausnahme in test_mindEineGerade", ex); } } // test_mindEineGerade // --------------------------------------------------------------------- public void test_alleGerade() { try { Method m = kob.getDeclaredMethod("alleGerade", int[].class); assertEquals(true, m.invoke(null, ir00)); assertEquals(true, m.invoke(null, ir01)); assertEquals(true, m.invoke(null, ir02)); int[] ir10 = {-18, 4, 1, 6, -8}; int[] ir11 = { 18, -4, 0, -6, 8}; assertEquals(false, m.invoke(null, ir10)); assertEquals(true, m.invoke(null, ir11)); } catch (Exception ex) { throw new Error("Ausnahme in test_alleGerade", ex); } } // test_alleGerade // --------------------------------------------------------------------- public void test_kommtVor() { try { Method m = kob.getDeclaredMethod("kommtVor", Integer.TYPE, int[].class); assertEquals(false, m.invoke(null, 20, ir00)); assertEquals(false, m.invoke(null, 20, ir01)); assertEquals(true, m.invoke(null, 20, ir02)); int[] ir10 = {-18, 4, 1, 6, -8}; int[] ir11 = { 18, -4, 0, -6, 8}; assertEquals(true, m.invoke(null, -18, ir10)); assertEquals(true, m.invoke(null, 1, ir10)); assertEquals(true, m.invoke(null, -8, ir10)); assertEquals(false, m.invoke(null, 5, ir10)); assertEquals(true, m.invoke(null, -4, ir11)); assertEquals(true, m.invoke(null, 8, ir11)); assertEquals(false, m.invoke(null, 1, ir11)); } catch (Exception ex) { throw new Error("Ausnahme in test_kommtVor", ex); } } // test_kommtVor // --------------------------------------------------------------------- public void test_index() { try { Method m = kob.getDeclaredMethod("index", Integer.TYPE, int[].class); assertEquals(-1, m.invoke(null, 20, ir00)); assertEquals(-1, m.invoke(null, 20, ir01)); assertEquals( 1, m.invoke(null, 20, ir02)); int[] ir10 = {-18, 4, 1, 6, -8}; int[] ir11 = { 18, -4, 0, -6, 8}; assertEquals( 0, m.invoke(null, -18, ir10)); assertEquals( 2, m.invoke(null, 1, ir10)); assertEquals( 4, m.invoke(null, -8, ir10)); assertEquals(-1, m.invoke(null, 5, ir10)); assertEquals( 1, m.invoke(null, -4, ir11)); assertEquals( 4, m.invoke(null, 8, ir11)); assertEquals(-1, m.invoke(null, 1, ir11)); } catch (Exception ex) { throw new Error("Ausnahme in test_index", ex); } } // test_index // --------------------------------------------------------------------- public void test_pAlleDurch2() { try { Method m = kob.getDeclaredMethod("pAlleDurch2", int[].class); final int[] SOLL00 = null; final int[] SOLL01 = {}; final int[] SOLL02 = {5, 10, 15}; m.invoke(null, ir00); assertEqualsIR(SOLL00, ir00); m.invoke(null, ir01); assertEqualsIR(SOLL01, ir01); m.invoke(null, ir02); assertEqualsIR(SOLL02, ir02); int[] ir10 = {-17, 3, 0, 6, -8}; int[] ir11 = { 17, -3, 1, -6, 8}; final int[] SOLL10 = {-8, 1, 0, 3, -4}; final int[] SOLL11 = { 8, -1, 0, -3, 4}; m.invoke(null, ir10); assertEqualsIR(SOLL10, ir10); m.invoke(null, ir11); assertEqualsIR(SOLL11, ir11); } catch (Exception ex) { throw new Error("Ausnahme in test_pAlleDurch2", ex); } } // test_pAlleDurch2 // --------------------------------------------------------------------- public void test_fAlleDurch2() { try { Method m = kob.getDeclaredMethod("fAlleDurch2", int[].class); final int[] SOLL00 = null; final int[] SOLL01 = {}; final int[] SOLL02 = {5, 10, 15}; final int[] ORIG02 = Arrays.copyOf(ir02, ir02.length); final int[] IST00 = (int[]) m.invoke(null, ir00); assertEqualsIR(SOLL00, IST00); final int[] IST01 = (int[]) m.invoke(null, ir01); assertEqualsIR(SOLL01, IST01); final int[] IST02 = (int[]) m.invoke(null, ir02); assertEqualsIR(SOLL02, IST02); assertEqualsIR(ORIG02, ir02); int[] ir10 = {-17, 3, 0, 6, -8}; int[] ir11 = { 17, -3, 1, -6, 8}; final int[] ORIG10 = Arrays.copyOf(ir10, ir10.length); final int[] ORIG11 = Arrays.copyOf(ir11, ir11.length); final int[] SOLL10 = {-8, 1, 0, 3, -4}; final int[] SOLL11 = { 8, -1, 0, -3, 4}; final int[] IST10 = (int[]) m.invoke(null, ir10); assertEqualsIR(SOLL10, IST10); assertEqualsIR(ORIG10, ir10); final int[] IST11 = (int[]) m.invoke(null, ir11); assertEqualsIR(SOLL11, IST11); assertEqualsIR(ORIG11, ir11); } catch (Exception ex) { throw new Error("Ausnahme in test_fAlleDurch2", ex); } } // test_fAlleDurch2 // --------------------------------------------------------------------- public void test_sindGleich() { try { Method m = kob.getDeclaredMethod("sindGleich", int[].class, int[].class); assertEquals(true, m.invoke(null, ir00, ir00)); assertEquals(true, m.invoke(null, ir01, ir01)); assertEquals(true, m.invoke(null, ir02, ir02)); assertEquals(false, m.invoke(null, ir00, ir01)); assertEquals(false, m.invoke(null, ir00, ir02)); assertEquals(false, m.invoke(null, ir01, ir00)); assertEquals(false, m.invoke(null, ir01, ir02)); assertEquals(false, m.invoke(null, ir02, ir00)); assertEquals(false, m.invoke(null, ir02, ir01)); int[] ir10 = {-18, 4, 1, 6, -8}; int[] ir11 = {-18, 4, 1, 6, -8}; int[] ir12 = {-18, 4, 1, 7, -8}; assertEquals(true, m.invoke(null, ir11, ir10)); assertEquals(true, m.invoke(null, ir10, ir11)); assertEquals(false, m.invoke(null, ir10, ir12)); assertEquals(false, m.invoke(null, ir12, ir10)); } catch (Exception ex) { throw new Error("Ausnahme in test_sindGleich", ex); } } // test_sindGleich // --------------------------------------------------------------------- public void test_sindDisjunkt() { try { Method m = kob.getDeclaredMethod("sindDisjunkt", int[].class, int[].class); assertEquals(true, m.invoke(null, ir00, ir00)); assertEquals(true, m.invoke(null, ir01, ir01)); assertEquals(false, m.invoke(null, ir02, ir02)); assertEquals(true, m.invoke(null, ir00, ir01)); assertEquals(true, m.invoke(null, ir00, ir02)); assertEquals(true, m.invoke(null, ir01, ir00)); assertEquals(true, m.invoke(null, ir01, ir02)); assertEquals(true, m.invoke(null, ir02, ir00)); assertEquals(true, m.invoke(null, ir02, ir01)); int[] ir10 = {-18, 4, 1, 6, -8}; int[] ir11 = {-19, 5, 2, 7, -9}; int[] ir12 = {-19, 5, 2, 4, -9}; assertEquals(true, m.invoke(null, ir11, ir10)); assertEquals(true, m.invoke(null, ir10, ir11)); assertEquals(false, m.invoke(null, ir10, ir12)); assertEquals(false, m.invoke(null, ir12, ir10)); } catch (Exception ex) { throw new Error("Ausnahme in test_sindDisjunkt", ex); } } // test_sindDisjunkt // --------------------------------------------------------------------- public void test_printRS() { try { Method m = kob.getDeclaredMethod("printR", String[].class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL00 = "null"; final String SOLL01 = "[]"; final String SOLL02 = "[\"AA\", \"B\", \"CCC\"]"; final String SOLL03 = "[null, \"AA\", null]"; m.invoke(null, (Object) sr00); final String IST00 = (String) h.invoke(null); assertEquals(SOLL00, IST00); m.invoke(null, (Object) sr01); final String IST01 = (String) h.invoke(null); assertEquals(SOLL01, IST01); m.invoke(null, (Object) sr02); final String IST02 = (String) h.invoke(null); assertEquals(SOLL02, IST02); m.invoke(null, (Object) sr03); final String IST03 = (String) h.invoke(null); assertEquals(SOLL03, IST03); } catch (Exception ex) { throw new Error("Ausnahme in test_printRS", ex); } } // test_printRS // --------------------------------------------------------------------- void assertEqualsIR(int[] soll, int[] ist) { // Dieser assert-Befehl gelingt, wenn die Variablen soll und ist // beide den Wert null haben oder // auf zwei Reihungen zeigen, die gleich lang sind und // "Komponente fuer Komponente" gleich sind. if (soll==null && ist==null) return; String msg1 = format("Expected <%s> but was <%s>", soll, ist); if (soll==null || ist==null) fail(msg1); String msg2 = format("Expected array length <%d> but was <%d>", soll.length, ist.length); if (soll.length != ist.length) fail(msg2); String msg3 = format("Expected <%s> but was <%s>", Arrays.toString(soll), Arrays.toString(ist)); for (int i=0; i kob; static { // Dies ist ein Klassen-Initialisierer (static initialiser) try { kob = Class.forName(KLASSEN_NAME); Method set =kob.getDeclaredMethod("set_zum_bildschirm", Boolean.TYPE); set.invoke(null, true); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } catch (Exception ex) { printf("-------------------------------------------------%n"); printf("Kann %s.set_zum_bildschirm nicht aufrufen!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } } // Klassen-Initialisierer // --------------------------------------------------------------------- // Globale Variablen, die in setUp initialisiert werden: int [][] irr00; int [][] irr01; int [][] irr02; int [][] irr03; // --------------------------------------------------------------------- public void setUp() { irr00 = new int[0][]; irr01 = new int[][]{{10, 11, 12}, {20, 21}, {30, 31, 32, 33}}; irr02 = new int[][]{{10, 20, 30}, {}, {40, 50, 60}, {70, 80}, {90}}; } // --------------------------------------------------------------------- public void test_summe() { try { Method m = kob.getDeclaredMethod("summe", int[][].class); final Integer SOLL00 = 0; final Integer SOLL01 = 200; final Integer SOLL02 = 450; final Integer IST00 = (Integer) m.invoke(null, (Object) irr00); assertEquals(SOLL00, IST00); final Integer IST01 = (Integer) m.invoke(null, (Object) irr01); assertEquals(SOLL01, IST01); final Integer IST02 = (Integer) m.invoke(null, (Object) irr02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_summe", ex); } } // test_summe // --------------------------------------------------------------------- public void test_alleGerade() { try { Method m = kob.getDeclaredMethod("alleGerade", int[][].class); final Boolean SOLL00 = true; final Boolean SOLL01 = false; final Boolean SOLL02 = true; final Boolean IST00 = (Boolean) m.invoke(null, (Object) irr00); assertEquals(SOLL00, IST00); final Boolean IST01 = (Boolean) m.invoke(null, (Object) irr01); assertEquals(SOLL01, IST01); final Boolean IST02 = (Boolean) m.invoke(null, (Object) irr02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_alleGerade", ex); } } // test_alleGerade // --------------------------------------------------------------------- public void test_anzahlGerade() { try { Method m = kob.getDeclaredMethod("anzahlGerade", int[][].class); final Integer SOLL00 = 0; final Integer SOLL01 = 5; final Integer SOLL02 = 9; final Integer IST00 = (Integer) m.invoke(null, (Object) irr00); assertEquals(SOLL00, IST00); final Integer IST01 = (Integer) m.invoke(null, (Object) irr01); assertEquals(SOLL01, IST01); final Integer IST02 = (Integer) m.invoke(null, (Object) irr02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_anzahlGerade", ex); } } // test_anzahlGerade // --------------------------------------------------------------------- public void test_kommtVor() { try { Method m = kob.getDeclaredMethod("kommtVor", Integer.TYPE, int[][].class); final Boolean SOLL00 = false; final Boolean SOLL01 = false; final Boolean SOLL02 = true; final Boolean IST00 = (Boolean) m.invoke(null, 17, (Object) irr00); assertEquals(SOLL00, IST00); final Boolean IST01 = (Boolean) m.invoke(null, 35, (Object) irr01); assertEquals(SOLL01, IST01); final Boolean IST02 = (Boolean) m.invoke(null, 90, (Object) irr02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_kommtVor", ex); } } // test_kommtVor // --------------------------------------------------------------------- public void test_anzahlKomponenten() { try { Method m = kob.getDeclaredMethod("anzahlKomponenten", int[][].class); final Integer SOLL00 = 0; final Integer SOLL01 = 9; final Integer SOLL02 = 9; final Integer IST00 = (Integer) m.invoke(null, (Object) irr00); assertEquals(SOLL00, IST00); final Integer IST01 = (Integer) m.invoke(null, (Object) irr01); assertEquals(SOLL01, IST01); final Integer IST02 = (Integer) m.invoke(null, (Object) irr02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_anzahlKomponenten", ex); } } // test_anzahlKomponenten // --------------------------------------------------------------------- public void test_printRR() { try { String[][] sr00 = null; String[][] sr01 = {}; String[][] sr02 = {{"ABC"}}; String[][] sr03 = {{}, {}, {}}; String[][] sr04 = {{"AB", "C", "DEF"}, {"G", "HI"}}; String[][] sr05 = {null, {"A", "B"}, null, null}; Method m = kob.getDeclaredMethod("printRR", String[][].class); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL00 = "null"; final String SOLL01 = "[]"; final String SOLL02 = "[[\"ABC\"]]"; final String SOLL03 = "[[], [], []]"; final String SOLL04 = "[[\"AB\", \"C\", \"DEF\"], [\"G\", \"HI\"]]"; final String SOLL05 = "[null, [\"A\", \"B\"], null, null]"; m.invoke(null, (Object) sr00); final String IST00 = (String) h.invoke(null); assertEquals(SOLL00, IST00); m.invoke(null, (Object) sr01); final String IST01 = (String) h.invoke(null); assertEquals(SOLL01, IST01); m.invoke(null, (Object) sr02); final String IST02 = (String) h.invoke(null); assertEquals(SOLL02, IST02); m.invoke(null, (Object) sr03); final String IST03 = (String) h.invoke(null); assertEquals(SOLL03, IST03); m.invoke(null, (Object) sr04); final String IST04 = (String) h.invoke(null); assertEquals(SOLL04, IST04); m.invoke(null, (Object) sr05); final String IST05 = (String) h.invoke(null); assertEquals(SOLL05, IST05); } catch (Exception ex) { throw new Error("Ausnahme in test_printRR", ex); } } // test_printRR // --------------------------------------------------------------------- public void test_anzBuchstaben() { try { String[] sr00 = {}; String[] sr01 = {"A1B2C"}; String[] sr02 = {"de", "1F2", "G!h:I"}; Method m = kob.getDeclaredMethod("anzBuchstaben", String[].class); final Integer SOLL00 = 0; final Integer SOLL01 = 3; final Integer SOLL02 = 6; final Integer IST00 = (Integer) m.invoke(null, (Object) sr00); assertEquals(SOLL00, IST00); final Integer IST01 = (Integer) m.invoke(null, (Object) sr01); assertEquals(SOLL01, IST01); final Integer IST02 = (Integer) m.invoke(null, (Object) sr02); assertEquals(SOLL02, IST02); } catch (Exception ex) { throw new Error("Ausnahme in test_anzBuchstaben", ex); } } // test_anzBuchstaben // --------------------------------------------------------------------- static public void main(String... sonja) throws Exception { printf("Getestet wird die Klasse %s%n", KLASSEN_NAME); junit.awtui.TestRunner.run(UebReihungenB_Jut.class); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebReihungenB_Jut *************************************************************************** // Datei UebMethodenA.java /* ------------------------------------------------------------------------ In diese Klasse UebMethodenA kann man Ruempfe fuer bestimmte Methoden eintragen und dann mit dem Testprogramm UebMethodenA_Jut testen. ACHTUNG: Fuer die Methoden gibAus und alleRechtwinklingen gilt: Alle Ausgaben sollen mit dem Befehl pln durchgefuehrt werden. Der Befehl p oder andere Ausgabebefehle sollen dort NICHT benutzt werden. In der main-Methode koennen Sie alle Ausgabebefehle (p, pln, printf) benutzen, ganz wie Sie wollen. ------------------------------------------------------------------------ */ public class UebMethodenA { // --------------------------------------------------------------------- static public int summe(int n1, int n2) { // Liefert die Summe von n1 und n2 return -999; // SOLL ERSETZT WERDEN } // summe // --------------------------------------------------------------------- static public void gibAus(int a, int b, int c) { // Gibt die Namen der Parameter (jeden auf einer neuen Zeile) gefolgt // von einem Doppelpunkt ":" und dem Wert des Parameters aus // (mit dem Befehl pln) z.B. so: // // a: 17 // b: -22 // c: 5 pln("Noch nicht fertig!"); // SOLL ERSETZT WERDEN } // gibAus // --------------------------------------------------------------------- static public int hochZwei(int grundzahl) { // Liefert folgenden Wert: grundzahl hoch 2. return -999; // SOLL ERSETZT WERDEN } // hochZwei // --------------------------------------------------------------------- static public int zweiHoch(int exponent) { // Liefert folgenden Wert: 2 hoch exponent. // Falls der exponent kleiner oder gleich 0 ist, wird 1 als // Ergebnis geliefert. return -999; // SOLL ERSETZT WERDEN } // zweiHoch // --------------------------------------------------------------------- static public int hoch(int grundzahl, int exponent) { // Liefert folgenden Wert: grundzahl hoch exponent. // Falls der exponent kleiner oder gleich 0 ist, wird 1 als // Ergebnis geliefert. return -999; // SOLL ERSETZT WERDEN } // hoch // --------------------------------------------------------------------- static public boolean istPrim(final int N) { // Liefert true, falls N prim ist, und sonst false. // Prueft nur Zahlen bis zur (Quadratwurzel aus N) als Teiler. // Behandelt alle geraden Zahlen "vorweg" als Sonderfälle. // Der Parameter N wurde als final ("konstant") vereinbart, // damit der Ausfuehrer unten in der for-Schleife // Math.sqrt(N) nur einmal berechnen muss. return false; // SOLL ERSETZT WERDEN } // istPrim // --------------------------------------------------------------------- static public int primDoublette(int minimum) { // Liefert die kleinste Primzahl p fuer die gilt: // p ist groesser oder gleich minimum // p ist ist eine Primzahl // p+2 ist auch eine Primzahl // Gibt es keine solche Primzahl p, wird 0 als Ergebnis geliefert. return -999; // SOLL ERSETZT WERDEN } // primDoublette // --------------------------------------------------------------------- static public void alleRechtwinkligen() { // Gibt alle Ganzzahltripel (a, b, c) aus fuer die gilt: // 1. a, b und c liegen zwischen 1 und MAX (einschliesslich) // 2. a ist groesser/gleich b und b ist groesser/gleich c // 3. Es gilt: a*a + b*b == c*c (Pythagoras) // Die Ausgabe *eines* solchen Ganzzahltripels sieht etwa so aus: // // Nr. 19: 50, 40, 30 // // und endet mit einem Zeilenwechsel (wird von pln erledigt). final int MAX = 100; int nr = 0; pln("Noch nicht fertig!"); // SOLL ERSETZT WERDEN } // alleRechtwinkligen // ===================================================================== // Der StringBuilder bildschirm taeuscht einen zweiten Bildschirm vor: // Die Methoden namens p und pln geben ihre Daten voreingestellt zur // Standardausgabe (Bildschirm) aus. Nur wenn das Attribut zum_bildschirm // auf true gesetzt wurde (z.B. mit der Methode set_zum_bildschirm), // "geben sie zum bildschirm aus" (und nicht zum Bildschirm!). // Das Testprogramm UebMethodenA_Jut setzt zum_bildschirm auf true. static boolean zum_bildschirm = false; static StringBuilder bildschirm = new StringBuilder(); static void p (Object ob) { if (zum_bildschirm) { bildschirm.append(ob.toString()); // gib zum bildschirm aus } else { System.out.print(ob); // gib zum Bildschirm aus } } static void pln(Object ob) { if (zum_bildschirm) { bildschirm.append(ob.toString() + "\n"); } else { System.out.println(ob); } } static void pln() { if (zum_bildschirm) { bildschirm.append("\n"); } else { System.out.println(); } } // --------------------------------------------------------------------- static void set_zum_bildschirm(boolean b) {zum_bildschirm=b;} // --------------------------------------------------------------------- static String holeUndLoescheBildschirmInhalt() { String erg = bildschirm.toString(); // Inhalt holen bildschirm.delete(0, bildschirm.length()); // bildschirm loeschen return erg; } // holeUndLoescheBildschirmInhalt // --------------------------------------------------------------------- static public void main(String [] sonja) { printf("-------------------------------------------------%n"); printf("Diese Klasse UebMethodenA kann man testen mit dem%n"); printf("Testprogramm UebMethodenA_Jut.java !%n"); printf("-------------------------------------------------%n"); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: // (gibt zum Bildschirm aus, nicht zum bildschirm!): static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebMethodenA *************************************************************************** // Datei UebMethodenA_Jut.java /* ------------------------------------------------------------------------ Ein Programm zum Testen der Klassen UebMethodenA und UebMethodenA_Loes. Erstellt mit und fuer JUnit Version 3.8. ------------------------------------------------------------------------ */ import junit.framework.Test; // Eine Schnittstelle import junit.framework.TestCase; // Eine Test-Klasse import junit.framework.TestSuite; // Eine Test-Klasse import java.lang.reflect.Method; public class UebMethodenA_Jut extends TestCase { // --------------------------------------------------------------------- // Welche Klasse soll getestet werden, UebMethodenA oder UebMethodenA_Loes? static String KLASSEN_NAME = "UebMethodenA"; static Class kob; static { // Dies ist ein Klassen-Initialisierer (static initialiser) try { kob = Class.forName(KLASSEN_NAME); Method set =kob.getDeclaredMethod("set_zum_bildschirm", Boolean.TYPE); set.invoke(null, true); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } catch (Exception ex) { printf("-------------------------------------------------%n"); printf("Kann %s.set_zum_bildschirm nicht aufrufen!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); } } // --------------------------------------------------------------------- public void test_summe() { try { Method m = kob.getDeclaredMethod("summe", Integer.TYPE, Integer.TYPE); assertEquals("Arg 1, 2", 3, m.invoke(null, 1, 2)); assertEquals("Arg 17, 4", 21, m.invoke(null, 17, 4)); assertEquals("Arg -8, 8", 0, m.invoke(null, -8, 8)); assertEquals("Arg 0, 0", 0, m.invoke(null, 0, 0)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta01", ex); } } // test_summe // --------------------------------------------------------------------- public void test_gibAus() { try { // Parameter-Typen der Methode gibAus: Class[] pt = {Integer.TYPE,Integer.TYPE,Integer.TYPE}; Method m = kob.getDeclaredMethod("gibAus", pt); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); final String SOLL1 = "a: 1\nb: 2\nc: 3\n"; final String SOLL2 = "a: 123\nb: 456\nc: 789\n"; final String SOLL3 = "a: -10\nb: 20\nc: -30\n"; m.invoke(null, 1, 2, 3); final String IST1 = (String) h.invoke("null"); assertEquals(SOLL1, IST1); m.invoke(null, 123, 456, 789); final String IST2 = (String) h.invoke("null"); assertEquals(SOLL2, IST2); m.invoke(null, -10, 20, -30); final String IST3 = (String) h.invoke("null"); assertEquals(SOLL3, IST3); } catch (Exception ex) { throw new Error("Ausnahme in test_gibAus", ex); } } // test_gibAus // --------------------------------------------------------------------- public void test_hochZwei() { try { Method m = kob.getDeclaredMethod("hochZwei", Integer.TYPE); assertEquals("Arg 0,", 0, m.invoke(null, 0)); assertEquals("Arg 1,", 1, m.invoke(null, 1)); assertEquals("Arg 2,", 4, m.invoke(null, 2)); assertEquals("Arg 3,", 9, m.invoke(null, 3)); assertEquals("Arg -1,", 1, m.invoke(null, -1)); assertEquals("Arg -2,", 4, m.invoke(null, -2)); assertEquals("Arg -3,", 9, m.invoke(null, -3)); } catch (Exception ex) { throw new Error("Ausnahme in test_ta03", ex); } } // test_hochZwei // --------------------------------------------------------------------- public void test_zweiHoch() { try { Method m = kob.getDeclaredMethod("zweiHoch", Integer.TYPE); assertEquals("Arg 0,", 1, m.invoke(null, 0)); assertEquals("Arg 1,", 2, m.invoke(null, 1)); assertEquals("Arg 2,", 4, m.invoke(null, 2)); assertEquals("Arg 3,", 8, m.invoke(null, 3)); assertEquals("Arg -1,", 1, m.invoke(null, -1)); assertEquals("Arg -2,", 1, m.invoke(null, -2)); assertEquals("Arg -3,", 1, m.invoke(null, -3)); } catch (Exception ex) { throw new Error("Ausnahme in test_zweiHoch", ex); } } // test_zweiHoch // --------------------------------------------------------------------- public void test_hoch() { try { Method m = kob.getDeclaredMethod("hoch", Integer.TYPE, Integer.TYPE); assertEquals("Arg 0, -1", 1, m.invoke(null, 0, -1)); assertEquals("Arg 0, 0", 1, m.invoke(null, 0, 0)); assertEquals("Arg 0, 1", 0, m.invoke(null, 0, 1)); assertEquals("Arg 0, 2", 0, m.invoke(null, 0, 2)); assertEquals("Arg 1, -1", 1, m.invoke(null, 1, -1)); assertEquals("Arg 1, 0", 1, m.invoke(null, 1, 0)); assertEquals("Arg 1, 1", 1, m.invoke(null, 1, 1)); assertEquals("Arg 1, 2", 1, m.invoke(null, 1, 2)); assertEquals("Arg 2, -1", 1, m.invoke(null, 2, -1)); assertEquals("Arg 2, 0", 1, m.invoke(null, 2, 0)); assertEquals("Arg 2, 1", 2, m.invoke(null, 2, 1)); assertEquals("Arg 2, 2", 4, m.invoke(null, 2, 2)); assertEquals("Arg 2, 3", 8, m.invoke(null, 2, 3)); assertEquals("Arg -2, -1", 1, m.invoke(null, -2, -1)); assertEquals("Arg -2, 0", 1, m.invoke(null, -2, 0)); assertEquals("Arg -2, 1", -2, m.invoke(null, -2, 1)); assertEquals("Arg -2, 2", 4, m.invoke(null, -2, 2)); assertEquals("Arg -2, 3", -8, m.invoke(null, -2, 3)); assertEquals("Arg 3, -1", 1, m.invoke(null, 3, -1)); assertEquals("Arg 3, 0", 1, m.invoke(null, 3, 0)); assertEquals("Arg 3, 1", 3, m.invoke(null, 3, 1)); assertEquals("Arg 3, 2", 9, m.invoke(null, 3, 2)); assertEquals("Arg 3, 3", 27, m.invoke(null, 3, 3)); assertEquals("Arg -3, -1", 1, m.invoke(null, -3, -1)); assertEquals("Arg -3, 0", 1, m.invoke(null, -3, 0)); assertEquals("Arg -3, 1", -3, m.invoke(null, -3, 1)); assertEquals("Arg -3, 2", 9, m.invoke(null, -3, 2)); assertEquals("Arg -3, 3",-27, m.invoke(null, -3, 3)); } catch (Exception ex) { throw new Error("Ausnahme in test_hoch", ex); } } // test_hoch // --------------------------------------------------------------------- public void test_istPrim() { try { Method m = kob.getDeclaredMethod("istPrim", Integer.TYPE); assertEquals("Arg -2,", false, m.invoke(null, -2)); assertEquals("Arg -1,", false, m.invoke(null, -1)); assertEquals("Arg 0,", false, m.invoke(null, 0)); assertEquals("Arg 1,", false, m.invoke(null, 1)); assertEquals("Arg 2,", true, m.invoke(null, 2)); assertEquals("Arg 3,", true, m.invoke(null, 3)); assertEquals("Arg 4,", false, m.invoke(null, 4)); assertEquals("Arg 16,", false, m.invoke(null, 16)); assertEquals("Arg 17,", true, m.invoke(null, 17)); assertEquals("Arg 18,", false, m.invoke(null, 18)); assertEquals("Arg 121,", false, m.invoke(null, 121)); assertEquals("Arg 126,", false, m.invoke(null, 126)); assertEquals("Arg 127,", true, m.invoke(null, 127)); assertEquals("Arg 128,", false, m.invoke(null, 128)); assertEquals("Arg 133,", false, m.invoke(null, 133)); assertEquals("Arg 2_147_482_949,", true, m.invoke(null, 2_147_482_949)); } catch (Exception ex) { throw new Error("Ausnahme in test_istPrim", ex); } } // test_istPrim // --------------------------------------------------------------------- public void test_primDoublette() { try { Method m = kob.getDeclaredMethod("primDoublette", Integer.TYPE); assertEquals("Args -27", 3, m.invoke(null, -27)); assertEquals("Args 0", 3, m.invoke(null, 0)); assertEquals("Args 1", 3, m.invoke(null, 1)); assertEquals("Args 2", 3, m.invoke(null, 3)); assertEquals("Args 3", 3, m.invoke(null, 3)); assertEquals("Args 4", 5, m.invoke(null, 4)); assertEquals("Args 5", 5, m.invoke(null, 5)); assertEquals("Args 6", 11, m.invoke(null, 6)); assertEquals("Args 1000", 1019, m.invoke(null, 1000)); assertEquals("Args 2000", 2027, m.invoke(null, 2000)); assertEquals("Args 2147482949", 2147482949, m.invoke(null, 2147482949)); assertEquals("Args 2147482950", 0, m.invoke(null, 2147482950)); } catch (Exception ex) { throw new Error("Ausnahme in test_primDoublette", ex); } } // test_primDoublette // --------------------------------------------------------------------- public void test_alleRechtwinkligen() { final String SOLL = "Nr. 1: 5, 4, 3\n" + "Nr. 2: 10, 8, 6\n" + "Nr. 3: 13, 12, 5\n" + "Nr. 4: 15, 12, 9\n" + "Nr. 5: 17, 15, 8\n" + "Nr. 6: 20, 16, 12\n" + "Nr. 7: 25, 20, 15\n" + "Nr. 8: 25, 24, 7\n" + "Nr. 9: 26, 24, 10\n" + "Nr. 10: 29, 21, 20\n" + "Nr. 11: 30, 24, 18\n" + "Nr. 12: 34, 30, 16\n" + "Nr. 13: 35, 28, 21\n" + "Nr. 14: 37, 35, 12\n" + "Nr. 15: 39, 36, 15\n" + "Nr. 16: 40, 32, 24\n" + "Nr. 17: 41, 40, 9\n" + "Nr. 18: 45, 36, 27\n" + "Nr. 19: 50, 40, 30\n" + "Nr. 20: 50, 48, 14\n" + "Nr. 21: 51, 45, 24\n" + "Nr. 22: 52, 48, 20\n" + "Nr. 23: 53, 45, 28\n" + "Nr. 24: 55, 44, 33\n" + "Nr. 25: 58, 42, 40\n" + "Nr. 26: 60, 48, 36\n" + "Nr. 27: 61, 60, 11\n" + "Nr. 28: 65, 52, 39\n" + "Nr. 29: 65, 56, 33\n" + "Nr. 30: 65, 60, 25\n" + "Nr. 31: 65, 63, 16\n" + "Nr. 32: 68, 60, 32\n" + "Nr. 33: 70, 56, 42\n" + "Nr. 34: 73, 55, 48\n" + "Nr. 35: 74, 70, 24\n" + "Nr. 36: 75, 60, 45\n" + "Nr. 37: 75, 72, 21\n" + "Nr. 38: 78, 72, 30\n" + "Nr. 39: 80, 64, 48\n" + "Nr. 40: 82, 80, 18\n" + "Nr. 41: 85, 68, 51\n" + "Nr. 42: 85, 75, 40\n" + "Nr. 43: 85, 77, 36\n" + "Nr. 44: 85, 84, 13\n" + "Nr. 45: 87, 63, 60\n" + "Nr. 46: 89, 80, 39\n" + "Nr. 47: 90, 72, 54\n" + "Nr. 48: 91, 84, 35\n" + "Nr. 49: 95, 76, 57\n" + "Nr. 50: 97, 72, 65\n" + "Nr. 51: 100, 80, 60\n" + "Nr. 52: 100, 96, 28\n" ; try { Method m = kob.getDeclaredMethod("alleRechtwinkligen"); Method h = kob.getDeclaredMethod("holeUndLoescheBildschirmInhalt"); m.invoke(null); final String IST = (String) h.invoke(null); assertEquals(SOLL, IST); } catch (Exception ex) { throw new Error("Ausnahme in test_alleRechtwinkligen", ex); } } // test_alleRechtwinkligen // --------------------------------------------------------------------- static public void main(String... sonja) throws Exception { printf("Getestet wird die Klasse %s%n", KLASSEN_NAME); junit.awtui.TestRunner.run(UebMethodenA_Jut.class); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebMethodenA_Jut *************************************************************************** *************************************************************************** // Datei UebMethodenB.java /* ------------------------------------------------------------------------ In diese Klasse UebMethodenB kann man Ruempfe fuer bestimmte Methoden eintragen und dann mit dem Testprogramm UebMethodenB_Jut testen. ------------------------------------------------------------------------ */ import java.util.Arrays; class UebMethodenB { // --------------------------------------------------------------------- static char[] a2b(char[] r) { // Liefert eine Kopie von r, in der alle Vorkommen von 'a' durch // 'b' ersetzt wurden. return new char[]{'?'}; // DIESE ZEILE SOLL ERSETZT WERDEN } // a2b // --------------------------------------------------------------------- static char[] a2bb(char[] r) { // Liefert eine Kopie von r, in der jedes Vorkommen von 'a' durch // je zwei 'b' ersetzt wurden. return new char[]{'?'}; // DIESE ZEILE SOLL ERSETZT WERDEN } // a2bb // HINWEIS: Falls das Zeichen 'a' in der Reihung r (ein oder mehrmals) // vorkommt, ist das Ergebnis der Methode eine Reihung, die länger ist // als der Parameter r. Achten Sie darauf, dass diese Ergebnis-Reihung // "genau die richtige Länge" hat, und nicht etwa "ein bisschen zu lang" // ist. // --------------------------------------------------------------------- static char[] aa2bbb(char[] r) { // Liefert eine Kopie von r, in der jedes Vorkommen von zwei unmittel- // bar nacheinander liegenden 'a' durch drei 'b' ersetzt wurden. // Nur nicht-ueberlappende Vorkommen von "Doppel-a" werden ersetzt. return new char[]{'?'}; // DIESE ZEILE SOLL ERSETZT WERDEN } // aa2bbb // HINWEIS: Auch hier soll die Ergebnis-Reihung "genau die richtige // Länge" haben. Ausserdem soll gelten: Eine Reihung {'a', 'a', 'a'} // soll in die folgende Reihung der Länge 4 übersetzt werden: // {'b', 'b', 'b', 'a'} (und nicht in die Reihung der Länge 6: // {'b', 'b', 'b', 'b', 'b', 'b'}). // --------------------------------------------------------------------- // HINWEIS: In den folgenden 3 Methoden (c2d, c2dd und cc2ddd) sollen // Sie (zur Uebung und aus Gruenden der Effizienz) nicht die Methode // replace der Klasse String verwenden, sondern die Methode replace // der Klasse StringBuilder. // --------------------------------------------------------------------- public static String c2d(String s) { // Liefert eine Kopie von s, in der alle Vorkommen von 'a' durch // 'b' ersetzt wurden. return "Noch nicht ersetzt!"; // DIESE ZEILE SOLL ERSETZT WERDEN } // c2d // --------------------------------------------------------------------- public static String c2dd(String s) { // Liefert eine Kopie von s, in der jedes Vorkommen von 'a' durch // je zwei 'b' ersetzt wurde. return "Noch nicht ersetzt!"; // DIESE ZEILE SOLL ERSETZT WERDEN } // c2dd // --------------------------------------------------------------------- public static String cc2ddd(String s) { // Liefert eine Kopie von s, in der jedes Vorkommen von zwei unmit- // telbar nacheinander liegenden 'c' durch drei 'd' ersetzt wurden. // Nur nicht-ueberlappende Vorkommen von "Doppel-as" werden ersetzt. return "Noch nicht ersetzt!"; // DIESE ZEILE SOLL ERSETZT WERDEN } // cc2ddd // --------------------------------------------------------------------- static public void main(String[] sonja) { printf("-------------------------------------------------%n"); printf("Diese Klasse UebMethodenB kann man testen mit dem%n"); printf("Testprogramm UebMethodenB_Jut.java !%n"); printf("-------------------------------------------------%n"); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebMethodenB *************************************************************************** // Datei UebMethodenB_Jut.java /* ------------------------------------------------------------------------ Ein Programm zum Testen der Klassen UebMethodenB und UebMethodenB_Loes. Erstellt mit und fuer JUnit Version 3.8. ------------------------------------------------------------------------ */ import junit.framework.Test; // Eine Schnittstelle import junit.framework.TestCase; // Eine Test-Klasse import junit.framework.TestSuite; // Eine Test-Klasse import java.lang.reflect.Method; import java.util.Arrays; import static java.lang.String.format; public class UebMethodenB_Jut extends TestCase { // --------------------------------------------------------------------- // Welche Klasse soll getestet werden, UebMethodenB oder UebMethodenB_Loes? static String KLASSEN_NAME = "UebMethodenB"; static Class kob; static { // Dies ist ein Klassen-Initialisierer try { kob = Class.forName(KLASSEN_NAME); } catch (ClassNotFoundException ex) { printf("-------------------------------------------------%n"); printf("Kann die Klasse %s nicht finden!%n", KLASSEN_NAME); printf("-------------------------------------------------%n"); System.exit(-1); } } // --------------------------------------------------------------------- final char a = 'a'; final char b = 'b'; final char x = 'x'; // --------------------------------------------------------------------- public void assertEqualsRR(char[] r1, char[] r2) { String s1 = Arrays.toString(r1); String s2 = Arrays.toString(r2); String msg = format("Arrays not equal:%n%s and%n%s%n", s1, s2); if (!Arrays.equals(r1, r2)) fail(msg); } // --------------------------------------------------------------------- public void test_a2b() { char[] par01 = {}; char[] par02 = {a}; char[] par03 = {x}; char[] par04 = {a, x}; char[] par05 = {x, a}; char[] par06 = {x, x}; char[] par07 = {a, x, a, a, x, x, a}; char[] par08 = {x, a, a, a, x, x, a}; char[] soll01 = {}; char[] soll02 = {b}; char[] soll03 = {x}; char[] soll04 = {b, x}; char[] soll05 = {x, b}; char[] soll06 = {x, x}; char[] soll07 = {b, x, b, b, x, x, b}; char[] soll08 = {x, b, b, b, x, x, b}; try { Method m = kob.getDeclaredMethod("a2b", char[].class); assertEqualsRR(soll01, (char[]) m.invoke(null, par01)); assertEqualsRR(soll02, (char[]) m.invoke(null, par02)); assertEqualsRR(soll03, (char[]) m.invoke(null, par03)); assertEqualsRR(soll04, (char[]) m.invoke(null, par04)); assertEqualsRR(soll05, (char[]) m.invoke(null, par05)); assertEqualsRR(soll06, (char[]) m.invoke(null, par06)); assertEqualsRR(soll07, (char[]) m.invoke(null, par07)); assertEqualsRR(soll08, (char[]) m.invoke(null, par08)); } catch (Exception ex) { throw new Error("Ausnahme in test_a2b", ex); } } // test_a2b // --------------------------------------------------------------------- public void test_a2bb() { char[] par01 = {}; char[] par02 = {a}; char[] par03 = {x}; char[] par04 = {a, x}; char[] par05 = {x, a}; char[] par06 = {x, x}; char[] par07 = {a, x, a, a, x,x, a}; char[] par08 = {x, a, a, a, x,x, a}; char[] soll01 = {}; char[] soll02 = {b, b}; char[] soll03 = {x}; char[] soll04 = {b, b, x}; char[] soll05 = {x, b, b}; char[] soll06 = {x, x}; char[] soll07 = {b, b, x, b, b, b, b, x, x, b, b}; char[] soll08 = {x, b, b, b, b, b, b, x, x, b, b}; try { Method m = kob.getDeclaredMethod("a2bb", char[].class); assertEqualsRR(soll01, (char[]) m.invoke(null, par01)); assertEqualsRR(soll02, (char[]) m.invoke(null, par02)); assertEqualsRR(soll03, (char[]) m.invoke(null, par03)); assertEqualsRR(soll04, (char[]) m.invoke(null, par04)); assertEqualsRR(soll05, (char[]) m.invoke(null, par05)); assertEqualsRR(soll06, (char[]) m.invoke(null, par06)); assertEqualsRR(soll07, (char[]) m.invoke(null, par07)); assertEqualsRR(soll08, (char[]) m.invoke(null, par08)); } catch (Exception ex) { throw new Error("Ausnahme in test_a2bb", ex); } } // test_a2bb // --------------------------------------------------------------------- public void test_aa2bbb() { char[] par01 = {}; char[] par02 = {a}; char[] par03 = {x}; char[] par04 = {a, x}; char[] par05 = {x, a}; char[] par06 = {x, x}; char[] par07 = {a, x, a, a, x, x, a}; char[] par08 = {x, a, a, a, x, x, a}; char[] par09 = {a, a,}; char[] par10 = {a, a, a}; char[] par11 = {a, a, a, a}; char[] par12 = {a, a, a, a, a}; char[] soll01 = {}; char[] soll02 = {a}; char[] soll03 = {x}; char[] soll04 = {a, x}; char[] soll05 = {x, a}; char[] soll06 = {x, x}; char[] soll07 = {a, x, b, b, b, x, x, a}; char[] soll08 = {x, b, b, b, a, x, x, a}; char[] soll09 = {b, b, b, b}; char[] soll10 = {b, b, b, b, a}; char[] soll11 = {b, b, b, b, b}; char[] soll12 = {b, b, b, b, b, a}; try { Method m = kob.getDeclaredMethod("aa2bbb", char[].class); assertEqualsRR(soll01, (char[]) m.invoke(null, par01)); assertEqualsRR(soll02, (char[]) m.invoke(null, par02)); assertEqualsRR(soll03, (char[]) m.invoke(null, par03)); assertEqualsRR(soll04, (char[]) m.invoke(null, par04)); assertEqualsRR(soll05, (char[]) m.invoke(null, par05)); assertEqualsRR(soll06, (char[]) m.invoke(null, par06)); assertEqualsRR(soll07, (char[]) m.invoke(null, par07)); assertEqualsRR(soll08, (char[]) m.invoke(null, par08)); } catch (Exception ex) { throw new Error("Ausnahme in test_aa2bbb", ex); } } // test_aa2bbb // --------------------------------------------------------------------- public void test_c2d() { String par01 = ""; String par02 = "c"; String par03 = "x"; String par04 = "cx"; String par05 = "xc"; String par06 = "xx"; String par07 = "cxccxxc"; String par08 = "xcccxxc"; String soll01 = ""; String soll02 = "d"; String soll03 = "x"; String soll04 = "dx"; String soll05 = "xd"; String soll06 = "xx"; String soll07 = "dxddxxd"; String soll08 = "xdddxxd";// try { Method m = kob.getDeclaredMethod("c2d", String.class); assertEquals(soll01, (String) m.invoke(null, par01)); assertEquals(soll02, (String) m.invoke(null, par02)); assertEquals(soll03, (String) m.invoke(null, par03)); assertEquals(soll04, (String) m.invoke(null, par04)); assertEquals(soll05, (String) m.invoke(null, par05)); assertEquals(soll06, (String) m.invoke(null, par06)); assertEquals(soll07, (String) m.invoke(null, par07)); assertEquals(soll08, (String) m.invoke(null, par08)); } catch (Exception ex) { throw new Error("Ausnahme in test_c2d", ex); } } // test_c2d // --------------------------------------------------------------------- public void test_c2dd() { String par01 = ""; String par02 = "c"; String par03 = "x"; String par04 = "cx"; String par05 = "xc"; String par06 = "xx"; String par07 = "cxccxxc"; String par08 = "xcccxxc"; String soll01 = ""; String soll02 = "dd"; String soll03 = "x"; String soll04 = "ddx"; String soll05 = "xdd"; String soll06 = "xx"; String soll07 = "ddxddddxxdd"; String soll08 = "xddddddxxdd";// try { Method m = kob.getDeclaredMethod("c2dd", String.class); assertEquals(soll01, (String) m.invoke(null, par01)); assertEquals(soll02, (String) m.invoke(null, par02)); assertEquals(soll03, (String) m.invoke(null, par03)); assertEquals(soll04, (String) m.invoke(null, par04)); assertEquals(soll05, (String) m.invoke(null, par05)); assertEquals(soll06, (String) m.invoke(null, par06)); assertEquals(soll07, (String) m.invoke(null, par07)); assertEquals(soll08, (String) m.invoke(null, par08)); } catch (Exception ex) { throw new Error("Ausnahme in test_c2dd", ex); } } // test_c2dd // --------------------------------------------------------------------- public void test_cc2ddd() { String par01 = ""; String par02 = "c"; String par03 = "x"; String par04 = "cx"; String par05 = "xc"; String par06 = "xx"; String par07 = "cxccxxc"; String par08 = "xcccxxc"; String par09 = "cc,"; String par10 = "ccc"; String par11 = "cccc"; String par12 = "ccccc"; String soll01 = ""; String soll02 = "c"; String soll03 = "x"; String soll04 = "cx"; String soll05 = "xc"; String soll06 = "xx"; String soll07 = "cxdddxxc"; String soll08 = "xdddcxxc"; String soll09 = "dddd"; String soll10 = "ddddc"; String soll11 = "ddddd"; String soll12 = "dddddc"; try { Method m = kob.getDeclaredMethod("cc2ddd", String.class); assertEquals(soll01, (String) m.invoke(null, par01)); assertEquals(soll02, (String) m.invoke(null, par02)); assertEquals(soll03, (String) m.invoke(null, par03)); assertEquals(soll04, (String) m.invoke(null, par04)); assertEquals(soll05, (String) m.invoke(null, par05)); assertEquals(soll06, (String) m.invoke(null, par06)); assertEquals(soll07, (String) m.invoke(null, par07)); assertEquals(soll08, (String) m.invoke(null, par08)); } catch (Exception ex) { throw new Error("Ausnahme in test_cc2ddd", ex); } } // test_cc2ddd // --------------------------------------------------------------------- static public void main(String... sonja) throws Exception { printf("Getestet wird die Klasse %s%n", KLASSEN_NAME); junit.awtui.TestRunner.run(UebMethodenB_Jut.class); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebMethodenB_Jut *************************************************************************** // Datei UebSammlungenA.java /* ------------------------------------------------------------------------ In eine Sammlung ali des Typs ArrayList sollen ein paar Integer-Objekte eingefuegt werden: Jede durch // SOLL ERSETZT WERDEN gekennzeichnete Zeile soll durch einen Einfuegebefehl ersetzt werden. Dabei soll der Kommentar in der Zeile davor beruecksichtig werden. ACHTUNG: Wenn man dieses Programm ausfuehren laesst, bevor man die Einfuegebefehle eingefuegt hat, wird es mit einer Ausnahme des Typs java.util.NoSuchElementException abgebrochen Unterhalb der STERNCHEN-ZEILE stehen bereits Java-Befehle, die eine Sammlung tea des Typs TreeSet vereinbaren und mit der Sammlung ali initialsieren (tea enthaelt dann die selben Integer- Objekte wie ali, allerdings in aufsteigend sortierter Reihenfolge). Mit Methoden wie first, lower, floor, ... etc. werden in tea bestimmte Komponenten gesucht und ausgegeben. Schliesslich wird noch eine leere Sammlung teo vereinbart. Wenn man darin mit den Methoden lower, floor, ... etc. nach Komponenten sucht, bekommt man nur null als Ergebnis (und die Methoden first und last werfen sogar eine Ausnahme des Typs java.util.NoSuchElementException). ------------------------------------------------------------------------ */ import java.util.ArrayList; import java.util.TreeSet; class UebSammlungenA { // --------------------------------------------------------------------- static public void main(String [] sonja) { printf("UebSammlungenA: Jetzt geht es los!%n"); printf("----------------------------------%n"); ArrayList ali = new ArrayList(); // Soll-Ausgabe zum Bildschirm printf("A ali: %s%n", ali); // A ali: [] // Fuege ein Integer-Objekt 40 in die Sammlung ali ein: // SOLL ERSETZT WERDEN // Fuege ein Integer-Objekt 20 dahinter ein: // SOLL ERSETZT WERDEN printf("B ali: %s%n", ali); // B ali: [40, 20] // Fuege ein Integer-Objekt 50 ganz am Anfang ein: // SOLL ERSETZT WERDEN // Fuege ein Integer-Objekt 10 ganz am Ende ein: // SOLL ERSETZT WERDEN printf("C ali: %s%n", ali); // C ali: [50, 40, 20, 10] // Fuege ein Integer-Objekt 30 zwischen der 40 und der 20 ein: // SOLL ERSETZT WERDEN printf("D ali: %s%n", ali); // D ali: [50, 40, 30, 20, 10] // ************************************************** STERNCHEN-ZEILE printf("----------------------------------%n"); printf("%n"); TreeSet tea = new TreeSet(ali); printf("E tea: %s%n", tea); // E tea: [10, 20, 30, 40, 50] printf("%n"); printf("----------------------------------%n"); printf("F tea.first ( ): %d (d.h. kleinste in tea )%n", tea.first ( )); printf("G tea.lower (25): %d (d.h. groesste kleiner 25)%n", tea.lower (25)); printf("H tea.lower (30): %d (d.h. groesste kleiner 30)%n", tea.lower (30)); printf("I tea.floor (25): %d (d.h. groesste kleiner/gleich 25)%n", tea.floor (25)); printf("J tea.floor (30): %d (d.h. groesste kleiner/gleich 30)%n", tea.floor (30)); printf("K tea.ceiling(30): %d (d.h. kleinste groesser/gleich 30)%n", tea.ceiling(30)); printf("L tea.ceiling(35): %d (d.h. kleinste groesser/gleich 35)%n", tea.ceiling(35)); printf("M tea.higher (30): %d (d.h. kleinste groesser 30)%n", tea.higher (30)); printf("N tea.higher (35): %d (d.h. kleinste groesser )%n", tea.higher (35)); printf("O tea.last ( ): %d (d.h. groesste in tea )%n", tea.last ( )); printf("----------------------------------%n"); TreeSet teo = new TreeSet(); // Eine leere Sammlung // printf("P teo.first ( ): %s%n", teo.first ( )); // NoSuchElementException! printf("Q teo.lower (30): %s%n", teo.lower (30)); printf("R teo.floor (30): %s%n", teo.floor (30)); printf("S teo.ceiling(30): %s%n", teo.ceiling(30)); printf("T teo.higher (30): %s%n", teo.higher (30)); // printf("U teo.last ( ): %s%n", teo.last ( )); // NoSuchElementException! printf("----------------------------------%n"); printf("UebSammlungenA: Das war's erstmal!%n"); } // main // --------------------------------------------------------------------- // Eine Methode mit einem kurzen Namen: static void printf(String f, Object... v) {System.out.printf(f, v);} // --------------------------------------------------------------------- } // class UebSammlungenA /* ------------------------------------------------------------------------ Nachdem man die korrekten Einfuegebefehle eingefuegt hat, sollte die Ausgabe dieses Programms wie folgt aussehen: UebSammlungenA: Jetzt geht es los! ---------------------------------- A ali: [] B ali: [40, 20] C ali: [50, 40, 20, 10] D ali: [50, 40, 30, 20, 10] ---------------------------------- E tea: [10, 20, 30, 40, 50] ---------------------------------- F tea.first ( ): 10 (d.h. kleinste in tea ) G tea.lower (25): 20 (d.h. groesste kleiner 25) H tea.lower (30): 20 (d.h. groesste kleiner 30) I tea.floor (25): 20 (d.h. groesste kleiner/gleich 25) J tea.floor (30): 30 (d.h. groesste kleiner/gleich 30) K tea.ceiling(30): 30 (d.h. kleinste groesser/gleich 30) L tea.ceiling(35): 40 (d.h. kleinste groesser/gleich 35) M tea.higher (30): 40 (d.h. kleinste groesser 30) N tea.higher (35): 40 (d.h. kleinste groesser ) O tea.last ( ): 50 (d.h. groesste in tea ) ---------------------------------- Q teo.lower (30): null R teo.floor (30): null S teo.ceiling(30): null T teo.higher (30): null ---------------------------------- UebSammlungenA: Das war's erstmal! ------------------------------------------------------------------------ */ ***************************************************************************