diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
index 1e8c80902cf8d08f3c1da4ff39b18a55028dac21..d166be1527024b2dbcf6c3d3c7442fd8e6cc3dc4 100644
--- a/src/main/java/Enigma/App.java
+++ b/src/main/java/Enigma/App.java
@@ -1,39 +1,112 @@
package Enigma;
+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.time.LocalDate;
+import java.time.ZoneId;
/**
* JavaFX App
*/
public class App extends Application {
- private static Scene scene;
+ 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();
+ 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();
+ }
- static void setRoot(String fxml) throws IOException {
- scene.setRoot(loadFXML(fxml));
- }
+ public static void main(String[] args) {
+ Application.launch();
+ }
- private static Parent loadFXML(String fxml) throws IOException {
- FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
- return fxmlLoader.load();
- }
+ @Override
+ public void start(Stage stage) throws IOException {
+ scene = new Scene(loadFXML("gui"));
+ stage.setScene(scene);
+ stage.show();
- public static void main(String[] args) {
- Application.launch();
- }
+ 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);
+
+ // 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..ee7b96e0aa0af4d2e3a48a12f88631c039944a2c 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 int[] 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 int[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,31 @@ 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 (int 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(",");
- svLoop = true;
- }
+ for (char[] verbindung : this.getSteckverbindung()) {
+ sb.append(verbindung[0]).append(":").append(verbindung[1]).append(",");
+ svLoop = true;
}
- if(svLoop) {
+ if (svLoop) {
sb.setLength(sb.length() - 1);
}
sb.append("\n");
@@ -80,65 +93,85 @@ 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 int[] 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 kabel : 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[] kabel) {
+ int counter = 0;
+
+ for (String stecker : kabel) {
+ char[] verbindung = new char[2];
+ 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, int ringstellung) {
+ this.ringstellung[position] = ringstellung;
}
}
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/Enigma/model/DatenbankSqlite.java
index 0a96e0654ae04e5c3dc49fa132e3f39b75ddf2ac..236b2bbeb90acf80cf2f127a627c5236e3757867 100644
--- a/src/main/java/Enigma/model/DatenbankSqlite.java
+++ b/src/main/java/Enigma/model/DatenbankSqlite.java
@@ -1,8 +1,6 @@
package Enigma.model;
-import javax.swing.text.html.HTML;
import java.sql.*;
-import java.util.Random;
/**
* Dies ist die SQLite Datenbank Klasse
@@ -53,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, Integer.parseInt(ringstellung[i]));
+ }
+
cb.setSteckverbindung(rs.getString("Steckverbindung").split(","));
}
@@ -64,14 +73,14 @@ public class DatenbankSqlite {
}
//region Random New Codebuch generieren
- /*
- *//**
+ /**
* Setzt zufällige Codebuch Einträge in die SQLite Datenbank
* Tag => int
* Walzenlage => String w1,w2,w3
* Ringstellung => String r1,r2,r3
* Steckverbindungen => s0,s1,s2,s3,s4,s5,s6,s7,s8,s9
- *//*
+ */
+ /*
public void autoGenCodebuch() throws SQLException {
Connection conn = connect();
@@ -88,11 +97,12 @@ public class DatenbankSqlite {
conn.commit();
}
- *//**
+ /**
* Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 5)
* die Zahlen sind durch Komma getrennt
* @return String => walzenlage mit drei Kommaseparierten Zufallszahlen zwischen 1 und 5
- *//*
+ */
+ /*
private static String walzenlage(){
String walzenlage;
Random random = new Random();
@@ -105,13 +115,14 @@ public class DatenbankSqlite {
}
walzenlage= w[0]+","+w[1]+","+w[2];
return walzenlage;
- }
+ }*/
- *//**
+ /**
* Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 26)
* die Zahlen sind durch Komma getrennt
* @return String => ringstellung mit drei Kommaseparierten Zufallszahlen zwischen 1 und 26
- *//*
+ */
+ /*
private static String ringstellung(){
String ringstellung;
Random random = new Random();
@@ -121,9 +132,9 @@ public class DatenbankSqlite {
}
ringstellung= w[0]+","+w[1]+","+w[2];
return ringstellung;
- }
+ }*/
- *//**
+ /**
* Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
* @return String => 10 Buchstabenkombinationen mit Komma getrennt
*//*
diff --git a/src/main/java/Enigma/model/Funkraum.java b/src/main/java/Enigma/model/Funkraum.java
index de283e750d219646a8fbca82f81626a4b94dff0d..acb4e632acca7338eebcb5ad1044df34a7570576 100644
--- a/src/main/java/Enigma/model/Funkraum.java
+++ b/src/main/java/Enigma/model/Funkraum.java
@@ -13,7 +13,6 @@ import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
-import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9eebc5f029af7cc8cceeddd9c828a70efee3039
--- /dev/null
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -0,0 +1,227 @@
+package Enigma.model;
+
+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;
+ private Steckbrett steckbrett;
+ private Reflektor reflektor;
+ private String nachricht;
+ private String kenngruppe;
+
+ /**
+ * 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];
+ this.nachricht = "";
+ }
+
+ /**
+ * Setzt eine Walze ein
+ *
+ * @param walze : int : Setzt die Walze mit der angegebenen Nummer ein
+ * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+ */
+ public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+ this.walzen[walze] = new Walze(walzenNr, ringstellung);
+ }
+
+ /**
+ * Setzt den Notch der Walze
+ *
+ * @param walze : int : Position der Walze
+ * @param position : int : Umspringpunkt auf der Walze
+ */
+ public void setzeRing(int walze, int position) {
+ this.walzen[walze].setRingstellung(position);
+ }
+
+ /**
+ * Setzt den Startwert (position) der Walze (walze)
+ *
+ * @param walze : int : Nummer der Walze
+ * @param buchstabe : char : Buchstabe der zugewiesen soll
+ */
+ public void setzePosition(int walze, char buchstabe) {
+ this.walzen[walze].setBuchstabe(buchstabe);
+ }
+
+ /**
+ * 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);
+ }
+
+ /**
+ * Gibt die letzte empfangene Nachricht zurück
+ * <p>
+ * String[0} Tag wann die Nachricht gesendet wurde
+ * String[1] = Die verschlüsselte Nachricht
+ * String[2] = Nachricht im Klartext
+ */
+ public String[] empfangeNachricht() {
+ String[] codierteNachricht = new String[3];
+ Morsecode mc = new Morsecode();
+
+ try {
+ codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+ String morsecode = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+ String decodiert = "";
+
+ for (char buchstabe : morsecode.toCharArray()) {
+ decodiert += this.codiere(buchstabe);
+ }
+
+ codierteNachricht[2] = decodiert;
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return codierteNachricht;
+ }
+
+ /**
+ * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
+ *
+ * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+ * @return char : Der ver/entschlüsselte Buchstabe
+ */
+ public char codiere(char buchstabe) {
+ this.dreheWalzen();
+
+ 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.reflektor.codiere(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.nachricht += buchstabe;
+
+ return buchstabe;
+ }
+
+ /**
+ * 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 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;
+ }
+
+ /**
+ * 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/Morsecode.java b/src/main/java/Enigma/model/Morsecode.java
index f8c759cf70fd7d17b2024ce91077b5835c46c618..38e2b1febd8d01994fd91365184f0d6c420ffe2c 100644
--- a/src/main/java/Enigma/model/Morsecode.java
+++ b/src/main/java/Enigma/model/Morsecode.java
@@ -93,7 +93,6 @@ public class Morsecode {
*/
private String getBuchstabe(String morsecode) {
// Initialisieren des Rückgabe Strings
- // TODO: Darf bei der Initialisierung gleich einen Wert setzten lauf JAVA Konventionen?
String result = null;
// Loopt duch die Codemap und erstellt daraus ein Set
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
index 86cf8f4e1e8a76861c3aca23ea5dfef415816121..36ac2336bc40ce093bbbc6bb7a9e124c9a4e1539 100644
--- a/src/main/java/Enigma/model/Walze.java
+++ b/src/main/java/Enigma/model/Walze.java
@@ -1,246 +1,239 @@
package Enigma.model;
+import java.time.Year;
+
/**
* Klasse Walze
- *
+ * <p>
* Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
- *
+ * <p>
* 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
* 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
* paarweise vertauschen)
- *
+ * <p>
* 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
* den Drehzeitpunkt der linken Nachbarwalze)
- *
*/
public class Walze {
- /**
- * Konstanten und Variablen der Klasse Walze
- *
- * buchstabe : Bestimmt den Buchstaben
- * ringstellung : Bestimmt den Umspringpunkt der Walze
- * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
- * iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder.
- * iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder.
- * private Character[] walze : Character-Array der Walze
- */
-
- private Character buchstabe;
- private Character ringstellung;
- private int walzennr;
- private int iPositionBuchstabe;
- private int iPositionBuchstabeRe;
- private Character[] walze;
-
-
-
- /**
- * Gibt die Parameter der Walze mit
- *
- * @param walzennr : int : Nummer der gewaehlten Walze
- * @param ringstellung : Character : Einstellung des Notch
- */
- public Walze(int walzennr, Character ringstellung) {
- this.walze = new Character[25];
- this.walzennr = walzennr;
- this.buchstabe = 'A';
- this.ringstellung = ringstellung;
- }
-
-
- /**
- * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
- *
- * @return walze : Character[] : gibt die gewaehlte Walze zurueck
- */
- private Character[] walzenNummer() {
-
- /*Walze nach der Chiffrierung*/
- Character[] walzeEins = {'E','K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
- Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
- Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
- Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
- Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
-
- switch (walzennr) {
- case 1:
- walze = walzeEins;
- break;
- case 2:
- walze = walzeZwei;
- break;
- case 3:
- walze = walzeDrei;
- break;
- case 4:
- walze = walzeVier;
- break;
- case 5:
- walze = walzeFuenf;
- break;
- }
-
- return walze;
- }
-
-
-
- //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
- public int walzenPosition() {
-
- /*Alphabetswalze*/
- Character[] walzeAlphabeth = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
- for(int index = 0; index < walzeAlphabeth.length; index++) {
- if(getBuchstabe().equals(walzeAlphabeth[index])) {
- iPositionBuchstabe = index;
- break;
- }
- }
- return iPositionBuchstabe;
- }
-
-
- //setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens
- // Setter für Ringstellung
- /**
- * Gibt die Initiale Ringstellung der Walze an.
- * Es sind nur Zahlen von 1 - 26 zugelassen.
- * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
- *
- * @param ringstellung : Character : Punkt an dem die Walze umspringt
- */
- public void setRingstellung(Character ringstellung) {
-
- if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
- this.ringstellung = ringstellung;
- } else {
- this.ringstellung = '1';
- }
- }
-
- /**
- * @return ringstellung : Character : gibt die neue Ringstellung zurueck
- */
- public Character getRingstellung() {
- return ringstellung;
- }
-
-
-
- //dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
- public boolean dreheWalze(){
-
- boolean checkRing;
-
- if(iPositionBuchstabe == 25) {
-
- iPositionBuchstabe = 0;
-
- } else {
-
- iPositionBuchstabe += 1;
- }
-
- if (iPositionBuchstabe == getRingstellung()){
-
- checkRing = true;
-
- }else{
-
- checkRing = false;
- }
-
- return checkRing;
- }
-
-
- //codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück
- /**
- * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
- * anhand der gewaehlten Walze.
- *
- * @param
- * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
- */
- public Character codiere(Character buchstabe) {
- setBuchstabe(buchstabe);
- walzenPosition();
- Character codierterBuchstabe = walzenNummer()[iPositionBuchstabe];
- return codierterBuchstabe;
- }
-
-
- //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
- /**
- * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
- * anhand der AlphaWalze.
- *
- * @param
- * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
- */
- public Character codiere2(char buchstabe) {
-
- /*Alphawalze*/
- Character[] walzeAlpha = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
- setBuchstabe(buchstabe);
-
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
- for(int index = 0; index < walzenNummer().length; index++) {
- if(getBuchstabe().equals(walzenNummer()[index])) {
- iPositionBuchstabeRe = index;
- break;
- }
- }
-
- Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
- return codierterBuchstabeRe;
-
-
- }
+ /**
+ * Konstanten und Variablen der Klasse Walze
+ * <p>
+ * buchstabe : Bestimmt den Buchstaben
+ * ringstellung : Bestimmt den Umspringpunkt der Walze
+ * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
+ * iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder.
+ * iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder.
+ * private Character[] walze : Character-Array der Walze
+ */
+ /*Alphawalze*/
+ private final static Character[] walzeAlpha = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+ private Character buchstabe;
+ private int ringstellung;
+ private int walzennr;
+ private int iPositionBuchstabe;
+ private Character[] walze;
+
+
+ /**
+ * Gibt die Parameter der Walze mit
+ *
+ * @param walzennr : int : Nummer der gewaehlten Walze
+ * @param ringstellung : Character : Einstellung des Notch
+ */
+ public Walze(int walzennr, int ringstellung) {
+ this.walze = new Character[25];
+ this.walzennr = walzennr;
+ this.buchstabe = 'A';
+ this.iPositionBuchstabe = 0;
+ this.ringstellung = ringstellung;
+ }
+
+
+ /**
+ * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
+ *
+ * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+ */
+ private Character[] walzenNummer() {
+
+ Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+ Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+ Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+
+ Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+ Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+
+ switch (this.walzennr) {
+ case 1:
+ walze = walzeEins;
+ break;
+ case 2:
+ walze = walzeZwei;
+ break;
+ case 3:
+ walze = walzeDrei;
+ break;
+ case 4:
+ walze = walzeVier;
+ break;
+ case 5:
+ walze = walzeFuenf;
+ break;
+ }
+
+ return walze;
+ }
+
+
+ //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
+ public char walzenPosition() {
+
+ /*Alphabetswalze*/
+ Character[] walzeAlphabeth = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+ return walzeAlphabeth[iPositionBuchstabe];
+ }
+
+
+ //setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens
+ // Setter für Ringstellung
+
+ /**
+ * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+ */
+ public int getRingstellung() {
+ return ringstellung;
+ }
+
+ /**
+ * Gibt die Initiale Ringstellung der Walze an.
+ * Es sind nur Zahlen von 1 - 26 zugelassen.
+ * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
+ *
+ * @param ringstellung : Character : Punkt an dem die Walze umspringt
+ */
+ public void setRingstellung(int ringstellung) {
+
+ if (ringstellung > 0 && ringstellung <= 26) {
+ this.ringstellung = ringstellung;
+ } else {
+ this.ringstellung = 1;
+ }
+ }
+
+ //dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
+ public boolean dreheWalze() {
+
+ boolean checkRing;
+
+ if (this.iPositionBuchstabe == 25) {
+ this.iPositionBuchstabe = 0;
+ } else {
+ this.iPositionBuchstabe += 1;
+ }
+
+ checkRing = this.iPositionBuchstabe == getRingstellung();
+
+ return checkRing;
+ }
+
+
+ //codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück
+
+ /**
+ * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
+ * anhand der gewaehlten Walze.
+ *
+ * @param
+ * @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;
+ }
+
+
+ //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
+
+ /**
+ * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+ * anhand der AlphaWalze.
+ *
+ * @param
+ * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
+ */
+ public char codiere2(char buchstabe) {
+
+ for (int i = 0; i < walzenNummer().length; i++) {
+ if (walzenNummer()[i].equals(buchstabe)) {
+ buchstabe = walzeAlpha[i];
+ break;
+ }
+ }
+
+ return buchstabe;
+ }
//_________________________________________________________________________________________
- /**
- * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
- */
- public Character getBuchstabe() {
- return buchstabe;
- }
-
- /**
- * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
- * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
- * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
- *
- * @param buchstabe : Character : Grundeinstellung der Walze
- */
- public void setBuchstabe(Character buchstabe) {
-
- if(Character.isLetter(buchstabe)) {
- this.buchstabe = Character.toUpperCase(buchstabe);
- } else {
- this.buchstabe = 'A';
- }
- }
-
-
- //TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
- /**
- * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
- *
- * @param walzennr : int : setzt die Walzennummer
- */
- public void setWalzennr(int walzennr) {
- if(walzennr > 0 && walzennr < 6) {
- this.walzennr = walzennr;
- } else {
- System.err.println("Keine gültige Walzennummer");
- }
- }
+ /**
+ * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
+ */
+ public Character getBuchstabe() {
+ return buchstabe;
+ }
+
+ /**
+ * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+ * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+ * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
+ *
+ * @param buchstabe : Character : Grundeinstellung der Walze
+ */
+ public void setBuchstabe(Character buchstabe) {
+
+ if (Character.isLetter(buchstabe)) {
+ this.buchstabe = Character.toUpperCase(buchstabe);
+ for (int i = 0; i < 25; i++) {
+ if (walzeAlpha[i].equals(buchstabe)) {
+ this.iPositionBuchstabe = i;
+ }
+ }
+ } else {
+ this.buchstabe = 'A';
+ }
+ }
+
+ //TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
+
+ /**
+ * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
+ *
+ * @param walzennr : int : setzt die Walzennummer
+ */
+ public void setWalzennr(int walzennr) {
+ if (walzennr > 0 && walzennr < 6) {
+ this.walzennr = walzennr;
+ } else {
+ System.err.println("Keine gültige Walzennummer");
+ }
+ }
}
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
new file mode 100644
index 0000000000000000000000000000000000000000..78bd24110f1742bd715af8f4bcceac50dfc7e243
--- /dev/null
+++ b/src/test/java/Enigma/model/HardwareTest.java
@@ -0,0 +1,62 @@
+package Enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HardwareTest {
+
+ @Test
+ public void tippeBuchstabe() {
+ Hardware h = new Hardware();
+ h.setReflektor(new Reflektor());
+ h.setSteckbrett(new Steckbrett());
+ h.setWalzen(0, 1, 1);
+ h.setWalzen(1, 2, 1);
+ h.setWalzen(2, 3, 1);
+
+ /*
+ A = E = S = G = Y = O = Y = O
+ I = V = Y = Q = O = Z = S = S
+ F = G = R = W = K = U = H = P
+
+ In S 1 2 3 R 3 2 1 S
+ A E D H X S Z J
+ J Z E J B D K N
+
+ Walze nach der Chiffrierung
+ Alphabet {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+ Steckbrett {'B', 'G', 'D', 'F'}
+ Steckbrett {'G', 'B', 'F', 'F'}
+ Walze 1 {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+ Walze 2 {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+ Walze 3 {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+ 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.codiere('A');
+ Assert.assertEquals("Codiere: Erwartet O, erhalten "+ result, 'O', result);
+ result = h.codiere('I');
+ Assert.assertEquals("Codiere: Erwartet S, erhalten "+ result, 'S', result);
+ result = h.codiere('F');
+ Assert.assertEquals("Codiere: Erwartet P, erhalten "+ result, 'P', result);
+
+ result = h.codiere('O');
+ Assert.assertEquals("Decodiere: Erwartet A, erhalten "+ result, 'A', result);
+ result = h.codiere('S');
+ Assert.assertEquals("Decodiere: Erwartet I, erhalten "+ result, 'I', result);
+ result = h.codiere('P');
+ Assert.assertEquals("Decodiere: Erwartet F, erhalten "+ result, 'F', result);
+
+ h.getSteckbrett().setzeVertauschung('B', 'G');
+ h.getSteckbrett().setzeVertauschung('D', 'F');
+ h.getSteckbrett().setzeVertauschung('I', 'L');
+ h.getSteckbrett().setzeVertauschung('M', 'Q');
+ h.getSteckbrett().setzeVertauschung('T', 'X');
+
+ result = h.codiere('I');
+ Assert.assertEquals("Codiere: Erwartet F, erhalten "+ result, 'F', result);
+
+ result = h.codiere('F');
+ Assert.assertEquals("Codiere: Erwartet I, erhalten "+ result, 'I', result);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/ReflektorTest.java b/src/test/java/Enigma/model/ReflektorTest.java
index 74ab4f6410b5aa1592c9ed50903372ef774c70f5..255e2ff280713b19c888c0f199ad07420fb2130b 100644
--- a/src/test/java/Enigma/model/ReflektorTest.java
+++ b/src/test/java/Enigma/model/ReflektorTest.java
@@ -7,7 +7,6 @@ public class ReflektorTest {
@Test
public void codiere() {
- /*
Reflektor r = new Reflektor();
Assert.assertEquals('E', r.codiere('A'));
@@ -15,19 +14,10 @@ public class ReflektorTest {
Assert.assertEquals('X', r.codiere('H'));
Assert.assertEquals('O', r.codiere('Q'));
Assert.assertEquals('I', r.codiere('V'));
- //Assert.assertNull(null, r.codiere(null));
- */
- }
-
- @Test
- public void codiere2() {
- /*
- Reflektor r = new Reflektor();
Assert.assertEquals('A', r.codiere('E'));
Assert.assertEquals('D', r.codiere('Z'));
Assert.assertEquals('H', r.codiere('X'));
Assert.assertEquals('Q', r.codiere('O'));
Assert.assertEquals('V', r.codiere('I'));
- */
}
}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/SteckbrettTest.java b/src/test/java/Enigma/model/SteckbrettTest.java
index df6051df00bcd397568a5e9e88ba5295eba803a0..f56b31eb015e3815d05aa8ff74ca766f9d10ca7c 100644
--- a/src/test/java/Enigma/model/SteckbrettTest.java
+++ b/src/test/java/Enigma/model/SteckbrettTest.java
@@ -3,34 +3,23 @@ package Enigma.model;
import org.junit.Assert;
import org.junit.Test;
-import static org.junit.Assert.*;
-
public class SteckbrettTest {
@Test
public void setzeVertauschung() {
- /*Steckbrett sb = new Steckbrett();
+ Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('H', sb.codiere('C'));
- Assert.assertEquals('G', sb.codiere('A'));*/
+ Assert.assertEquals('G', sb.codiere('A'));
}
@Test
public void codiere() {
- /*Steckbrett sb = new Steckbrett();
+ Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('H', sb.codiere('C'));
- Assert.assertEquals('G', sb.codiere('A'));*/
- }
-
- @Test
- public void codiere2() {
- /*Steckbrett sb = new Steckbrett();
- sb.setzeVertauschung('A', 'G');
- sb.setzeVertauschung('C', 'H');
- Assert.assertEquals('C', sb.codiere2('H'));
- Assert.assertEquals('A', sb.codiere2('G'));*/
+ Assert.assertEquals('G', sb.codiere('A'));
}
}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/WalzeTest.java b/src/test/java/Enigma/model/WalzeTest.java
index 1c58136c318dbbdce13c250cbadba805805aa0ad..3379019d7913fee1ba2e072b3cc68a6fdb792045 100644
--- a/src/test/java/Enigma/model/WalzeTest.java
+++ b/src/test/java/Enigma/model/WalzeTest.java
@@ -8,38 +8,36 @@ import static org.junit.Assert.*;
public class WalzeTest {
@Test
- public void setzeNotch() {
- /*Walze w = new Walze(1);
- w.setzeNotch('G');
- Assert.assertEquals('G', w.wlazenPosition());*/
+ public void setRingstellung() {
+ Walze w = new Walze(1, 1);
+ Assert.assertEquals('A', w.walzenPosition());
}
@Test
public void dreheWalze() {
- /*Walze w = new Walze(1);
- w.setzeNotch('G');
- w.dreheWalze();
- Assert.assertEquals('H', w.wlazenPosition());*/
+ Walze w = new Walze(1, 3);
+ assertFalse("false erwartet, true geliefert", w.dreheWalze());
+ char temp = w.walzenPosition();
+ Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);
}
@Test
public void walzenPoition() {
- /*Walze w = new Walze(1);
- w.setzeNotch('G');
- Assert.assertEquals('G', w.wlazenPosition());*/
+ Walze w = new Walze(1, 1);
+ Assert.assertEquals('A', w.walzenPosition());
}
@Test
public void codiere() {
- /*Walze w = new Walze(1);
- w.setzeNotch('A');
- Assert.assertEquals('E', w.codiere('A'));*/
+ Walze w = new Walze(1, 1);
+ char result = w.codiere('G');
+ Assert.assertEquals("Erwartet D erhalten " + result, 'D', result);
}
@Test
public void codiere2() {
- /*Walze w = new Walze(1);
- w.setzeNotch('A');
- Assert.assertEquals('A', w.codiere('E'));*/
+ Walze w = new Walze(1, 1);
+ char result = w.codiere2('E');
+ Assert.assertEquals("Erwartet A erhalten " + result, 'A', result);
}
}
\ No newline at end of file