Merge branch 'dev' into snarkyTable

merge

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

@@ -2,13 +2,16 @@ package io.zipcoder.casino.Leviathan;
 
 
 public class Casino {
-    Console aConsole = new Console();
-    Player aPlayer;
-    Table aTable;
+    private Console aConsole = new Console();
+    private Player aPlayer;
 
     public void setaPlayer() {
         String name = aConsole.getStringInput("What is your name?");
         aPlayer = new Player(name.substring(0, 1).toUpperCase() + name.substring(1),0,aConsole.getIntInput("What is your age?"));
+        checkAge();
+    }
+
+    private void checkAge(){
         if (aPlayer.getAge() > 20) {
             aPlayer.setTotalChips(aConsole.getIntInput("How many chips would you like to purchase?"));
         } else {
@@ -17,7 +20,7 @@ public class Casino {
     }
 
     public void run() {
-        aTable = new Table(aPlayer);
+        Table aTable = new Table(aPlayer);
         aTable.startGame();
     }
 }

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

@@ -8,7 +8,6 @@ public class Die {
 
     public int getValue() {
         return value;
-
     }
 
     public void rollADice() {

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

@@ -8,16 +8,21 @@ import java.util.*;
 
 public class Yahtzee extends DiceGame {
 
-    Player aPlayer;
-    Dice diceRoller = new Dice(5);
-    Die[] dice = diceRoller.rollAll();
-    int[] diceValueCounts = new int[6];
-    Console aConsole = new Console();
-    boolean playAgain;
-    boolean scoreSheetFull = false;
-    Map<YahtzeeField, Integer> scoreSheet = new LinkedHashMap<YahtzeeField, Integer>();
-
+    //==================================================================================
+    // Fields
+    //==================================================================================
+    private Console aConsole = new Console();
+    private Player aPlayer;
+    private Map<YahtzeeField, Integer> scoreSheet = new LinkedHashMap<>();
+    private Dice diceRoller = new Dice(5);
+    private Die[] dice = diceRoller.rollAll();
+    private int[] diceValues = new int[5];
+    private int[] diceValueCounts = new int[6];
+    private boolean playAgain = true;
 
+    //==================================================================================
+    // Constructor
+    //==================================================================================
     public Yahtzee(Player aPlayer) {
         this.aPlayer = aPlayer;
     }
@@ -27,32 +32,23 @@ public class Yahtzee extends DiceGame {
     //==================================================================================
 
     public void playGame() {
-
-        aConsole.println("Welcome to Yahtzee " + aPlayer.getName());
-
-        boolean playAgain = true;
+        printWelcomeMessage();
         while (playAgain) {
-
             createBlankScoreSheet();
             printScoreSheet();
-
+            boolean scoreSheetFull = false;
             while (!scoreSheetFull) {
                 rollDice();
-                printDice(getDiceValues(this.dice));
-
+                printDice();
                 rollAgainLoop();
-
-                YahtzeeField fieldChoice = chooseYahtzeeField();
-                int score = scoreDice(fieldChoice);
-                updateScoreSheet(fieldChoice, score);
+                scoreRoll();
                 printScoreSheet();
                 scoreSheetFull = checkScoreSheetForCompletion();
             }
-
             int totalScore = getTotalScore();
             printEndOfGameMessage(totalScore);
+            playAgain = userInputYesNoToBoolean(userInputPlayAgain());
         }
-
     }
 
     //==================================================================================
@@ -60,18 +56,9 @@ public class Yahtzee extends DiceGame {
     //==================================================================================
 
     /*
-    Create blank score sheet
-     */
-    public void createBlankScoreSheet() {
-        for (YahtzeeField field : YahtzeeField.values()) {
-            scoreSheet.put(field, null);
-        }
-    }
-
-    /*
     Check score sheet for completion
      */
-    public boolean checkScoreSheetForCompletion() {
+    private boolean checkScoreSheetForCompletion() {
         for (Map.Entry<YahtzeeField, Integer> entry : scoreSheet.entrySet()) {
             Integer value = entry.getValue();
             if (value == null) {
@@ -82,19 +69,12 @@ public class Yahtzee extends DiceGame {
     }
 
     /*
-    Print score sheet
-     */
-    public void printScoreSheet() {
-        aConsole.println("Scoresheet: " + scoreSheet.toString());
-    }
-
-    /*
     Get total score
      */
-    public int getTotalScore() {
+    private int getTotalScore() {
         int sumOfUpperSection = getUpperSectionScore();
         int bonus = 0;
-        if (sumOfUpperSection >= 63){
+        if (sumOfUpperSection >= 63) {
             bonus = 35;
         }
         int sumOfLowerSection = getLowerSectionScore();
@@ -104,15 +84,15 @@ public class Yahtzee extends DiceGame {
     /*
     Get upper section score
      */
-    public int getUpperSectionScore(){
+    private int getUpperSectionScore() {
         int upperScore = 0;
         Iterator it = scoreSheet.entrySet().iterator();
-        while (it.hasNext()){
-            Map.Entry scoreEntry = (Map.Entry)it.next();
+        while (it.hasNext()) {
+            Map.Entry scoreEntry = (Map.Entry) it.next();
             if (scoreEntry.getKey() == YahtzeeField.ACES || scoreEntry.getKey() == YahtzeeField.TWOS ||
                     scoreEntry.getKey() == YahtzeeField.THREES || scoreEntry.getKey() == YahtzeeField.FOURS ||
-                    scoreEntry.getKey() == YahtzeeField.FIVES || scoreEntry.getKey() == YahtzeeField.SIXES){
-                upperScore += (int)(scoreEntry.getValue());
+                    scoreEntry.getKey() == YahtzeeField.FIVES || scoreEntry.getKey() == YahtzeeField.SIXES) {
+                upperScore += (int) (scoreEntry.getValue());
             }
         }
         return upperScore;
@@ -121,56 +101,44 @@ public class Yahtzee extends DiceGame {
     /*
     Get lower section score
      */
-    public int getLowerSectionScore(){
+    private int getLowerSectionScore() {
         int lowerScore = 0;
         Iterator it = scoreSheet.entrySet().iterator();
-        while (it.hasNext()){
-            Map.Entry scoreEntry = (Map.Entry)it.next();
+        while (it.hasNext()) {
+            Map.Entry scoreEntry = (Map.Entry) it.next();
             if (scoreEntry.getKey() == YahtzeeField.THREEOFAKIND || scoreEntry.getKey() == YahtzeeField.FOUROFAKIND ||
                     scoreEntry.getKey() == YahtzeeField.FULLHOUSE || scoreEntry.getKey() == YahtzeeField.SMSTRAIGHT ||
                     scoreEntry.getKey() == YahtzeeField.LGSTRAIGHT || scoreEntry.getKey() == YahtzeeField.YAHTZEE ||
-                    scoreEntry.getKey() == YahtzeeField.CHANCE){
-                lowerScore += (int)(scoreEntry.getValue());
+                    scoreEntry.getKey() == YahtzeeField.CHANCE) {
+                lowerScore += (int) (scoreEntry.getValue());
             }
         }
         return lowerScore;
     }
 
-     /*
-    Print end of game stats
-     */
-     public void printEndOfGameMessage(int totalScore){
-         aConsole.println("Game over!");
-         aConsole.println("Your total score is: " + totalScore);
-         if(aConsole.yesOrNo("Would you like to play again?").equalsIgnoreCase("no")){
-             playAgain= false;
-         }
-     }
 
     //==================================================================================
     // SCORING ROLL METHODS
     //==================================================================================
 
     /*
-    See fields and formula for score
+    Score roll
      */
-    public void printRules(){
-        aConsole.println("Roll 5 dice up to 3 times and try to get the highest score");
+    public void scoreRoll() {
+        YahtzeeField fieldChoice = chooseYahtzeeField();
+        int score = scoreDice(fieldChoice);
+        updateScoreSheet(fieldChoice, score);
     }
 
     /*
     Choose yahtzee field to score
      */
     public YahtzeeField chooseYahtzeeField() {
-        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();
-            inputIsValid = isValidYahtzeeField(userInput);
+        String userInput = userInputFieldToScore();
+        while (!isValidYahtzeeField(userInput)) {
+            printYahtzeeFieldErrorMessage();
+            userInput = userInputFieldToScore();
         }
-
         return YahtzeeField.valueOf(userInput);
     }
 
@@ -180,7 +148,7 @@ public class Yahtzee extends DiceGame {
     public boolean isValidYahtzeeField(String userInput) {
         for (YahtzeeField aYahtzeeField : YahtzeeField.values()) {
             if (aYahtzeeField.toString().equals(userInput)) {
-                if(scoreSheet.get(YahtzeeField.valueOf(userInput)) == null){
+                if (scoreSheet.get(YahtzeeField.valueOf(userInput)) == null) {
                     return true;
                 }
             }
@@ -191,10 +159,8 @@ public class Yahtzee extends DiceGame {
     /*
     Score dice
     */
-    public int scoreDice(YahtzeeField yahtzeeField) {
-
-        updateDiceValues();
-
+    private int scoreDice(YahtzeeField yahtzeeField) {
+        setDiceValueCounts();
         int score = 0;
         switch (yahtzeeField) {
             case ACES:
@@ -225,7 +191,7 @@ public class Yahtzee extends DiceGame {
                 score = scoreFullHouse(fullHouseCriteria());
                 break;
             case SMSTRAIGHT:
-                score = scoreSmStraight(smStraighCriteria());
+                score = scoreSmStraight(smStraightCriteria());
                 break;
             case LGSTRAIGHT:
                 score = scoreLgStraight(lgStraightCriteria());
@@ -241,30 +207,18 @@ public class Yahtzee extends DiceGame {
     }
 
     /*
-    Get count of each value in dice
-    */
-    public void updateDiceValues(){
-        resetDiceValues();
-        for (Die d : dice){
-            diceValueCounts[d.getValue()-1]++;
-        }
-    }
-
-    /*
-    Reset count of each value in dice
+    Score dice "count" fields: aces, twos, threes, fours, fives, or sixes
     */
-    public void resetDiceValues(){
-        for (int i=0; i < diceValueCounts.length; i++){
-            diceValueCounts[i] = 0;
-        }
+    public int scoreCountFields(int countField) {
+        return diceValueCounts[countField - 1] * countField;
     }
 
     /*
-    Check "of a kind" criteria is met
+    Check "of a kind" criteria is met: 3/4 of a kind, chance, yahtzee
     */
-    public boolean ofAKindCriteria(int ofAKind){
-        for (int count : diceValueCounts){
-            if (count >= ofAKind){
+    public boolean ofAKindCriteria(int ofAKind) {
+        for (int count : diceValueCounts) {
+            if (count >= ofAKind) {
                 return true;
             }
         }
@@ -272,12 +226,12 @@ public class Yahtzee extends DiceGame {
     }
 
     /*
-    Score dice "of a kind" fields: 3 of a kind, 4 of a kind, or chance
+    Score dice 3/4 of a kind, or chance
     */
     public int scoreOfAKind(boolean meetsOfAKindCriteria) {
         int score = 0;
         if (meetsOfAKindCriteria) {
-            for (Die d : dice){
+            for (Die d : dice) {
                 score += d.getValue();
             }
         }
@@ -287,9 +241,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score yahtzee
      */
-    public int scoreYahtzee(boolean meetsOfAKindCriteria){
+    private int scoreYahtzee(boolean meetsOfAKindCriteria) {
         int score = 0;
-        if (meetsOfAKindCriteria){
+        if (meetsOfAKindCriteria) {
             score = 50;
         }
         return score;
@@ -298,14 +252,14 @@ public class Yahtzee extends DiceGame {
     /*
     Check Full House criteria is met
     */
-    public boolean fullHouseCriteria(){
+    public boolean fullHouseCriteria() {
         int i = 0;
-        for (int count : diceValueCounts){
-            if (count >= 2){
+        for (int count : diceValueCounts) {
+            if (count >= 2) {
                 i++;
             }
         }
-        if(i==2){
+        if (i == 2) {
             return true;
         }
         return false;
@@ -314,9 +268,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score Full House
      */
-    public int scoreFullHouse(boolean meetsFullHouseCriteria){
+    public int scoreFullHouse(boolean meetsFullHouseCriteria) {
         int score = 0;
-        if (meetsFullHouseCriteria){
+        if (meetsFullHouseCriteria) {
             score = 25;
         }
         return score;
@@ -325,15 +279,15 @@ public class Yahtzee extends DiceGame {
     /*
     Check Small Straight criteria is met
     */
-    public boolean smStraighCriteria(){
+    public boolean smStraightCriteria() {
         boolean meetsCriteria = false;
         int i = 0;
-        for (int count : diceValueCounts){
-            if (count > 1){
+        for (int count : diceValueCounts) {
+            if (count > 1) {
                 i++;
             }
         }
-        if(i<=1){
+        if (i <= 1) {
             meetsCriteria = true;
         }
         return meetsCriteria;
@@ -342,9 +296,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score SM Straight
      */
-    public int scoreSmStraight(boolean meetsSmStraightCriteria){
+    private int scoreSmStraight(boolean meetsSmStraightCriteria) {
         int score = 0;
-        if (meetsSmStraightCriteria){
+        if (meetsSmStraightCriteria) {
             score = 30;
         }
         return score;
@@ -353,15 +307,15 @@ public class Yahtzee extends DiceGame {
     /*
     Check Large Straight criteria is met
     */
-    public boolean lgStraightCriteria(){
+    public boolean lgStraightCriteria() {
         boolean meetsCriteria = false;
         int i = 0;
-        for (int count : diceValueCounts){
-            if (count > 1){
+        for (int count : diceValueCounts) {
+            if (count > 1) {
                 i++;
             }
         }
-        if(i<1){
+        if (i < 1) {
             meetsCriteria = true;
         }
         return meetsCriteria;
@@ -370,100 +324,60 @@ public class Yahtzee extends DiceGame {
     /*
     Score LG Straight
      */
-    public int scoreLgStraight(boolean meetsLgStraightCriteria){
+    public int scoreLgStraight(boolean meetsLgStraightCriteria) {
         int score = 0;
-        if (meetsLgStraightCriteria){
+        if (meetsLgStraightCriteria) {
             score = 40;
         }
         return score;
     }
 
-    /*
-    Score dice "count" fields: aces, twos, threes, fours, fives, or sixes
-    */
-    public int scoreCountFields(int countField) {
-        return diceValueCounts[countField-1] * countField;
-    }
-
-    /*
-    Update score sheet with scored value
-    */
-    public void updateScoreSheet(YahtzeeField yahtzeeField, int score) {
-        scoreSheet.put(yahtzeeField, score);
-    }
-
     //==================================================================================
     // ROLLING DICE METHODS
     //==================================================================================
 
     /*
-    Roll dice
-     */
-    public Die[] rollDice() {
-        dice = diceRoller.rollAll();
-        return dice;
-    }
-
-    /*
-    Ask user if they want to roll again
-     */
-    public String userInputRollAgain() {
-        return aConsole.yesOrNo("Roll again?").toUpperCase();
-    }
-
-    /*
-    Convert user's choice to roll again to boolean
-     */
-    public boolean userInputRollAgainBoolean(String userInputString) {
-        if (userInputString.equals("YES")) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /*
     Allow the user to roll again up to 2 more times
      */
     public void rollAgainLoop() {
-
-        String rollAgainString = userInputRollAgain();
-        boolean rollAgain = userInputRollAgainBoolean(rollAgainString);
-
+        boolean rollAgain = userInputYesNoToBoolean(userInputRollAgain());
         int rollCounter = 1;
         while (rollAgain) {
-            //select the dice to keep
-            List<Integer> diceToRollAgainList = userInputChooseDice();
-            Integer[] diceToRollAgain = turnUserInputRollAgainToArray(diceToRollAgainList);
-            //roll remaining dice
-            rollSelectedDiceAgain(diceToRollAgain);
-            printDice(getDiceValues(this.dice));
+            rollAgain();
+            printDice();
             rollCounter++;
             if (rollCounter >= 3) {
                 break;
             }
-
-            rollAgainString = userInputRollAgain();
-            rollAgain = userInputRollAgainBoolean(rollAgainString);
+            rollAgain = userInputYesNoToBoolean(userInputRollAgain());
         }
     }
 
     /*
+    Roll again
+     */
+    public void rollAgain() {
+        List<Integer> diceToRollAgainList = userInputChooseDice();
+        Integer[] diceToRollAgain = turnRollAgainListToArray(diceToRollAgainList);
+        rollSelectedDiceAgain(diceToRollAgain);
+    }
+
+    /*
     Ask user to select which dice to roll again
      */
     public List<Integer> userInputChooseDice() {
         List<Integer> diceToRollAgainList = new ArrayList<Integer>();
-        boolean stillSelecting;
+        boolean stillSelecting = true;
+        String dicePosition;
         do {
-            String positionOfDiceToKeep = aConsole.getStringInput("Enter position of dice to roll again or enter to perform roll");
-            if (positionOfDiceToKeep.equals("")) {
+            dicePosition = userInputDiceToRollAgain();
+            if (dicePosition.equals("1") || dicePosition.equals("2") || dicePosition.equals("3") ||
+                    dicePosition.equals("4") || dicePosition.equals("5")){
+                diceToRollAgainList.add(Integer.parseInt(dicePosition));
+            } else if (dicePosition.equals("")){
                 stillSelecting = false;
-            } else if (Integer.parseInt(positionOfDiceToKeep) > 0 || Integer.parseInt(positionOfDiceToKeep) < 6){
-                diceToRollAgainList.add(Integer.parseInt(positionOfDiceToKeep));
-                stillSelecting = true;
-                aConsole.println("Enter a number between 1 and 5 or enter to roll");
             } else {
-                stillSelecting = false;
+                printDicePositionErrorMessage();
             }
         } while (stillSelecting);
         return diceToRollAgainList;
@@ -472,9 +386,9 @@ public class Yahtzee extends DiceGame {
     /*
     Turn user input of dice to roll again into an array
      */
-    public Integer[] turnUserInputRollAgainToArray(List<Integer> diceToRollAgainList) {
+    public Integer[] turnRollAgainListToArray(List<Integer> diceToRollAgainList) {
         Integer[] diceToRollAgainArray = null;
-        diceToRollAgainArray = diceToRollAgainList.toArray(new Integer[diceToRollAgainList.size()]);
+        diceToRollAgainArray = diceToRollAgainList.toArray(new Integer[0]);
         return diceToRollAgainArray;
     }
 
@@ -487,23 +401,184 @@ public class Yahtzee extends DiceGame {
         }
     }
 
+    //==================================================================================
+    // Get User Input
+    //==================================================================================
+
+    /*
+    Ask user if they want to roll again
+     */
+    public String userInputRollAgain() {
+        return aConsole.yesOrNo("Roll again?");
+    }
+
+    /*
+    Ask user the position of the dice that they want to roll again
+     */
+    public String userInputDiceToRollAgain() {
+     return aConsole.getStringInput("Enter position of dice to roll again or enter to perform roll");
+    }
+
+    /*
+    Ask user which field they want to score
+     */
+    public String userInputFieldToScore() {
+        return aConsole.getStringInput("Which field do you want to score?").toUpperCase();
+    }
+
+    /*
+    Ask user if they want to play again
+     */
+    public String userInputPlayAgain(){
+        return aConsole.yesOrNo("Would you like to play again?");
+    }
+
+    /*
+    Convert user input to boolean
+     */
+    public boolean userInputYesNoToBoolean(String userInputString) {
+        return (userInputString.toUpperCase().equals("YES"));
+    }
+
+    //==================================================================================
+    // Print Output
+    //==================================================================================
+
     /*
     Print dice
      */
-    public void printDice(int[] diceValues) {
+    public void printDice() {
         DrawYahtzeeDice diceDrawer = new DrawYahtzeeDice();
+        setDiceValues();
         aConsole.println(diceDrawer.drawYahtzeeDice(diceValues).toString());
         aConsole.println("    1           2           3           4           5    ");
     }
 
     /*
-    Create dice values array
+    Print welcome message
+     */
+    public void printWelcomeMessage() {
+        aConsole.println("Welcome to Yahtzee " + aPlayer.getName());
+        printRules();
+    }
+
+    /*
+    Print rules
+    */
+    public void printRules() {
+        aConsole.println("Roll 5 dice up to 3 times and try to get the highest score");
+    }
+
+    /*
+    Print score sheet
+     */
+    private void printScoreSheet() {
+        aConsole.println("Scoresheet: " + scoreSheet.toString());
+    }
+
+    /*
+    Print end of game stats
+    */
+    public void printEndOfGameMessage(int totalScore) {
+        aConsole.println("Game over!");
+        aConsole.println("Your total score is: " + totalScore);
+    }
+
+    /*
+    Print error when yahtzee field input is invalid or already full
      */
-    public int[] getDiceValues(Die[] dice){
-        int[] diceValues = new int[5];
+    public void printYahtzeeFieldErrorMessage() {
+        aConsole.println("please enter valid & free yahtzee field.");
+    }
+
+    /*
+    Print error when user enters dice to roll outside of 1-5 bounds
+     */
+    public void printDicePositionErrorMessage() {
+        aConsole.println("Enter a number between 1 and 5 or enter to roll");
+    }
+
+    //==================================================================================
+    // Getters and Setters (and Re-setters)
+    //==================================================================================
+
+    /*
+    Set dice (roll all dice)
+     */
+    public void rollDice() {
+        dice = diceRoller.rollAll();
+    }
+
+    /*
+    Get dice
+     */
+    public Die[] getDice(){
+        return this.dice;
+    }
+
+
+    /*
+    Set value count array
+    */
+    public void setDiceValueCounts() {
+        resetDiceValueCounts();
+        for (Die d : dice) {
+            diceValueCounts[d.getValue() - 1]++;
+        }
+    }
+
+    /*
+    Reset count of each value in dice
+    */
+    public void resetDiceValueCounts() {
+        for (int i = 0; i < diceValueCounts.length; i++) {
+            diceValueCounts[i] = 0;
+        }
+    }
+
+    /*
+    Get value count array
+     */
+    public int[] getDiceValueCounts() {
+        return this.diceValueCounts;
+    }
+
+    /*
+    Set dice values array
+     */
+    public void setDiceValues() {
         for (int i = 0; i < dice.length; i++) {
             diceValues[i] = (dice[i].getValue());
         }
-        return diceValues;
     }
-}
+
+    /*
+    Get dice values array
+     */
+    public int[] getDiceValues() {
+        return this.diceValues;
+    }
+
+    /*
+    Set score sheet with scored value
+    */
+    public void updateScoreSheet(YahtzeeField yahtzeeField, int score) {
+        scoreSheet.put(yahtzeeField, score);
+    }
+
+    /*
+    Reset score sheet to blank
+     */
+    public void createBlankScoreSheet() {
+        for (YahtzeeField field : YahtzeeField.values()) {
+            scoreSheet.put(field, null);
+        }
+    }
+
+    /*
+    Get score sheet
+     */
+    public Map<YahtzeeField, Integer> getScoreSheet() {
+        return this.scoreSheet;
+    }
+}

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

@@ -19,73 +19,60 @@ public class YahtzeeTest {
     }
 
     @Test
-    public void printDiceTest(){
-        //Given
-        int[] diceValuesTest = {1,2,3,4,5};
-        //Actual
-        yahtzee.printDice(diceValuesTest);
-        //Expected
-            //Print dice with values from 1-5;
-        //Test
-            //Check console display for dice values 1-5;
+    public void getDiceValuesTest(){
+//        //Given
+//        Die testDie = new Die();
+//        testDie.rollADice();
+//        Die[] testDieArray = {testDie, testDie, testDie, testDie, testDie};
+//        int testDieValue = testDie.getValue();
+//        int[] expectedArray = {testDieValue, testDieValue, testDieValue, testDieValue, testDieValue};
+//        //Actual
+//        boolean actual = Arrays.equals(actualArray, expectedArray);
+//        //Expected
+//        boolean expected = true;
+//        //Test
+//        assertEquals(expected, actual);
     }
 
     @Test
     public void rollSelectedDiceAgainTest(){
-
         //Given
-        yahtzee.rollSelectedDiceAgain(1,3,5);
+
+        yahtzee.rollSelectedDiceAgain(1,2,3,4,5);
+        //Actual
+
     }
 
     @Test
-    public void turnUserInputRollAgainToArray(){
+    public void turnTurnRollAgainListToArray(){
         //Given
         List<Integer> testUserInputList = new ArrayList<Integer>();
         testUserInputList.add(1);
         testUserInputList.add(2);
         testUserInputList.add(3);
         //Actual
-        Integer[] actual = yahtzee.turnUserInputRollAgainToArray(testUserInputList);
+        Integer[] actual = yahtzee.turnRollAgainListToArray(testUserInputList);
         //Expected
         Integer[] expected = {1,2,3};
         //Test
         assertEquals(expected,actual);
-
-    }
-
-    @Test
-    public void userInputChooseDiceTest(){
-
-    }
-
-    @Test
-    public void rollAgainLoopTest(){
-
     }
 
     @Test
-    public void userInputRollAgainBooleanTest(){
+    public void userInputRollAgainBooleanTestYes(){
         //Actual
-        boolean actual = yahtzee.userInputRollAgainBoolean("YES");
+        boolean actual = yahtzee.userInputYesNoToBoolean("YES");
         //Expected
         boolean expected = true;
         assertEquals(expected, actual);
     }
 
     @Test
-    public void userInputRollAgainTest(){
-
-    }
-
-    @Test
-    public void rollDiceTest(){
-        //Given
-        Die[] dice = yahtzee.rollDice();
+    public void userInputRollAgainBooleanTestNo(){
         //Actual
-        boolean actual = dice instanceof Die[];
+        boolean actual = yahtzee.userInputYesNoToBoolean("NO");
         //Expected
-        boolean expected = true;
-        //Test
+        boolean expected = false;
         assertEquals(expected, actual);
     }
 
@@ -93,23 +80,19 @@ public class YahtzeeTest {
     public void isYahtzeeFieldValidTest(){
         //Actual
         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;
-        boolean expected3 = true;
-        boolean expected4 = false;
         //Test
         assertEquals(actual, expected);
-        assertEquals(actual2, expected2);
-        assertEquals(actual3, expected3);
-        assertEquals(actual4, expected4);
     }
 
-
-
-
-}
-
+    @Test
+    public void isYahtzeeFieldValidTest2(){
+        //Actual
+        boolean actual = yahtzee.isValidYahtzeeField("ONES");
+        //Expected
+        boolean expected = false;
+        //Test
+        assertEquals(actual, expected);
+    }
+}