src/main/java/ch/zhaw/pm2/racetrack/Game.java

@@ -222,7 +222,7 @@ public class Game implements GameSpecification {
             direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
             if (direction == null) {
                 track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
-                direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove(); //TODO: Entfernen?
+                track.getCar(currentCarIndex).getMoveStrategy().nextMove();
             }else {
                 doCarTurn(direction);
             }

src/test/java/ch/zhaw/pm2/racetrack/GameTest.java

@@ -1,39 +1,51 @@
 package ch.zhaw.pm2.racetrack;
 
 import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
-import org.junit.Before;
+import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.DisplayName;
-
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
 import java.io.File;
 import java.util.List;
-
 import static ch.zhaw.pm2.racetrack.Game.NO_WINNER;
 import static ch.zhaw.pm2.racetrack.PositionVector.Direction.*;
 
+
+/**
+ * Test for Class Game
+ */
 class GameTest {
     private UserInterface userInterface;
     private Game game;
     private Track track;
 
+    private String TRACK_FILE_PATH = ".\\tracks\\challenge.txt";
+    private int CAR_INDEX_ONE = 0;
+    private int CAR_INDEX_TWO = 1;
+
+    /**
+     * This nested Class tests if the game gets initiatet correctly
+     */
     @Nested
     @DisplayName("Test correct Setup")
     class Setup {
+
         @BeforeEach
         void setup() {
             userInterface = new UserInterface("Test");
             game = new Game(userInterface);
-            track = game.selectTrack(new File(".\\tracks\\challenge.txt"));
+            track = game.selectTrack(new File(TRACK_FILE_PATH));
-            game.selectMoveStrategy(track.getCar(0), new UserMoveStrategy(new UserInterface("Testing"), 0, track.getCarId(0)));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_ONE), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_ONE, track.getCarId(CAR_INDEX_ONE)));
-            game.selectMoveStrategy(track.getCar(1), new UserMoveStrategy(new UserInterface("Testing"), 1, track.getCarId(1)));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_TWO), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_TWO, track.getCarId(CAR_INDEX_TWO)));
 
         }
 
-
         @Test
         void getCurrentCarIndex() {
-            Assertions.assertEquals(0, game.getCurrentCarIndex());
+            Assertions.assertEquals(CAR_INDEX_ONE, game.getCurrentCarIndex());
             game.switchToNextActiveCar();
-            Assertions.assertEquals(1, game.getCurrentCarIndex());
+            Assertions.assertEquals(CAR_INDEX_TWO, game.getCurrentCarIndex());
         }
 
         @Test
@@ -70,16 +82,20 @@ class GameTest {
         }
     }
 
+    /**
+     * This nested Class makes basic manipulation after Game init.
+     */
     @Nested
     @DisplayName("Basic manipulation")
-    class manipulation {
+    class Manipulation {
+
         @BeforeEach
         void setup() {
             userInterface = new UserInterface("Test");
             game = new Game(userInterface);
-            track = game.selectTrack(new File(".\\tracks\\challenge.txt"));
+            track = game.selectTrack(new File(TRACK_FILE_PATH));
-            game.selectMoveStrategy(track.getCar(0), new UserMoveStrategy(new UserInterface("Testing"), 0, track.getCarId(0)));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_ONE), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_ONE, track.getCarId(CAR_INDEX_ONE)));
-            game.selectMoveStrategy(track.getCar(1), new UserMoveStrategy(new UserInterface("Testing"), 1, track.getCarId(1)));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_TWO), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_TWO, track.getCarId(CAR_INDEX_TWO)));
 
         }
 
@@ -104,6 +120,9 @@ class GameTest {
         }
     }
 
+    /**
+     * This nested Class tests a Playtrough. And implements a UserInterface interagtion to pretend a real player
+     */
     @Nested
     @DisplayName("Playtrough")
     class Play {
@@ -111,75 +130,86 @@ class GameTest {
 
         @Test
         void winner() {
-            game = new Game(new interFace("Test"));
+            game = new Game(new interFace("Test",new Integer[]{0,2,1},new PositionVector.Direction[]{RIGHT,
+                RIGHT,
+                RIGHT,
+                NONE,
+                NONE,
+                NONE,
+                NONE,
+                UP,
+                LEFT,
+                LEFT,
+                LEFT,
+                LEFT,
+                UP_LEFT,
+                NONE,
+                RIGHT,
+                RIGHT,
+                RIGHT,
+                NONE,
+                LEFT,
+                DOWN_LEFT,
+                DOWN_LEFT,
+                LEFT,
+                LEFT,
+                NONE,
+                RIGHT,
+                NONE,
+                DOWN,
+                DOWN,
+                RIGHT,
+                NONE,
+                RIGHT,
+                DOWN,
+                NONE,
+                UP_RIGHT,
+                RIGHT,
+                UP_RIGHT,
+                UP_RIGHT,
+                RIGHT,
+                RIGHT}));
             try {
                 game.initPhase();
-                Assertions.assertEquals('a',game.gamePhase());
+                Assertions.assertEquals("a",game.gamePhase());
             } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
                 e.printStackTrace();
             }
         }
 
-
+        @Test
+        void crashA() {
+            game = new Game(new interFace("Test",new Integer[]{0,2,2},new PositionVector.Direction[]{UP}));
+            try {
+                game.initPhase();
+                Assertions.assertEquals("b",game.gamePhase());
+            } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
+                e.printStackTrace();
+            }
+        }
 
     }
 
     private class interFace extends UserInterface {
 
-        private static PositionVector.Direction[] directions = {RIGHT,
+        private final PositionVector.Direction[] directions;
-            RIGHT,
+        private final Integer[] instructions;
-            RIGHT,
+        private int pointerDir,pointerInstruction;
-            NONE,
-            NONE,
-            NONE,
-            NONE,
-            UP,
-            LEFT,
-            LEFT,
-            LEFT,
-            LEFT,
-            UP_LEFT,
-            NONE,
-            RIGHT,
-            RIGHT,
-            RIGHT,
-            NONE,
-            LEFT,
-            DOWN_LEFT,
-            DOWN_LEFT,
-            LEFT,
-            LEFT,
-            NONE,
-            RIGHT,
-            NONE,
-            DOWN,
-            DOWN,
-            RIGHT,
-            NONE,
-            RIGHT,
-            DOWN,
-            NONE,
-            UP_RIGHT,
-            RIGHT,
-            UP_RIGHT,
-            UP_RIGHT,
-            RIGHT,
-            RIGHT};
 
-        private static int pointer = -1;
 
-        public interFace(String welcometxt) {
+        public interFace(String welcometxt, Integer[] instructions, PositionVector.Direction[] directions) {
             super(welcometxt);
+            pointerDir = -1;
+            pointerInstruction = -1;
+            this.instructions = instructions;
+            this.directions = directions;
         }
 
         @Override
         public int selectOption(String text, List<String> options) {
-            if (text.equals("Select Track file")) {
+            pointerInstruction++;
-                return 1;
+            return instructions[pointerInstruction];
-            } else if (text.contains("Select Strategy for Car")) {
+
-                return 2;
-            }
-            return 0;
         }
 
         public void printInformation(String text) {
@@ -192,9 +222,9 @@ class GameTest {
         }
 
         public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
-            pointer += 1;
+            pointerDir += 1;
-            if(pointer < directions.length) {
+            if(pointerDir < directions.length) {
-                return directions[pointer];
+                return directions[pointerDir];
             }
             return NONE;
         }