diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
index 1e8c80902cf8d08f3c1da4ff39b18a55028dac21..397e3da90e1e0d2b82b59228454c2238967d18c2 100644
--- a/src/main/java/Enigma/App.java
+++ b/src/main/java/Enigma/App.java
@@ -1,5 +1,8 @@
package Enigma;
+import Enigma.model.Codebuch;
+import Enigma.model.DatenbankSqlite;
+import Enigma.model.Hardware;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
@@ -7,6 +10,9 @@ import javafx.scene.Scene;
import javafx.stage.Stage;
import java.io.IOException;
+import java.sql.SQLException;
+import java.util.Calendar;
+import java.util.TimeZone;
/**
* JavaFX App
@@ -14,13 +20,15 @@ import java.io.IOException;
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 {
@@ -36,4 +44,31 @@ public class App extends Application {
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();
+ Steckbrett sb = new Steckbrett();
+
+ if(w1.dreheWalze()) {
+ if(w2.dreheWalze()) {
+ w3.dreheWalze();
+ }
+ }*/
+ }
+
}
\ No newline at end of file
diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
new file mode 100644
index 0000000000000000000000000000000000000000..4280ddc35b124f5b229a8bfab1315961a0d5c237
--- /dev/null
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -0,0 +1,128 @@
+package Enigma.model;
+
+import org.apache.http.HttpException;
+
+import java.io.IOException;
+
+public class Hardware {
+
+ private Walze[] walzen;
+ private Steckbrett steckbrett;
+ private Reflektor reflektor;
+ private String nachricht;
+ private String kenngruppe;
+
+ public Hardware() {
+ this.walzen = new Walze[4];
+ }
+
+ /**
+ * 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) {
+ }
+
+ /**
+ * 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) {
+ }
+
+ /**
+ * Setzt den Startwert (position) der Walze (walze)
+ *
+ * @param walze
+ * @param buchstabe
+ */
+ public void setzePosition(int walze, char buchstabe) {
+ }
+
+ // Befehl die Nachricht an den Funker zu übergeben
+ 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] = Die verschlüsselte Nachricht
+ * String[1] = Nachricht im Klartext
+ */
+ public String[] empfangeNachricht() {
+ String[] result = new String[2];
+
+ return result;
+ }
+
+ /**
+ * Fügt die gedrückte Taste der Nachricht hinzu
+ *
+ * @param buchstabe char : Der zu verschlüsselnde Buchstabe
+ * @return char : Der verschlüsselte Buchstabe
+ */
+ public char tippeBuchstabe(char buchstabe) {
+ buchstabe = this.steckbrett.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.steckbrett.codiere(buchstabe);
+
+ this.nachricht += buchstabe;
+
+ return buchstabe;
+ }
+
+ /**
+ * Nachricht entschlüsseln
+ *
+ * @param nachricht : String : Verschlüsselte Nachricht
+ * @return String : Die Klartext Nachricht
+ */
+ private String decodiereNachricht(String nachricht) {
+ String result = "";
+
+ return result;
+ }
+
+ public Walze[] getWalzen() {
+ return this.walzen;
+ }
+
+ public void setWalzen(int walze, int position, int ringstellung) {
+ this.walzen[position] = new Walze(walze, ringstellung);
+ }
+
+ public Steckbrett getSteckbrett() {
+ return steckbrett;
+ }
+
+ public void setSteckbrett(Steckbrett steckbrett) {
+ this.steckbrett = steckbrett;
+ }
+
+ public Reflektor getReflektor() {
+ return reflektor;
+ }
+
+ public void setReflektor(Reflektor reflektor) {
+ this.reflektor = reflektor;
+ }
+
+ public String getKenngruppe() {
+ return kenngruppe;
+ }
+
+ public void setKenngruppe(String kenngruppe) {
+ this.kenngruppe = kenngruppe;
+ }
+}
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..f12de2a19e99bdb33b4ef8ae9f4d50a6d875b105 100644
--- a/src/main/java/Enigma/model/Walze.java
+++ b/src/main/java/Enigma/model/Walze.java
@@ -1,246 +1,236 @@
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() {
+ /**
+ * 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 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, 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'};
-
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
- for(int index = 0; index < walzeAlphabeth.length; index++) {
- if(getBuchstabe().equals(walzeAlphabeth[index])) {
- iPositionBuchstabe = index;
+ 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 (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 char codiere(char buchstabe) {
+ for(int i = 0; i < walzeAlpha.length; i++) {
+ if(walzeAlpha[i].equals(buchstabe)) {
+ buchstabe = walzenNummer()[i];
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;
- }
+ return buchstabe;
+ }
- if (iPositionBuchstabe == getRingstellung()){
- checkRing = true;
+ //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
- }else{
+ /**
+ * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+ * anhand der AlphaWalze.
+ *
+ * @param
+ * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
+ */
+ public char codiere2(char buchstabe) {
- 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;
+ for(int i = 0; i < walzenNummer().length; i++) {
+ if(walzenNummer()[i].equals(buchstabe)) {
+ buchstabe = walzeAlpha[i];
break;
}
}
- Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
- return codierterBuchstabeRe;
-
-
- }
+ 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/ReflektorTest.java b/src/test/java/Enigma/model/ReflektorTest.java
index 74ab4f6410b5aa1592c9ed50903372ef774c70f5..dbaaa528d98b87f3e89748c5ad7b5a67108d484c 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'));
@@ -16,18 +15,15 @@ public class ReflektorTest {
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..114294f23c5326f9c9fea018cb79d7ef2db5da25 100644
--- a/src/test/java/Enigma/model/SteckbrettTest.java
+++ b/src/test/java/Enigma/model/SteckbrettTest.java
@@ -9,28 +9,28 @@ 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'));*/
+ Assert.assertEquals('G', sb.codiere('A'));
}
@Test
public void codiere2() {
- /*Steckbrett sb = new Steckbrett();
+ 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('A', sb.codiere2('G'));
}
}
\ 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..5b526b615288b9351fa276f90a3763ed3195d51f 100644
--- a/src/test/java/Enigma/model/WalzeTest.java
+++ b/src/test/java/Enigma/model/WalzeTest.java
@@ -9,37 +9,37 @@ public class WalzeTest {
@Test
public void setzeNotch() {
- /*Walze w = new Walze(1);
+ Walze w = new Walze(1);
w.setzeNotch('G');
- Assert.assertEquals('G', w.wlazenPosition());*/
+ Assert.assertEquals('G', w.wlazenPosition());
}
@Test
public void dreheWalze() {
- /*Walze w = new Walze(1);
+ Walze w = new Walze(1);
w.setzeNotch('G');
w.dreheWalze();
- Assert.assertEquals('H', w.wlazenPosition());*/
+ Assert.assertEquals('H', w.wlazenPosition());
}
@Test
public void walzenPoition() {
- /*Walze w = new Walze(1);
+ Walze w = new Walze(1);
w.setzeNotch('G');
- Assert.assertEquals('G', w.wlazenPosition());*/
+ Assert.assertEquals('G', w.wlazenPosition());
}
@Test
public void codiere() {
- /*Walze w = new Walze(1);
+ Walze w = new Walze(1);
w.setzeNotch('A');
- Assert.assertEquals('E', w.codiere('A'));*/
+ Assert.assertEquals('E', w.codiere('A'));
}
@Test
public void codiere2() {
- /*Walze w = new Walze(1);
+ Walze w = new Walze(1);
w.setzeNotch('A');
- Assert.assertEquals('A', w.codiere('E'));*/
+ Assert.assertEquals('A', w.codiere('E'));
}
}
\ No newline at end of file