FactorySystemTest vervollständigt

Roboter/tpe/exceptions/roboter/Nexus6.java

@@ -38,4 +38,9 @@ public class Nexus6 extends Robots {
 	public RobotType getRobotType () {
 		return this.robotType;
 	}
+	
+	@Override
+	public void triggerPowerSwitch () {
+		powerSwitch = false;
+	}
 }

Roboter/tpe/exceptions/roboter/Robots.java

@@ -7,81 +7,84 @@ import tpe.exceptions.RobotException;
 import tpe.exceptions.RobotIllegalStateException;
 import tpe.exceptions.RobotMagicValueException;
 
-
+public abstract class Robots implements Robot {
-public abstract class Robots implements Robot{
 	protected String name;
 	protected RobotException error;
 	protected boolean powerStatus;
+
 	/**
-	 * Legt fest das ein Roboter standardmäßig einen Namen hat und setzt den Power Knopf bei Erstellung auf aus
+	 * Legt fest das ein Roboter standardmäßig einen Namen hat und setzt den Power
+	 * Knopf bei Erstellung auf aus
+	 * 
 	 * @param name
 	 */
 	public Robots(String name) {
 		this.name = name;
 		this.powerStatus = false;
 	}
+
 	@Override
 	public abstract int getId();
+
 	@Override
 	public String getName() {
 		return name;
 	}
+
 	@Override
 	public void triggerPowerSwitch() {
-		if(powerStatus==false)
+		if (powerStatus == false)
-			powerStatus=true;
+			powerStatus = true;
 		else
-			powerStatus=false;
+			powerStatus = false;
 
 	}
+
 	@Override
 	public boolean isPowerOn() {
 
 		return powerStatus;
 	}
+
 	@Override
 	public RobotException getLastException() {
 		return error;
 	}
+
 	public boolean checkRobotMagicValueException(int[] zahlen) {
-	boolean error=false;
+		boolean error = false;
-		for(int i = 0; i < zahlen.length; i++) {
+		for (int i = 0; i < zahlen.length; i++) {
-			if(zahlen[i]==42) {
+			if (zahlen[i] == 42) {
-				error=true;
+				error = true;
 			}
 		}
 		return error;
 	}
+
 	/**
 	 * Unterscheidung der Ausgabe durch die Art der Sortierung: <br>
-	 * R2D2: sortiert aufsteigend Wert an der Stelle 0 des Arrays ist kleiner als an der letzten Stelle <br>
+	 * R2D2: sortiert aufsteigend Wert an der Stelle 0 des Arrays ist kleiner als an
-	 * C3PO: sortiert absteigend Wert an der Stelle 0 des Arrays ist größer als an der letzten Stelle
+	 * der letzten Stelle <br>
+	 * C3PO: sortiert absteigend Wert an der Stelle 0 des Arrays ist größer als an
+	 * der letzten Stelle
 	 */
 	public String speak(int[] zahlen) throws RobotException {
 
-		if(powerStatus==false)
+		if (powerStatus == false) {
-		{
+
-			throw new RobotIllegalStateException("Der Roboter ist ausgeschaltet!", this.getName());
+			error = new RobotIllegalStateException("Der Roboter ist ausgeschaltet!", this.getName());
-		}
+			throw error;
-		else if(checkRobotMagicValueException(zahlen)==true)
+		} else if (checkRobotMagicValueException(zahlen) == true) {
-		{
+			error = new RobotMagicValueException("Zahl 42 kann nicht verarbeitet werden!", this.getName());
-			throw new RobotMagicValueException("Zahl 42 kann nicht verarbeitet werden!",this.getName());
+			throw error;
-		}else
+		} else if (zahlen[0] < zahlen[zahlen.length - 1]) {
-		if(zahlen[0]<zahlen[zahlen.length-1])
+			return Arrays.stream(zahlen).mapToObj(String::valueOf).collect(Collectors.joining(", "));
-		{
+		} else {
-			  return Arrays.stream(zahlen)
+			return Arrays.stream(zahlen).mapToObj(String::valueOf).collect(Collectors.joining("; "));
-					    .mapToObj(String::valueOf)
-					    .collect(Collectors.joining(", "));
-		}
-		else
-		{
-			 return Arrays.stream(zahlen)
-					    .mapToObj(String::valueOf)
-					    .collect(Collectors.joining("; "));
 		}
 
-		
 	}
+
 	@Override
 	public abstract int[] think(int[] zahlen) throws RobotException;
 }

Roboter/tpe/facade/FactorySystem.java

@@ -22,6 +22,8 @@ public class FactorySystem {
 			int id = rf.constructRobot(RobotType.C3PO, name);
 			return id;
 		}
+		
+		
 	}
 
 	public boolean triggerPower(int id) {
@@ -32,9 +34,9 @@ public class FactorySystem {
 		return rf.powerStatus(id);
 	}
 
-	public String robotInfo(int id) {
+//	public String robotInfo(int id) {
-		return rf.robotInfo(id);
+//		return rf.robotInfo(id).toString();
-	}
+//	}
 
 
 	public RobotException robotBlackbox(int id) {

Roboter/tpe/facade/FactorySystemTest.java

@@ -1,5 +1,69 @@
 package tpe.facade;
 
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.*;
+
+import tpe.exceptions.RobotException;
+import tpe.exceptions.RobotIllegalStateException;
+import tpe.exceptions.RobotMagicValueException;
+
 public class FactorySystemTest {
 
+FactorySystem fs = new FactorySystem ("Testfabrik");
+int testid = fs.constructRobot(2, "Testname");
+int testid2 = fs.constructRobot(1, "Testname");
+int[] testZahlen1= {1,4,3,42,78,20};
+int[] testZahlen2= {1,4,3,41,78,20};
+	
+	@Test
+	void powerStatusTest() {
+					
+		/**
+		 * 1. Roboter wird gebaut, er ist ausgeschaltet
+		 * 2. Roboter wird angeschaltet
+		 * 3. Roboter wird ausgeschaltet 
+		 */
+		assertFalse(fs.powerStatus(testid));
+		assertTrue(fs.triggerPower(testid));
+		assertFalse(fs.triggerPower(testid));
+		
+		/**
+		 * 1. Da Nexus6 bereits erstellt wurde, wird beim erstellen zwei neuer Roboter der Stock auf 3 sein
+		 * 2. Nexus6 ist ausgeschaltet
+		 * 3. Er kann auch nicht angeschaltet werden
+		 */
+		
+		assertEquals(fs.robotStockSize(),3);
+		assertFalse(fs.powerStatus(19281982));
+		assertFalse(fs.triggerPower(19281982));
+				
+	}
+	
+	@Test
+	void robotInstructions() throws RobotException {
+		RobotIllegalStateException thrownState = Assertions.assertThrows(RobotIllegalStateException.class,() -> fs.robotInstructions(testid,testZahlen2));
+		assertEquals(thrownState.getMessage(),"Robotname-Testname: Der Roboter ist ausgeschaltet!");
+		
+		fs.triggerPower(testid);
+		RobotMagicValueException thrownValue=Assertions.assertThrows(RobotMagicValueException.class,() -> fs.robotInstructions(testid,testZahlen1));
+		assertEquals(thrownValue.getMessage(),"Robotname-Testname: Zahl 42 kann nicht verarbeitet werden!");
+		
+		fs.triggerPower(testid2);
+		assertEquals(fs.robotInstructions(testid, testZahlen2), "78; 41; 20; 4; 3; 1");
+		assertEquals(fs.robotInstructions(testid2, testZahlen2), "1, 3, 4, 20, 41, 78");
+	}
+	
+	@Test
+	void robotBlackBox() {
+		fs.triggerPower(testid);
+		RobotMagicValueException thrownValue=Assertions.assertThrows(RobotMagicValueException.class,() -> fs.robotInstructions(testid,testZahlen1));
+		assertEquals(thrownValue.getMessage(),fs.robotBlackbox(testid));
+		
+//		RobotIllegalStateException thrownState = Assertions.assertThrows(RobotIllegalStateException.class,() -> fs.robotInstructions(testid,testZahlen2));
+//		assertEquals(thrownState.getMessage(),fs.robotBlackbox(testid));
+	}
+	
+
 }

Roboter/tpe/ui/UI.java

@@ -12,19 +12,16 @@ public class UI {
 	private FactorySystem fs;
 	Scanner sc = new Scanner(System.in);
 
-public UI (FactorySystem fs) {
+	public UI(FactorySystem fs) {
 		this.fs = fs;
 		menu();
-}
+	}
 
-
+	private void menu() {
-
-private void menu() {
 
 		System.out.println("Willkommen bei der " + fs.getFName() + "!");
 
-	mainloop: 
+		mainloop: while (true) {
-		while (true) {
 			System.out.println();
 			System.out.println("--------");
 			System.out.println("Hauptmenü");
@@ -38,17 +35,22 @@ private void menu() {
 			int input = Integer.parseInt(sc.nextLine());
 			System.out.println();
 
-			switch(input) {
+			switch (input) {
 //			case 1: showRobots(); break;
-			case 2: buildRobot(); break;
+			case 2:
-			case 3: choseRobot(); break;
+				buildRobot();
-			case 4: break mainloop;
+				break;
+			case 3:
+				choseRobot();
+				break;
+			case 4:
+				break mainloop;
 			}
 
 			System.out.println();
 
 		}
-}
+	}
 
 //	private void showRobots() {
 //		
@@ -58,25 +60,47 @@ private void menu() {
 //	}
 
 	private void buildRobot() {
+		String name = null;
+
 		System.out.println("Sie haben sich dazu entschieden einen Roboter zu bauen. "
 				+ "Wenn Sie einen Roboter vom Typ R2D2 bauen möchten, dann drücken Sie die (1). "
-				+ "Wenn Sie einen Roboter vom TYp C3PO bauen möchten, dann drücken Sie die (2).");
+				+ "Wenn Sie einen Roboter vom Typ C3PO bauen möchten, dann drücken Sie die (2).");
-		
 
 		System.out.print("> ");
-		int robotType = Integer.parseInt(sc.nextLine()); //robotType als Variable für Typ
+		int robotType = Integer.parseInt(sc.nextLine());
+
+		if (robotType > 2 || robotType < 1) {
+			System.out.println(
+					"Es stehen nur (1) oder (2) bei der Auswahl des Robotertypen zur verfügung. Bitte erneut wählen.");
+			System.out.println();
+			buildRobot();
+		} else {
 			System.out.println();
 
-		//Namensgabe
+			// Namensgabe
-		System.out.println("Welchen Namen möchten Sie dem Roboter geben?");
+
+			boolean realname = true;
+
+			while (realname) {
+				System.out.println("Welchen Namen möchten Sie dem Roboter geben.");
 
 				System.out.print("> ");
-		String name = sc.nextLine(); //name als Variable für Name
+				name = sc.nextLine();
+
+				if (name != "")
+					break;
+
+			}
+
 			System.out.println();
 
-		int serialnumber = fs.constructRobot( robotType, name);
+			int serialnumber = fs.constructRobot(robotType, name);
+
+			System.out.println("Sie haben einen Roboter vom Typ " + robotType + " mit dem Namen " + name
+					+ " mit der Seriennummer " + serialnumber + " erstellt.");
+
+		}
 
-		System.out.println("Sie haben einen Roboter vom Typ " + robotType + " mit dem Namen " + name + " mit der Seriennummer " + serialnumber + " erstellt.");
 	}
 
 	private void choseRobot() {
@@ -91,34 +115,45 @@ private void menu() {
 //		 System.out.println("Es exisitiert kein Roboter mit der Seriennummer " + id " .");
 //		 else
 
-		loop: 
+		loop: while (true) {
-			while (true) {
 			System.out.println("Was möchten Sie mit Ihrem Roboter tun?");
 			System.out.println("1 -> Zustand des Roboters");
 			System.out.println("2 -> AN oder Aus schalten");
 			System.out.println("3 -> Roboter spricht");
 			System.out.println("4 -> Letzte Fehlermeldung auslesen"); // Haben bzw. brauchen wir solch eine Funktion
-				System.out.println("5 -> Daten des Roboters abrufen");	
+//			System.out.println("5 -> Daten des Roboters abrufen");
 			System.out.println("6 -> Zurück ins Hauptmenü");
 
 			System.out.print("> ");
 			int input = Integer.parseInt(sc.nextLine());
 
 			switch (input) {
-					case 1: robotStatus(id); break;
+			case 1:
-					case 2: onoffbutton(id); break;
+				robotStatus(id);
-					case 3: robotSpeak(id); break;
+				break;
-					case 4:	lastError(id); break;
+			case 2:
-					case 5: robotData(id); break;
+				onoffbutton(id);
-					case 6:	break loop;
+				break;
+			case 3:
+				robotSpeak(id);
+				break;
+			case 4:
+				lastError(id);
+				break;
+//			case 5:
+//				robotData(id);
+//				break;
+			case 6:
+				break loop;
 			}
 
 		}
 
-		
 	}
+
 	/**
 	 * Gibt den Status des Roboters an
+	 * 
 	 * @param id
 	 */
 	private void robotStatus(int id) {
@@ -144,8 +179,8 @@ private void menu() {
 		ArrayList<Integer> arrayNumbers = new ArrayList<>();
 		boolean next = true;
 
-		
+		System.out.println(
-		System.out.println("Um den Robotersprechen zu lassen, müssen Sie eine beliebig lange Folge von ganzen Zahlen angeben");
+				"Um den Robotersprechen zu lassen, müssen Sie eine beliebig lange Folge von ganzen Zahlen angeben");
 		System.out.println();
 		System.out.println("Geben Sie die 1. Zahl Ihrer Folge ein.");
 		int num = Integer.parseInt(sc.nextLine());
@@ -154,35 +189,32 @@ private void menu() {
 		int i = 2;
 		while (next) {
 
-			System.out.println("Geben Sie die " + i + ". Zahl Ihrer Folge ein." );
+			System.out.println("Geben Sie die " + i + ". Zahl Ihrer Folge ein.");
 			num = Integer.parseInt(sc.nextLine());
 			arrayNumbers.add(num);
 
-			System.out.println("Wenn Sie eine weiter Zahl eingeben möchten, wählen Sie (1). Wenn Sie die Eingabe beenden möchten (2).");
+			System.out.println(
+					"Wenn Sie eine weiter Zahl eingeben möchten, wählen Sie (1). Wenn Sie die Eingabe beenden möchten (2).");
 			int election = Integer.parseInt(sc.nextLine());
 
 			if (election == 1) {
 				i++;
 				next = true;
-			}
+			} else {
-			else {
 				next = false;
-				int [] numbers = arrayNumbers.stream().mapToInt(j -> j).toArray();
+				int[] numbers = arrayNumbers.stream().mapToInt(j -> j).toArray();
 
 				String output;
 				try {
 					output = fs.robotInstructions(id, numbers);
 					System.out.println("Der Roboter gibt folgendes aus: " + output);
-				}	
+				} catch (RobotException e) {
-				catch (RobotException e) {
 					System.out.println("Fehler!");
 				}
 			}
 
 		}
 
-		
-		
 	}
 
 	private void lastError(int id) {
@@ -190,9 +222,8 @@ private void menu() {
 
 	}
 
-	private void robotData(int id) {
+//	private void robotData(int id) {
-		System.out.println(fs.robotInfo(id));	
+//		System.out.println(fs.robotInfo(id));
-	}
+//	}
-		
-	}
 
+}