Merge branch 'master' into 'master'

Hardware Klasse, Unit Tests, Fixes für Walzen und Reflektor

See merge request alfatrainingkurse/java/enigma!19

src/main/java/Enigma/App.java

 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

src/main/java/Enigma/model/Hardware.java

+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;
+	}
+}

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

src/main/java/Enigma/model/Walze.java

 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");
+		}
+	}
 
 }

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

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

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