refactor(domain tests) <- configurable state

4 files changed, 69 insertions, 60 deletions

diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java
index fece393..8a214da 100644
--- a/domain/src/main/java/mancala/domain/Bowl.java
+++ b/domain/src/main/java/mancala/domain/Bowl.java
@@ -1,12 +1,12 @@
 package mancala.domain;
 
 abstract class Bowl {
-    protected int myRocks;
+    protected int myStones;
     protected Player myOwner;
     protected Bowl nextBowl;
 
     public int getMyStones() {
-        return myRocks;
+        return myStones;
     }
 
     public Bowl getNextBowl() {
@@ -25,19 +25,19 @@ abstract class Bowl {
 
     abstract Kalaha getKalaha();
 
-    abstract SmallBowl getSmallBowl();
+    abstract SmallBowl getNextSmallBowl();
 
     abstract SmallBowl goToFirstBowlOfPlayerWithTurn();
 
     abstract boolean isEmpty();
     // abstract SmallBowl getNextSmallBowl();
 
-    boolean endTheGame() {
-        return goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0);
+    void endTheGame() {
+        goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0);
     }
 
-    protected boolean endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) {
-        if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return false;
+    protected void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) {
+        if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return;
 
         if (this.equals(startOfLoop)) {
 
@@ -48,8 +48,6 @@ abstract class Bowl {
                 if (scorePlayer == scoreOpponent) getMyOwner().gotADraw();
                 else if (scorePlayer > scoreOpponent) getMyOwner().isTheWinner();
                 else getMyOwner().getOpponent().isTheWinner();
-
-                return true;
             }
 
 
@@ -58,9 +56,8 @@ abstract class Bowl {
                 scorePlayer = scorePlayer + getMyStones();
             } else scoreOpponent = scoreOpponent + getMyStones();
 
-            return getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent);
+            getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent);
         }
-        return false;
     }
 
 
diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java
index 7ab954c..a13ebd8 100644
--- a/domain/src/main/java/mancala/domain/Kalaha.java
+++ b/domain/src/main/java/mancala/domain/Kalaha.java
@@ -1,31 +1,33 @@
 package mancala.domain;
 
+import java.util.List;
+
 class Kalaha extends Bowl {
-    Kalaha(int boardSize, int bowlsToAdd, Bowl startBowl, Player playerOwningThisSide) {
+    Kalaha(int boardSize, int bowlsToAdd, List<Integer> stonesList, Bowl startBowl, Player playerOwningThisSide) {
         bowlsToAdd = bowlsToAdd - 1;
 
-        this.myRocks = 0;
+        this.myStones = stonesList.remove(0);
         this.myOwner = playerOwningThisSide;
 
         if (bowlsToAdd == 0) this.nextBowl = startBowl;
 
-        else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide.getOpponent());
+        else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide.getOpponent());
     }
 
     Kalaha getKalaha() {
         return this;
     }
 
-    SmallBowl getSmallBowl() {
-        return getNextBowl().getSmallBowl();
+    SmallBowl getNextSmallBowl() {
+        return getNextBowl().getNextSmallBowl();
     }
 
     @Override
     SmallBowl goToFirstBowlOfPlayerWithTurn() {
         if (getMyOwner().hasTheTurn()) {
-            return getNextBowl().getKalaha().getSmallBowl();
+            return getNextBowl().getKalaha().getNextSmallBowl();
         } else {
-            return getSmallBowl();
+            return getNextSmallBowl();
         }
     }
 
@@ -38,10 +40,10 @@ class Kalaha extends Bowl {
     }
 
     void distribute(int remainingRocks) {
-        myRocks++;
+        myStones++;
         // Skip?
         if (getMyOwner().hasTheTurn() == false) {
-            myRocks--;
+            myStones--;
             getNextBowl().distribute(remainingRocks);
         } else if (remainingRocks == 1) {
             endTheGame();
@@ -55,6 +57,6 @@ class Kalaha extends Bowl {
 
 
     void claimStolenBooty(int booty) {
-        myRocks = myRocks + booty;
+        myStones = myStones + booty;
     }
 }
diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java
index 82f914f..29048ff 100644
--- a/domain/src/main/java/mancala/domain/MancalaImpl.java
+++ b/domain/src/main/java/mancala/domain/MancalaImpl.java
@@ -6,19 +6,21 @@ import java.util.stream.IntStream;
 
 public class MancalaImpl implements Mancala {
 
-    public static HashSet<Integer> PLAYER_ONE_PITS = new HashSet<>(
+    public static final HashSet<Integer> PLAYER_ONE_PITS = new HashSet<>(
             IntStream.rangeClosed(0, 5).boxed().collect(Collectors.toList())
     );
-    public static HashSet<Integer> PLAYER_TWO_PITS = new HashSet<>(
+    public static final 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;
+    public static final int PLAYER_ONE_KALAHA = 6;
+    public static final int PLAYER_TWO_KALAHA = 13;
 
     private SmallBowl domainReference;
 
     public MancalaImpl() {
         domainReference = new SmallBowl();
+        domainPlayer = domainReference.getMyOwner();
+        domainOpponent = domainPlayer.getOpponent();
     }
 
     @Override
@@ -75,13 +77,22 @@ public class MancalaImpl implements Mancala {
             return -1;
     }
 
-	@Override
+    private final mancala.domain.Player domainPlayer;
+    private final mancala.domain.Player domainOpponent;
+
+    @Override
 	public boolean isEndOfGame() {
-        return domainReference.endTheGame();
+        return domainPlayer.won() || domainOpponent.won();
     }
 
 	@Override
 	public int getWinner() {
-        return Mancala.NO_PLAYERS;
+        if (!isEndOfGame()) return Mancala.NO_PLAYERS;
+
+        if (domainPlayer.won()) return Mancala.PLAYER_ONE;
+        else if (domainOpponent.won()) return Mancala.PLAYER_TWO;
+        else if (domainPlayer.won() && domainOpponent.won()) return Mancala.BOTH_PLAYERS;
+        else return Mancala.NO_PLAYERS;
     }
+
 }
\ No newline at end of file
diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java
index ce4c0ce..07fa1e0 100644
--- a/domain/src/main/java/mancala/domain/SmallBowl.java
+++ b/domain/src/main/java/mancala/domain/SmallBowl.java
@@ -1,45 +1,44 @@
 package mancala.domain;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class SmallBowl extends Bowl {
 
     public SmallBowl() {
-        this.myRocks = 4;
+        this(
+                Arrays.stream(new int[] {4,4,4,4,4,4,0,4,4,4,4,4,4,0}).boxed().collect(Collectors.toList())
+        );
+    }
+
+    public SmallBowl(List<Integer> stonesList) {
         this.myOwner = new Player();
 
-        int boardSize = 14;
+        int boardSize = stonesList.size();
         int bowlsToAdd = boardSize - 1;
 
-        this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, this, this.getMyOwner());
-    }
+        this.myStones = stonesList.remove(0);
+
+        this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner());
 
-    public SmallBowl(int boardSize) {
-        try {
-            if (boardSize < 4) {
-                throw new Exception("Can't have a board smaller than four bowls.");
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        this.myRocks = 4;
-        this.myOwner = new Player();
-        int bowlsToAdd = boardSize - 1;
-        this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, this, this.getMyOwner());
     }
 
-    SmallBowl(int boardSize, int bowlsToAdd, Bowl startBowl, Player playerOwningThisSide) {
+    SmallBowl(int boardSize, int bowlsToAdd, List<Integer> stonesList, Bowl startBowl, Player playerOwningThisSide) {
         bowlsToAdd = bowlsToAdd - 1;
         this.myOwner = playerOwningThisSide;
-        this.myRocks = 4;
+        this.myStones = stonesList.remove(0);
 
         if (bowlsToAdd == 0) nextBowl = startBowl;
 
-        else if (bowlsToAdd == (boardSize / 2) + 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide);
+        else if (bowlsToAdd == (boardSize / 2) + 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide);
 
-        else if (bowlsToAdd == 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide);
+        else if (bowlsToAdd == 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide);
 
-        else nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide);
+        else nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide);
     }
 
+
     public SmallBowl getNextSmallBowlTimes(int remainingTimes) {
         if (remainingTimes == 0)
             return this;
@@ -52,18 +51,18 @@ public class SmallBowl extends Bowl {
         if (myOwner.hasTheTurn() == false) return;
         if (isEmpty()) return;
 
-        int passThese = myRocks;
-        myRocks = 0;
+        int passThese = myStones;
+        myStones = 0;
         getNextBowl().distribute(passThese);
     }
 
     @Override
     boolean isEmpty() {
-        return this.myRocks == 0;
+        return this.myStones == 0;
     }
 
     void distribute(int remainingRocks) {
-        this.myRocks++;
+        this.myStones++;
         // last?
         if (remainingRocks == 1)
             lastSmallBowl();
@@ -81,16 +80,16 @@ public class SmallBowl extends Bowl {
         endTheGame();
     }
 
-    SmallBowl getSmallBowl() {
+    SmallBowl getNextSmallBowl() {
         return this;
     }
 
     @Override
     SmallBowl goToFirstBowlOfPlayerWithTurn() {
         if (getMyOwner().hasTheTurn()) {
-            return getKalaha().getNextBowl().getKalaha().getSmallBowl();
+            return getKalaha().getNextBowl().getKalaha().getNextSmallBowl();
         } else {
-            return getKalaha().getSmallBowl();
+            return getKalaha().getNextSmallBowl();
         }
     }
 
@@ -100,14 +99,14 @@ public class SmallBowl extends Bowl {
 
     private void stealTheBooty(boolean victim) {
         if (victim){
-            getOpposite().getKalaha().claimStolenBooty(myRocks);
-            myRocks = 0;
+            getOpposite().getKalaha().claimStolenBooty(myStones);
+            myStones = 0;
 
         } else if (getMyStones() == 1 &&
                 getOpposite().getMyStones() != 0) {
 
-            getKalaha().claimStolenBooty(myRocks);
-            myRocks = 0;
+            getKalaha().claimStolenBooty(myStones);
+            myStones = 0;
             getOpposite().stealTheBooty(true);
         }
     }