Unit Tests. Fix der Walzen Klasse.

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

 package Enigma.model;
 
-import java.time.Year;
-
 /**
  * Klasse Walze
  * <p>
@@ -26,8 +24,8 @@ public class Walze {
 	 * 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'};
+	/*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;
@@ -58,12 +56,12 @@ public class Walze {
 	 */
 	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[] 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'};
+		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:
@@ -90,10 +88,10 @@ public class 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'};
+		/*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];
+		return walzeAlphabeth[iPositionBuchstabe];
 	}
 
 
@@ -132,13 +130,13 @@ public class Walze {
 			iPositionBuchstabe = 0;
 		} else {
 			iPositionBuchstabe += 1;
-    	}
+		}
 
 		if (iPositionBuchstabe == getRingstellung()) {
 			checkRing = true;
 		} else {
 			checkRing = false;
-    	}
+		}
 
 		return checkRing;
 	}
@@ -154,14 +152,14 @@ public class Walze {
 	 * @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 buchstabe;
+		for (int i = 0; i < walzeAlpha.length; i++) {
+			if (walzeAlpha[i].equals(buchstabe)) {
+				buchstabe = walzenNummer()[i];
+				break;
+			}
+		}
+
+		return buchstabe;
 	}
 
 
@@ -176,12 +174,12 @@ public class Walze {
 	 */
 	public char codiere2(char buchstabe) {
 
-	    for(int i = 0; i < walzenNummer().length; i++) {
-            if(walzenNummer()[i].equals(buchstabe)) {
-                buchstabe = walzeAlpha[i];
-                break;
-            }
-        }
+		for (int i = 0; i < walzenNummer().length; i++) {
+			if (walzenNummer()[i].equals(buchstabe)) {
+				buchstabe = walzeAlpha[i];
+				break;
+			}
+		}
 
 		return buchstabe;
 	}
@@ -207,17 +205,16 @@ public class Walze {
 
 		if (Character.isLetter(buchstabe)) {
 			this.buchstabe = Character.toUpperCase(buchstabe);
-			for(int i = 0; i < 25; i++) {
-			    if(walzeAlpha[i].equals(buchstabe)) {
-                    this.iPositionBuchstabe = i;
-                }
-            }
+			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.
 
 	/**

src/test/java/Enigma/model/HardwareTest.java

+package Enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class HardwareTest {
+
+	@Test
+	public void tippeBuchstabe() {
+		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);
+
+		/*
+	        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.tippeBuchstabe('A');
+		Assert.assertEquals("Codiere: Erwartet O, erhalten "+ result, 'O', result);
+		result = h.tippeBuchstabe('I');
+		Assert.assertEquals("Codiere: Erwartet S, erhalten "+ result, 'S', result);
+		result = h.tippeBuchstabe('F');
+		Assert.assertEquals("Codiere: Erwartet P, erhalten "+ result, 'P', result);
+
+		result = h.tippeBuchstabe('O');
+		Assert.assertEquals("Decodiere: Erwartet A, erhalten "+ result, 'A', result);
+		result = h.tippeBuchstabe('S');
+		Assert.assertEquals("Decodiere: Erwartet I, erhalten "+ result, 'I', result);
+		result = h.tippeBuchstabe('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.tippeBuchstabe('I');
+		Assert.assertEquals("Codiere: Erwartet F, erhalten "+ result, 'F', result);
+
+		result = h.tippeBuchstabe('F');
+		Assert.assertEquals("Codiere: Erwartet I, erhalten "+ result, 'I', result);
+	}
+}
\ No newline at end of file

src/test/java/Enigma/model/ReflektorTest.java

@@ -14,12 +14,6 @@ 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'));

src/test/java/Enigma/model/SteckbrettTest.java

@@ -24,13 +24,4 @@ public class SteckbrettTest {
 		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'));
-	}
 }
\ No newline at end of file

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