diff --git a/.idea/misc.xml b/.idea/misc.xml
index b573818..c3dfb30 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_X" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>
\ No newline at end of file
diff --git a/test/ch/zhaw/catan/SiedlerGameTest.java b/test/ch/zhaw/catan/SiedlerGameTest.java
index 3dd6fe8..60b91f7 100644
--- a/test/ch/zhaw/catan/SiedlerGameTest.java
+++ b/test/ch/zhaw/catan/SiedlerGameTest.java
@@ -7,10 +7,7 @@ import ch.zhaw.catan.games.ThreePlayerStandard;
 import org.beryx.textio.TextIO;
 import org.beryx.textio.TextIoFactory;
 import org.beryx.textio.TextTerminal;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.*;
 
 import java.awt.*;
 import java.util.*;
@@ -28,158 +25,236 @@ import java.util.List;
 
 public class SiedlerGameTest {
 
-    private final static int DEFAULT_WINPOINTS = 10;
+    private final static int DEFAULT_WINPOINTS = 5;
     private final static int DEFAULT_PLAYERAMOUNT = 4;
 
 
-    private final static Map<Config.Faction, Point> START_SETTLEMENT_POSITIONS = new HashMap<>(
-            Map.of(
-                    Config.Faction.BLUE, new Point(5, 7),
-                    Config.Faction.RED, new Point(1, 3),
-                    Config.Faction.GREEN, new Point(11, 13),
-                    Config.Faction.YELLOW, new Point(13, 5)
-            ));
 
-    private final static Map<Config.Faction, Tuple<Point, Point>> START_ROADS_POSITIONS = new HashMap<>(
-            Map.of(
-                    Config.Faction.BLUE, new Tuple<>(new Point(5, 6), new Point(5, 6)),
-                    Config.Faction.RED, new Tuple<>(new Point(1, 2), new Point(1, 1)),
-                    Config.Faction.GREEN, new Tuple<>(new Point(12, 12), new Point(13, 11)),
-                    Config.Faction.YELLOW, new Tuple<>(new Point(13, 6), new Point(13, 7))
-            ));
+    @Nested
+    @DisplayName("Positive test cases")
+    class PositiveTestcases {
+
+        /**
+         * To Test getLongestRoad in SiedlerBoard
+         *
+         */
+        @Test
+        public void testLongestRoad() {
+            HashMap<Config.Faction,Integer> currentLongestRoad = new HashMap<>();
+            //currentLongestRoad.put(Config.Faction.RED,5);
+            List<Config.Faction> factionList = Arrays.asList(Config.Faction.values());
+
+            SiedlerBoard board = new SiedlerBoard();
+            board.createFixGamefield();
+            board.setEdge(new Point(6, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(6, 6),new Point(5, 7)));
+            board.setEdge(new Point(4, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(5, 7)));
+            board.setEdge(new Point(4, 6), new Point(4, 4), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(4, 4)));
+            board.setEdge(new Point(4, 6), new Point(3, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(3, 7)));
+            board.setEdge(new Point(3, 7), new Point(3, 9), new Road(Config.Faction.BLUE,new Point(3, 7),new Point(3, 9)));
+            board.setEdge(new Point(3, 9), new Point(4, 10), new Road(Config.Faction.BLUE,new Point(3, 9),new Point(4, 10)));
+            board.setEdge(new Point(4, 10), new Point(5, 9), new Road(Config.Faction.BLUE,new Point(4, 10),new Point(5, 9)));
+            board.setCorner(new Point(3,7),new Settlement(Config.Faction.BLUE,new Point(3,7)));
+            board.getLongestRoadFaction(currentLongestRoad,factionList);
+            assertEquals(6,currentLongestRoad.get(Config.Faction.BLUE));
+
+        }
+
+        /**
+         *
+         */
+        @Test
+        @DisplayName("Test")
+        public void TestHandle7() {
+
+            SiedlerGame game = SystemTestcases.startGame();
+
+        }
+    }
+
+    @Nested
+    @DisplayName("Negative test cases")
+    class NegativeTestcases {
+        /**
+         * Tests if the method will fail when given false Data
+         * {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
+         */
+        @Test
+        public void destructiveTestBuildCity() {
+            SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
+
+            //Too
+            Assertions.assertFalse(model.buildCity(new Point(50, 60)));
+
+            //Factions wants to build a city on a city from another faction
+            Assertions.assertFalse(model.buildCity(new Point(3, 3)));
+        }
+
+        /**
+         * Tests if the method fails when given false Data
+         * {@link ThreePlayerStandard#getAfterSetupPhase(int)}
+         */
+        @Test
+        public void destructiveTestBuildRoad() {
+
+            SiedlerGame model = ThreePlayerStandard.getAfterSetupPhase(DEFAULT_WINPOINTS);
+
+            System.out.println(model.buildRoad(new Point(3, 7),new Point(3, 9)));
+        }
+
+        /**
+         * Tests if the method fails when trading material with the same material
+         * {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
+         */
+        @Test
+        public void destructiveTestTradeWithBank() {
+            SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
+            model.switchToNextPlayer();
+
+            Map<Config.Resource, Integer> expectedResourceCards = ThreePlayerStandard.BANK_ALMOST_EMPTY_RESOURCE_CARD_STOCK.get(model.getCurrentPlayerFaction());
+            assertEquals(expectedResourceCards.get(Config.Resource.WOOL), model.getCurrentPlayerResourceStock(Config.Resource.WOOL));
+            assertEquals(expectedResourceCards.get(Config.Resource.LUMBER), model.getCurrentPlayerResourceStock(Config.Resource.LUMBER));
+
+            System.out.println(model.tradeWithBankFourToOne(Config.Resource.WOOL, Config.Resource.WOOL));
+        }
+    }
 
     /**
-     * To Test getLongestRoad in SiedlerBoard
+     * @Class SystemTestCases
+     *
+     * This class simulates a running game and tests multiple sequences of this game.
+     * Those test cases will be
      *
      */
-    @Test
-    public void testLongestRoad() {
-        HashMap<Config.Faction,Integer> currentLongestRoad = new HashMap<>();
-        //currentLongestRoad.put(Config.Faction.RED,5);
-        List<Config.Faction> factionList = Arrays.asList(Config.Faction.values());
+    @Nested
+    @DisplayName("System test cases")
+    class SystemTestcases {
 
-        SiedlerBoard board = new SiedlerBoard();
-        board.createFixGamefield();
-        board.setEdge(new Point(6, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(6, 6),new Point(5, 7)));
-        board.setEdge(new Point(4, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(5, 7)));
-        board.setEdge(new Point(4, 6), new Point(4, 4), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(4, 4)));
-        board.setEdge(new Point(4, 6), new Point(3, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(3, 7)));
-        board.setEdge(new Point(3, 7), new Point(3, 9), new Road(Config.Faction.BLUE,new Point(3, 7),new Point(3, 9)));
-        board.setEdge(new Point(3, 9), new Point(4, 10), new Road(Config.Faction.BLUE,new Point(3, 9),new Point(4, 10)));
-        board.setEdge(new Point(4, 10), new Point(5, 9), new Road(Config.Faction.BLUE,new Point(4, 10),new Point(5, 9)));
-        board.setCorner(new Point(3,7),new Settlement(Config.Faction.BLUE,new Point(3,7)));
-        board.getLongestRoadFaction(currentLongestRoad,factionList);
-        assertEquals(6,currentLongestRoad.get(Config.Faction.BLUE));
+        private final static Map<Config.Faction, Point> START_SETTLEMENT_POSITIONS = new HashMap<>(
+                Map.of(
+                        Config.Faction.BLUE, new Point(4, 4),
+                        Config.Faction.RED, new Point(10, 4),
+                        Config.Faction.GREEN, new Point(4, 18),
+                        Config.Faction.YELLOW, new Point(10, 18)
+                ));
 
-    }
+        /**
+         * @Datafield START_ROADS_POSITION
+         *
+         * This are a set of Roads, that have been
+         */
+        private final static Map<Config.Faction, Tuple<Point, Point>> START_ROADS_POSITIONS = new HashMap<>(
+                Map.of(
+                        Config.Faction.BLUE, new Tuple<>(new Point(4, 4), new Point(4, 6)),
+                        Config.Faction.RED, new Tuple<>(new Point(10, 4), new Point(10, 6)),
+                        Config.Faction.GREEN, new Tuple<>(new Point(4, 18), new Point(4, 16)),
+                        Config.Faction.YELLOW, new Tuple<>(new Point(10, 18), new Point(10, 16))
+                ));
 
-    /**
-     * Tests if the method will fail when given false Data
-     * {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
-     */
-    @Test
-    public void destructiveTestBuildCity() {
-        SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
-
-        //Too
-        Assertions.assertFalse(model.buildCity(new Point(50, 60)));
-
-        //Factions wants to build a city on a city from another faction
-        Assertions.assertFalse(model.buildCity(new Point(3, 3)));
-    }
-
-    /**
-     * Tests if the method fails when given false Data
-     * {@link ThreePlayerStandard#getAfterSetupPhase(int)}
-     */
-    @Test
-    public void destructiveTestBuildRoad() {
-
-        SiedlerGame model = ThreePlayerStandard.getAfterSetupPhase(DEFAULT_WINPOINTS);
-
-        System.out.println(model.buildRoad(new Point(3, 7),new Point(3, 9)));
-    }
-
-    /**
-     * Tests if the method fails when trading material with the same material
-     * {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
-     */
-    @Test
-    public void destructiveTestTradeWithBank() {
-        SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
-        model.switchToNextPlayer();
-
-        Map<Config.Resource, Integer> expectedResourceCards = ThreePlayerStandard.BANK_ALMOST_EMPTY_RESOURCE_CARD_STOCK.get(model.getCurrentPlayerFaction());
-        assertEquals(expectedResourceCards.get(Config.Resource.WOOL), model.getCurrentPlayerResourceStock(Config.Resource.WOOL));
-        assertEquals(expectedResourceCards.get(Config.Resource.LUMBER), model.getCurrentPlayerResourceStock(Config.Resource.LUMBER));
-
-        System.out.println(model.tradeWithBankFourToOne(Config.Resource.WOOL, Config.Resource.WOOL));
-    }
-
-    @Test
-    public void TestGameInSetupPhase() {
-        SiedlerGame game = startGame();
-
-        for (Config.Faction faction: game.getPlayerFactions()) {
-            HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
-
-            Assertions.assertEquals(0, resources.get(Config.Resource.BRICK));
-            Assertions.assertEquals(0, resources.get(Config.Resource.GRAIN));
-            Assertions.assertEquals(0, resources.get(Config.Resource.LUMBER));
-            Assertions.assertEquals(0, resources.get(Config.Resource.ORE));
-            Assertions.assertEquals(0, resources.get(Config.Resource.WOOL));
-
-            game.switchToNextPlayer();
-        }
-    }
-
-    @Test
-    public void TestGameAfterSetupPhase() {
-        SiedlerGame game = gameAfterSetupPhase();
-
-        throwDiceSeveralTimes(game, 5, 5);
-
-        System.out.println("\n\nVerteilung \n\n");
-        for (Config.Faction faction: game.getPlayerFactions()) {
-            HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
-            System.out.println(faction.toString() + "\n");
-            System.out.println(" BRICK " + resources.get(Config.Resource.BRICK).toString());
-            System.out.println(" GRAIN " + resources.get(Config.Resource.GRAIN));
-            System.out.println(" LUMBER " + resources.get(Config.Resource.LUMBER));
-            System.out.println(" ORE " + resources.get(Config.Resource.ORE));
-            System.out.println(" WOOL " + resources.get(Config.Resource.WOOL));
-
-            game.switchToNextPlayer();
-        }
-    }
-
-    @Test
-    public void TestGameInMiddle() {
-
-    }
-
-    private SiedlerGame startGame() {
-        return new SiedlerGame(DEFAULT_WINPOINTS, DEFAULT_PLAYERAMOUNT);
-    }
-
-    private void throwDiceSeveralTimes(SiedlerGame game, int dice, int amountDiceThrows) {
-        for (int i = 0; i < amountDiceThrows; i++) {
-            System.out.println(game.getCurrentPlayerFaction().toString());
-            game.throwDice(dice);
-        }
-    }
-
-    private SiedlerGame gameAfterSetupPhase() {
-        SiedlerGame game = startGame();
-
-        for (Config.Faction faction: game.getPlayerFactions()) {
-
-            game.buildSettlement(START_SETTLEMENT_POSITIONS.get(faction));
-            game.buildRoad(START_ROADS_POSITIONS.get(faction).first, START_ROADS_POSITIONS.get(faction).second);
-
-            game.switchToNextPlayer();
+        private static SiedlerGame startGame() {
+            return new SiedlerGame(DEFAULT_WINPOINTS, DEFAULT_PLAYERAMOUNT);
         }
 
-        return game;
+
+        @Test
+        @DisplayName("Game initializing")
+        public void TestGameInitialization() {
+            SiedlerGame game = startGame();
+
+            for (Config.Faction faction: game.getPlayerFactions()) {
+                HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
+
+                Assertions.assertEquals(0, resources.get(Config.Resource.BRICK));
+                Assertions.assertEquals(0, resources.get(Config.Resource.GRAIN));
+                Assertions.assertEquals(0, resources.get(Config.Resource.LUMBER));
+                Assertions.assertEquals(0, resources.get(Config.Resource.ORE));
+                Assertions.assertEquals(0, resources.get(Config.Resource.WOOL));
+
+                game.switchToNextPlayer();
+            }
+        }
+
+        /**
+         * This will test when
+         */
+        @Test
+        public void TestGameInSetupPhase() {
+            SiedlerGame game = gameInSetupPhase();
+
+            for (Config.Faction faction: game.getPlayerFactions()) {
+                HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
+
+                Assertions.assertEquals(0, resources.get(Config.Resource.BRICK));
+                Assertions.assertEquals(0, resources.get(Config.Resource.GRAIN));
+                Assertions.assertEquals(0, resources.get(Config.Resource.LUMBER));
+                Assertions.assertEquals(0, resources.get(Config.Resource.ORE));
+                Assertions.assertEquals(0, resources.get(Config.Resource.WOOL));
+
+                game.switchToNextPlayer();
+            }
+        }
+
+        private static SiedlerGame gameInSetupPhase() {
+            SiedlerGame game = startGame();
+
+            for (Config.Faction faction: game.getPlayerFactions()) {
+
+                game.placeInitialSettlement(START_SETTLEMENT_POSITIONS.get(faction), false);
+                game.placeInitialRoad(START_ROADS_POSITIONS.get(faction).first, START_ROADS_POSITIONS.get(faction).second);
+
+                game.switchToNextPlayer();
+            }
+
+            return game;
+        }
+
+        @Test
+        public void TestGameAfterSetupPhase() {
+            SiedlerGame game = gameAfterSetupPhase();
+
+            throwDiceSeveralTimes(game, 5, 5);
+
+            System.out.println("\n\nVerteilung \n\n");
+            for (Config.Faction faction: game.getPlayerFactions()) {
+                HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
+                System.out.println(faction.toString() + "\n");
+                System.out.println(" BRICK " + resources.get(Config.Resource.BRICK).toString());
+                System.out.println(" GRAIN " + resources.get(Config.Resource.GRAIN));
+                System.out.println(" LUMBER " + resources.get(Config.Resource.LUMBER));
+                System.out.println(" ORE " + resources.get(Config.Resource.ORE));
+                System.out.println(" WOOL " + resources.get(Config.Resource.WOOL));
+
+                game.switchToNextPlayer();
+            }
+        }
+
+        private static SiedlerGame gameAfterSetupPhase() {
+            SiedlerGame game = gameInSetupPhase();
+
+
+
+            return game;
+        }
+
+        @Test
+        @DisplayName("End of Game test")
+        public void TestGameEnd() {
+
+        }
+
+        private static SiedlerGame gameNearEnd() {
+            SiedlerGame game = gameAfterSetupPhase();
+
+            return game;
+
+        }
+
+        private static void throwDiceSeveralTimes(SiedlerGame game, int dice, int amountDiceThrows) {
+            for (int i = 0; i < amountDiceThrows; i++) {
+                System.out.println(game.getCurrentPlayerFaction().toString());
+                game.throwDice(dice);
+            }
+        }
+
+
     }
 }
\ No newline at end of file