ScoreSheet complete with tests other than ones where I need a Dice[]

src/main/java/io/zipcoder/casino/Dice.java

@@ -7,4 +7,8 @@ public class Dice {
     public void Roll(){
 
     }
+
+    public int getValue() {
+        return value;
+    }
 }

src/main/java/io/zipcoder/casino/ScoreSheet.java

@@ -45,7 +45,10 @@ public class ScoreSheet {
 
     public void setRow(ROW row, Dice[] cup){
 
-        ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(cup);
+        ArrayList<Integer> numbers = new ArrayList<>();
+        for(Dice d : cup) {
+            numbers.add(d.getValue());
+        }
         Collections.sort(numbers);
 
         switch(row) {
@@ -89,14 +92,14 @@ public class ScoreSheet {
                 }
                 break;
             case SMALLSTRAIGHT:
-                if(checkSmallStraight()) {
+                if(checkSmallStraight(numbers)) {
                     scores.put(ROW.SMALLSTRAIGHT, 30);
                 } else {
                     scores.put(ROW.SMALLSTRAIGHT, 0);
                 }
                 break;
             case LARGESTRAIGHT:
-                if(checkLargeStraight()) {
+                if(checkLargeStraight(numbers)) {
                     scores.put(ROW.LARGESTRAIGHT, 40);
                 } else {
                     scores.put(ROW.LARGESTRAIGHT, 0);
@@ -116,7 +119,7 @@ public class ScoreSheet {
 
     }
 
-    private boolean checkFullHouse(ArrayList<Integer> numbers) {
+    public boolean checkFullHouse(ArrayList<Integer> numbers) {
 
         boolean check2 = checkOfaKind(numbers, 2);
         boolean check3 = checkOfaKind(numbers, 3);
@@ -124,17 +127,49 @@ public class ScoreSheet {
         return (check2 && check3);
     }
 
-    private boolean checkSmallStraight() {
+    public boolean checkSmallStraight(ArrayList<Integer> numbers) {
 
-        return false;
+        for(int i = 0; i < numbers.size() - 1; i++) {
+            if(numbers.get(i) == numbers.get(i+1)) {
+                numbers.remove(i);
+            }
+        }
+        System.out.println(numbers);
+        while(numbers.size() > 4) {
+            if (numbers.get(0) + 1 != numbers.get(1)) {
+                numbers.remove(0);
+            } else {
+                numbers.remove(4);
+            }
+        }
+        if(numbers.size() < 4) return false;
+        System.out.println(numbers);
+
+        boolean check = false;
+        if(numbers.toString().equals("[1, 2, 3, 4]") ||
+                numbers.toString().equals("[2, 3, 4, 5]") ||
+                numbers.toString().equals("[3, 4, 5, 6]")) {
+            check = true;
+        } else {
+            check = false;
+        }
+        return check;
     }
 
-    private boolean checkLargeStraight() {
+    public boolean checkLargeStraight(ArrayList<Integer> numbers) {
 
-        return false;
+        boolean check = false;
+        for(int i = 0; i < numbers.size() - 1; i++) {
+            if((numbers.get(i) + 1) == numbers.get(i + 1)) {
+                check = true;
+            } else {
+                check = false;
+            }
+        }
+        return check;
     }
 
-    private boolean checkOfaKind(ArrayList<Integer> numbers, int numb) {
+    public boolean checkOfaKind(ArrayList<Integer> numbers, int numb) {
 
         int[] counts = new int[6];
 
@@ -147,7 +182,7 @@ public class ScoreSheet {
         return false;
     }
 
-    private int scoreNumbers(ArrayList<Integer> numbers, int numb){
+    public int scoreNumbers(ArrayList<Integer> numbers, int numb){
 
         int count = 0;
         for(Integer i : numbers) {
@@ -158,7 +193,7 @@ public class ScoreSheet {
         return count * numb;
     }
 
-    private int scoreTotalDice(ArrayList<Integer> numbers) {
+    public int scoreTotalDice(ArrayList<Integer> numbers) {
 
         int score = 0;
         for(Integer i : numbers) {

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

@@ -1,4 +1,283 @@
 package io.zipcoder.casino;
 
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
 public class ScoreSheetTest {
+
+    @Test
+    public void testCheckThreeOfAKindFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkOfaKind(test, 3));
+
+    }
+
+    @Test
+    public void testCheckThreeOfAKindTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkOfaKind(test, 3));
+
+    }
+
+    @Test
+    public void testCheckFourOfAKindFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkOfaKind(test, 4));
+
+    }
+
+    @Test
+    public void testCheckFourOfAKindTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(2);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkOfaKind(test, 4));
+
+    }
+
+    @Test
+    public void testCheckYahtzeeFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkOfaKind(test, 5));
+
+    }
+
+    @Test
+    public void testCheckYahtzeeTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(2);
+        test.add(2);
+        test.add(2);
+        test.add(2);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkOfaKind(test, 5));
+
+    }
+
+    @Test
+    public void testCheckFullHouseFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkFullHouse(test));
+
+    }
+
+    @Test
+    public void testCheckFullHouseTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkFullHouse(test));
+
+    }
+
+    @Test
+    public void testCheckLargeStraightFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkLargeStraight(test));
+
+    }
+
+    @Test
+    public void testCheckLargeStraightTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(1);
+        test.add(5);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkLargeStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightTrue1() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(5);
+        test.add(2);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightTrue2() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(1);
+        test.add(3);
+        test.add(6);
+        test.add(2);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightTrue3() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(1);
+        test.add(3);
+        test.add(5);
+        test.add(6);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testScoreNumbers() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        int expected = 6;
+
+        //When
+        int actual = scoreSheet.scoreNumbers(test, 2);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testScoreTotalDice() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        int expected = 12;
+
+        //When
+        int actual = scoreSheet.scoreTotalDice(test);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
 }