„README.md“ ändern

Reviewed-on: #1

README.md

@@ -1,2 +1,6 @@
 # Robbie-Management-System
 
+Teammitglieder:
+
+1) Nico Piehl (2211320)
+2) Cedric Bienert (2210800)

Robbie-Management-System/.classpath

@@ -6,5 +6,6 @@
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

Robbie-Management-System/Readme

@@ -0,0 +1,4 @@
+Teammitglieder:
+
+1) Nico Piehl (2211320)
+2) Cedric Bienert (2210800)

Robbie-Management-System/src/T1000

@@ -0,0 +1,8 @@
+Implementierung eines neuen Robotermodells (T1000):
+
+- Die Klasse T1000 anlegen
+- Diese Klasse erbt von Robotermodell und implementiert Robot
+- Ähnlich wie die anderen Roboterklassen anlegen und Konstruktor/Methoden implementieren
+- Bei Robotermodell müsste bei speak mit instanceof das hilfszeichen bestimmt werden
+- Der T1000 müsste ebenfalls in der RobotFactory angelegt werden
+- Der T1000 müsste mit ins Enum aufgenommen werden

Robbie-Management-System/src/domain/C3PO.java

@@ -1,22 +1,76 @@
 package domain;
 
 import exceptions.RobotException;
+import exceptions.RobotIllegalStateException;
+import exceptions.RobotMagicValueException;
 import roboterSystem.Robot;
 
+/**
+ * Die Klasse repräsentiert das C3PO Modell.
+ *
+ * Der Roboter hat einen Konstruktor <code>C3PO(...)</code> welcher einen Namen, 
+ * eine iD und einen Zähler besitzt der die iD erhöht.
+ * 
+ * <code>think(...)</code> lässt den Roboter ein int Array absteigend sortieren
+ * und dann zurückgeben.
+ */
 public class C3PO extends Robotermodell implements Robot {
 	
-	private int zähler = 10000;
+	/**
+	 * Der Zähler repräsentiert die iD.
+	 */
+	private static int zähler = 10000;
 
+    /**
+     * Der Konstruktor des C3PO Roboters besitzt einen Namen, eine iD
+     * und einen Zähler.
+     * 
+     * @param String name der den Namen des Roboters repräsentiert.
+     */
 	public C3PO(String name) {
 		setName(name);
 		setiD(zähler);
 		zähler++;
 	}
 
+    /**
+     * Sortiert ein Array von Zahlen. Die Reihenfolge verläuft absteigend.
+     *
+     * @param zahlen Zahlen, die sortiert werden sollen.
+     * @return Sortierte Zahlen
+     * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist,
+     *             oder das Array nicht seinen Vorstellungen entspricht.
+     */
 	@Override
 	public int[] think(int[] zahlen) throws RobotException {
-		// TODO Auto-generated method stub
+		try {
-		return null;
+			if (this.isPowerOn() == false) {
+				throw new RobotIllegalStateException(this.getName());
+			}
+			
+			for (int i = 0; i < zahlen.length; i++) {
+				if (zahlen[i] == 42) {
+					throw new RobotMagicValueException(this.getName());
+				}
+			}
+			for (int i = 0; i < zahlen.length - 1; i++) {
+				int k = i;
+				while (k >= 0 && zahlen[k] < zahlen[k+1]) {
+					int zwischenspeicher = zahlen[k];
+					zahlen[k] = zahlen[k+1];
+					zahlen[k+1] = zwischenspeicher;
+					k--;
+				}
+			}
+		} catch (RobotIllegalStateException rise) {
+			letzteException = rise;
+			rise.printStackTrace();
+		} catch (RobotMagicValueException rmve) {
+			letzteException = rmve;
+			rmve.printStackTrace();
+		}
+		
+		return zahlen;
 	}
 
 }

Robbie-Management-System/src/domain/C3POTest.java

@@ -0,0 +1,62 @@
+package domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import exceptions.RobotException;
+
+import org.junit.Assert;
+
+class C3POTest {
+
+	@Test
+	void testSetNameGetName() {
+		C3PO c = new C3PO("Test");
+		assertEquals("Test", c.getName());
+		c.setName("TestNeu");
+		assertEquals("TestNeu", c.getName());
+	}
+
+	@Test
+	void testSetiDGetiD() {
+		C3PO c = new C3PO("Test");
+		assertEquals(10000, c.getId());
+		C3PO c2 = new C3PO("Test2");
+		assertNotEquals(10001, c2.getId());
+		c2.setiD(10002);
+		assertEquals(10002, c2.getId());
+	}
+
+	@Test
+	void testTriggerPowerSwitchIsPowerOn() {
+		C3PO c = new C3PO("Test");
+		assertEquals(true, c.isPowerOn());
+		c.triggerPowerSwitch();
+		assertEquals(false, c.isPowerOn());
+	}
+
+	@Test
+	void testThinkSpeak() throws RobotException {
+		C3PO c = new C3PO("Test");
+		int[] zahlen = {2,4,3,1,6,5};
+		assertEquals("2; 4; 3; 1; 6; 5", c.speak(zahlen));
+		int[] zahlenNeu = {6,5,4,3,2,1};
+		Assert.assertArrayEquals(zahlenNeu, c.think(zahlen));
+		assertEquals("6; 5; 4; 3; 2; 1", c.speak(c.think(zahlen)));
+	}
+	
+	@Test
+	void testGetLastException() throws RobotException {
+		C3PO c = new C3PO("Test");
+		int[] zahlen = {42,4,3,1,6,5};
+		c.think(zahlen);
+		assertEquals("exceptions.RobotMagicValueException: Test: Zahl 42 kommt vor - Roboter: \"Ihhhhh\"!", c.getLastException().toString());
+		c.speak(zahlen);
+		assertEquals("exceptions.RobotMagicValueException: Test: Zahl 42 kommt vor - Roboter: \"Ihhhhh\"!", c.getLastException().toString());
+		c.triggerPowerSwitch();
+		c.think(zahlen);
+		assertEquals("exceptions.RobotIllegalStateException: Test: Leider ist der Roboter aus und kann nichts machen!", c.getLastException().toString());
+		c.speak(zahlen);
+		assertEquals("exceptions.RobotIllegalStateException: Test: Leider ist der Roboter aus und kann nichts machen!", c.getLastException().toString());
+	}
+}

Robbie-Management-System/src/domain/Nexus6.java

@@ -0,0 +1,79 @@
+package domain;
+
+import exceptions.RobotException;
+import exceptions.RobotIllegalStateException;
+import roboterSystem.Robot;
+
+/**
+ * Die Klasse repräsentiert das Nexus6 Modell.
+ *
+ * Der Roboter hat einen privaten Konstruktor <code>Nexus6()</code> welcher einen 
+ * festen Namen, eine feste iD hat und der Roboter ist ausgestellt.
+ * 
+ * Damit auf den Singleton Roboter zugegriffen werden kann wird <code>getInstance()</code>
+ * diesen spezifischen Roboter zurückgeben.
+ * 
+ * Der Roboter ist immer ausgestellt, daher macht <code>triggerPowerSwitch()</code>
+ * nichts.
+ * 
+ * <code>think(...)</code> lässt den Roboter Exceptions werfen, macht allerdings
+ * nichts anderes.
+ */
+public class Nexus6 extends Robotermodell implements Robot {
+	
+	/**
+	 * Die private final Nexus6 Variable erzeugt immer einen Nexus6 Roboter 
+	 * und verhindert die erneute Erzeugung eines weiteren Nuxus6 Roboters.
+	 */
+	private static final Nexus6 NEXUS6 = new Nexus6();
+	
+    /**
+     * Der Konstruktor des Nexus6 Roboters besitzt einen Namen, eine iD
+     * und seine Power ist immer aus.
+     */
+	private Nexus6() {
+		setName("Pris");
+		setiD(19281982);
+		power = false;
+	}
+	
+    /**
+     * Gibt die einzige Instanz des Roboters zurück.
+     *
+     * @return Eine eindeutige Identifikation in Form des Objekts.
+     */
+	public static Nexus6 getInstance() {
+		return NEXUS6;
+	}
+	
+    /**
+     * Power ändern machts nichts, da der Roboter immer aus ist.
+     */
+	@Override
+	public void triggerPowerSwitch() {
+		//bleibt ausgeschaltet
+	}
+	
+    /**
+     * Macht rein gar nichts, außer die Exception zu werfen
+     *
+     * @param zahlen Zahlen, die in einer anderen Zeitlinie sortiert werden sollten.
+     * @return null, da nichts gemacht wird
+     * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist,
+     *             oder das Array nicht seinen Vorstellungen entspricht.
+     */
+	@Override
+	public int[] think(int[] zahlen) throws RobotException {
+		try {
+			if (this.isPowerOn() == false) {
+				throw new RobotIllegalStateException(this.getName());
+			}
+		} catch (RobotIllegalStateException rise) {
+			letzteException = rise;
+			rise.printStackTrace();
+		}
+		
+		return null;
+	}
+
+}

Robbie-Management-System/src/domain/Nexus6Test.java

@@ -0,0 +1,24 @@
+package domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+import exceptions.RobotException;
+
+class Nexus6Test {
+
+	@Test
+	void testInstanceNameiDPowerThink() throws RobotException {
+		assertTrue(Nexus6.getInstance() != null);
+		assertTrue(Nexus6.getInstance().getId() != 0);
+		assertEquals(19281982, Nexus6.getInstance().getId());
+		assertTrue(Nexus6.getInstance().getName() != null);
+		assertEquals("Pris", Nexus6.getInstance().getName());
+		assertTrue(Nexus6.getInstance().isPowerOn() != true);
+		Nexus6.getInstance().triggerPowerSwitch();
+		assertTrue(Nexus6.getInstance().isPowerOn() != true);
+		assertTrue(Nexus6.getInstance().think(null) == null);
+	}
+
+}

Robbie-Management-System/src/domain/R2D2.java

@@ -1,33 +1,79 @@
 package domain;
 
 import exceptions.RobotException;
+import exceptions.RobotIllegalStateException;
+import exceptions.RobotMagicValueException;
 import roboterSystem.Robot;
 
+/**
+ * Die Klasse repräsentiert das R2D2 Modell.
+ *
+ * Der Roboter hat einen Konstruktor <code>R2D2(...)</code> welcher einen Namen, 
+ * eine iD und einen Zähler besitzt der die iD erhöht.
+ * 
+ * <code>think(...)</code> lässt den Roboter ein int Array aufsteigend sortieren
+ * und dann zurückgeben.
+ */
 public class R2D2 extends Robotermodell implements Robot {
 
-	private int zähler = 0;
+	/**
+	 * Der Zähler repräsentiert die iD.
+	 */
+	private static int zähler = 0;
 	
+    /**
+     * Der Konstruktor des R2D2 Roboters besitzt einen Namen, eine iD
+     * und einen Zähler.
+     * 
+     * @param String name der den Namen des Roboters repräsentiert.
+     */
 	public R2D2(String name) {
 		setName(name);
 		setiD(zähler);
 		zähler++;
 	}
 
+    /**
+     * Sortiert ein Array von Zahlen. Die Reihenfolge verläuft aufsteigend.
+     *
+     * @param zahlen Zahlen, die sortiert werden sollen.
+     * @return Sortierte Zahlen
+     * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist,
+     *             oder das Array nicht seinen Vorstellungen entspricht.
+     */
 	@Override
 	public int[] think(int[] zahlen) throws RobotException {
-		for (int i = 0; i < zahlen.length; i++) {
+		try {
-			int kMin = i;
+			if (this.isPowerOn() == false) {
-			for (int k = i + 1; k < zahlen.length; k++) {
+				throw new RobotIllegalStateException(this.getName());
-				if (zahlen[k] < zahlen[kMin]) {
+			}
-					kMin = k;
+			
+			for (int i = 0; i < zahlen.length; i++) {
+				if (zahlen[i] == 42) {
+					throw new RobotMagicValueException(this.getName());
 				}
 			}
 			
-			if(kMin != i) {
+			for (int i = 0; i < zahlen.length; i++) {
-				int zwischenspeicher = zahlen[i];
+				int kMin = i;
-				zahlen[i] = zahlen[kMin];
+				for (int k = i + 1; k < zahlen.length; k++) {
-				zahlen[kMin] = zwischenspeicher;	
+					if (zahlen[k] < zahlen[kMin]) {
+						kMin = k;
+					}
+				}
+				
+				if(kMin != i) {
+					int zwischenspeicher = zahlen[i];
+					zahlen[i] = zahlen[kMin];
+					zahlen[kMin] = zwischenspeicher;	
+				}
 			}			
+		} catch (RobotIllegalStateException rise) {
+			letzteException = rise;
+			rise.printStackTrace();
+		} catch (RobotMagicValueException rmve) {
+			letzteException = rmve;
+			rmve.printStackTrace();
 		}
 		
 		return zahlen;

Robbie-Management-System/src/domain/R2D2Test.java

@@ -0,0 +1,62 @@
+package domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import exceptions.RobotException;
+
+import org.junit.Assert;
+
+class R2D2Test {
+
+	@Test
+	void testSetNameGetName() {
+		R2D2 r = new R2D2("Test");
+		assertEquals("Test", r.getName());
+		r.setName("TestNeu");
+		assertEquals("TestNeu", r.getName());
+	}
+
+	@Test
+	void testSetiDGetiD() {
+		R2D2 r = new R2D2("Test");
+		assertEquals(0, r.getId());
+		R2D2 r2 = new R2D2("Test2");
+		assertNotEquals(1, r2.getId());
+		r2.setiD(2);
+		assertEquals(2, r2.getId());
+	}
+
+	@Test
+	void testTriggerPowerSwitchIsPowerOn() {
+		R2D2 r = new R2D2("Test");
+		assertEquals(true, r.isPowerOn());
+		r.triggerPowerSwitch();
+		assertEquals(false, r.isPowerOn());
+	}
+
+	@Test
+	void testThinkSpeak() throws RobotException {
+		R2D2 r = new R2D2("Test");
+		int[] zahlen = {2,4,3,1,6,5};
+		assertEquals("2, 4, 3, 1, 6, 5", r.speak(zahlen));
+		int[] zahlenNeu = {1,2,3,4,5,6};
+		Assert.assertArrayEquals(zahlenNeu, r.think(zahlen));
+		assertEquals("1, 2, 3, 4, 5, 6", r.speak(r.think(zahlen)));
+	}
+	
+	@Test
+	void testGetLastException() throws RobotException {
+		R2D2 r = new R2D2("Test");
+		int[] zahlen = {42,4,3,1,6,5};
+		r.think(zahlen);
+		assertEquals("exceptions.RobotMagicValueException: Test: Zahl 42 kommt vor - Roboter: \"Ihhhhh\"!", r.getLastException().toString());
+		r.speak(zahlen);
+		assertEquals("exceptions.RobotMagicValueException: Test: Zahl 42 kommt vor - Roboter: \"Ihhhhh\"!", r.getLastException().toString());
+		r.triggerPowerSwitch();
+		r.think(zahlen);
+		assertEquals("exceptions.RobotIllegalStateException: Test: Leider ist der Roboter aus und kann nichts machen!", r.getLastException().toString());
+		r.speak(zahlen);
+		assertEquals("exceptions.RobotIllegalStateException: Test: Leider ist der Roboter aus und kann nichts machen!", r.getLastException().toString());
+	}
+}

Robbie-Management-System/src/domain/RobotType.java

@@ -1,5 +1,10 @@
 package domain;
 
+/**
+ * Die Klasse repräsentiert alle Roboter Modelle die existieren.
+ *
+ * Die Roboter können vom Modell C3PO, R2D2 oder NEXUS6 sein.
+ */
 public enum RobotType {
-	C3PO, R2D2;
+	C3PO, R2D2, NEXUS6;
 }

Robbie-Management-System/src/domain/Robotermodell.java

@@ -1,12 +1,17 @@
 package domain;
 
+import java.util.Arrays;
+
 import exceptions.RobotException;
+import exceptions.RobotIllegalStateException;
+import exceptions.RobotMagicValueException;
 import roboterSystem.Robot;
 
 public abstract class Robotermodell implements Robot {
 	private int iD;
 	private String name;
-	private boolean power = true;
+	protected boolean power = true;
+	protected RobotException letzteException;
 	
 	public void setName(String name) {
 		this.name = name;
@@ -42,14 +47,49 @@ public abstract class Robotermodell implements Robot {
 
 	@Override
 	public RobotException getLastException() {
-		// TODO Auto-generated method stub
+		return letzteException;
-		return null;
 	}
 
 	@Override
 	public String speak(int[] zahlen) throws RobotException {
-		// TODO Auto-generated method stub
+		StringBuilder sb = new StringBuilder();
-		return null;
+		
+		try {
+			if (this.isPowerOn() == false) {
+				throw new RobotIllegalStateException(name);
+			}
+			
+			for (int i = 0; i < zahlen.length; i++) {
+				if (zahlen[i] == 42) {
+					throw new RobotMagicValueException(name);
+				}
+			}
+			
+			String hilfszeichen;
+			
+			if (this instanceof C3PO) {
+				hilfszeichen = ";";
+			} else if (this instanceof R2D2){
+				hilfszeichen = ",";
+			} else {
+				//wird beim Nexus6 geworfen
+				throw new RobotIllegalStateException(name);
+			}
+			
+			Arrays.stream(zahlen)
+			.forEach(z -> sb.append(z + hilfszeichen + " "));
+			
+			sb.setLength(sb.length() - 2);
+			
+		} catch (RobotIllegalStateException rise) {
+			letzteException = rise;
+			rise.printStackTrace();
+		} catch (RobotMagicValueException rmve) {
+			letzteException = rmve;
+			rmve.printStackTrace();
+		}
+		
+		return sb.toString();
 	}
 	
 }

Robbie-Management-System/src/exceptions/RobotException.java

@@ -1,7 +1,30 @@
 package exceptions;
 
+/**
+ * Die Klasse repräsentiert die Exceptions der Roboter.
+ *
+ * Der Roboter hat einen Konstruktor <code>RobotException()</code> welcher nichts macht.
+ * 
+ * Der Roboter hat einen weiteren Konstruktor <code>RobotException(...)</code> welcher
+ * einen String übergeben bekommt und diesen an seine Superklasse übergibt.
+ */
 public class RobotException extends Exception{
 
+	/**
+	 * Der Konstruktor macht nichts.
+	 */
+	public RobotException() {
 		
+	}
+	
+	/**
+	 * Der Konstruktor bekommt einen String übergeben und gibt diesen an
+	 * seine Superklasse weiter.
+	 * 
+     * @param String fehlertext repräsentiert den Text den die Exception wirft.
+	 */
+	public RobotException(String fehlertext) {
+		super(fehlertext);
+	}
 
 }

Robbie-Management-System/src/exceptions/RobotIllegalStateException.java

@@ -1,6 +1,32 @@
 package exceptions;
 
-public class RobotIllegalStateException extends Exception{
+/**
+ * Die Klasse repräsentiert die RobotIllegalStateException der Roboter.
+ *
+ * Der Roboter hat einen Konstruktor <code>RobotException()</code> welcher einen
+ * Fehlertext an seine Superklasse übergibt.
+ * 
+ * Der Roboter hat einen weiteren Konstruktor <code>RobotException(...)</code> welcher
+ * einen String übergeben bekommt und diesen an seine Superklasse übergibt.
+ */
+public class RobotIllegalStateException extends RobotException{
 
+	/**
+	 * Der Konstruktor erzeugt einen Fehlertext und übergibt diesen an
+	 * seine Superkalsse.
+	 */
+	public RobotIllegalStateException() {
+		super("Leider ist der Roboter aus und kann nichts machen!");
+	}
+	
+	/**
+	 * Der Konstruktor bekommt einen String (den Namen) übergeben und gibt diesen an
+	 * seine Superklasse weiter.
+	 * 
+     * @param String name repräsentiert den Namen des Roboters der die Exception wirft.
+	 */
+	public RobotIllegalStateException(String name) {
+		super(name + ": Leider ist der Roboter aus und kann nichts machen!");
+	}
 	
 }

Robbie-Management-System/src/exceptions/RobotMagicValueException.java

@@ -1,6 +1,32 @@
 package exceptions;
 
-public class RobotMagicValueException extends Exception{
+/**
+ * Die Klasse repräsentiert die RobotMagicValueException der Roboter.
+ *
+ * Der Roboter hat einen Konstruktor <code>RobotException()</code> welcher einen
+ * Fehlertext an seine Superklasse übergibt.
+ * 
+ * Der Roboter hat einen weiteren Konstruktor <code>RobotException(...)</code> welcher
+ * einen String übergeben bekommt und diesen an seine Superklasse übergibt.
+ */
+public class RobotMagicValueException extends RobotException{
 
+	/**
+	 * Der Konstruktor erzeugt einen Fehlertext und übergibt diesen an
+	 * seine Superkalsse.
+	 */
+	public RobotMagicValueException() {
+		super("Zahl 42 kommt vor - Roboter: \"Ihhhhh\"!");
+	}
+	
+	/**
+	 * Der Konstruktor bekommt einen String (den Namen) übergeben und gibt diesen an
+	 * seine Superklasse weiter.
+	 * 
+     * @param String name repräsentiert den Namen des Roboters der die Exception wirft.
+	 */
+	public RobotMagicValueException(String name) {
+		super(name + ": Zahl 42 kommt vor - Roboter: \"Ihhhhh\"!");
+	}
 	
 }

Robbie-Management-System/src/main/RobotFactory.java

@@ -5,8 +5,21 @@ import domain.R2D2;
 import domain.RobotType;
 import domain.Robotermodell;
 
+/**
+ * Die Klasse repräsentiert die RobotFactory.
+ *
+ * Mit <code>robotFactory(...)</code> werden die jeweiligen Modelle bzw. Instanzen
+ * der Roboter erzeugt.
+ */
 public class RobotFactory {
 
+    /**
+     * Erzeugt die jeweiligen Modelle der Roboter.
+     *
+     * @param RobotType modell stellt als Enum das Modell des Roboters dar.
+     * @param String name stellt den Namen des Roboters dar.
+     * @return Eine eindeutige Instanz in Form des Objekts oder eben null.
+     */
 	public static Robotermodell robotFactory (RobotType modell, String name) {
 		switch(modell) {
 			case C3PO:

Robbie-Management-System/src/main/RobotFactoryTest.java

@@ -0,0 +1,19 @@
+package main;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+import domain.RobotType;
+
+class RobotFactoryTest {
+
+	@Test
+	void testRobotFactory() {
+		assertEquals(10000, RobotFactory.robotFactory(RobotType.C3PO, "Test").getId());
+		assertEquals("Test", RobotFactory.robotFactory(RobotType.C3PO, "Test").getName());
+		assertEquals(0, RobotFactory.robotFactory(RobotType.R2D2, "Tes2t").getId());
+		assertEquals("Test2", RobotFactory.robotFactory(RobotType.R2D2, "Test2").getName());
+		assertTrue(RobotFactory.robotFactory(RobotType.NEXUS6, "Tes2t") == null);
+	}
+}