refactoring endgame

10 files changed, 336 insertions, 81 deletions

diff --git a/client/src/Mancala/Play.tsx b/client/src/Mancala/Play.tsx
index 3b8ff25..b72bce1 100644
--- a/client/src/Mancala/Play.tsx
+++ b/client/src/Mancala/Play.tsx
@@ -14,4 +14,4 @@ export function Play({ gameState, setGameState }: PlayProps) {
             To do...
         </div>
     )
-}
\ No newline at end of file
+}
diff --git a/domain/build.gradle b/domain/build.gradle
index 001d2dd..fe53df0 100644
--- a/domain/build.gradle
+++ b/domain/build.gradle
@@ -11,8 +11,8 @@ repositories {
 
 dependencies {
     // Download JUnit so that we can use it in our tests.
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.2'
     testRuntimeOnly "org.junit.platform:junit-platform-commons:1.7.0"
 }
 
diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java
index ade728d..a7a2e78 100644
--- a/domain/src/main/java/mancala/domain/Bowl.java
+++ b/domain/src/main/java/mancala/domain/Bowl.java
@@ -5,7 +5,7 @@ abstract class Bowl {
     protected Player myOwner;
     protected Bowl nextBowl;
 
-    public int getMyRocks() {
+    public int getMyStones() {
         return myRocks;
     }
 
@@ -27,24 +27,25 @@ abstract class Bowl {
 
     abstract SmallBowl getSmallBowl();
 
+    abstract SmallBowl goToFirstBowlOfPlayerWithTurn();
+
+    abstract boolean isEmpty();
     // abstract SmallBowl getNextSmallBowl();
 
     void endTheGame() {
-        getNextBowl().endTheGame(this, 0, 0);
+        goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0);
     }
 
-    abstract boolean isEmpty();
-
-    private void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) {
-        if (isEmpty() == false && myOwner.hasTheTurn()) return;
+    protected void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) {
+        if (isEmpty() == false) return;
 
         if (getMyOwner().equals(startOfLoop.getMyOwner())) {
-            scorePlayer = scorePlayer + getMyRocks();
-        } else scoreOpponent = scoreOpponent + getMyRocks();
+            scorePlayer = scorePlayer + getMyStones();
+        } else scoreOpponent = scoreOpponent + getMyStones();
 
         if (this.equals(startOfLoop)) {
 
-            int playerKalaha = getKalaha().getMyRocks();
+            int playerKalaha = getKalaha().getMyStones();
 
             if (scorePlayer == playerKalaha) {
 
@@ -58,4 +59,6 @@ abstract class Bowl {
         } else getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent);
     }
 
+
+
 }
diff --git a/domain/src/main/java/mancala/domain/Foo.java b/domain/src/main/java/mancala/domain/Foo.java
deleted file mode 100644
index bcce6fa..0000000
--- a/domain/src/main/java/mancala/domain/Foo.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package mancala.domain;
-
-// Make your own mancala implementation using your design.
-// You can take this stub as an example how to make a 
-// class inside a package and how to test it.
-public class Foo {
-
-    public int theAnswerToLifeTheUniverseAndEverything() {
-        return 41;
-    }
-}
\ No newline at end of file
diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java
index 9e70e6c..7ab954c 100644
--- a/domain/src/main/java/mancala/domain/Kalaha.java
+++ b/domain/src/main/java/mancala/domain/Kalaha.java
@@ -20,6 +20,15 @@ class Kalaha extends Bowl {
         return getNextBowl().getSmallBowl();
     }
 
+    @Override
+    SmallBowl goToFirstBowlOfPlayerWithTurn() {
+        if (getMyOwner().hasTheTurn()) {
+            return getNextBowl().getKalaha().getSmallBowl();
+        } else {
+            return getSmallBowl();
+        }
+    }
+
     SmallBowl getOpposite(int countTillThis) {
         return getNextBowl().getNextSmallBowlTimes(countTillThis - 1);
     }
diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java
index de04c8f..81dbbe8 100644
--- a/domain/src/main/java/mancala/domain/MancalaImpl.java
+++ b/domain/src/main/java/mancala/domain/MancalaImpl.java
@@ -1,29 +1,83 @@
 package mancala.domain;
 
+import java.util.HashSet;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
 public class MancalaImpl implements Mancala {
+
+    public static HashSet<Integer> PLAYER_ONE_PITS = new HashSet<>(
+            IntStream.rangeClosed(0, 5).boxed().collect(Collectors.toList())
+    );
+    public static HashSet<Integer> PLAYER_TWO_PITS = new HashSet<>(
+            IntStream.rangeClosed(7, 12).boxed().collect(Collectors.toList())
+    );
+    public static int PLAYER_ONE_KALAHA = 6;
+    public static int PLAYER_TWO_KALAHA = 13;
+
+    private SmallBowl domainReference;
+
     public MancalaImpl() {
-        // Initialize the game here.
+        domainReference = new SmallBowl();
     }
 
     @Override
     public boolean isPlayersTurn(int player) {
-        return true;
+        switch (player) {
+            case Mancala.PLAYER_ONE:
+                return domainReference.getMyOwner().hasTheTurn();
+            case Mancala.PLAYER_TWO:
+                return domainReference.getMyOwner().getOpponent().hasTheTurn();
+            default:
+                return false;
+        }
     }
 
     @Override
 	public void playPit(int index) throws MancalaException {
-        // Implement playing a pit.
+        if (isPlayersTurn(Mancala.PLAYER_ONE) && MancalaImpl.PLAYER_TWO_PITS.contains(index)) {
+            throw new MancalaException("Player one cannot play player two's pits.");
+        }
+        if (isPlayersTurn(Mancala.PLAYER_TWO) && MancalaImpl.PLAYER_ONE_PITS.contains(index)) {
+            throw new MancalaException("Player two cannot play player one's pits.");
+        }
+        if (index == MancalaImpl.PLAYER_ONE_KALAHA || index == MancalaImpl.PLAYER_TWO_KALAHA) {
+            throw new MancalaException("A kalaha can never be played!");
+        }
+        if (getStonesForPit(index) == 0) {
+            throw new MancalaException("The pit was empty when played!");
+        }
+
+        if (isPlayersTurn(Mancala.PLAYER_ONE)) {
+            domainReference.getNextSmallBowlTimes(index).play();
+        } else {
+            int skipKalahaIndex = index - 1;
+            domainReference.getNextSmallBowlTimes(skipKalahaIndex).play();
+        }
+
     }
 	
 	@Override
 	public int getStonesForPit(int index) {
-        // Make a sane implementation.
-        if((index + 1 % 7) == 0) return 0;
-        return 4;
+        if (MancalaImpl.PLAYER_ONE_PITS.contains(index)) {
+            return domainReference.getNextSmallBowlTimes(index).getMyStones();
+        }
+        else if (MancalaImpl.PLAYER_TWO_PITS.contains(index)) {
+            return domainReference.getNextSmallBowlTimes(--index).getMyStones();
+        }
+        else if (index == MancalaImpl.PLAYER_ONE_KALAHA) {
+            return domainReference.getKalaha().getMyStones();
+        }
+        else if (index == MancalaImpl.PLAYER_TWO_KALAHA) {
+            return domainReference.getKalaha().getNextBowl().getKalaha().getMyStones();
+        }
+        else
+            return -1;
     }
 
 	@Override
 	public boolean isEndOfGame() {
+        //domainReference.endTheGame();
         return false;
     }
 
diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java
index 5c97d72..ce4c0ce 100644
--- a/domain/src/main/java/mancala/domain/SmallBowl.java
+++ b/domain/src/main/java/mancala/domain/SmallBowl.java
@@ -85,6 +85,15 @@ public class SmallBowl extends Bowl {
         return this;
     }
 
+    @Override
+    SmallBowl goToFirstBowlOfPlayerWithTurn() {
+        if (getMyOwner().hasTheTurn()) {
+            return getKalaha().getNextBowl().getKalaha().getSmallBowl();
+        } else {
+            return getKalaha().getSmallBowl();
+        }
+    }
+
     Kalaha getKalaha() {
         return getNextBowl().getKalaha();
     }
@@ -94,8 +103,8 @@ public class SmallBowl extends Bowl {
             getOpposite().getKalaha().claimStolenBooty(myRocks);
             myRocks = 0;
 
-        } else if (getMyRocks() == 1 &&
-                getOpposite().getMyRocks() != 0) {
+        } else if (getMyStones() == 1 &&
+                getOpposite().getMyStones() != 0) {
 
             getKalaha().claimStolenBooty(myRocks);
             myRocks = 0;
diff --git a/domain/src/test/java/mancala/domain/BowlTest.java b/domain/src/test/java/mancala/domain/BowlTest.java
index 530f628..34ca42d 100644
--- a/domain/src/test/java/mancala/domain/BowlTest.java
+++ b/domain/src/test/java/mancala/domain/BowlTest.java
@@ -54,21 +54,21 @@ class BowlTest {
                 for (int i = 0; i < 14; i++) {
                     current = current.getNextBowl();
                     if (current.getClass() == SmallBowl.class)
-                        assertEquals(current.getMyRocks(), 4);
+                        assertEquals(current.getMyStones(), 4);
                 }
                 assertSame(current, firstSmallBowlPlayer);
             }
 
             @Test
             public void WHEN_chosen_by_the_player_that_has_the_turn_THEN_distribute_its_rocks_anti_clockwise() {
-                int initialRocks = firstSmallBowlPlayer.getMyRocks();
+                int initialRocks = firstSmallBowlPlayer.getMyStones();
                 firstSmallBowlPlayer.play();
                 Bowl neighbour = firstSmallBowlPlayer.getNextBowl();
                 for (int i = 0; i < initialRocks; i++) {
-                    assertEquals(5, neighbour.getMyRocks());
+                    assertEquals(5, neighbour.getMyStones());
                     neighbour = neighbour.getNextBowl();
                 }
-                assertEquals(4, neighbour.getMyRocks());
+                assertEquals(4, neighbour.getMyStones());
             }
         }
 
@@ -78,22 +78,22 @@ class BowlTest {
             @Test
             public void its_not_the_players_turn_WHEN_played_by_the_player_THEN_nothing_happens() {
                 firstSmallBowlPlayer.getMyOwner().switchTurn();
-                int initialRocks = firstSmallBowlPlayer.getMyRocks();
+                int initialRocks = firstSmallBowlPlayer.getMyStones();
                 firstSmallBowlPlayer.play();
                 Bowl neighbour = firstSmallBowlPlayer.getNextBowl();
                 for (int i = 0; i < initialRocks; i++) {
-                    assertEquals(4, neighbour.getMyRocks());
+                    assertEquals(4, neighbour.getMyStones());
                     neighbour = neighbour.getNextBowl();
                 }
-                assertEquals(4, neighbour.getMyRocks());
+                assertEquals(4, neighbour.getMyStones());
             }
 
             @Test
             public void play_can_reach_opponents_kalaha_WHEN_played_by_the_player_THEN_opponents_kalaha_is_skipped() {
                 SmallBowl playWillSkipFromThisBowl = goToSkippableState();
-                int opponentKalahaRocksBefore = firstSmallBowlPlayer.getNextSmallBowlTimes(11).getNextBowl().getMyRocks();
+                int opponentKalahaRocksBefore = firstSmallBowlPlayer.getNextSmallBowlTimes(11).getNextBowl().getMyStones();
                 playWillSkipFromThisBowl.play();
-                int opponentKalahaRocksAfter = firstSmallBowlPlayer.getNextSmallBowlTimes(11).getNextBowl().getMyRocks();
+                int opponentKalahaRocksAfter = firstSmallBowlPlayer.getNextSmallBowlTimes(11).getNextBowl().getMyStones();
                 assertEquals(opponentKalahaRocksBefore, opponentKalahaRocksAfter);
             }
 
@@ -104,7 +104,7 @@ class BowlTest {
                 assertTrue(firstSmallBowlPlayer.getMyOwner().hasTheTurn());
                 firstSmallBowlPlayer.play();
                 assertTrue(firstSmallBowlPlayer.getMyOwner().hasTheTurn());
-                assertEquals(5, firstSmallBowlPlayer.getNextBowl().getMyRocks());
+                assertEquals(5, firstSmallBowlPlayer.getNextBowl().getMyStones());
             }
 
             @Test
@@ -132,9 +132,9 @@ class BowlTest {
             public void the_play_would_skip_past_opponent_kalaha_at_the_last_rock_and_steal_WHEN_played_THEN_should_skip_and_steal_correctly() {
                 goToSkipAndStealOnLast();
                 SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6);
-                assertEquals(3, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(3, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
                 firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
-                assertEquals(19, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(19, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
             }
 
             private void goToSkipAndStealOnLast() {
@@ -154,13 +154,13 @@ class BowlTest {
                 firstSmallBowlOpponent.getMyOwner().switchTurn();
                 // Should skip and steal
                 // this bowls rocks
-                assertEquals(10, firstSmallBowlOpponent.getNextSmallBowlTimes(3).getMyRocks());
+                assertEquals(10, firstSmallBowlOpponent.getNextSmallBowlTimes(3).getMyStones());
                 // End up here by looping around the board, thus skipping
-                assertEquals(0, firstSmallBowlOpponent.getMyRocks());
+                assertEquals(0, firstSmallBowlOpponent.getMyStones());
                 // Thus steal from last bowl on players side
-                assertEquals(8, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getMyRocks());
+                assertEquals(8, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getMyStones());
                 // Result is big kalaha booty
-                assertEquals(8, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(8, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
             }
 
             private void goToEndOfGameWhereOpponentWins() {
@@ -185,7 +185,7 @@ class BowlTest {
                 firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 // Set up for steal move
                 firstSmallBowlPlayer.getNextSmallBowlTimes(4).play();
-                assertEquals(2, firstSmallBowlPlayer.getKalaha().getMyRocks());
+                assertEquals(2, firstSmallBowlPlayer.getKalaha().getMyStones());
 
                 // opponent
                 // ... worst opening?
@@ -195,8 +195,8 @@ class BowlTest {
                 assertSame(firstSmallBowlPlayer.getNextSmallBowlTimes(4).getOpposite(), firstSmallBowlPlayer.getKalaha().getNextBowl().getNextBowl());
                 firstSmallBowlPlayer.play();
                 // Check if i did it properly on paper
-                assertEquals(9, firstSmallBowlPlayer.getKalaha().getMyRocks());
-                assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getMyRocks());
+                assertEquals(9, firstSmallBowlPlayer.getKalaha().getMyStones());
+                assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getMyStones());
                 // assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getOpposite().getMyRocks());
 
                 // opponent
@@ -204,20 +204,20 @@ class BowlTest {
 
                 //Player
                 firstSmallBowlPlayer.getNextSmallBowlTimes(3).play();
-                assertEquals(10, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(10, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
 
                 // opponent makes stupid move again
                 firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
 
                 // player makes big steal
                 //assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
-                assertEquals(10, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(10, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
                 firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
-                assertEquals(19, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(19, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
 
                 // opponent steals tiny booty
                 firstSmallBowlOpponent.play();
-                assertEquals(3, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(3, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
 
                 // player is stalling until the end
                 firstSmallBowlPlayer.play();
@@ -230,7 +230,7 @@ class BowlTest {
                 firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
                 // everything empty!
                 for (int i = 0; i < 6; i++) {
-                    assertEquals(0, firstSmallBowlOpponent.getNextSmallBowlTimes(i).getMyRocks());
+                    assertEquals(0, firstSmallBowlOpponent.getNextSmallBowlTimes(i).getMyStones());
                 }
 
             }
@@ -251,7 +251,7 @@ class BowlTest {
                 firstSmallBowlOpponent.getNextSmallBowlTimes(4).play();
 
                 // Playing this bowl should give a skip!
-                assertTrue(firstSmallBowlPlayer.getNextSmallBowlTimes(5).getMyRocks() >= 8);
+                assertTrue(firstSmallBowlPlayer.getNextSmallBowlTimes(5).getMyStones() >= 8);
                 return firstSmallBowlPlayer.getNextSmallBowlTimes(5);
             }
         }
@@ -285,7 +285,7 @@ class BowlTest {
                 assertSame(firstSmallBowlPlayer.getNextSmallBowlTimes(1).getOpposite(), firstSmallBowlPlayer.getKalaha().getSmallBowl().getNextSmallBowlTimes(4));
                 // assertSame(firstSmallBowlPlayer.getOpposite(), firstSmallBowlPlayer.getKalaha().getNextSmallBowlTimes(5));
                 firstSmallBowlPlayer.play();
-                assertEquals(7, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(7, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
             }
 
         }
@@ -317,7 +317,7 @@ class BowlTest {
             for (int i = 0; i < 14; i++) {
                 current = current.getNextBowl();
                 if (current.getClass() == Kalaha.class)
-                    assertEquals(current.getMyRocks(), 0);
+                    assertEquals(current.getMyStones(), 0);
             }
         }
     }
diff --git a/domain/src/test/java/mancala/domain/FooTest.java b/domain/src/test/java/mancala/domain/FooTest.java
deleted file mode 100644
index fa784d3..0000000
--- a/domain/src/test/java/mancala/domain/FooTest.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package mancala.domain;
-
-// Your test class should be in the same 
-// package as the class you're testing.
-// Usually the test directory mirrors the
-// main directory 1:1. So for each class in src/main,
-// there is a class in src/test.
-
-// Import our test dependencies. We import the Test-attribute
-// and a set of assertions.
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-public class FooTest {
-    // Define a test starting with @Test. The test is like
-    // a small main method - you need to setup everything
-    // and you can write any arbitrary Java code in it.
-    @Test 
-    public void aNormalBorlStartsWith4Stones() {
-        Foo foo = new Foo();
-        assertEquals(42, foo.theAnswerToLifeTheUniverseAndEverything());
-    }
-}
\ No newline at end of file
diff --git a/domain/src/test/java/mancala/domain/MancalaImplTest.java b/domain/src/test/java/mancala/domain/MancalaImplTest.java
new file mode 100644
index 0000000..b040b02
--- /dev/null
+++ b/domain/src/test/java/mancala/domain/MancalaImplTest.java
@@ -0,0 +1,214 @@
+package mancala.domain;
+
+import org.junit.jupiter.api.*;
+
+import java.util.HashSet;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@IndicativeSentencesGeneration(separator = " -> ", generator = DisplayNameGenerator.ReplaceUnderscores.class)
+class MancalaImplTest {
+
+    Mancala mancala;
+
+    @BeforeEach
+    void setUp() {
+        mancala = new MancalaImpl();
+    }
+
+    /**
+     * Method indicating if the first player has the next turn or not.
+     * If player 1 is not in turn, then player 2 is in turn.
+     *
+     * @param The player which you want to know the turn for.
+     * @return True if the first player has the next turn, false if it's the turn of the other player.
+     */
+    @Nested
+    class isPlayersTurn {
+        @Test
+        void given_mancala_PLAYER_ONE_when_first_player_has_next_turn_then_return_true() {
+            assertTrue(mancala.isPlayersTurn(Mancala.PLAYER_ONE));
+        }
+
+        @Test
+        void given_mancala_PLAYER_ONE_when_second_player_has_next_turn_then_return_false() {
+            playPitAndFailIfNotValid(0);
+            assertFalse(mancala.isPlayersTurn(Mancala.PLAYER_ONE));
+        }
+
+
+        @Test
+        void given_mancala_PLAYER_TWO_when_second_player_has_next_turn_then_return_true() {
+            playPitAndFailIfNotValid(0);
+            assertTrue(mancala.isPlayersTurn(Mancala.PLAYER_TWO));
+        }
+
+        @Test
+        void given_mancala_PLAYER_TWO_when_second_player_has_turn_then_return_false() {
+            assertFalse(mancala.isPlayersTurn(Mancala.PLAYER_TWO));
+        }
+    }
+
+    /**
+     * Method for playing the specified recess. Index is as specified below:
+     *
+     *    12 11 10  9  8  7
+     * 13                    6
+     *     0  1  2  3  4  5
+     *
+     * @param index Index of the recess to be played.
+     * @return 15 item long Array with the current state of the game. The 15th item indicates which player has the next turn (possible values are 1 or 2).
+     */
+    @Nested
+    class playPit {
+        @Test
+        void given_a_pit_index_from_PLAYER_one_choice_when_pit_doesnt_belong_to_player_one_then_throw_MancalaException() {
+            for (int index: MancalaImpl.PLAYER_TWO_PITS) {
+                playPitAndFailIfNoException(index, "Player one could play a pit that was not his without an exception!");
+            }
+        }
+
+        @Test
+        void given_a_pit_index_from_PLAYER_two_choice_when_pit_doesnt_belong_to_player_two_then_throw_MancalaException() {
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNotValid(0);
+
+            assumeTurn(Mancala.PLAYER_TWO);
+            for (int index: MancalaImpl.PLAYER_ONE_PITS) {
+                playPitAndFailIfNoException(index, "Player two could play a pit that was not his without an exception!");
+            }
+        }
+
+        @Test
+        void given_a_Kalaha_index_when_playPit_is_called_then_always_throw_MancalaException() {
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNoException(MancalaImpl.PLAYER_ONE_KALAHA, "Kalaha of player one was played without throwing exception!");
+            playPitAndFailIfNoException(MancalaImpl.PLAYER_TWO_KALAHA, "Kalaha of player two was played without throwing exception!");
+
+            playPitAndFailIfNotValid(0);
+
+            assumeTurn(Mancala.PLAYER_TWO);
+            playPitAndFailIfNoException(MancalaImpl.PLAYER_ONE_KALAHA, "Kalaha of player one was played without throwing exception!");
+            playPitAndFailIfNoException(MancalaImpl.PLAYER_TWO_KALAHA, "Kalaha of player two was played without throwing exception!");
+        }
+
+        @Test
+        void given_that_valid_play_is_made_when_play_is_done_then_players_switch_turns() {
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNotValid(0);
+
+            assumeNotTurn(Mancala.PLAYER_ONE);
+            assumeTurn(Mancala.PLAYER_TWO);
+        }
+
+        @Test
+        void given_that_pit_has_no_stones_when_play_is_made_by_player_one_then_throw_MancalaException() {
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNotValid(0);
+
+            assumeTurn(Mancala.PLAYER_TWO);
+            playPitAndFailIfNotValid(7);
+
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNoException(0, "Didn't throw exception when Pit was empty when played!");
+        }
+
+        @Test
+        void given_that_pit_has_no_stones_when_play_is_made_by_player_two_then_throw_MancalaException() {
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNotValid(5);
+
+            assumeTurn(Mancala.PLAYER_TWO);
+            playPitAndFailIfNotValid(7);
+
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNotValid(0);
+
+            assumeTurn(Mancala.PLAYER_TWO);
+            playPitAndFailIfNoException(7, "Didn't throw exception when Pit was empty when played!");
+        }
+
+    }
+
+    @Nested
+    class getStonesForPit {
+        @Test
+        void given_any_Pit_index_when_getStonesForPit_is_called_then_return_stones_of_pits() {
+            HashSet<Integer> allPitIndexes = new HashSet<>(MancalaImpl.PLAYER_ONE_PITS);
+            allPitIndexes.addAll(MancalaImpl.PLAYER_TWO_PITS);
+
+            for (int pitIndex: allPitIndexes) {
+                assertEquals(4, mancala.getStonesForPit(pitIndex),
+                        "pit should have four stones when created in the domain model.");
+            }
+        }
+
+        @Test
+        void given_any_Kalaha_index_when_getStonesForPit_is_called_then_return_stones_of_Kalaha() {
+            HashSet<Integer> allKalahaIndexes = new HashSet<>();
+            allKalahaIndexes.add(MancalaImpl.PLAYER_ONE_KALAHA);
+            allKalahaIndexes.add(MancalaImpl.PLAYER_TWO_KALAHA);
+            for (int kalahaIndex: allKalahaIndexes) {
+                assertEquals(0, mancala.getStonesForPit(kalahaIndex),
+                        "Kalaha should have zero stones when created in the domain model.");
+            }
+        }
+
+        @Test
+        void given_that_a_play_has_been_made_and_not_looped_around_board_when_getting_stones_then_should_give_zero() {
+            assumeTurn(Mancala.PLAYER_ONE);
+            playPitAndFailIfNotValid(5);
+
+            assertEquals(0, mancala.getStonesForPit(5),
+                    "In this situation play should leave zero rocks!");
+
+            assumeTurn(Mancala.PLAYER_TWO);
+            playPitAndFailIfNotValid(7);
+
+            assertEquals(0, mancala.getStonesForPit(7),
+                    "In this situation play should leave zero rocks!");
+        }
+
+    }
+
+    @Nested
+    class isEndOfGame {
+        void given_the_game_is_not_ended_when_isEndOfGame_is_called_then_return_false() {
+            assertFalse(mancala.isEndOfGame());
+        }
+    }
+
+    @Nested
+    class getWinner {
+    }
+
+    void assumeTurn(int player) {
+        assertTrue(mancala.isPlayersTurn(player),
+                "It's not PLAYER " + (player == 1 ? "ONE's" : "TWO's") + " turn!");
+    }
+
+    void assumeNotTurn(int player) {
+        assertFalse(mancala.isPlayersTurn(player),
+                "It's PLAYER " + (player == 1 ? "ONE's" : "TWO's") + " turn!");
+    }
+
+    void playPitAndFailIfNotValid(int index) {
+        try {
+            mancala.playPit(index);
+        } catch (MancalaException e) {
+            fail("Invalid play.");
+        }
+    }
+
+    void playPitAndFailIfNoException(int index, String message) {
+        try {
+            mancala.playPit(index);
+            fail(message);
+        } catch (MancalaException e) {
+        }
+    }
+
+    void notImplementedYet() {
+        fail("Not implemented yet.");
+    }
+}
\ No newline at end of file