diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
index 8b1674a30fab0fa501d21942d83e330619d5f0db..21d6626d16aa06a322975e008f4625ee543dad1a 100644
--- a/src/main/java/Enigma/model/Hardware.java
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -1,10 +1,5 @@
package Enigma.model;
-import org.apache.http.HttpException;
-
-import java.io.IOException;
-import java.util.Random;
-
/**
* In dieser Klasse wird die Hardware zusammen gefasst.
* Alle Komponenter der Enigma laufen hier zusammen.
@@ -59,7 +54,7 @@ public class Hardware {
* @param buchstabe : char : Buchstabe der zugewiesen soll
*/
public void setzePosition(int walze, char buchstabe) {
- this.walzen[walze].setBuchstabe(buchstabe);
+ this.walzen[walze].setPosition(buchstabe);
}
/**
@@ -69,17 +64,29 @@ public class Hardware {
* @return char : Der ver/entschlüsselte Buchstabe
*/
public char codiere(char buchstabe) {
+ System.out.println(this.walzen[2].getPosition());
this.dreheWalzen();
+ System.out.println(this.walzen[2].getPosition());
+ System.out.print(buchstabe);
buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
- buchstabe = this.walzen[0].codiere(buchstabe);
- buchstabe = this.walzen[1].codiere(buchstabe);
+ System.out.print(" : " + buchstabe);
buchstabe = this.walzen[2].codiere(buchstabe);
+ System.out.print(" : " + buchstabe);
+ buchstabe = this.walzen[1].codiere(buchstabe);
+ System.out.print(" : " + buchstabe);
+ buchstabe = this.walzen[0].codiere(buchstabe);
+ System.out.print(" : " + buchstabe);
buchstabe = this.reflektor.codiere(buchstabe);
- buchstabe = this.walzen[2].codiere2(buchstabe);
- buchstabe = this.walzen[1].codiere2(buchstabe);
+ System.out.print(" : " + buchstabe);
buchstabe = this.walzen[0].codiere2(buchstabe);
+ System.out.print(" : " + buchstabe);
+ buchstabe = this.walzen[1].codiere2(buchstabe);
+ System.out.print(" : " + buchstabe);
+ buchstabe = this.walzen[2].codiere2(buchstabe);
+ System.out.print(" : " + buchstabe);
buchstabe = this.steckbrett.codiere(buchstabe);
+ System.out.println(" : " + buchstabe);
return buchstabe;
}
@@ -89,9 +96,9 @@ public class Hardware {
* 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[2].dreheWalze()) {
if (this.walzen[1].dreheWalze()) {
- this.walzen[2].dreheWalze();
+ this.walzen[0].dreheWalze();
}
}
}
diff --git a/src/main/java/Enigma/model/Reflektor.java b/src/main/java/Enigma/model/Reflektor.java
index a3069b863341a420aa9e30cd70620d8d043706c6..f1a34870aefeb8b1de5952a4e91e049396c39e75 100644
--- a/src/main/java/Enigma/model/Reflektor.java
+++ b/src/main/java/Enigma/model/Reflektor.java
@@ -44,6 +44,7 @@ public class Reflektor {
break;
}
}
+
/*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
return WALZE_REFLEKTOR[iPositionReflektor];
}
diff --git a/src/main/java/Enigma/model/Steckbrett.java b/src/main/java/Enigma/model/Steckbrett.java
index d4c503af76d16371f4791c3e6cdf2e6552aaa766..5e7652a2ba64dba43d8d799a93fb267157853115 100644
--- a/src/main/java/Enigma/model/Steckbrett.java
+++ b/src/main/java/Enigma/model/Steckbrett.java
@@ -1,18 +1,18 @@
package Enigma.model;
/**
- *
+ *TODO Dokumentieren
*/
public class Steckbrett {
/**
- *
+ *TODO Dokumentieren
*/
private int zaehler;
private Character[] orginalBuchstaben;
private Character[] getauschteBuchstaben;
/**
- *
+ *TODO Dokumentieren
*/
public Steckbrett() {
@@ -22,7 +22,7 @@ public class Steckbrett {
/**
- *
+ *TODO Dokumentieren
* @param buchstabe1
* @param buchstabe2
* @return
@@ -40,7 +40,7 @@ public class Steckbrett {
}
/**
- *
+ *TODO Dokumentieren
* @return
*/
public boolean ueberpruefeVertauschungen() {
@@ -57,7 +57,7 @@ public class Steckbrett {
}
/**
- *
+ * TODO Dokumentieren
* @param buchstabe
* @return
*/
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
index 6be3bde64f424e9489a1ef742b017137d2bed073..b6c1327e4ff335403e46c6d2e35c01b9b4506321 100644
--- a/src/main/java/Enigma/model/Walze.java
+++ b/src/main/java/Enigma/model/Walze.java
@@ -1,7 +1,5 @@
package Enigma.model;
-import java.time.Year;
-
/**
* Klasse Walze
* <p>
@@ -27,13 +25,12 @@ public class Walze {
* 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[] walzeAlpha;
private Character buchstabe;
- private int ringstellung;
+ private char ringstellung;
private int walzennr;
private int iPositionBuchstabe;
- private int verschoben;
- private Character[] walze;
+ private Character[] alphabet;
/**
@@ -43,12 +40,12 @@ public class Walze {
* @param ringstellung : Character : Einstellung des Notch
*/
public Walze(int walzennr, int ringstellung) {
- this.walze = new Character[26];
+ this.alphabet = new Character[]{'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'};
this.walzennr = walzennr;
this.buchstabe = 'A';
this.iPositionBuchstabe = 0;
- this.verschoben = 0;
- this.ringstellung = ringstellung;
+ this.ringstellung = this.alphabet[ringstellung - 1];
+ this.walzeAlpha = new Character[]{'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'};
}
@@ -58,11 +55,10 @@ public class Walze {
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
*/
private Character[] walzenNummer() {
-
+ Character[] walze = new Character[26];
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'};
@@ -88,6 +84,10 @@ public class Walze {
}
+ /**
+ * TODO Dokumentieren
+ * @return
+ */
//walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
public char walzenPosition() {
@@ -102,9 +102,10 @@ public class Walze {
// Setter für Ringstellung
/**
+ * TODO Dokumentieren
* @return ringstellung : Character : gibt die neue Ringstellung zurueck
*/
- public int getRingstellung() {
+ public char getRingstellung() {
return ringstellung;
}
@@ -118,39 +119,48 @@ public class Walze {
public void setRingstellung(int ringstellung) {
if (ringstellung > 0 && ringstellung <= 26) {
- this.ringstellung = ringstellung;
+ this.ringstellung = this.alphabet[ringstellung - 1];
} else {
- this.ringstellung = 1;
+ this.ringstellung = 'Z';
}
}
- //dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
- public boolean dreheWalze() {
+ /**
+ * dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
+ * TODO Doku
+ */
+ public boolean dreheWalze(int... args) {
- boolean checkRing;
+ boolean checkRing = false;
- if (this.iPositionBuchstabe == 25) {
- this.iPositionBuchstabe = 0;
+ if (args[0] > 1) {
+ for (int i = 0; i < args[0]; i++) {
+ verschiebung();
+ }
} else {
- this.iPositionBuchstabe += 1;
+ verschiebung();
}
- checkRing = this.iPositionBuchstabe == (getRingstellung() - 1);
+ setPosition(walzeAlpha[0]);
- setBuchstabe(walzeAlpha[iPositionBuchstabe]);
+ if(this.getPosition().equals(this.ringstellung)) {
+ checkRing = true;
+ }
return checkRing;
}
- public int verschiebung(int i) {
+ /**
+ * TODO Dokumentieren
+ */
+ public void verschiebung() {
- if((i + iPositionBuchstabe) >= 26) {
- int verschoben = (i + iPositionBuchstabe) - 26 ;
- } else {
- verschoben = i + iPositionBuchstabe;
+ Character[] neueWalze = new Character[26];
+ for (int index = 0; index < 25; index++) {
+ neueWalze[index + 1] = this.walzeAlpha[index];
}
-
- return verschoben;
+ neueWalze[0] = this.walzeAlpha[25];
+ this.walzeAlpha = neueWalze;
}
@@ -164,7 +174,7 @@ public class Walze {
for (int i = 0; i < walzeAlpha.length; i++) {
if (walzeAlpha[i].equals(buchstabe)) {
- buchstabe = walzenNummer()[verschiebung(i)];
+ buchstabe = walzenNummer()[i];
break;
}
}
@@ -180,10 +190,9 @@ public class Walze {
* @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[verschiebung(i)];
+ buchstabe = walzeAlpha[i];
break;
}
}
@@ -195,6 +204,7 @@ public class Walze {
/**
+ * TODO Dokumentieren
* @return buchstabe : Character : gibt den neuen Buchstaben zurueck
*/
public Character getBuchstabe() {
@@ -205,24 +215,41 @@ public class Walze {
* 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.
+ * TODO Funktionsname hat sich geändert
*
* @param buchstabe : Character : Grundeinstellung der Walze
*/
- public void setBuchstabe(Character buchstabe) {
+ public void setPosition(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;
- }
- }
+ System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
+ dreheWalze(this.getArrayIndex(buchstabe, this.alphabet) + 1);
} else {
this.buchstabe = 'A';
}
}
+ /**
+ * TODO Dokumentieren
+ * @param buchstabe
+ * @param array
+ * @return
+ */
+ public int getArrayIndex(Character buchstabe, Character[] array) {
+ int result = -1;
+
+ for (int i = 0; i < array.length; i++) {
+ if (array[i].equals(buchstabe)) {
+ result = i;
+ }
+ }
+
+ return result;
+ }
+
//TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
+ // Überprüfung sollte in walzenNummer() statt finden.
/**
* Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
@@ -237,4 +264,12 @@ public class Walze {
}
}
+ /**
+ * TODO: Dokumentieren
+ *
+ * @return
+ */
+ public Character getPosition() {
+ return walzeAlpha[0];
+ }
}
diff --git a/src/test/java/Enigma/model/HardwareTest.java b/src/test/java/Enigma/model/HardwareTest.java
index 78bd24110f1742bd715af8f4bcceac50dfc7e243..90a3936f217a4a9c74176ecbe6345070843de251 100644
--- a/src/test/java/Enigma/model/HardwareTest.java
+++ b/src/test/java/Enigma/model/HardwareTest.java
@@ -15,37 +15,35 @@ public class HardwareTest {
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 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'};
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'};
+ 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'};
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);
+ char result;
+ result = h.codiere('A');
+ Assert.assertEquals("Codiere: A Erwartet P, erhalten "+ result, 'P', result);
+ result = h.codiere('B');
+ Assert.assertEquals("Codiere: B Erwartet R, erhalten "+ result, 'R', result);
result = h.codiere('I');
- Assert.assertEquals("Codiere: Erwartet S, erhalten "+ result, 'S', result);
+ Assert.assertEquals("Codiere: I Erwartet E, erhalten "+ result, 'E', result);
result = h.codiere('F');
- Assert.assertEquals("Codiere: Erwartet P, erhalten "+ result, 'P', result);
+ Assert.assertEquals("Codiere: F Erwartet A, erhalten "+ result, 'A', 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);
+ h.getWalzen()[2].setPosition('A');
result = h.codiere('P');
- Assert.assertEquals("Decodiere: Erwartet F, erhalten "+ result, 'F', result);
+ Assert.assertEquals("Decodiere: P Erwartet A, erhalten "+ result, 'A', result);
+ result = h.codiere('R');
+ Assert.assertEquals("Decodiere: R Erwartet B, erhalten "+ result, 'B', result);
+ result = h.codiere('E');
+ Assert.assertEquals("Decodiere: E Erwartet I, erhalten "+ result, 'I', result);
+ result = h.codiere('A');
+ Assert.assertEquals("Decodiere: A Erwartet F, erhalten "+ result, 'F', result);
h.getSteckbrett().setzeVertauschung('B', 'G');
h.getSteckbrett().setzeVertauschung('D', 'F');