completed dicey lab

pom.xml

@@ -8,5 +8,15 @@
     <artifactId>Dicey-Lab</artifactId>
     <version>1.0-SNAPSHOT</version>
 
+    <dependencies>
+        <!-- https://mvnrepository.com/artifact/junit/junit -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
 
 </project>

src/main/java/Bins.java

@@ -1,4 +1,31 @@
-
 public class Bins {
 
-}
+    //array to store the results of the dice rolls
+    private int[] result;
+    //amount of dice whos results are being stored in this bin
+    private int amount;
+    //the amount of sides on the dice
+    private int sides;
+
+    public Bins(int amount, int sides){
+        this.amount = amount;
+        this.sides = sides;
+        this.result = new int[((this.amount * this.sides) - (amount - 1))];
+    }
+
+    //mutator function to manipulate the results from the dice rolls
+    public void addToBin(int resultGiven){
+        this.result[(resultGiven - this.amount)] ++;
+    }
+
+    //accessor function to retrieve the amount of a given result
+    public int retrieveSums(int resultGiven){
+        return this.result[(resultGiven - this.amount)];
+    }
+
+    //accessor method to get results of the roll
+    public int[] getResults()
+    {
+        return this.result;
+    }
+}

src/main/java/Dice.java

@@ -1,4 +1,36 @@
-public class Dice {
+public class Dice
+{
+    //the amount of dice being created
+    private int amount = 0;
+    //the amount of sides the dice has
+    private int sides = 0;
 
+    public Dice(int amount, int sides)
+    {
+        this.amount = amount;
+        this.sides = sides;
+    }
 
-}
+    //method to roll the dice, and store the results in the bin
+    public int roll(){
+        //default the sum of these dice rolls to 0
+        int sum = 0;
+        //for each dice created
+        for(int i = 0; i < this.amount; i ++) {
+            //roll the dice
+            int random = (int) (Math.floor(Math.random() * this.sides) + 1);
+            //add the random number to the sum of the current roll
+            sum += random;
+        }
+        return sum;
+    }
+
+    //accessor function to access the dices sides
+    public int getSides(){
+        return this.sides;
+    }
+    //accessor function to get the dice amount;
+    public int getAmount(){
+        return this.amount;
+    }
+}

src/main/java/Main.java

@@ -0,0 +1,14 @@
+public class Main
+{
+    public static void main(String[] args)
+    {
+        //create a new simulation
+        Simulation sim = new Simulation(100, 6,100);
+
+        //run the new simulation
+        sim.runSimulation();
+
+        //print the results of simulation
+        sim.printResult();
+    }
+}

src/main/java/Simulation.java

@@ -1,5 +1,51 @@
+import java.math.RoundingMode;
+import java.math.BigDecimal;
+
 public class Simulation {
 
+    private Dice dice;
+    private Bins bin;
+    private int rolls = 0;
+
+    public Simulation(int numberOfDice, int diceSides, int timesROlled){
+        this.dice = new Dice(numberOfDice, diceSides);
+        this.bin = new Bins(numberOfDice, diceSides);
+        this.rolls = timesROlled;
+    }
+
+    public static double round(double value, int places) {
+        if (places < 0) throw new IllegalArgumentException();
+
+        BigDecimal bd = new BigDecimal(value);
+        bd = bd.setScale(places, RoundingMode.HALF_UP);
+        return bd.doubleValue();
+    }
 
+    //method to run the dice simulation
+    public void runSimulation()
+    {
+        //for each amount of time we roll
+        for(int i = 0; i < this.rolls; i ++){
+            //roll the dice and store the values
+            int sum = this.dice.roll();
+            //store the sum in the bin
+            bin.addToBin(sum);
+        }
+    }
 
+    //method to print the results of the roll
+    public void printResult(){
+        //store the results of the bin
+        int[] results = this.bin.getResults();
+        //loop through the bin
+        for(int i = 0; i < this.bin.getResults().length; i ++)
+        {
+            //for each value in the bin
+            int currentResult = this.bin.getResults()[i];
+            //get the statistics
+            double stats = ((double)currentResult/(double)this.rolls);
+            stats = round(stats, 2);
+            System.out.println("index of the array: " +i + " | value rolled : " + (i + this.dice.getAmount()) + " | amount of times this value was rolled: " + currentResult + " | percent : " + stats);
+        }
+    }
 }

src/test/java/TestClass.java

@@ -0,0 +1,170 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestClass {
+
+    //BIN TESTING
+
+    @Test
+    public void test01()
+    {
+        //GIVEN
+        //initialize the amount of rolls to 100;
+        int rollAmount = 100;
+        //create a new dice to test the bin;
+        Dice dice = new Dice(1, 6);
+        //create a new bin to test
+        Bins bin = new Bins(1, 6);
+        boolean expted = true;
+        boolean actual = false;
+        int counter = 0;
+
+        //WHEN
+        //loop one headred times
+        for(int i = 0; i < rollAmount; i++)
+        {
+            //create a new random number between 1 and 6 each time
+            int random = (int) (Math.floor(Math.random() * 6) + 1);
+            //add it to the bin to test addToBin
+            bin.addToBin(random);
+        }
+        //loop for each result in the bin // testing getResults();
+        for(int m = 0; m < bin.getResults().length; m++)
+        {
+            //store the current result
+            int binresult = bin.getResults()[m];
+            //if the result is not a negative number, and all results are less than
+            //the max amount of results
+            if(binresult >= 0 && binresult < 100)
+            {
+                //increase the counter
+                counter ++;
+            }
+        }
+        //if the counter was increased for every iteration
+        if(counter == bin.getResults().length)
+        {
+            //then pass the test
+            actual = true;
+        }
+        Assert.assertEquals(expted, actual);
+    }
+
+    //DICE TESTING
+
+    @Test
+    public void test02() {
+        //GIVEN
+        //amount of times rolling
+        int rollAmount = 100;
+        //amount of dice being rolled
+        int amountOfDice = 3;
+        //sum of the dice roll
+        int sum = 0;
+        //dice to be rolled
+        Dice dice = new Dice(amountOfDice, 6);
+        //bin results will be stored in
+        Bins bin = new Bins(amountOfDice, 6);
+        //result to pass the test
+        boolean expected = true;
+        //default result
+        boolean result = false;
+
+        //WHEN
+        //perform 100 rolls, testing every roll
+        for(int i = 0; i < rollAmount; i ++)
+        {
+            //reset the sum each time it is rolled
+            sum = 0;
+            //roll the dice and collect the sum
+            sum = dice.roll();
+            //check if the roll is between the correct numbers
+            bin.addToBin(sum);
+            if(sum >= 3 && sum <= 18)
+            {
+                result = true;
+
+            }
+        }
+
+        //RESULT
+        Assert.assertEquals(expected, result);
+    }
+
+    @Test
+    public void test03() {
+        //GIVEN
+        //amount of times rolling
+        int rollAmount = 100;
+        //amount of dice being rolled
+        int amountOfDice = 100;
+        //sum of the dice roll
+        int sum = 0;
+        //dice to be rolled
+        Dice dice = new Dice(amountOfDice, 6);
+        //bin results will be stored in
+        Bins bin = new Bins(amountOfDice, 6);
+        //result to pass the test
+        boolean expected = true;
+        //default result
+        boolean result = false;
+
+        //WHEN
+        //perform 100 rolls, testing every roll
+        for(int i = 0; i < rollAmount; i ++)
+        {
+            //reset the sum each time it is rolled
+            sum = 0;
+            //roll the dice and collect the sum
+            sum = dice.roll();
+            //check if the roll is between the correct numbers
+            //at least 1 for every dice, and 600 for if every dice landed 6
+            if(sum >= dice.getAmount() && sum <= 600)
+            {
+                result = true;
+            }
+        }
+
+        //RESULT
+        Assert.assertEquals(expected, result);
+    }
+
+    @Test
+    public void test04() {
+        //GIVEN
+        //amount of times rolling
+        int rollAmount = 10000;
+        //amount of dice being rolled
+        int amountOfDice = 100;
+        //sum of the dice roll
+        int sum = 0;
+        //dice to be rolled
+        Dice dice = new Dice(amountOfDice, 100);
+        //bin results will be stored in
+        Bins bin = new Bins(amountOfDice, 100);
+        //result to pass the test
+        boolean expected = true;
+        //default result
+        boolean result = false;
+
+        //WHEN
+        //perform 100 rolls, testing every roll
+        for(int i = 0; i < rollAmount; i ++)
+        {
+            //reset the sum each time it is rolled
+            sum = 0;
+            //roll the dice and collect the sum
+            sum = dice.roll();
+            //check if the roll is between the correct numbers
+            //at least 1 for every dice, and 10000 for if every dice landed 100
+            if(sum >= dice.getAmount() && sum <= 10000)
+            {
+                result = true;
+            }
+        }
+
+        //RESULT
+        Assert.assertEquals(expected, result);
+    }
+}
+