diff --git a/Roboter/tpe/exceptions/roboter/Nexus6.java b/Roboter/tpe/exceptions/roboter/Nexus6.java
index 73e3a5c..7069618 100644
--- a/Roboter/tpe/exceptions/roboter/Nexus6.java
+++ b/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;
+	}
 }
diff --git a/Roboter/tpe/exceptions/roboter/Robots.java b/Roboter/tpe/exceptions/roboter/Robots.java
index 6d93507..0299c34 100644
--- a/Roboter/tpe/exceptions/roboter/Robots.java
+++ b/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)
-			powerStatus=true;
+		if (powerStatus == false)
+			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;
-		for(int i = 0; i < zahlen.length; i++) {
-			if(zahlen[i]==42) {
-				error=true;
+		boolean error = false;
+		for (int i = 0; i < zahlen.length; i++) {
+			if (zahlen[i] == 42) {
+				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>
-	 * C3PO: sortiert absteigend Wert an der Stelle 0 des Arrays ist größer als an der letzten Stelle
+	 * R2D2: sortiert aufsteigend Wert an der Stelle 0 des Arrays ist kleiner als an
+	 * 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)
-		{
-			throw new RobotIllegalStateException("Der Roboter ist ausgeschaltet!", this.getName());
+
+		if (powerStatus == false) {
+
+			error = new RobotIllegalStateException("Der Roboter ist ausgeschaltet!", this.getName());
+			throw error;
+		} else if (checkRobotMagicValueException(zahlen) == true) {
+			error = new RobotMagicValueException("Zahl 42 kann nicht verarbeitet werden!", this.getName());
+			throw error;
+		} else if (zahlen[0] < zahlen[zahlen.length - 1]) {
+			return Arrays.stream(zahlen).mapToObj(String::valueOf).collect(Collectors.joining(", "));
+		} else {
+			return Arrays.stream(zahlen).mapToObj(String::valueOf).collect(Collectors.joining("; "));
 		}
-		else if(checkRobotMagicValueException(zahlen)==true)
-		{
-			throw new RobotMagicValueException("Zahl 42 kann nicht verarbeitet werden!",this.getName());
-		}else
-		if(zahlen[0]<zahlen[zahlen.length-1])
-		{
-			  return Arrays.stream(zahlen)
-					    .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;
 }
diff --git a/Roboter/tpe/facade/FactorySystem.java b/Roboter/tpe/facade/FactorySystem.java
index bbb7ed1..3c85708 100644
--- a/Roboter/tpe/facade/FactorySystem.java
+++ b/Roboter/tpe/facade/FactorySystem.java
@@ -18,10 +18,12 @@ public class FactorySystem {
 		if (select == 1) {
 			int id = rf.constructRobot(RobotType.R2D2, name);
 			return id;
-		} else {
+		} else  {
 			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) {
-		return rf.robotInfo(id);
-	}
+//	public String robotInfo(int id) {
+//		return rf.robotInfo(id).toString();
+//	}
 
 
 	public RobotException robotBlackbox(int id) {
diff --git a/Roboter/tpe/facade/FactorySystemTest.java b/Roboter/tpe/facade/FactorySystemTest.java
index b9c9825..5b9de0c 100644
--- a/Roboter/tpe/facade/FactorySystemTest.java
+++ b/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));
+	}
+	
+
 }
diff --git a/Roboter/tpe/ui/UI.java b/Roboter/tpe/ui/UI.java
index 1c0f936..092f0b7 100644
--- a/Roboter/tpe/ui/UI.java
+++ b/Roboter/tpe/ui/UI.java
@@ -8,23 +8,20 @@ import tpe.exceptions.roboter.RobotFactory;
 import tpe.facade.FactorySystem;
 
 public class UI {
-	
+
 	private FactorySystem fs;
 	Scanner sc = new Scanner(System.in);
 
-public UI (FactorySystem fs) {
-	this.fs = fs;
-	menu();
-}
-	
+	public UI(FactorySystem fs) {
+		this.fs = fs;
+		menu();
+	}
 
+	private void menu() {
 
-private void menu() {
-	
-	System.out.println("Willkommen bei der " + fs.getFName() + "!");
+		System.out.println("Willkommen bei der " + fs.getFName() + "!");
 
-	mainloop: 
-		while (true) {
+		mainloop: while (true) {
 			System.out.println();
 			System.out.println("--------");
 			System.out.println("Hauptmenü");
@@ -37,18 +34,23 @@ private void menu() {
 			System.out.print("> ");
 			int input = Integer.parseInt(sc.nextLine());
 			System.out.println();
-	
-			switch(input) {
+
+			switch (input) {
 //			case 1: showRobots(); break;
-			case 2: buildRobot(); break;
-			case 3: choseRobot(); break;
-			case 4: break mainloop;
+			case 2:
+				buildRobot();
+				break;
+			case 3:
+				choseRobot();
+				break;
+			case 4:
+				break mainloop;
 			}
-			
+
 			System.out.println();
-			
-		}	
-}
+
+		}
+	}
 
 //	private void showRobots() {
 //		
@@ -56,143 +58,172 @@ private void menu() {
 //	
 //		// Seriennummer, Typ und Name aller Roboter soll aufgelistet werden
 //	}
-	
+
 	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
-		System.out.println();
-		
-		//Namensgabe
-		System.out.println("Welchen Namen möchten Sie dem Roboter geben?");
-		
-		System.out.print("> ");
-		String name = sc.nextLine(); //name als Variable für Name
-		System.out.println();
-		
-		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.");
+		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
+
+			boolean realname = true;
+
+			while (realname) {
+				System.out.println("Welchen Namen möchten Sie dem Roboter geben.");
+
+				System.out.print("> ");
+				name = sc.nextLine();
+
+				if (name != "")
+					break;
+
+			}
+
+			System.out.println();
+
+			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.");
+
+		}
+
 	}
-	
+
 	private void choseRobot() {
-		
+
 		System.out.println("Geben Sie die Seriennummer des Roboters ein, mit dem Sie arbeiten möchten.");
-		
+
 		System.out.print("> ");
-		int id = Integer.parseInt(sc.nextLine()); 
+		int id = Integer.parseInt(sc.nextLine());
 		System.out.println();
-		
+
 //		if (id ist nicht vorhanden )
 //		 System.out.println("Es exisitiert kein Roboter mit der Seriennummer " + id " .");
 //		 else
-		
-		loop: 
-			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("6 -> Zurück ins Hauptmenü");
-				
-				System.out.print("> ");
-				int input = Integer.parseInt(sc.nextLine());
 
-				switch (input) {
-					case 1: robotStatus(id); break;
-					case 2: onoffbutton(id); break;
-					case 3: robotSpeak(id); break;
-					case 4:	lastError(id); break;
-					case 5: robotData(id); break;
-					case 6:	break loop;
-				}
+		loop: 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("6 -> Zurück ins Hauptmenü");
+
+			System.out.print("> ");
+			int input = Integer.parseInt(sc.nextLine());
+
+			switch (input) {
+			case 1:
+				robotStatus(id);
+				break;
+			case 2:
+				onoffbutton(id);
+				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) {
-		boolean status = fs.powerStatus(id); 
-		if (status == true) 
+		boolean status = fs.powerStatus(id);
+		if (status == true)
 			System.out.println("Der Roboter ist angeschaltet.");
-		else 
+		else
 			System.out.println("Der Roboter ist ausgeschaltet.");
 	}
-		
+
 	private void onoffbutton(int id) {
 		boolean status = fs.triggerPower(id);
 		if (status == true)
 			System.out.println("Der Roboter wurde eingeschaltet.");
 		else
 			System.out.println("Der Roboter wurde ausgeschaltet.");
-		
+
 		System.out.println();
 	}
-	
+
 	private void robotSpeak(int id) {
-		
+
 		ArrayList<Integer> arrayNumbers = new ArrayList<>();
 		boolean next = true;
-	
-		
-		System.out.println("Um den Robotersprechen zu lassen, müssen Sie eine beliebig lange Folge von ganzen Zahlen angeben");
+
+		System.out.println(
+				"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());
 		arrayNumbers.add(num);
-		
+
 		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) {
 		System.out.println(fs.robotBlackbox(id));
-		
+
 	}
-	
-	private void robotData(int id) {
-		System.out.println(fs.robotInfo(id));	
-	}
-		
-	}
-	
+
+//	private void robotData(int id) {
+//		System.out.println(fs.robotInfo(id));
+//	}
+
+}