dicey

README.md

@@ -1,23 +1,23 @@
-# Kris-Tof Dice Toss
+# Kris-Tof Bedolla.Jose.Dice Toss
 
-Create a `Dice` class that acts like a set of N random-tossed dies.
+Create a `Bedolla.Jose.Dice` class that acts like a set of N random-tossed dies.
 ```
-Dice dice = new Dice(2); // for craps
-Dice dice = new Dice(5); // for yatzee
+Bedolla.Jose.Dice dice = new Bedolla.Jose.Dice(2); // for craps
+Bedolla.Jose.Dice dice = new Bedolla.Jose.Dice(5); // for yatzee
 
 Integer toss = dice.tossAndSum();
 ```
-make a couple unit tests for the Dice class. 
+make a couple unit tests for the Bedolla.Jose.Dice class. 
 
-Create a tracking class `Bins` that can be used to track the results of dice tosses.
+Create a tracking class `Bedolla.Jose.Bins` that can be used to track the results of dice tosses.
 
 ```
-Bins results = new Bins(2, 12); // for bins from 2..12
+Bedolla.Jose.Bins results = new Bedolla.Jose.Bins(2, 12); // for bins from 2..12
 Integer numberOfTens = results.getBin(10); // returns the number of tens in the 10 bin
 results.incrementBin(10); // should increment bin # 10
 
 ```
-make a couple unit tests for the Bins class. Your test methods should follow this template:
+make a couple unit tests for the Bedolla.Jose.Bins class. Your test methods should follow this template:
 
     in the tests
     Create a new Bin
@@ -27,7 +27,7 @@ make a couple unit tests for the Bins class. Your test methods should follow thi
     
     
 
-Create a `Simulation` class whose Constructor takes arguments:
+Create a `Bedolla.Jose.Simulation` class whose Constructor takes arguments:
     numberOfDies to throw
     numberOfTosses to run
 
@@ -35,7 +35,7 @@ Create a simulation where two dies are thrown *one million times*.
 Keep track of each roll by incrementing the correct Bin.
 
 ```
-Simulation sim = new Simulation(2, 10000);
+Bedolla.Jose.Simulation sim = new Bedolla.Jose.Simulation(2, 10000);
 
 sim.runSimulation();
 
@@ -53,7 +53,7 @@ the results of the sim.printResults() should be an output string that looks like
 
 ```
 ***
-Simulation of 2 dice tossed for 1000000 times.
+Bedolla.Jose.Simulation of 2 dice tossed for 1000000 times.
 ***
 
  2 :    27917: 0.03 **

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.10</version>
+            <scope>test</scope>
+        </dependency>
+
+</dependencies>
 
 </project>

src/Test/java/Bedolla/Jose/BinsTest.java

@@ -0,0 +1,37 @@
+package Bedolla.Jose;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+
+public class BinsTest {
+
+    @Test
+    public void constructorTest()
+    {
+        Bins bin =  new Bins(2,12);
+
+        Integer actual = bin.bins.get(12);
+
+        Assert.assertTrue(actual==0);
+    }
+
+    @Test
+    public void trackTossTest()
+    {
+        //given
+        Bins bin = new Bins(2,12);
+
+        Dice dice = new Dice(2);
+        Integer tossSum = dice.tossAndSUM();
+        bin.trackToss(tossSum);
+        //when
+
+        Integer actual = bin.bins.get(tossSum);
+
+        //then
+        Assert.assertTrue(actual==1);
+
+    }
+}

src/Test/java/Bedolla/Jose/DiceTest.java

@@ -0,0 +1,32 @@
+package Bedolla.Jose;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DiceTest {
+
+
+    @Test
+    public void getNumberOfDice()
+    {
+        //given
+        Dice dice = new Dice(2);
+
+        Integer expected = 2;
+
+        Integer actual = dice.getNumOfDice();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void tossAndSumTest()
+    {
+        Dice dice = new Dice(2);
+
+        Integer actual = dice.tossAndSUM();
+
+        Assert.assertTrue(actual >= 2 && actual <= 12);
+
+    }
+}

src/Test/java/Bedolla/Jose/LocalTest.java

@@ -0,0 +1,28 @@
+package Bedolla.Jose;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LocalTest {
+
+    @Test
+    public void rollTest()
+    {
+        //given
+        Local die = new Local();
+        //when
+        int actual = die.toss();
+        //then
+        Assert.assertTrue(actual>=1 && actual<=6);
+    }
+    @Test
+    public void rollTest2()
+    {
+
+        //given
+        Local die = new Local();
+        //when
+        int actual = die.toss();
+        //then
+        Assert.assertTrue(actual>=1 && actual<=20);
+    }
+}

src/Test/java/Bedolla/Jose/SimulationTest.java

@@ -0,0 +1,13 @@
+package Bedolla.Jose;
+
+import org.junit.Test;
+
+public class SimulationTest {
+    @Test
+    public void runSimulation()
+    {
+        Simulation simu = new Simulation(2,100);
+        simu.runSimulation();
+    }
+
+}

src/main/java/Bedolla/Jose/Bins.java

@@ -0,0 +1,27 @@
+package Bedolla.Jose;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Bins {
+
+    HashMap<Integer,Integer> bins;
+
+    public Bins(Integer min, Integer max) {
+        bins = new HashMap<Integer, Integer>();
+        initializeBins(min,max);
+    }
+
+    private void initializeBins(Integer min, Integer max)
+    {
+     for(int i= min; i <= max; i++)
+        {
+         bins.put(i,0);
+        }
+    }
+
+    public void trackToss(int tossSum)
+    {
+       bins.put(tossSum,bins.get(tossSum)+1);
+    }
+}

src/main/java/Bedolla/Jose/Dice.java

@@ -0,0 +1,39 @@
+package Bedolla.Jose;
+
+import java.util.ArrayList;
+
+public class Dice {
+
+    ArrayList<Local> dice;
+
+    public Dice(Integer numberOfD) {
+
+        dice = new ArrayList<Local>();
+        initializeD(numberOfD);
+    }
+
+    private void initializeD(Integer number )
+    {
+        for(int i =0; i <number; i++)
+        {
+            Local die = new Local();
+            dice.add(die);
+        }
+    }
+
+    public Integer getNumOfDice()
+    {
+        return dice.size();
+    }
+
+    public Integer tossAndSUM()
+    {
+        Integer sum = 0;
+        for(Local d: dice)
+        {
+
+            sum+=d.toss();
+        }
+        return sum;
+    }
+}

src/main/java/Bedolla/Jose/Local.java

@@ -0,0 +1,24 @@
+package Bedolla.Jose;
+
+import java.util.Random;
+
+public class Local {
+    int side;
+
+    public Local(int side) {
+        this.side=side;
+    }
+
+    public Local()
+    {
+        this(6);
+    }
+
+    public Integer toss()
+    {
+
+        Random random = new Random();
+        return random.nextInt(6)+1;
+    }
+
+}

src/main/java/Bedolla/Jose/Main.java

@@ -0,0 +1,10 @@
+package Bedolla.Jose;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Simulation simu = new Simulation(2,1000000000);
+        simu.runSimulation();
+        System.out.println(simu.bin.bins);
+    }
+}

src/main/java/Bedolla/Jose/Simulation.java

@@ -0,0 +1,34 @@
+package Bedolla.Jose;
+
+public class Simulation {
+
+    int numberOfDies;
+    int numberOfTosses;
+    Dice dice;
+    public Bins bin;
+
+    public Simulation(int numberOfDies, int numberOfTosses)
+    {
+    this.numberOfDies = numberOfDies;
+    this.numberOfTosses = numberOfTosses;
+    this.dice = new Dice(numberOfDies);
+    this.bin =  new Bins(numberOfDies,numberOfDies*6);
+    }
+
+    public void runSimulation()
+    {
+
+        for(int i =0; i< numberOfTosses; i++)
+        {
+            bin.trackToss(dice.tossAndSUM());
+        }
+    }
+
+    public Bins returnResults()
+    {
+        return this.bin;
+    }
+
+
+
+    }

src/main/java/Bins.java

@@ -1,4 +0,0 @@
-
-public class Bins {
-
-}

src/main/java/Dice.java

@@ -1,4 +0,0 @@
-public class Dice {
-
-
-}

src/main/java/Simulation.java

@@ -1,5 +0,0 @@
-public class Simulation {
-
-
-
-}