Merge branch 'dev' into HigherCards

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

     //==================================================================================
     // PLAY GAME METHOD
     //==================================================================================
-
     public void playGame() {
         printWelcomeMessage();
         while (playAgain) {
     // SCORE SHEET METHODS
     //==================================================================================
 
-    /*
-    Check score sheet for completion
-     */
+    //Check score sheet for completion
     private boolean checkScoreSheetForCompletion() {
         for (Map.Entry<YahtzeeField, Integer> entry : scoreSheet.entrySet()) {
             Integer value = entry.getValue();
         return true;
     }
 
-    /*
-    Get total score
-     */
+    //Get total score
     private int getTotalScore() {
         int sumOfUpperSection = getUpperSectionScore();
         int bonus = 0;
         return sumOfUpperSection + bonus + sumOfLowerSection;
     }
 
-    /*
-    Get upper section score
-     */
+    //Get upper section score
     private int getUpperSectionScore() {
         int upperScore = 0;
         Iterator it = scoreSheet.entrySet().iterator();
         return upperScore;
     }
 
-    /*
-    Get lower section score
-     */
+    //Get lower section score
     private int getLowerSectionScore() {
         int lowerScore = 0;
         Iterator it = scoreSheet.entrySet().iterator();
         return lowerScore;
     }
 
-
     //==================================================================================
     // SCORING ROLL METHODS
     //==================================================================================
 
-    /*
-    Score roll
-     */
+    //Score roll
     public void scoreRoll() {
         YahtzeeField fieldChoice = chooseYahtzeeField();
         int score = scoreDice(fieldChoice);
         updateScoreSheet(fieldChoice, score);
     }
 
-    /*
-    Choose yahtzee field to score
-     */
+    //Convert user input into yahtzee field to score
     public YahtzeeField chooseYahtzeeField() {
         String userInput = userInputFieldToScore();
         while (!isValidYahtzeeField(userInput)) {
         return YahtzeeField.valueOf(userInput);
     }
 
-    /*
-    Check if yahtzee field is valid and free
-     */
+    //Check if yahtzee field is valid and free
     public boolean isValidYahtzeeField(String userInput) {
         for (YahtzeeField aYahtzeeField : YahtzeeField.values()) {
             if (aYahtzeeField.toString().equals(userInput)) {
         return false;
     }
 
-    /*
-    Score dice
-    */
+    //Score dice
     private int scoreDice(YahtzeeField yahtzeeField) {
         setDiceValueCounts();
         int score = 0;
         return score;
     }
 
-    /*
-    Score dice "count" fields: aces, twos, threes, fours, fives, or sixes
-    */
+    //Score dice "count" fields: aces, twos, threes, fours, fives, or sixes
     public int scoreCountFields(int countField) {
         return diceValueCounts[countField - 1] * countField;
     }
 
-    /*
-    Check "of a kind" criteria is met: 3/4 of a kind, chance, yahtzee
-    */
+    //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) {
         return false;
     }
 
-    /*
-    Score dice 3/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) {
-                score += d.getValue();
-            }
+            score = sumOfDice();
         }
         return score;
     }
 
-    /*
-    Score yahtzee
-     */
-    private int scoreYahtzee(boolean meetsOfAKindCriteria) {
+    //Get sum of dice
+    public int sumOfDice(){
+        int sum = 0;
+        for (Die d : dice) {
+            sum += d.getValue();
+        }
+        return sum;
+    }
+
+    //Score yahtzee
+    public int scoreYahtzee(boolean meetsOfAKindCriteria) {
         int score = 0;
         if (meetsOfAKindCriteria) {
             score = 50;
         return score;
     }
 
-    /*
-    Check Full House criteria is met
-    */
+    //Check Full House criteria is met
     public boolean fullHouseCriteria() {
         int i = 0;
         for (int count : diceValueCounts) {
         return false;
     }
 
-    /*
-    Score Full House
-     */
+    //Score Full House
     public int scoreFullHouse(boolean meetsFullHouseCriteria) {
         int score = 0;
         if (meetsFullHouseCriteria) {
         return score;
     }
 
-    /*
-    Check Small Straight criteria is met
-    */
+    //Check Small Straight criteria is met
     public boolean smStraightCriteria() {
         boolean meetsCriteria = false;
         int i = 0;
         return meetsCriteria;
     }
 
-    /*
-    Score SM Straight
-     */
-    private int scoreSmStraight(boolean meetsSmStraightCriteria) {
+    //Score SM Straight
+    public int scoreSmStraight(boolean meetsSmStraightCriteria) {
         int score = 0;
         if (meetsSmStraightCriteria) {
             score = 30;
         return score;
     }
 
-    /*
-    Check Large Straight criteria is met
-    */
+    //Check Large Straight criteria is met
     public boolean lgStraightCriteria() {
         boolean meetsCriteria = false;
         int i = 0;
         return meetsCriteria;
     }
 
-    /*
-    Score LG Straight
-     */
+    //Score LG Straight
     public int scoreLgStraight(boolean meetsLgStraightCriteria) {
         int score = 0;
         if (meetsLgStraightCriteria) {
     // ROLLING DICE METHODS
     //==================================================================================
 
-    /*
-    Allow the user to roll again up to 2 more times
-     */
+    //Allow the user to roll again up to 2 more times
     public void rollAgainLoop() {
         boolean rollAgain = userInputYesNoToBoolean(userInputRollAgain());
         int rollCounter = 1;
         }
     }
 
-    /*
-    Roll again
-     */
+    //Roll again
     public void rollAgain() {
         List<Integer> diceToRollAgainList = userInputChooseDice();
         Integer[] diceToRollAgain = turnRollAgainListToArray(diceToRollAgainList);
         rollSelectedDiceAgain(diceToRollAgain);
     }
 
-    /*
-    Ask user to select which dice to roll again
-     */
+    //Ask user to select which dice to roll again
     public List<Integer> userInputChooseDice() {
         List<Integer> diceToRollAgainList = new ArrayList<Integer>();
         boolean stillSelecting = true;
         return diceToRollAgainList;
     }
 
-    /*
-    Turn user input of dice to roll again into an array
-     */
+    //Turn user input of dice to roll again into an array
     public Integer[] turnRollAgainListToArray(List<Integer> diceToRollAgainList) {
         Integer[] diceToRollAgainArray = null;
         diceToRollAgainArray = diceToRollAgainList.toArray(new Integer[0]);
         return diceToRollAgainArray;
     }
 
-    /*
-    Roll the selected dice again
-     */
+    //Roll the selected dice again
     public void rollSelectedDiceAgain(Integer... diceToRollAgain) {
         for (int i = 0; i < diceToRollAgain.length; i++) {
             dice[diceToRollAgain[i] - 1].rollADice();
     }
 
     //==================================================================================
-    // Get User Input
+    // Console Methods Input
     //==================================================================================
 
-    /*
-    Ask user if they want to roll again
-     */
+    //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
-     */
+    //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
-     */
+    //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
-     */
+    //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
-     */
+    //Convert user input to boolean
     public boolean userInputYesNoToBoolean(String userInputString) {
         return (userInputString.toUpperCase().equals("YES"));
     }
 
     //==================================================================================
-    // Print Output
+    // Console Methods Output
     //==================================================================================
 
-    /*
-    Print dice
-     */
+    //Print dice
     public void printDice() {
         DrawYahtzeeDice diceDrawer = new DrawYahtzeeDice();
         setDiceValues();
         aConsole.println("    1           2           3           4           5    ");
     }
 
-    /*
-    Print welcome message
-     */
+    //Print welcome message
     public void printWelcomeMessage() {
         aConsole.println("Welcome to Yahtzee " + aPlayer.getName());
         printRules();
     }
 
-    /*
-    Print rules
-    */
+    //Print rules
     public void printRules() {
         aConsole.println("Roll 5 dice up to 3 times and try to get the highest score");
     }
 
-    /*
-    Print score sheet
-     */
+    //Print score sheet
     private void printScoreSheet() {
         aConsole.println("Scoresheet: " + scoreSheet.toString());
     }
 
-    /*
-    Print end of game stats
-    */
+    //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
-     */
+    //Print error when yahtzee field input is invalid or already full
     public void printYahtzeeFieldErrorMessage() {
         aConsole.println("please enter valid & free yahtzee field.");
     }
 
-    /*
-    Print error when user enters dice to roll outside of 1-5 bounds
-     */
+    //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)
-     */
+    //Set dice (roll all dice)
     public void rollDice() {
         dice = diceRoller.rollAll();
     }
 
-    /*
-    Get dice
-     */
-    public Die[] getDice(){
-        return this.dice;
-    }
-
-
-    /*
-    Set value count array
-    */
+    //Set value count array
     public void setDiceValueCounts() {
         resetDiceValueCounts();
         for (Die d : dice) {
         }
     }
 
-    /*
-    Reset count of each value in dice
-    */
+    //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
-     */
+    //Get value count array
     public int[] getDiceValueCounts() {
         return this.diceValueCounts;
     }
 
-    /*
-    Set dice values array
-     */
+    //Set dice values array
     public void setDiceValues() {
         for (int i = 0; i < dice.length; i++) {
             diceValues[i] = (dice[i].getValue());
         }
     }
 
-    /*
-    Get dice values array
-     */
-    public int[] getDiceValues() {
-        return this.diceValues;
-    }
-
-    /*
-    Set score sheet with scored value
-    */
+    //Set score sheet with scored value
     public void updateScoreSheet(YahtzeeField yahtzeeField, int score) {
         scoreSheet.put(yahtzeeField, score);
     }
 
-    /*
-    Reset score sheet to blank
-     */
+    //Reset score sheet to blank
     public void createBlankScoreSheet() {
         for (YahtzeeField field : YahtzeeField.values()) {
             scoreSheet.put(field, null);
         }
     }
 
-    /*
-    Get score sheet
-     */
+    //Get score sheet
     public Map<YahtzeeField, Integer> getScoreSheet() {
         return this.scoreSheet;
     }

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

     }
 
     @Test
-    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
+    public void scoreCountFieldsTestPositive(){
+        //Actual
+        int actual = yahtzee.scoreCountFields(2);
+        //Expected
+        int[] getDiceValueCounts = yahtzee.getDiceValueCounts();
+        int expected = getDiceValueCounts[1]*2;
+        //Test
+        assertEquals(expected, actual);
+    }
 
-        yahtzee.rollSelectedDiceAgain(1,2,3,4,5);
+    @Test
+    public void scoreThreeOfAKindTestPositive(){
         //Actual
+        int actual = yahtzee.scoreOfAKind(true);
+        //Expected
+        int expected = yahtzee.sumOfDice();
+        //Test
+        assertEquals(expected, actual);
+    }
 
+    @Test
+    public void scoreThreeOfAKindTestNegative(){
+        //Actual
+        int actual = yahtzee.scoreOfAKind(false);
+        //Expected
+        int expected = 0;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreYahtzeeTestPositive(){
+        //Actual
+        int actual = yahtzee.scoreYahtzee(true);
+        //Expected
+        int expected = 50;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreYahtzeeTestNegative(){
+        //Actual
+        int actual = yahtzee.scoreYahtzee(false);
+        //Expected
+        int expected = 0;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreFullHouseTestPositive(){
+        //Actual
+        int actual = yahtzee.scoreFullHouse(true);
+        //Expected
+        int expected = 25;
+        //Test
+        assertEquals(expected, actual);
     }
 
     @Test
-    public void turnTurnRollAgainListToArray(){
+    public void scoreFullHouseTestNegative(){
+        //Actual
+        int actual = yahtzee.scoreFullHouse(false);
+        //Expected
+        int expected = 0;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreSmStraightTestPositive(){
+        //Actual
+        int actual = yahtzee.scoreSmStraight(true);
+        //Expected
+        int expected = 30;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreSmStraightTestNegative(){
+        //Actual
+        int actual = yahtzee.scoreSmStraight(false);
+        //Expected
+        int expected = 0;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreLgStraightTestPositive(){
+        //Actual
+        int actual = yahtzee.scoreLgStraight(true);
+        //Expected
+        int expected = 40;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void scoreLgStraightTestNegative(){
+        //Actual
+        int actual = yahtzee.scoreLgStraight(false);
+        //Expected
+        int expected = 0;
+        //Test
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void turnTurnRollAgainListToArrayTest(){
         //Given
         List<Integer> testUserInputList = new ArrayList<Integer>();
         testUserInputList.add(1);
     }
 
     @Test
-    public void userInputRollAgainBooleanTestYes(){
+    public void userInputRollAgainBooleanTestPositive(){
         //Actual
         boolean actual = yahtzee.userInputYesNoToBoolean("YES");
         //Expected
     }
 
     @Test
-    public void userInputRollAgainBooleanTestNo(){
+    public void userInputRollAgainBooleanTestNegative(){
         //Actual
         boolean actual = yahtzee.userInputYesNoToBoolean("NO");
         //Expected
     }
 
     @Test
-    public void isYahtzeeFieldValidTest(){
+    public void isYahtzeeFieldValidTestPositive(){
         //Actual
         boolean actual = yahtzee.isValidYahtzeeField("ACES");
         //Expected
     }
 
     @Test
-    public void isYahtzeeFieldValidTest2(){
+    public void isYahtzeeFieldValidTestNegative(){
         //Actual
         boolean actual = yahtzee.isValidYahtzeeField("ONES");
         //Expected