finished making my life easier (domain tests)

4 files changed, 117 insertions, 155 deletions

diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java
index 8a214da..a36c621 100644
--- a/domain/src/main/java/mancala/domain/Bowl.java
+++ b/domain/src/main/java/mancala/domain/Bowl.java
@@ -61,5 +61,5 @@ abstract class Bowl {
     }
 
 
-
+    protected abstract String makeString(String playerBowls, String opponentBowls, String kalahas);
 }
diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java
index a13ebd8..c85af4a 100644
--- a/domain/src/main/java/mancala/domain/Kalaha.java
+++ b/domain/src/main/java/mancala/domain/Kalaha.java
@@ -55,6 +55,20 @@ class Kalaha extends Bowl {
         return true;
     }
 
+    @Override
+    protected String makeString(String playerBowls, String opponentBowls, String kalahas) {
+        if (getMyOwner().equals(SmallBowl.referencePoint.getMyOwner().getOpponent())) {
+            return "  " + opponentBowls + "\n" +
+                    getMyStones() + "\t\t\t\t   " + kalahas + "\n" +
+                    "  " + playerBowls;
+        }
+        else {
+            return getNextBowl().makeString(
+                    playerBowls,
+                    opponentBowls,
+                    kalahas + getMyStones());
+        }
+    }
 
     void claimStolenBooty(int booty) {
         myStones = myStones + booty;
diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java
index b9e4b45..216e2ad 100644
--- a/domain/src/main/java/mancala/domain/SmallBowl.java
+++ b/domain/src/main/java/mancala/domain/SmallBowl.java
@@ -6,8 +6,11 @@ import java.util.stream.Collectors;
 
 public class SmallBowl extends Bowl {
 
+    public static SmallBowl referencePoint;
+
     public SmallBowl() throws DomainSmallBowlException {
         this(Arrays.stream(new int[] {4,4,4,4,4,4,0,4,4,4,4,4,4,0}).boxed().collect(Collectors.toList()));
+        referencePoint = this;
     }
 
     public SmallBowl(List<Integer> stonesList) throws DomainSmallBowlException {
@@ -22,7 +25,7 @@ public class SmallBowl extends Bowl {
         this.myStones = stonesList.remove(0);
 
         this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner());
-
+        referencePoint = this;
     }
 
     SmallBowl(int boardSize, int bowlsToAdd, List<Integer> stonesList, Bowl startBowl, Player playerOwningThisSide) {
@@ -76,9 +79,10 @@ public class SmallBowl extends Bowl {
         // Did play end in smallbowl of my player? steal, otherwise do nothing
         if (getMyOwner().hasTheTurn()) stealTheBooty(false);
 
+        endTheGame();
+
         getMyOwner().switchTurn();
 
-        endTheGame();
     }
 
     SmallBowl getNextSmallBowl() {
@@ -100,11 +104,13 @@ public class SmallBowl extends Bowl {
 
     private void stealTheBooty(boolean victim) {
         if (victim){
+            System.out.println("help! i'm being robbed, my precious " + getMyStones() + " stones are gone :(.");
             getOpposite().getKalaha().claimStolenBooty(myStones);
             myStones = 0;
 
         } else if (getMyStones() == 1 &&
                 getOpposite().getMyStones() != 0) {
+            System.out.println("stealing");
 
             getKalaha().claimStolenBooty(myStones);
             myStones = 0;
@@ -120,4 +126,23 @@ public class SmallBowl extends Bowl {
         count = count + 1;
         return getNextBowl().getOpposite(count);
     }
+
+    public String stateString() {
+        return SmallBowl.referencePoint.makeString("", "", "");
+    }
+
+    protected String makeString(String playerBowls, String opponentBowls, String kalahas) {
+        if (!this.getMyOwner().equals(SmallBowl.referencePoint.getMyOwner())) {
+            return getNextBowl().makeString(
+                    playerBowls,
+                    (getMyStones() + ", ") + opponentBowls,
+                    kalahas);
+        } else {
+            return getNextBowl().makeString(
+                    playerBowls + (playerBowls.equals("") ? getMyStones() : ", " + getMyStones()),
+                    opponentBowls,
+                    kalahas);
+        }
+    }
+
 }
diff --git a/domain/src/test/java/mancala/domain/BowlTest.java b/domain/src/test/java/mancala/domain/BowlTest.java
index 6d5a12f..0f2ea4a 100644
--- a/domain/src/test/java/mancala/domain/BowlTest.java
+++ b/domain/src/test/java/mancala/domain/BowlTest.java
@@ -143,10 +143,24 @@ class BowlTest {
             }
         }
 
+        void setupGameSituationAndFailIfInvalid(int[] stonesArray) {
+            try {
+                referenceSmallBowl = new SmallBowl(
+                        Arrays.stream(
+                                stonesArray
+                        ).boxed().collect(Collectors.toList())
+                );
+            } catch (DomainSmallBowlException e) {
+                fail("Invalid instantiation.");
+            }
+        }
+
         @Nested
         class playBehaviour {
 
             {
+                // setup default game in this sub class
+                // by default
                 try {
                     referenceSmallBowl = new SmallBowl();
                 } catch (DomainSmallBowlException e) {
@@ -155,22 +169,14 @@ class BowlTest {
             }
 
             @Test
-            public void given_stones_can_reach_oppenent_kalaha_when_played_validly_then_opponents_kalaha_is_skipped() {
-                try {
-                    referenceSmallBowl = new SmallBowl(
-                            Arrays.stream(
-                                    new int[] {0,0,0,0,0,100,0,0,0,0,0,0,0,0}
-                            ).boxed().collect(Collectors.toList())
-                    );
-                } catch (DomainSmallBowlException e) {
-                    fail("Invalid instantiation.");
-                }
+            void given_stones_can_reach_oppenent_kalaha_when_played_validly_then_opponents_kalaha_is_skipped() {
+                setupGameSituationAndFailIfInvalid(new int[] {0,0,0,0,0,100,0,0,0,0,0,0,0,0});
                 referenceSmallBowl.getNextSmallBowlTimes(5).play();
                 assertEquals(0, referenceSmallBowl.getKalaha().getNextBowl().getKalaha().getMyStones());
             }
 
             @Test
-            public void its_not_the_players_turn_when_play_is_called_then_nothing_happens() {
+            void given_its_not_the_players_turn_when_play_is_called_then_nothing_happens() {
                 referenceSmallBowl.getMyOwner().switchTurn();
                 int initialRocks = referenceSmallBowl.getMyStones();
                 referenceSmallBowl.play();
@@ -182,14 +188,8 @@ class BowlTest {
                 assertEquals(4, neighbour.getMyStones());
             }
 
-        }
-
-
-        @Nested
-        class and_the_game_is_in_a_state_where {
-
             @Test
-            public void the_bowl_is_empty_WHEN_the_player_plays_the_empty_bowl_THEN_nothing_happens() {
+            void given_the_bowl_is_empty_when_play_called_on_the_bowl_then_nothing_happens() {
                 referenceSmallBowl.play();
                 referenceSmallBowl.getMyOwner().switchTurn();
                 assertTrue(referenceSmallBowl.getMyOwner().hasTheTurn());
@@ -199,168 +199,91 @@ class BowlTest {
             }
 
             @Test
-            public void all_small_bowls_of_the_player_are_empty_WHEN_a_play_ends_THEN_tell_players_who_won() {
-                Player player = referenceSmallBowl.getMyOwner();
-                Player opponent = referenceSmallBowl.getNextSmallBowlTimes(6).getMyOwner();
-                assertFalse(player.won());
-                assertFalse(opponent.won());
-                goToEndOfSillyGame();
-                assertTrue(player.won());
-                assertFalse(opponent.won());
+            void given_stones_would_skip_opponent_kalaha_at_the_last_rock_and_steal_when_played_then_should_skip_and_steal_correctly() {
+                setupGameSituationAndFailIfInvalid(new int[] {13,0,0,0,0,0,
+                                                            0,
+                                                                0,0,0,0,0,8,
+                                                            0});
+                System.out.println(referenceSmallBowl.getMyStones());
+                System.out.println(referenceSmallBowl.stateString());
+                referenceSmallBowl.play();
+                System.out.println(referenceSmallBowl.stateString());
 
+                assertEquals(11, referenceSmallBowl.getKalaha().getMyStones(),
+                        "resulting kalaha stones after stealing should be 11.");
+                assertEquals(0, referenceSmallBowl.getMyStones(),
+                        "played bowl should be zero, since steal happened");
+                assertEquals(0, referenceSmallBowl.getNextSmallBowlTimes(12).getMyStones());
             }
 
             @Test
-            public void all_small_bowls_of_the_player_are_empty_WHEN_a_play_ends_THEN_tell_players_who_wonOPPONENTVARIATION() {
-                Player player = referenceSmallBowl.getMyOwner();
-                Player opponent = referenceSmallBowl.getNextSmallBowlTimes(6).getMyOwner();
-                goToEndOfGameWhereOpponentWins();
-                assertFalse(player.won());
-                assertTrue(opponent.won());
+            void given_that_play_ends_in_own_kalaha_when_play_is_called_validly_then_turn_is_not_switched() {
+                referenceSmallBowl.getNextSmallBowlTimes(2).play();
+                assertTrue(referenceSmallBowl.getMyOwner().hasTheTurn());
             }
 
             @Test
-            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 = referenceSmallBowl.getNextSmallBowlTimes(6);
-                assertEquals(3, referenceSmallBowl.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
-                firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
-                assertEquals(19, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
-            }
-
-            private void goToSkipAndStealOnLast() {
-                SmallBowl firstSmallBowlOpponent = referenceSmallBowl.getNextSmallBowlTimes(6);
-                referenceSmallBowl.getNextSmallBowlTimes(1).play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(2).play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
-                referenceSmallBowl.getNextSmallBowlTimes(1).play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
-                referenceSmallBowl.getNextSmallBowlTimes(2).play();
-                firstSmallBowlOpponent.play();
-                referenceSmallBowl.getNextSmallBowlTimes(3).play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
-                referenceSmallBowl.getNextSmallBowlTimes(4).play();
-                firstSmallBowlOpponent.play();
-                // Cheating here, let player go again >:), i'm too dumb too make a loop/skip and steal play happen in fair game
-                firstSmallBowlOpponent.getMyOwner().switchTurn();
-                // Should skip and steal
-                // this bowls rocks
-                assertEquals(10, firstSmallBowlOpponent.getNextSmallBowlTimes(3).getMyStones());
-                // End up here by looping around the board, thus skipping
-                assertEquals(0, firstSmallBowlOpponent.getMyStones());
-                // Thus steal from last bowl on players side
-                assertEquals(8, referenceSmallBowl.getNextSmallBowlTimes(5).getMyStones());
-                // Result is big kalaha booty
-                assertEquals(8, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
+            void given_that_play_ends_in_own_small_bowl_when_play_is_called_validly_then_turn_is_switched() {
+                referenceSmallBowl.play();
+                assertFalse(referenceSmallBowl.getMyOwner().hasTheTurn());
             }
 
-            private void goToEndOfGameWhereOpponentWins() {
-                goToSkipAndStealOnLast();
-                SmallBowl firstSmallBowlOpponent = referenceSmallBowl.getNextSmallBowlTimes(6);
-                firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
-                referenceSmallBowl.getNextSmallBowlTimes(1).play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
-                referenceSmallBowl.play();
-                referenceSmallBowl.getMyOwner().switchTurn();
-                referenceSmallBowl.getNextSmallBowlTimes(3).play();
-                referenceSmallBowl.getMyOwner().switchTurn();
-                referenceSmallBowl.getNextSmallBowlTimes(4).play();
+            @Test
+            void given_that_play_ends_in_opponents_small_bowl_when_play_is_called_validly_then_turn_is_switched() {
                 referenceSmallBowl.getNextSmallBowlTimes(5).play();
+                assertFalse(referenceSmallBowl.getMyOwner().hasTheTurn());
             }
 
-            private void goToEndOfSillyGame() {
+            @Test
+            void given_that_play_ends_in_own_empty_small_bowl_and_opposite_has_rocks_when_play_is_called_validly_then_rocks_of_opposite_plus_last_rock_of_play_are_added_to_next_kalaha() {
+                System.out.println(referenceSmallBowl.stateString());
+                referenceSmallBowl.getNextSmallBowlTimes(5).play();
+                System.out.println(referenceSmallBowl.stateString());
                 SmallBowl firstSmallBowlOpponent = referenceSmallBowl.getNextSmallBowlTimes(6);
-
-                // player
-                // Best opening
-                referenceSmallBowl.getNextSmallBowlTimes(2).play();
-                // Set up for steal move
-                referenceSmallBowl.getNextSmallBowlTimes(4).play();
-                assertEquals(2, referenceSmallBowl.getKalaha().getMyStones());
-
-                // opponent
-                // ... worst opening?
-                firstSmallBowlOpponent.play();
-
-                // player
-                assertSame(referenceSmallBowl.getNextSmallBowlTimes(4).getOpposite(), referenceSmallBowl.getKalaha().getNextBowl().getNextBowl());
-                referenceSmallBowl.play();
-                // Check if i did it properly on paper
-                assertEquals(9, referenceSmallBowl.getKalaha().getMyStones());
-                assertEquals(0, referenceSmallBowl.getNextSmallBowlTimes(4).getMyStones());
-                // assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getOpposite().getMyRocks());
-
-                // opponent
-                firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
-
-                //Player
-                referenceSmallBowl.getNextSmallBowlTimes(3).play();
-                assertEquals(10, referenceSmallBowl.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, referenceSmallBowl.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
-                referenceSmallBowl.getNextSmallBowlTimes(2).play();
-                assertEquals(19, referenceSmallBowl.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
-
-                // opponent steals tiny booty
-                firstSmallBowlOpponent.play();
-                assertEquals(3, firstSmallBowlOpponent.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
-
-                // player is stalling until the end
-                referenceSmallBowl.play();
-
-                // opponent is heading for disaster
                 firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
+                System.out.println(referenceSmallBowl.stateString());
                 referenceSmallBowl.play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(4).play();
-                referenceSmallBowl.play();
-                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
-                // everything empty!
-                for (int i = 0; i < 6; i++) {
-                    assertEquals(0, firstSmallBowlOpponent.getNextSmallBowlTimes(i).getMyStones());
-                }
-
+                System.out.println(referenceSmallBowl.stateString());
+                assertEquals(7, referenceSmallBowl.getKalaha().getMyStones());
+                assertEquals(0, referenceSmallBowl.getNextSmallBowlTimes(5).getMyStones());
+                assertEquals(0, referenceSmallBowl.getKalaha().getNextBowl().getMyStones());
             }
         }
 
-
         @Nested
-        class GIVEN_the_play_ends{
-
-            @Test
-            public void in_own_kalaha_WHEN_play_ends_THEN_turn_is_not_switched() {
-                referenceSmallBowl.getNextSmallBowlTimes(2).play();
-                assertTrue(referenceSmallBowl.getMyOwner().hasTheTurn());
-            }
-
-            @Test
-            public void in_own_small_bowl_WHEN_play_ends_THEN_turn_is_switched() {
-                referenceSmallBowl.play();
-                assertFalse(referenceSmallBowl.getMyOwner().hasTheTurn());
-            }
+        class endGameBehaviour {
 
             @Test
-            public void in_opponents_small_bowl_WHEN_player_plays_this_bowl_THEN_turn_is_switched() {
+            void given_all_small_bowls_of_the_player_are_empty_when_a_play_ends_then_tell_players_who_won() {
+                setupGameSituationAndFailIfInvalid(new int[] {0,0,0,0,0,1,0,4,4,4,4,4,4,0});
+                Player player = referenceSmallBowl.getMyOwner();
+                Player opponent = referenceSmallBowl.getNextSmallBowlTimes(6).getMyOwner();
+                assertFalse(player.won(), "players haven't won at start of game");
+                assertFalse(opponent.won(), "players haven't won at start of game");
                 referenceSmallBowl.getNextSmallBowlTimes(5).play();
-                assertFalse(referenceSmallBowl.getMyOwner().hasTheTurn());
+                assertFalse(player.won(), "player should lose here.");
+                assertTrue(opponent.won(), "opponent should win here.");
+
+                setupGameSituationAndFailIfInvalid(new int[] {4,4,4,4,4,4,0,0,0,0,0,0,1,0});
+                player = referenceSmallBowl.getMyOwner();
+                opponent = referenceSmallBowl.getNextSmallBowlTimes(6).getMyOwner();
+                assertFalse(player.won(), "players haven't won at start of game");
+                assertFalse(opponent.won(), "players haven't won at start of game");
+                player.switchTurn();
+                referenceSmallBowl.getNextSmallBowlTimes(6 + 5).play();
+                assertTrue(player.won(), "player should win here.");
+                assertFalse(opponent.won(), "opponent should lose here.");
             }
 
             @Test
-            public void in_own_empty_small_bowl_and_opposite_has_rocks_WHEN_play_ends_THEN_rocks_of_opposite_plus_last_rock_of_play_are_added_to_kalaha() {
+            void given_all_small_bowls_of_the_player_are_empty_and_score_is_tied_when_a_play_ends_then_tell_both_player_they_won() {
+                setupGameSituationAndFailIfInvalid(new int[] {0,0,0,0,0,1,0,0,0,0,0,0,1,0});
+                System.out.println(referenceSmallBowl.stateString());
                 referenceSmallBowl.getNextSmallBowlTimes(5).play();
-                SmallBowl firstSmallBowlOpponent = referenceSmallBowl.getNextSmallBowlTimes(6);
-                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
-                assertSame(referenceSmallBowl.getNextSmallBowlTimes(1).getOpposite(), referenceSmallBowl.getKalaha().getNextSmallBowl().getNextSmallBowlTimes(4));
-                // assertSame(firstSmallBowlPlayer.getOpposite(), firstSmallBowlPlayer.getKalaha().getNextSmallBowlTimes(5));
-                referenceSmallBowl.play();
-                assertEquals(7, referenceSmallBowl.getNextSmallBowlTimes(5).getNextBowl().getMyStones());
+                System.out.println(referenceSmallBowl.stateString());
+                assertTrue(referenceSmallBowl.getMyOwner().won() && referenceSmallBowl.getMyOwner().getOpponent().won());
             }
 
         }
-
     }
 }
\ No newline at end of file