diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
index 397e3da90e1e0d2b82b59228454c2238967d18c2..d166be1527024b2dbcf6c3d3c7442fd8e6cc3dc4 100644
--- a/src/main/java/Enigma/App.java
+++ b/src/main/java/Enigma/App.java
@@ -1,74 +1,112 @@
package Enigma;
-import Enigma.model.Codebuch;
-import Enigma.model.DatenbankSqlite;
-import Enigma.model.Hardware;
+import Enigma.model.*;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
+import org.apache.http.HttpException;
import java.io.IOException;
import java.sql.SQLException;
-import java.util.Calendar;
-import java.util.TimeZone;
+import java.time.LocalDate;
+import java.time.ZoneId;
/**
* JavaFX App
*/
public class App extends Application {
- private static Scene scene;
- private Codebuch cb;
- private Hardware h;
-
- @Override
- public void start(Stage stage) throws IOException {
- scene = new Scene(loadFXML("gui"));
- stage.setScene(scene);
- stage.show();
- holeCodebuch();
- }
-
- static void setRoot(String fxml) throws IOException {
- scene.setRoot(loadFXML(fxml));
- }
-
- private static Parent loadFXML(String fxml) throws IOException {
- FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
- return fxmlLoader.load();
- }
-
- public static void main(String[] args) {
- Application.launch();
- }
-
- public void holeCodebuch() {
- Calendar calendar = Calendar.getInstance(TimeZone.getDefault());
-
- try {
- this.cb = new DatenbankSqlite().getCodebuch(Calendar.DATE);
- } catch (SQLException ignored) { }
-
- for(int i = 0; i < 3; i++) {
- h.setWalzen(i + 1, Integer.parseInt(cb.getWalzenlage()[i]), cb.getRingstellung()[i].charAt(0));
- }
-
- /*Walze w1 = new Walze(3);
- w1.setzeNotch(13);
- Walze w2 = new Walze(5);
- w2.setzeNotch(1);
- Walze w3 = new Walze(1);
- w3.setzeNotch(20);
- Reflektor r = new Reflektor();
+ private static Scene scene;
+ private Codebuch cb;
+ private Hardware h;
+
+ static void setRoot(String fxml) throws IOException {
+ scene.setRoot(loadFXML(fxml));
+ }
+
+ private static Parent loadFXML(String fxml) throws IOException {
+ FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
+ return fxmlLoader.load();
+ }
+
+ public static void main(String[] args) {
+ Application.launch();
+ }
+
+ @Override
+ public void start(Stage stage) throws IOException {
+ scene = new Scene(loadFXML("gui"));
+ stage.setScene(scene);
+ stage.show();
+
+ initialisiereHardware();
+
+ /**
+ * TODO: Nur zum Testen muss später wieder gelöscht werden.
+ */
+ //region Test
+ h.setKenngruppe("deisold");
+ String nachricht = "Hello world.";
+
+ for (char buchstabe : nachricht.toCharArray()) {
+ System.out.print(buchstabe + ":");
+ System.out.print(h.codiere(buchstabe));
+ System.out.println(" W1:" + h.getWalzen()[0].getBuchstabe() + " W2:" + h.getWalzen()[1].getBuchstabe() + " W3:" + h.getWalzen()[2].getBuchstabe());
+ }
+ try {
+ System.out.println(h.getNachricht());
+ h.sendeNachricht();
+ } catch (HttpException e) {
+ e.printStackTrace();
+ }
+ //endregion
+ }
+
+ /**
+ * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
+ * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
+ * in die Hardware gebaut.
+ * <p>
+ * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
+ * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
+ * <p>
+ * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
+ * Codebuch Eintrag.
+ */
+ private void initialisiereHardware() {
+
+ // Hole den heutigen Eintrag aus der SQLite Datenbank und erstelle daraus ein Codebuch Objekt
+ try {
+ this.cb = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
+ } catch (SQLException ignored) {
+ }
+
+ // TODO: Was zum Henker macht der hier????!?
+ System.out.println(this.cb.toString());
+
+ // Das Steckbrett initialisieren
Steckbrett sb = new Steckbrett();
+ char[][] verbinder = cb.getSteckverbindung();
+ // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
+ for (char[] kabel : verbinder) {
+ sb.setzeVertauschung(kabel[0], kabel[1]);
+ }
+
+ // Die Hardware aus dem Koffer holen (initialisieren)
+ this.h = new Hardware();
+
+ // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
+ h.setWalzen(0, cb.getWalzenlage()[0], cb.getRingstellung()[0]);
+ h.setWalzen(1, cb.getWalzenlage()[1], cb.getRingstellung()[1]);
+ h.setWalzen(2, cb.getWalzenlage()[2], cb.getRingstellung()[2]);
+
+ // Der Hardware das gesetzte Steckbrett zuweisen
+ h.setSteckbrett(sb);
- if(w1.dreheWalze()) {
- if(w2.dreheWalze()) {
- w3.dreheWalze();
- }
- }*/
- }
+ // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
+ h.setReflektor(new Reflektor());
+ }
}
\ No newline at end of file
diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
index 0c6d01da135415010d27909d1a07f604de085f00..60f699eb693909af145a24a1d2d376a7446807d5 100644
--- a/src/main/java/Enigma/model/Codebuch.java
+++ b/src/main/java/Enigma/model/Codebuch.java
@@ -9,23 +9,38 @@ package Enigma.model;
* vorgenommen.
* Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
* festgelegt war.
- *
+ * <p>
* Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
* verarbeitet werden können.
- *
+ * <p>
* Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
* geben kann.
*/
public class Codebuch {
private int tag;
- private String[] Walzenlage;
- private String[] Ringstellung;
- private String[] Steckverbindung;
-
- Codebuch() {
- this.Walzenlage = new String[3];
- this.Ringstellung = new String[3];
- this.Steckverbindung = new String[10];
+ private int[] walzenlage;
+ private char[] ringstellung;
+ private char[][] steckverbindung;
+
+ /**
+ * Im Konstruktor werden die Standart Werte gesetzt
+ * <p>
+ * walzenlage : int[3] : Hier wird die Position der drei Walzen festgelegt.
+ * ringstellung : char[3] : Jede Walze hat einen Ring. Der Index steht für die Walze und der Value für
+ * die Position des Ringes.
+ * steckverbindung : char[10][] : Zehn Kabel können in das Steckbrett gesteckt werden. In diesem Array werden
+ * die Kabel mit ihren jeweiligen Buchsen hinterlegt.
+ */
+ public Codebuch() {
+ this.walzenlage = new int[3];
+ this.ringstellung = new char[3];
+ this.steckverbindung = new char[10][];
+
+ for(int i = 0; i < 10; i++) {
+ this.steckverbindung[i] = new char[2];
+ this.steckverbindung[i][0] = 'A';
+ this.steckverbindung[i][1] = 'A';
+ }
}
/**
@@ -44,33 +59,33 @@ public class Codebuch {
sb.append("Tag: ").append(this.getTag()).append("\n");
sb.append("Walzenlage: ");
- for(String wl : this.getWalzenlage()) {
+ for (int wl : this.getWalzenlage()) {
sb.append(wl).append(",");
wlLoop = true;
}
- if(wlLoop) {
+ if (wlLoop) {
sb.setLength(sb.length() - 1);
}
sb.append("\n");
sb.append("Ringstellung: ");
- for(String rs : this.getRingstellung()) {
+ for (char rs : this.getRingstellung()) {
sb.append(rs).append(",");
rsLoop = true;
}
- if(rsLoop) {
+ if (rsLoop) {
sb.setLength(sb.length() - 1);
}
sb.append("\n");
sb.append("Steckverbindung: ");
- for (String s : this.getSteckverbindung()) {
- if (!s.isEmpty()) {
- sb.append(s).append(",");
+ for (char[] s : this.getSteckverbindung()) {
+ if (Character.isLetter(s[0])) {
+ sb.append(s[0]).append(":").append(s[1]).append(",");
svLoop = true;
}
}
- if(svLoop) {
+ if (svLoop) {
sb.setLength(sb.length() - 1);
}
sb.append("\n");
@@ -80,65 +95,84 @@ public class Codebuch {
/**
* Gibt den Tag dieser Instanz zurück
+ *
* @return int : Tag
*/
public int getTag() {
return tag;
}
+ /**
+ * Setzt den Tag dieser Instanz
+ *
+ * @param tag : int
+ */
+ public void setTag(int tag) {
+ this.tag = tag;
+ }
+
/**
* Gibt die Walzenlage dieser Instanz zurück
+ *
* @return String[] : Walzenlage
*/
- public String[] getWalzenlage() {
- return Walzenlage;
+ public int[] getWalzenlage() {
+ return walzenlage;
}
/**
* Gibt die Ringstellung dieser Instanz zurück
+ *
* @return String[] : Ringstellung
*/
- public String[] getRingstellung() {
- return Ringstellung;
+ public char[] getRingstellung() {
+ return ringstellung;
}
/**
* Gibt die Steckverbindung dieser Instanz zurück
+ *
* @return String[] : Steckverbindung
*/
- public String[] getSteckverbindung() {
- return Steckverbindung;
+ public char[][] getSteckverbindung() {
+ return this.steckverbindung;
}
/**
- * Setzt den Tag dieser Instanz
- * @param tag : int
+ * Setzt die Steckverbindung dieser Instanz
+ *
+ * @param steckverbindung : String[] : Die Steckverbindungen die gesteckt werden sollen.
+ * Jeder Eintrag im Array ist ein String mit zwei Zeichen.
+ * Diese werden in zwei char zerlegt und anschließend im globalen
+ * Array gespeichert.
*/
- public void setTag(int tag) {
- this.tag = tag;
+ public void setSteckverbindung(String[] steckverbindung) {
+ int counter = 0;
+ char[] verbindung = new char[2];
+ for (String stecker : steckverbindung) {
+ verbindung[0] = stecker.charAt(0);
+ verbindung[1] = stecker.charAt(1);
+ this.steckverbindung[counter++] = verbindung;
+ }
}
/**
* Setzt die Walzenlage dieser Instanz
- * @param walzenlage : String[]
+ *
+ * @param position : int : Position der Walze
+ * @param walzenlage : int : Welche Walze wurde eingesetzt
*/
- public void setWalzenlage(String[] walzenlage) {
- Walzenlage = walzenlage;
+ public void setWalzenlage(int position, int walzenlage) {
+ this.walzenlage[position] = walzenlage;
}
/**
* Setzt die Ringstellung dieser Instanz
- * @param ringstellung : String[]
- */
- public void setRingstellung(String[] ringstellung) {
- Ringstellung = ringstellung;
- }
-
- /**
- * Setzt die Steckverbindung dieser Instanz
- * @param steckverbindung : String[]
+ *
+ * @param position : int : Auf welche Walze wird der Ring aufgesetzt?
+ * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.
*/
- public void setSteckverbindung(String[] steckverbindung) {
- Steckverbindung = steckverbindung;
+ public void setRingstellung(int position, char ringstellung) {
+ this.ringstellung[position] = ringstellung;
}
}
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/Enigma/model/DatenbankSqlite.java
index f9e0a9b11d03a5fa75b25bb1604c3fb689484306..51f34c1bf1c59f343bb5ef7ea9123133995defdb 100644
--- a/src/main/java/Enigma/model/DatenbankSqlite.java
+++ b/src/main/java/Enigma/model/DatenbankSqlite.java
@@ -51,10 +51,21 @@ public class DatenbankSqlite {
pstm.setInt(1, tag);
ResultSet rs = pstm.executeQuery();
+ String[] walzenlage, ringstellung, steckverbindung;
+
while (rs.next()) {
cb.setTag(rs.getInt("Tag"));
- cb.setWalzenlage(rs.getString("Walzenlage").split(","));
- cb.setRingstellung(rs.getString("Ringstellung").split(","));
+
+ walzenlage = rs.getString("Walzenlage").split(",");
+ for(int i = 0; i < 3; i++) {
+ cb.setWalzenlage(i, Integer.parseInt(walzenlage[i]));
+ }
+
+ ringstellung = rs.getString("Ringstellung").split(",");
+ for(int i = 0; i < 3; i++) {
+ cb.setRingstellung(i, ringstellung[i].charAt(0));
+ }
+
cb.setSteckverbindung(rs.getString("Steckverbindung").split(","));
}
diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
index 694912c870fbb74753a9657abcfefbd853214721..efb0517db59ec4ed9e56a381b05d623aa4fd6004 100644
--- a/src/main/java/Enigma/model/Hardware.java
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -4,6 +4,19 @@ import org.apache.http.HttpException;
import java.io.IOException;
+/**
+ * In dieser Klasse wird die Hardware zusammen gefasst.
+ * Alle Komponenter der Enigma laufen hier zusammen.
+ *
+ * <p>
+ * walzen : Walze[] : Ist ein Array der drei eingebauten Walzen Objekte
+ * steckbrett : Steckbrett : Das Steckbrett mit den Verbindungen aus dem Codebuch
+ * reflektor : Reflektor : Dies ist das Objekt der Reflektors
+ * nachricht : String : Die verschlüsselte Nachricht wird in diesem String zusammen gesetzt und gespeichert
+ * kenngruppe : String : Früher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
+ * Wir missbrauchen die Kenngruppe für einen Benutzernamen
+ * </p>
+ */
public class Hardware {
private Walze[] walzen;
@@ -12,8 +25,12 @@ public class Hardware {
private String nachricht;
private String kenngruppe;
- Hardware() {
- this.walzen = new Walze[4];
+ /**
+ * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
+ * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
+ */
+ public Hardware() {
+ this.walzen = new Walze[3];
}
/**
@@ -37,13 +54,18 @@ public class Hardware {
/**
* Setzt den Startwert (position) der Walze (walze)
*
- * @param walze : int : Nummer der Walze
+ * @param walze : int : Nummer der Walze
* @param buchstabe : char : Buchstabe der zugewiesen soll
*/
public void setzePosition(int walze, char buchstabe) {
}
- // Befehl die Nachricht an den Funker zu übergeben
+ /**
+ * Befehl die Nachricht an den Funker zu übergeben
+ *
+ * @throws IOException : Die Antwort konnte nicht gelesen werden
+ * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+ */
public void sendeNachricht() throws IOException, HttpException {
new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe);
}
@@ -60,67 +82,125 @@ public class Hardware {
}
/**
- * Fügt die gedrückte Taste der Nachricht hinzu
+ * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
*
- * @param buchstabe char : Der zu verschlüsselnde Buchstabe
- * @return char : Der verschlüsselte Buchstabe
+ * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+ * @return char : Der ver/entschlüsselte Buchstabe
*/
- public char tippeBuchstabe(char buchstabe) {
- buchstabe = this.steckbrett.codiere(buchstabe);
+ public char codiere(char buchstabe) {
+ buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+ buchstabe = this.walzen[0].codiere(buchstabe);
buchstabe = this.walzen[1].codiere(buchstabe);
buchstabe = this.walzen[2].codiere(buchstabe);
- buchstabe = this.walzen[3].codiere(buchstabe);
buchstabe = this.reflektor.codiere(buchstabe);
- buchstabe = this.walzen[3].codiere2(buchstabe);
buchstabe = this.walzen[2].codiere2(buchstabe);
buchstabe = this.walzen[1].codiere2(buchstabe);
+ buchstabe = this.walzen[0].codiere2(buchstabe);
buchstabe = this.steckbrett.codiere(buchstabe);
+ this.dreheWalzen();
+
this.nachricht += buchstabe;
return buchstabe;
}
/**
- * Nachricht entschlüsseln
- *
- * @param nachricht : String : Verschlüsselte Nachricht
- * @return String : Die Klartext Nachricht
+ * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
+ * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
*/
- private String decodiereNachricht(String nachricht) {
-
- return "";
+ private void dreheWalzen() {
+ if (this.walzen[0].dreheWalze()) {
+ if (this.walzen[1].dreheWalze()) {
+ this.walzen[2].dreheWalze();
+ }
+ }
}
+ /**
+ * Gibt die verbauten Walzen Objekte zurück
+ *
+ * @return Walze[] : Array mit den Walzen Objekten
+ */
public Walze[] getWalzen() {
return this.walzen;
}
- public void setWalzen(int walze, int position, int ringstellung) {
+ /**
+ * Setzt eine Walze ein und speichert das Objekt im Walzen Array
+ *
+ * @param position : int : Position der Walze
+ * @param walze : int : Die Nummer der Walze
+ * @param ringstellung : int : Umsprung Punkt der Walze
+ */
+ public void setWalzen(int position, int walze, int ringstellung) {
this.walzen[position] = new Walze(walze, ringstellung);
}
+ /**
+ * Gibt das Objekt des Steckbretts zurück
+ *
+ * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
+ */
public Steckbrett getSteckbrett() {
return steckbrett;
}
+ /**
+ * Setzt das übergebene Steckbrett Objekt in die Hardware ein
+ *
+ * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
+ */
public void setSteckbrett(Steckbrett steckbrett) {
this.steckbrett = steckbrett;
}
+ /**
+ * Liest den Reflektor aus und gibt ihn zurück
+ *
+ * @return Reflektor : Objekt des Reflektors
+ */
public Reflektor getReflektor() {
return reflektor;
}
+ /**
+ * Setzt den Reflektor ein.
+ * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
+ * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
+ * welches ausgetauscht werden kann.
+ *
+ * @param reflektor : Reflektor : Das Obejtk des Reflektors
+ */
public void setReflektor(Reflektor reflektor) {
this.reflektor = reflektor;
}
+ /**
+ * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
+ * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+ *
+ * @return String : Kenngruppe
+ */
public String getKenngruppe() {
return kenngruppe;
}
+ /**
+ * Setzt die Kenngruppe welche die Enigma gerade benutzt.
+ *
+ * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+ */
public void setKenngruppe(String kenngruppe) {
this.kenngruppe = kenngruppe;
}
+
+ /**
+ * Gibt die bisher erstellte Nachricht zurück
+ *
+ * @return String : Erstellte Nachricht
+ */
+ public String getNachricht() {
+ return nachricht;
+ }
}
diff --git a/src/main/java/Enigma/model/Reflektor.java b/src/main/java/Enigma/model/Reflektor.java
index 1457cf3a7c6fc302ec19deae15dc826154966e11..a3069b863341a420aa9e30cd70620d8d043706c6 100644
--- a/src/main/java/Enigma/model/Reflektor.java
+++ b/src/main/java/Enigma/model/Reflektor.java
@@ -10,7 +10,7 @@ package Enigma.model;
* nach Betätigung einer Taste nicht dreht (starr montiert) und sie gibt keine Signale
* an andere Walzen zum drehen.
*/
-class Reflektor {
+public class Reflektor {
/**
* Konstanten und Variablen der Klasse Reflektor
@@ -34,7 +34,7 @@ class Reflektor {
*
* @return reflektorBuchstabeRaus: Character: Der kodierte Buchstabe aus dem Reflektor
*/
- char codiere(Character buchstabe) {
+ public char codiere(Character buchstabe) {
int iPositionReflektor = 0;
/*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
index 4f7317fbaf0fa4267cafe073394d3315cb63c9c8..376934b695ee61103bb01773c67f0536342fcc6e 100644
--- a/src/main/java/Enigma/model/Walze.java
+++ b/src/main/java/Enigma/model/Walze.java
@@ -125,13 +125,13 @@ public class Walze {
boolean checkRing;
- if (iPositionBuchstabe == 25) {
- iPositionBuchstabe = 0;
+ if (this.iPositionBuchstabe == 25) {
+ this.iPositionBuchstabe = 0;
} else {
- iPositionBuchstabe += 1;
+ this.iPositionBuchstabe += 1;
}
- checkRing = iPositionBuchstabe == getRingstellung();
+ checkRing = this.iPositionBuchstabe == getRingstellung();
return checkRing;
}
@@ -147,12 +147,21 @@ public class Walze {
* @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
*/
public char codiere(char buchstabe) {
+ /**
+ * TODO: contains fragt ab ob der char im Alphabet enthalten ist. Das sollten wir vielleicht noch in eine
+ * Hilfsfunktion packen. Vielleicht sogar in der Hardware Klasse.
+ */
+ boolean contains = false;
for (int i = 0; i < walzeAlpha.length; i++) {
if (walzeAlpha[i].equals(buchstabe)) {
buchstabe = walzenNummer()[i];
+ contains = true;
break;
}
}
+ if(!contains) {
+ buchstabe = 'X';
+ }
return buchstabe;
}
diff --git a/src/test/java/Enigma/model/CodebuchTest.java b/src/test/java/Enigma/model/CodebuchTest.java
index 91e265342537fdf07e92ca735f9e377b48b4e424..aa64deaa3f9c17f57767b284a452cf00149c923d 100644
--- a/src/test/java/Enigma/model/CodebuchTest.java
+++ b/src/test/java/Enigma/model/CodebuchTest.java
@@ -14,11 +14,9 @@ public class CodebuchTest {
"Steckverbindung: CO,DI,FR,HU,JW,LS,TX\n";
try {
- // Codebuch abrufen
- Codebuch cb = new DatenbankSqlite().getCodebuch(1);
// Ausgabe auf der Konsole
String result = new DatenbankSqlite().getCodebuch(1).toString();
- Assert.assertEquals(expected, result);
+ Assert.assertEquals(result, expected, result);
} catch (SQLException e) {
e.printStackTrace();
}
diff --git a/src/test/java/Enigma/model/HardwareTest.java b/src/test/java/Enigma/model/HardwareTest.java
index 1d7196ff2c6ebdfe0c8095dfcaca2f579b56f39c..78bd24110f1742bd715af8f4bcceac50dfc7e243 100644
--- a/src/test/java/Enigma/model/HardwareTest.java
+++ b/src/test/java/Enigma/model/HardwareTest.java
@@ -10,9 +10,9 @@ public class HardwareTest {
Hardware h = new Hardware();
h.setReflektor(new Reflektor());
h.setSteckbrett(new Steckbrett());
- h.setWalzen(1, 1, 1);
- h.setWalzen(2, 2, 1);
- h.setWalzen(3, 3, 1);
+ h.setWalzen(0, 1, 1);
+ h.setWalzen(1, 2, 1);
+ h.setWalzen(2, 3, 1);
/*
A = E = S = G = Y = O = Y = O
@@ -33,18 +33,18 @@ public class HardwareTest {
Reflektor {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
*/
- char result = h.tippeBuchstabe('A');
+ char result = h.codiere('A');
Assert.assertEquals("Codiere: Erwartet O, erhalten "+ result, 'O', result);
- result = h.tippeBuchstabe('I');
+ result = h.codiere('I');
Assert.assertEquals("Codiere: Erwartet S, erhalten "+ result, 'S', result);
- result = h.tippeBuchstabe('F');
+ result = h.codiere('F');
Assert.assertEquals("Codiere: Erwartet P, erhalten "+ result, 'P', result);
- result = h.tippeBuchstabe('O');
+ result = h.codiere('O');
Assert.assertEquals("Decodiere: Erwartet A, erhalten "+ result, 'A', result);
- result = h.tippeBuchstabe('S');
+ result = h.codiere('S');
Assert.assertEquals("Decodiere: Erwartet I, erhalten "+ result, 'I', result);
- result = h.tippeBuchstabe('P');
+ result = h.codiere('P');
Assert.assertEquals("Decodiere: Erwartet F, erhalten "+ result, 'F', result);
h.getSteckbrett().setzeVertauschung('B', 'G');
@@ -53,10 +53,10 @@ public class HardwareTest {
h.getSteckbrett().setzeVertauschung('M', 'Q');
h.getSteckbrett().setzeVertauschung('T', 'X');
- result = h.tippeBuchstabe('I');
+ result = h.codiere('I');
Assert.assertEquals("Codiere: Erwartet F, erhalten "+ result, 'F', result);
- result = h.tippeBuchstabe('F');
+ result = h.codiere('F');
Assert.assertEquals("Codiere: Erwartet I, erhalten "+ result, 'I', result);
}
}
\ No newline at end of file