public class ToolboxTestSelf { public static void main(String[] args) { /** * Hinweise: Bitte versuche nicht, das nachfolgende * Programm zu verstehen! Es soll dir lediglich beim Testen helfen und * dich nicht weiterbilden! Da es sich hierbei um ein Testprogramm * handelt, wurden Duplikate bewusst nicht vermieden! Orientiere dich * also für künftige Aufgaben nicht an dieser Methode! Für Tests nutzt * man in der Regel JUnit-Tests, wobei hier der Einfachheit wegen alles * in einer Methode geschrieben wurde, die in der main-Methode * aufgerufen werden soll (um es euch nicht unnötig kompliziert zu * machen). */ System.out.print("Welche Methode soll getestet werden (bitte hier " + "eingeben und Enter drücken):\n" + "0 = evenSum() [2]\n" + "1 = multiplication() [3]\n" + "2 = reverse() [2]\n" + "3 = numberOfOddIntegers() [3]\n" + "4 = filterOdd() [3]\n" + "5 = Alle in dieser Reihenfolge.\n" + "Deine Wahl: "); java.util.Scanner s = new java.util.Scanner(System.in); int input; do { try { input = s.nextInt(); } catch (java.util.InputMismatchException e) { System.out.println("Ungültige Eingabe."); input = -1; s = new java.util.Scanner(System.in); } } while (input == -1); int inputN; System.out.println("\nTest:\n"); boolean all = input == 5; if (all) { input = 0; } boolean works; java.util.Random R = new java.util.Random(); switch (input) { case 0: // evenSum: if (!all) { System.out.println("evenSum [2 P.]: Was soll getestet werden?\n" + "- 0 = positive Eingabe [+1]\n" + "- 1 = negative Eingabe [+1]\n" + "- 2 = Alles [2/2]"); while (true) { do { try { inputN = s.nextInt(); } catch (java.util.InputMismatchException e) { System.out.println("Ungültige Eingabe"); inputN = -1; s = new java.util.Scanner(System.in); } } while (inputN == -1); if (inputN >= 0 && inputN <= 2) break; System.out.println("Falsche Eingabe."); } } else { inputN = 2; } System.out.print("evenSum: "); works = true; int[][] testCases = {{4, 6}, {6, 12}, {10, 30}, {14, 56}, {5, 6}, {7, 12}, {17, 72},{3, 2}, {31, 240}, {4289, 4598880}, {10000, 25005000}}; for (int vz = (inputN == 1 ? -1 : 1); vz >= (inputN == 0 ? 1 : -1); vz -= 2) { for (int i = 0; i < testCases.length; i++) { int result = Toolbox.evenSum(vz * testCases[i][0]); if (result != vz * testCases[i][1]) { System.out.println("Fehlgeschlagen.\n" + "-> evenSum(" + vz * testCases[i][0] + ")" + " hat zu " + result + " evaluiert," + " während " + vz * testCases[i][1] + " richtig wäre."); works = false; break; } } if (!works) break; else { boolean wrongZero = false, wrongOne = false, wrongTwo = false; if(Toolbox.evenSum(vz * 1) != 0) wrongOne = true; if(Toolbox.evenSum(0) != 0) wrongZero = true; if(Toolbox.evenSum(vz * 2) != vz * 2) wrongTwo = true; if (wrongZero || wrongOne || wrongTwo) { System.out.println("Fehlgeschlagen.\n" + "-> Fast vollständig richtig, allerdings hat " + (wrongZero ? " evenSum(0) zu " + Toolbox.evenSum(0) + " statt 0 ausgewertet, " : "") + (wrongOne ? " evenSum(" + vz + ") zu " + Toolbox.evenSum(1*vz) + " statt 0 ausgewertet, " : "") + (wrongTwo ? " evenSum(" + 2*vz + ") zu " + Toolbox.evenSum(2*vz) + " statt " + (2*vz) + " ausgewertet, " : "") + " [1-1,5]."); works = false; break; } } } if (works) System.out.println("Erfolgreich."); if (!all) break; case 1: // multiplication: if (!all) { System.out.println("multiplication [3 P.]: Was soll getestet werden?\n" + "- 0 = positive Eingaben [+1]\n" + "- 1 = falls ein Parameter 0 ist [+1]\n" + "- 2 = beliebige Eingaben [+1]\n" + "- 3 = Alles [3/3]"); while (true) { do { try { inputN = s.nextInt(); } catch (java.util.InputMismatchException e) { System.out.println("Ungültige Eingabe"); inputN = -1; s = new java.util.Scanner(System.in); } } while (inputN == -1); if (inputN >= 0 && inputN <= 3) break; System.out.println("Falsche Eingabe."); } } else { inputN = 3; } System.out.print("multiplication: "); works = true; for (int i = 0; i < 10000; i++) { int a = R.nextInt(inputN != 2 ? 10000 : 20000) - (inputN != 2 ? 0 : 10000); int b = R.nextInt(inputN != 2 ? 10000 : 20000) - (inputN != 2 ? 0 : 10000); if (inputN == 1) { if (R.nextBoolean()) a = 0; else b = 0; } try { if (Toolbox.multiplication(a, b) != (a * b)) { System.out.println("Fehlgeschlagen.\n" + "-> Fehler: multiplication(" + a + ", " + b + ")" + " hat zu " + Toolbox.multiplication(a, b) + " ausgewertet," + " während " + (a * b) + " richtig wäre."); works = false; break; } } catch (StackOverflowError e) { System.out.println("Unbekannt.\n" + "-> StackOverflowError, d. h. entweder falsch implementiert, oder" + " Stack Size zu klein. In NetBeans " + "Rechtsklick auf Projekt -> Properties -> Run -> bei " + "VM Options \"-Xss2048k\" einfügen. Wenn es dann noch passiert, " + "dann vermutlich falsch implementiert (evtl. nur negative unbeachtet?)."); works = false; break; } } if (works) System.out.println("Erfolgreich."); if (!all) break; case 2: // reverse: if (!all) { System.out.println("reverse [2 P.]: Was soll getestet werden?\n" + "- 0 = nicht leeres (befülltes) Array [+1]\n" + "- 1 = leeres Array (ab Größe 0) [+1]\n" + "- 2 = Alles [2/2]"); while (true) { do { try { inputN = s.nextInt(); } catch (java.util.InputMismatchException e) { System.out.println("Ungültige Eingabe"); inputN = -1; s = new java.util.Scanner(System.in); } } while (inputN == -1); if (inputN >= 0 && inputN <= 2) { break; } System.out.println("Falsche Eingabe."); } } else { inputN = 2; } System.out.print("reverse: "); works = true; for (int i = 0; i < 1000; i++) { int[] array = new int[inputN == 1 ? R.nextInt(5) : R.nextInt(40)+1]; if (inputN != 1) { for (int j = 0; j < array.length; j++) { array[j] = R.nextInt(40)-20; } } // Kopie erstellen, um Originalarray ggf. auszugeben: int[] dupl = java.util.Arrays.copyOf(array, array.length); int[] reversed = new int[array.length]; // das korrekte Ergebnis for (int j = 0; j < array.length; j++) { reversed[j] = array[array.length - j - 1]; } try { Toolbox.reverse(array); // Fktaufruf if (!java.util.Arrays.equals(array, reversed)) { System.out.println("Fehlgeschlagen.\n" + "-> reverse(" + java.util.Arrays.toString(dupl) + ") hat das Array zu " + java.util.Arrays.toString(array) + " verändert, während " + java.util.Arrays.toString(reversed) + " richtig wäre."); works = false; break; } } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Fehlgeschlagen.\n" + "-> ArrayIndexOutOfBoundsException" + " - vermutlich leeres Array nicht beachtet!"); //e.printStackTrace(); works = false; break; } } if (works) System.out.println("Erfolgreich."); if (!all) { break; } case 3: // numberOfOddIntegers: if (!all) { System.out.println("numberOfOddIntegers [3 P.]: Was soll getestet werden?\n" + "- 0 = Array mit einer oder mehr positiven Zahlen [+1]\n" + "- 1 = Array mit einer oder mehr positiven und negativen Zahlen [+1]\n" + "- 2 = leeres Array (ab Größe 0) [+1]\n" + "- 3 = Alles [3/3]"); while (true) { do { try { inputN = s.nextInt(); } catch (java.util.InputMismatchException e) { System.out.println("Ungültige Eingabe"); inputN = -1; s = new java.util.Scanner(System.in); } } while (inputN == -1); if (inputN >= 0 && inputN <= 3) { break; } System.out.println("Falsche Eingabe."); } } else { inputN = 3; } System.out.print("numberOfOddIntegers: "); works = true; for (int i = 0; i < 1000; i++) { int[] array = new int[inputN == 2 ? R.nextInt(8) : R.nextInt(40) + (inputN == 3 ? 0 : 1)]; int countOdd = 0; if (inputN != 2) { for (int j = 0; j < array.length; j++) { array[j] = R.nextInt(100) - (inputN != 0 ? 50 : 0); if (array[j] % 2 != 0) { countOdd++; } } } int countedOdd = -1; try { countedOdd = Toolbox.numberOfOddIntegers(array); if (countOdd != countedOdd) { System.out.println("Fehlgeschlagen.\n" + "-> numberOfOddIntegers(" + java.util.Arrays.toString(array) + ") hat " + countedOdd + " ungerade Zahlen gezählt, während " + countOdd + " richtig wäre."); works = false; break; } } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Fehlgeschlagen.\n" + "-> ArrayIndexOutOfBoundsException" + " - vermutlich leeres Array niht beachtet!"); //e.printStackTrace(); works = false; break; } } if (works) System.out.println("Erfolgreich."); if (!all) break; case 4: // filterOdd: if (!all) { System.out.println("filterOdd [3 P.]: Was soll getestet werden?\n" + "- 0 = Array mit einer oder mehr positiven Zahlen [+1]\n" + "- 1 = Array mit einer oder mehr positiven und negativen Zahlen [+1]\n" + "- 2 = leeres Array (ab Größe 0) [+1]\n" + "- 3 = Alles [3/3]"); while (true) { do { try { inputN = s.nextInt(); } catch (java.util.InputMismatchException e) { System.out.println("Ungültige Eingabe"); inputN = -1; s = new java.util.Scanner(System.in); } } while (inputN == -1); if (inputN >= 0 && inputN <= 3) { break; } System.out.println("Falsche Eingabe."); } } else { inputN = 3; } System.out.print("filterOdd: "); works = true; for (int i = 0; i < 1000; i++) { int[] array = new int[inputN == 2 ? R.nextInt(4) : R.nextInt(40) + (inputN == 3 ? 0 : 1)]; int countOdd = 0; if (inputN != 2) { for (int j = 0; j < array.length; j++) { array[j] = R.nextInt(100) - (inputN != 0 ? 50 : 0); if (array[j] % 2 != 0) { countOdd++; } } } // Kopie erstellen, falls fehlerhafterweise Original verändert: int[] arrayDupl = java.util.Arrays.copyOf(array, array.length); int[] arrayOddSol = new int[countOdd]; int c = 0; if (inputN != 2) { for (int j = 0; j < array.length; j++) { if (array[j] % 2 != 0) { arrayOddSol[c++] = array[j]; } } } int[] arrayOddResult = null; try { arrayOddResult = Toolbox.filterOdd(array); if (!java.util.Arrays.equals(arrayDupl, array)) { System.out.println("Fehlgeschlagen.\n" + "-> filterOdd führt eine Änderung am " + "übergebenen Array durch, was laut Aufgabenstellung " + "verboten ist!"); works = false; break; } else if (!java.util.Arrays.equals(arrayOddResult, arrayOddSol)) { System.out.println("Fehlgeschlagen.\n" + "-> filterOdd(" + java.util.Arrays.toString(array) + ") hat " + java.util.Arrays.toString(arrayOddResult) + " zurückgegeben, während " + java.util.Arrays.toString(arrayOddSol) + " richtig wäre."); works = false; break; } } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Fehlgeschlagen.\n" + "-> ArrayIndexOutOfBoundsException" + " - vermutlich leeres Array nicht beachtet!"); //e.printStackTrace(); works = false; break; } } if (works) System.out.println("Erfolgreich."); break; default: System.out.println("Die Eingabe " + input + " ist ungültig."); } System.out.println(); } }