Merge branch 'dev' into HigherCards

src/main/java/io/zipcoder/casino/Leviathan/Console.java

         return b;
     }
 
-    public String yesOrNo(String prompt){
+    public String yesOrNo(String prompt) {
         boolean good = false;
-        String correct= "";
-        while(good == false){
-        String answer = getStringInput(prompt);
-        if(answer.equalsIgnoreCase("yes") || answer.equalsIgnoreCase("no")){
-            good = true;
-            correct = answer;
-        } else{
-            println("what was that? Please say yes or no.");
-        }
+        String correct = "";
+        while (good == false) {
+            String answer = getStringInput(prompt);
+            if (answer.equalsIgnoreCase("yes") || answer.equalsIgnoreCase("no")) {
+                good = true;
+                correct = answer;
+            } else {
+                println("what was that? Please say yes or no.");
+            }
         }
         return correct;
     }

src/main/java/io/zipcoder/casino/Leviathan/Games/BlackJack.java

 package io.zipcoder.casino.Leviathan.Games;
+
 import io.zipcoder.casino.Leviathan.Interfaces.*;
 import io.zipcoder.casino.Leviathan.*;
-import  io.zipcoder.casino.Leviathan.Games.GameUtilities.*;
+import io.zipcoder.casino.Leviathan.Games.GameUtilities.*;
+
+import java.util.ArrayList;
+import java.util.List;
 
 public class BlackJack extends CardGame implements Gambling {
 
     int wageAmount;
     int totalChips;
     Player aPlayer;
+    boolean playAgain = true;
 
-    public BlackJack(Player aPlayer){
+    public BlackJack(Player aPlayer) {
         this.aPlayer = aPlayer;
     }
 
     int aPlayerScore = Game.playerScore;
     int aHouseScore = Game.houseScore;
 
-    //assuming this to be a random card rank in int
-    //Card aCard = new Card(Rank.ACE,Suit.CLUBS);
-    //Rank aGetRank = aCard.getRank();
-
     Deck deck = new Deck();
 
-
-
     String playerDecision;
 
+    boolean win;
 
-    public void playGame() {
-        
-    }
-
-    public int drawASingleCard(int cardRank){
-
-        Card card = deck.draw();
-
-        Rank rank = card.getRank();
-
-        int cardInt =rank.getValue();
+////////////////////////////////////////////////////////////////////////////////////
 
-        return cardInt;
+    //draws the initial two cards
+    public List<Card> drawNewHand() {
+        List<Card> hand = new ArrayList<>();
+        hand.add(deck.draw());
+        hand.add(deck.draw());
+        return hand;
     }
 
-    //Player making the starting bet
-    public int wageMoney() {
-
-        totalChips=aPlayer.getTotalChips();
-
-        wageAmount = aConsole.getIntInput("Please make your starting bet:");
-        if (wageAmount <= totalChips) {
-            aConsole.println("Your current bet amount is: " + wageAmount);
-            return wageAmount;
+    //get the sum int value of the drawn cards
+    public int getHandTotal(List<Card> hand) {
+        int sum = 0;
+        int countAces = 0;
+
+        for (Card c : hand) {
+            Rank rank = c.getRank();
+            int value = rank.getValue();
+
+            if (value <= 10) {
+                sum += value;
+            }
+            if (rank.equals(Rank.JACK) || rank.equals(Rank.QUEEN) || rank.equals(Rank.KING)) {
+                sum += 10;
+            }
+            if (rank.equals(Rank.ACE)) {
+                sum += 0;
+            }
+            if (rank.equals(Rank.ACE)) {
+                countAces += 1;
+            }
+        }
+        if (countAces == 0) {
+            return sum;
+        }
+        if ((sum + 11 + (countAces - 1)) <= 21) {
+            return sum + 11 + (countAces - 1);
         } else {
-            aConsole.println("Insufficient Chips!");
-            //Recursion - this runs the method again and asks user to make the starting bet again
-            return wageMoney();
+            return sum + countAces;
         }
     }
 
-    //initial player card value
-    private int startPlayerHand() {
-
-//        Card card = deck.draw();
-//
-//        Rank rank = card.getRank();
-//
-//        int cardInt =rank.getRank();
-
-        //aPlayerScore = drawASingleCard();
+    //lets the player know of the starting hand
+    public String handToString(List<Card> hand) {
+        StringBuilder builder = new StringBuilder();
+        for (Card c : hand) {
+            String cardString = (c.getRank() + " of " + c.getSuit());
+            builder.append(cardString).append("\n");
+        }
+        return builder.toString();
+    }
 
+    //lets the player know one of house's starting hand
+    public String houseHandToString(List<Card> hand, int cardsToShow) {
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < cardsToShow; i++) {
+            builder.append(hand.get(i).getRank() + " of " + hand.get(i).getSuit() + "\n");
+        }
+        return builder.toString();
+    }
 
 
-        return aPlayerScore; //= aGetRank + aGetRank;
-    }
+    //draws a singe card
+    public Card drawSingleCard() {
 
-    //initial house card value
-    public int startHouseHand() {
-        return aHouseScore; //= aGetRank + aGetRank;
+        return deck.draw();
     }
 
+    //Gets the int value of a single drawn card
+    public int getSingleCardValue(List<Card> hand) {
+        int cardValue = 0;
 
-    //ask for player's next move
-    public String blackJack(String playerDecision) {
-        if(startPlayerHand() < 21){
-            playerDecision = aConsole.getStringInput("Please make a call:\nHit\nStand\nRaise Bet");
+        for (Card c : hand) {
+            Rank rank = c.getRank();
+            int value = rank.getValue();
+            cardValue += value;
         }
-        return playerDecision;
+        return cardValue;
     }
 
+    public String drawnCardToString(Card card) {
+        return card.getRank() + " of " + card.getSuit();
+    }
 
+////////////////////////////////////////////////////////////////////////////////////
 
-    //Hit
-    public int hit(int playerHand) {
-
+    public void playGame() {
 
-        return 0;
+        while (playAgain == true) {
+
+            aConsole.println("*** Welcome " + this.aPlayer.getName() +
+                    ", let’s play BlackJack! ***\n");
+
+            int wageAmount = wageMoney();
+
+            //draw a fresh hand
+            List<Card> playerHand = drawNewHand();
+
+            //get the player's hand total
+            int handTotal = getHandTotal(playerHand);
+
+            //update player score with hand total
+            aPlayerScore = handTotal;
+
+            //show the player their hand
+            String handString = handToString(playerHand);
+            aConsole.println("\n You have drawn: \n" + handString);
+
+            //display hand total
+            aConsole.println("Your current hand value: " + aPlayerScore + "\n");
+
+            //draw a fresh hand for house
+            List<Card> houseHand = drawNewHand();
+
+            //get the house hand total
+            int houseHandTotal = getHandTotal(houseHand);
+
+            //update house score with hand total
+            aHouseScore = houseHandTotal;
+
+            //show the player one of house's card
+            //I need to figure out how I could only show one card
+            String houseHandString = houseHandToString(houseHand, 1);
+            aConsole.println("\n The house has drawn: \n" + houseHandString +
+                    "And has one card faced down");
+
+            //Decision
+            while (aPlayerScore < 21) {
+                //playerDecision = aConsole.getStringInput("Please make a call:\nHit\nStand\nRaise Bet");
+                playerDecision = aConsole.getStringInput("Please make a call:\nHit\nStand");
+
+                //Hit
+                if (playerDecision.equalsIgnoreCase("Hit")) {
+                    playerHit(playerHand);
+                }
+                if (playerDecision.equalsIgnoreCase("Stand")) {
+
+                    //House start drawing cards
+                    houseDraws(houseHand);
+                    break;
+                }
+            }
+
+            //House winning situation
+            if (aPlayerScore > 21) {
+                aConsole.println("Bust!");
+                win = false;
+                betChages(bet);
+                aConsole.println("Your current available chips: \n" + aPlayer.getTotalChips());
+            }else if ((aHouseScore >= aPlayerScore && aHouseScore < 21) || aHouseScore == 21) {
+                aConsole.println("You lose\n" + "Your score: " + aPlayerScore +
+                        "\nHouse score: " + aHouseScore);
+                aConsole.println("\n Dealer's hand: \n" + handToString(houseHand));
+                win = false;
+                betChages(bet);
+                aConsole.println("Your current available chips: \n" + aPlayer.getTotalChips());
+            }
+
+            //Player winning situation
+            else if (aHouseScore < 21) {
+                aConsole.println("You win!");
+                win = true;
+                betChages(bet);
+                aConsole.println("Your current available chips: \n" + aPlayer.getTotalChips());
+            } else {
+                //aConsole.println("You win!");
+                aConsole.println("You win!\n" + "Your score: " + aPlayerScore +
+                        "\nHouse score: " + aHouseScore);
+                win = true;
+                betChages(bet);
+                aConsole.println("Your current available chips: \n" + aPlayer.getTotalChips());
+            }
+            if ((aPlayer.getTotalChips() == 0) || aConsole.yesOrNo("Would you like to play again?").equalsIgnoreCase("no")) {
+                playAgain = false;
+            }
+        }
     }
 
+    private void playerHit(List<Card> playerHand) {
+        //draw a new card
+        Card drawSingleCard = drawSingleCard();
+        playerHand.add(drawSingleCard);
 
-    //Stand
-    public int stand(int playerHand) {
+        //update player score with card value
+        aPlayerScore = getHandTotal(playerHand);
 
+        //show the newly drawn card
+        String newCardString = drawnCardToString(drawSingleCard);
+        aConsole.println("\n You have drawn: \n" + newCardString);
 
-        return 0;
+        //display updated hand total
+        aConsole.println("Your current hand value: " + aPlayerScore + "\n");
     }
 
-    //Raise bet
-    public int raiseBet(int wageAmount) {
+    private void houseDraws(List<Card> houseHand) {
+        while (aPlayerScore > aHouseScore && aHouseScore < 21) {
+            //draw a new card
+            Card drawSingleCard = drawSingleCard();
+            houseHand.add(drawSingleCard);
 
+            //update house score with card value
+            aHouseScore = getHandTotal(houseHand);
 
-        return 0;
+            //show the newly drawn card
+            String newCardString = drawnCardToString(drawSingleCard);
+            aConsole.println("\n House have drawn: \n" + newCardString);
+        }
     }
 
+    int bet;
+    public int wageMoney() {
+        //int bet;
+        totalChips = aPlayer.getTotalChips();
+        bet = aConsole.getIntInput("Please make your starting bet:\n" +
+                "You currently have: " + aPlayer.getTotalChips() + " chips.");
+        if (bet > 0 && bet <= totalChips) {
+            aConsole.println("Your current bet amount is: " + bet);
+            return bet;
+        } else if (bet == 0 || bet < 0) {
+            aConsole.println("You need to bet at least 1 chip");
+            return wageMoney();
+        } if(bet > totalChips) {
+            aConsole.println("Insufficient Chips!");
 
+            //return wageMoney();
+            return wageMoney();
+        }
+        return bet;
+    }
 
-
-
-
-
+    public void betChages(int wageAmount){
+        totalChips = aPlayer.getTotalChips();
+        if(win == true){
+            aPlayer.setTotalChips(totalChips + wageAmount);
+        } else{
+            aPlayer.setTotalChips(totalChips - wageAmount);
+        }
+    }
 }
 
 
-//    public boolean playGame(Player aPlayer) {
-//        return false;
-//    }
-//
-//
-//    public int wageMoney() {
-//        return 0;
-//    }
-//
-//
-//
-//    private static final String HOLD_CONSTANT = "hold";
-//
-//
-//    public void blackJack (String[] args){
-//
-//        //user input for Int
-//        int betAmount = 0;
-//
-//        //user input for String
-//        String decision;
-//
-//
-//
-//
-//
-//
-//        int aPlayerScore = Game.playerScore;
-//
-//        int aHouseScore = Game.houseScore;
-//
-//
-//
-//
-//        //How do I make this work??
-//        //Card aCard = new Card();
-//        //or
-//        //int aCard = Card.getRank;
-//
-//
-//        ////////public int startTheGame(int playerScore, int houseScore, int getRank)
-//
-//        //playerScore = Card.getRank() + Card.getRank();
-//
-//        //houseScore = Card.getRank() + Card.getRank();
-//
-//
-//
-//
-//
-//        while(!HOLD_CONSTANT.equals(decision) || playerScore < 21) {
-//
-//            //IF statement that asks for userInput after each loop(?)
-//            //add sum values of two cards to playerScore hand
-//            //add sum values of two cards to houseScore hand
-//
-//           decision = aConsole.getStringInput("Please make a call:\nHit\nStand");
-//
-//
-//            If(decision.equals("Hit")) {
-//
-//                If(decision.equals("Ace") && playerScore > 10) {
-//                    playerScore + 1;
-//                }
-//                else{
-//                    playerScore + 11;
-//                }
-//            }
-//            else if(aConsole.getStringInput().equals("Stand"))
-//
-//
-//
-//    }
-//
-//    If(playerScore > 21){
-//
-//        }
-//
-//
-//    }
-
 
 
 

src/main/java/io/zipcoder/casino/Leviathan/Games/DiceGame.java

 package io.zipcoder.casino.Leviathan.Games;
-import io.zipcoder.casino.Leviathan.Interfaces.*;
-import io.zipcoder.casino.Leviathan.*;
-import io.zipcoder.casino.Leviathan.Games.GameUtilities.*;
 
-public abstract class DiceGame implements Game{
-    Dice aDice ;
+import io.zipcoder.casino.Leviathan.Games.GameUtilities.Dice;
+import io.zipcoder.casino.Leviathan.Interfaces.Game;
+
+public abstract class DiceGame implements Game {
+    Dice aDice;
 
 }

src/main/java/io/zipcoder/casino/Leviathan/Games/GameUtilities/Dice.java

         return dice;
     }
 
+    public int sumAllDice() {
+        int sum = 0;
+        for (int i = 0; i < dice.length; i++) {
+            sum += dice[i].getValue();
+        }
+        return sum;
+    }
 
 }

src/main/java/io/zipcoder/casino/Leviathan/Games/GameUtilities/DiceBuilder.java

 package io.zipcoder.casino.Leviathan.Games.GameUtilities;
+
 import java.util.Arrays;
 import java.util.Iterator;
-import java.util.List;
 
 public class DiceBuilder implements Iterable<String> {
-private static final String[][] lines = {
-        {
-        "+-------+",
-        "|       |",
-        "|   o   |",
-        "|       |",
-        "+-------+",
-        },
-        {
-        "+-------+",
-        "| o     |",
-        "|       |",
-        "|     o |",
-        "+-------+",
-        },
-        {
-        "+-------+",
-        "| o     |",
-        "|   o   |",
-        "|     o |",
-        "+-------+",
-        },
-        {
-        "+-------+",
-        "| o   o |",
-        "|       |",
-        "| o   o |",
-        "+-------+",
-        },
-        {
-        "+-------+",
-        "| o   o |",
-        "|   o   |",
-        "| o   o |",
-        "+-------+",
-        },
-        {
-        "+-------+",
-        "| o   o |",
-        "| o   o |",
-        "| o   o |",
-        "+-------+",
-        }
-        };
+    private static final String[][] lines = {
+            {
+                    "+-------+",
+                    "|       |",
+                    "|   o   |",
+                    "|       |",
+                    "+-------+",
+            },
+            {
+                    "+-------+",
+                    "| o     |",
+                    "|       |",
+                    "|     o |",
+                    "+-------+",
+            },
+            {
+                    "+-------+",
+                    "| o     |",
+                    "|   o   |",
+                    "|     o |",
+                    "+-------+",
+            },
+            {
+                    "+-------+",
+                    "| o   o |",
+                    "|       |",
+                    "| o   o |",
+                    "+-------+",
+            },
+            {
+                    "+-------+",
+                    "| o   o |",
+                    "|   o   |",
+                    "| o   o |",
+                    "+-------+",
+            },
+            {
+                    "+-------+",
+                    "| o   o |",
+                    "| o   o |",
+                    "| o   o |",
+                    "+-------+",
+            }
+    };
 
-private int value;
+    private int value;
 
-public DiceBuilder(int value) {
+    public DiceBuilder(int value) {
         if (value < 0 || value >= 7) {
-        throw new IllegalArgumentException("Illegal die value");
+            throw new IllegalArgumentException("Illegal die value");
         }
         this.value = value;
-        }
+    }
 
-public Iterator<String> iterator() {
+    public Iterator<String> iterator() {
         return Arrays.asList(lines[value]).iterator();
-        }
-        }
+    }
+}
 

src/main/java/io/zipcoder/casino/Leviathan/Games/GameUtilities/DrawSingleDie.java

 
 public class DrawSingleDie {
 
-    public StringBuilder drawSingleDie(int x){
-            DiceBuilder die1 = new DiceBuilder(x-1);
+    public StringBuilder drawSingleDie(int x) {
+        DiceBuilder die1 = new DiceBuilder(x - 1);
 
-            List<Iterator<String>> dice = Arrays.asList(
-                    die1.iterator());
-            StringBuilder sb = new StringBuilder();
+        List<Iterator<String>> dice = Arrays.asList(
+                die1.iterator());
+        StringBuilder sb = new StringBuilder();
 
-            outer:
-            while (true) {
-                for (Iterator<String> iter : dice) {
-                    if (!iter.hasNext()) {
-                        break outer;
-                    }
+        outer:
+        while (true) {
+            for (Iterator<String> iter : dice) {
+                if (!iter.hasNext()) {
+                    break outer;
                 }
+            }
 
-                for (Iterator<String> iter : dice) {
-                    sb.append(iter.next()).append("   ");
-                }
-                sb.append("\r\n");
+            for (Iterator<String> iter : dice) {
+                sb.append(iter.next()).append("   ");
             }
-            return sb;
+            sb.append("\r\n");
         }
+        return sb;
     }
+}
 

src/main/java/io/zipcoder/casino/Leviathan/Games/GameUtilities/DrawYahtzeeDice.java

 
 public class DrawYahtzeeDice {
 
-    public StringBuilder drawYahtzeeDice(int x, int y, int z, int a, int b){
-        DiceBuilder die1 = new DiceBuilder(x-1);
-        DiceBuilder die2 = new DiceBuilder(y-1);
-        DiceBuilder die3 = new DiceBuilder(z-1);
-        DiceBuilder die4 = new DiceBuilder(a-1);
-        DiceBuilder die5 = new DiceBuilder(b-1);
+    public StringBuilder drawYahtzeeDice(int... ints) {
+        DiceBuilder die1 = new DiceBuilder(ints[0] - 1);
+        DiceBuilder die2 = new DiceBuilder(ints[1] - 1);
+        DiceBuilder die3 = new DiceBuilder(ints[2] - 1);
+        DiceBuilder die4 = new DiceBuilder(ints[3] - 1);
+        DiceBuilder die5 = new DiceBuilder(ints[4] - 1);
 
         List<Iterator<String>> dice = Arrays.asList(
                 die1.iterator(),
             sb.append("\r\n");
         }
 
-        return(sb);
+        return (sb);
     }
 }

src/main/java/io/zipcoder/casino/Leviathan/Games/HigherDice.java

             aConsole.getStringInput("Please roll your die");
             aDie.rollADice();
             int player = aDie.getValue();
-            aConsole.println("Your Roll:\n"+draw.drawSingleDie(player).toString());
+            aConsole.println("Your Roll:\n" + draw.drawSingleDie(player).toString());
             aDie.rollADice();
             int croupier = aDie.getValue();
-            aConsole.println("House Roll:\n"+draw.drawSingleDie(croupier).toString());
+            aConsole.println("House Roll:\n" + draw.drawSingleDie(croupier).toString());
             findWinner(player, croupier, bet);
             repeat();
         }

src/main/java/io/zipcoder/casino/Leviathan/Games/Yahtzee.java

     Choose yahtzee field to score
      */
     public YahtzeeField chooseYahtzeeField() {
-        boolean inputValid;
-        boolean inputIsFree = false;
-        String userInput;
-        do {
+        String userInput = aConsole.getStringInput("Which field do you want to score?").toUpperCase();
+        boolean inputIsValid = isValidYahtzeeField(userInput);
+
+        while (!inputIsValid){
+            aConsole.println("please enter valid & free yahtzee field.");
             userInput = aConsole.getStringInput("Which field do you want to score?").toUpperCase();
-            inputValid = isYahtzeeField(userInput);
-            if (inputValid){
-                inputIsFree = isYahtzeeFieldFree(userInput);
-            }
-        } while(!inputValid && !inputIsFree);
+            inputIsValid = isValidYahtzeeField(userInput);
+        }
+
         return YahtzeeField.valueOf(userInput);
     }
 
     /*
-    Check if yahtzee field is valid
+    Check if yahtzee field is valid and free
      */
-    public boolean isYahtzeeField(String userInput) {
+    public boolean isValidYahtzeeField(String userInput) {
         for (YahtzeeField aYahtzeeField : YahtzeeField.values()) {
             if (aYahtzeeField.toString().equals(userInput)) {
-                return true;
+                if(scoreSheet.get(YahtzeeField.valueOf(userInput)) == null){
+                    return true;
+                }
             }
         }
         return false;
     }
 
     /*
-    Check if yahtzee field is free
-     */
-    public boolean isYahtzeeFieldFree(String userInput) {
-        if(scoreSheet.get(YahtzeeField.valueOf(userInput)) != null){
-            return false;
-        }
-        return true;
-    }
-
-    /*
     Score dice
     */
     public int scoreDice(YahtzeeField yahtzeeField) {
     Display dice
      */
     public void printDice() {
-        StringBuilder currentDice = new StringBuilder();
+//        StringBuilder currentDice = new StringBuilder();
+//        for (int i = 0; i < dice.length; i++) {
+//            currentDice.append(dice[i].getValue());
+//            if (i < dice.length - 1) {
+//                currentDice.append(", ");
+//            }
+//        }
+//        String currentDiceString = currentDice.toString();
+//        aConsole.println(currentDiceString);
+
+        int[] diceValues = new int[5];
         for (int i = 0; i < dice.length; i++) {
-            currentDice.append(dice[i].getValue());
-            if (i < dice.length - 1) {
-                currentDice.append(", ");
-            }
+            diceValues[i] = (dice[i].getValue());
         }
-        aConsole.println("current roll: " + currentDice.toString());
+
+        DrawYahtzeeDice diceDrawer = new DrawYahtzeeDice();
+        aConsole.println(diceDrawer.drawYahtzeeDice(diceValues).toString());
+        aConsole.println("    1           2           3           4           5    ");
     }
 
     /*

src/main/java/io/zipcoder/casino/Leviathan/Table.java

                 aGame = new BlackJack(aPlayer);
                 aGame.playGame();
                 played = true;
-                aConsole.println("You Lose\n");
             } else if (choice == 4) //Yahtzee
             {
                 aGame = new Yahtzee(aPlayer);

src/test/java/io/zipcoder/casino/BlackJackTest.java

 package io.zipcoder.casino;
 
+import io.zipcoder.casino.Leviathan.Games.BlackJack;
+import io.zipcoder.casino.Leviathan.Games.GameUtilities.Card;
+import io.zipcoder.casino.Leviathan.Games.GameUtilities.Rank;
+import io.zipcoder.casino.Leviathan.Games.GameUtilities.Suit;
+import io.zipcoder.casino.Leviathan.Player;
 import org.junit.Before;
 import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
 import static org.junit.Assert.assertEquals;
 
 public class BlackJackTest {
 
+    private BlackJack testBlackJack;
+
     @Before
-    public void setUp()
-    {
+    public void setUp() {
+        Player p = new Player("name", 25, 25);
+        this.testBlackJack = new BlackJack(p);
     }
 
     @Test
-    public void testStartPlayerScore(){
+    public void testStartPlayerScore() {
         //Given
 
         //When
     }
 
     @Test
-    public void testStartHouseScore(){
+    public void testStartHouseScore() {
         //Given
 
         //When
         assertEquals(actual, expected);
     }
 
+    @Test
+    public void testDrawNewHandHasTwoCards() {
+        int expected = 2;
+        int actual = testBlackJack.drawNewHand().size();
+
+        assertEquals(expected, actual);
+    }
+
+
+
+
+    @Test
+    public void testGetHandTotal() {
+        Card c1 = new Card(Rank.FOUR, Suit.CLUBS);
+        Card c2 = new Card(Rank.EIGHT, Suit.CLUBS);
+        Card c3 = new Card(Rank.TWO, Suit.CLUBS);
 
+        List<Card> hand = new ArrayList<>();
+        hand.add(c1);
+        hand.add(c2);
+        hand.add(c3);
 
+        int expected = 14;
+        int actual = testBlackJack.getHandTotal(hand);
+
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void testHandToString() {
+        Card c1 = new Card(Rank.FOUR, Suit.CLUBS);
+        Card c2 = new Card(Rank.EIGHT, Suit.CLUBS);
+        Card c3 = new Card(Rank.TWO, Suit.CLUBS);
+
+        List<Card> hand = new ArrayList<>();
+        hand.add(c1);
+        hand.add(c2);
+        hand.add(c3);
+
+        String expected = "FOUR of CLUBS\n" +
+                "EIGHT of CLUBS\n" +
+                "TWO of CLUBS\n";
+        String actual = testBlackJack.handToString(hand);
+
+        System.out.println(actual);
+
+        assertEquals(expected, actual);
+    }
 }

src/test/java/io/zipcoder/casino/DiceTest.java

         public void rollAllTest(){
             //Given
             test.rollAll();
-            int sum = 0;
 
-            for(int i = 0; i< test.getDice().length; i++){
-                sum+= test.getDice()[i].getValue();
-            }
             //When
+            int actual = test.getDice()[0].getValue();
+            int expected = 3;
 
-            int actual = sum;
+            //Result
+            assertEquals(actual, expected, 3);
+
+        }
+
+        @Test
+        public void sumAllTest(){
+            //Given
+            test.rollAll();
+
+            //When
+            int actual = test.sumAllDice();
             int expected = 17;
+
             //Result
             assertEquals(actual, expected, 13);
 

src/test/java/io/zipcoder/casino/YahtzeeTest.java

 
     Yahtzee yahtzee;
     Player aPlayer;
-    Dice diceRoller;
-    Die[] dice;
-    Console console = new Console();
 
     public YahtzeeTest(){
-        this.aPlayer = new Player("eric", 20, 18);
-        this.yahtzee = new Yahtzee(aPlayer);
+        aPlayer = new Player("eric", 20, 18);
+        yahtzee = new Yahtzee(aPlayer);
     }
 
     @Test
     }
 
     @Test
-    public void isYahtzeeFieldTest(){
+    public void isYahtzeeFieldValidTest(){
         //Actual
-        boolean actual = yahtzee.isYahtzeeField("ACES");
-        boolean actual2 = yahtzee.isYahtzeeField("ONES");
-        boolean actual3 = yahtzee.isYahtzeeField("TWOS");
-        boolean actual4 = yahtzee.isYahtzeeField("SEVENS");
+        boolean actual = yahtzee.isValidYahtzeeField("ACES");
+        boolean actual2 = yahtzee.isValidYahtzeeField("ONES");
+        boolean actual3 = yahtzee.isValidYahtzeeField("TWOS");
+        boolean actual4 = yahtzee.isValidYahtzeeField("SEVENS");
         //Expected
         boolean expected = true;
         boolean expected2 = false;
         assertEquals(actual4, expected4);
     }
 
+    @Test
+    public void printDiceTest(){
+        yahtzee.printDice();
+    }
+