Merge branch 'master' into 'master'

Unittests etc

See merge request alfatrainingkurse/java/enigma!20

src/main/java/Enigma/model/DatenbankSqlite.java

 package Enigma.model;
 
-import javax.swing.text.html.HTML;
 import java.sql.*;
-import java.util.Random;
 
 /**
  * Dies ist die SQLite Datenbank Klasse
@@ -64,14 +62,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 +86,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 +104,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,12 +121,13 @@ 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
-	 *//*
+	 */
+	/*
 	private static String steckverbindung(){
 		Random rnd = new Random();
 		String steckverbindung="";

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;
 

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

@@ -37,8 +37,8 @@ public class Hardware {
 	/**
 	 * Setzt den Startwert (position) der Walze (walze)
 	 *
-	 * @param walze
-	 * @param buchstabe
+	 * @param walze : int : Nummer der Walze
+	 * @param buchstabe : char : Buchstabe der zugewiesen soll
 	 */
 	public void setzePosition(int walze, char buchstabe) {
 	}
@@ -55,9 +55,8 @@ public class Hardware {
 	 * String[1] = Nachricht im Klartext
 	 */
 	public String[] empfangeNachricht() {
-		String[] result = new String[2];
 
-		return result;
+		return new String[2];
 	}
 
 	/**
@@ -89,9 +88,8 @@ public class Hardware {
 	 * @return String : Die Klartext Nachricht
 	 */
 	private String decodiereNachricht(String nachricht) {
-		String result = "";
 
-		return result;
+		return "";
 	}
 
 	public Walze[] getWalzen() {

src/main/java/Enigma/model/Reflektor.java

@@ -10,7 +10,7 @@ package Enigma.model;
  * nach Betätigung einer Taste nicht dreht (starr montiert) und sie gibt keine Signale
  * an andere Walzen zum drehen.
  */
-public class Reflektor {
+class Reflektor {
 
     /**
      * Konstanten und Variablen der Klasse Reflektor
@@ -34,7 +34,7 @@ public class Reflektor {
      *
      * @return reflektorBuchstabeRaus: Character: Der kodierte Buchstabe aus dem Reflektor
      */
-    public char codiere(Character buchstabe) {
+    char codiere(Character buchstabe) {
         int iPositionReflektor = 0;
 
         /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/

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

@@ -26,13 +26,12 @@ 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;
 	private int iPositionBuchstabe;
-	private int iPositionBuchstabeRe;
 	private Character[] walze;
 
 
@@ -58,12 +57,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 +89,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 +131,9 @@ public class Walze {
 			iPositionBuchstabe = 0;
 		} else {
 			iPositionBuchstabe += 1;
-    	}
+		}
 
-		if (iPositionBuchstabe == getRingstellung()) {
-			checkRing = true;
-		} else {
-			checkRing = false;
-    	}
+		checkRing = iPositionBuchstabe == getRingstellung();
 
 		return checkRing;
 	}
@@ -154,14 +149,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 +171,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 +202,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;
+
+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

@@ -3,8 +3,6 @@ package Enigma.model;
 import org.junit.Assert;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
-
 public class SteckbrettTest {
 
 	@Test
@@ -24,13 +22,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