upate

MathUtilities.ctxt

 comment24.params=multiplicand\ multiplier
 comment24.target=java.lang.Double\ multiply(double,\ double)
 comment24.text=\n\ @param\ multiplicand\ value\ to\ be\ multiplied\n\ @param\ multiplier\ value\ to\ multiply\ by\n\ @return\ product\ of\ `multiplicand`\ by\ `multiplier`\n
-comment25.params=
-comment25.target=java.lang.Boolean\ returnTrue()
-comment25.text=\n\ @return\ true\n
-comment26.params=
-comment26.target=java.lang.Boolean\ returnFalse()
-comment26.text=\n\ @return\ false\n
 comment3.params=baseValue\ difference
 comment3.target=java.lang.Short\ add(short,\ short)
 comment3.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ add\ to\ starting\ value\n\ @return\ sum\ of\ `baseValue`\ and\ `difference`\n
 comment9.params=baseValue\ difference
 comment9.target=java.lang.Short\ subtract(short,\ short)
 comment9.text=\n\ @param\ baseValue\ \ starting\ value\n\ @param\ difference\ value\ to\ subtract\ from\ starting\ value\n\ @return\ difference\ between\ `baseValue`\ and\ `difference`\n
-numComments=27
+numComments=25

MathUtilities.java

     public Double multiply(double multiplicand, double multiplier) {
         return null;
     }
-
-
-    /**
-      * @return true
-     */
-    public Boolean returnTrue() {
-        return null;
-    }
-
-    /**
-     * @return false
-     */
-    public Boolean returnFalse() {
-        return null;
-    }
-
 }

MathUtilitiesTest.ctxt

-#BlueJ class context
-comment0.target=MathUtilitiesTest
-comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
-comment1.params=
-comment1.target=void\ testAdditions()
-comment10.params=
-comment10.target=void\ testSubtractions3()
-comment11.params=
-comment11.target=void\ testSubtractions4()
-comment12.params=
-comment12.target=void\ testSubtractions5()
-comment13.params=
-comment13.target=void\ testDivision()
-comment14.params=
-comment14.target=void\ testDivision1()
-comment15.params=
-comment15.target=void\ testDivision2()
-comment16.params=
-comment16.target=void\ testDivision3()
-comment17.params=
-comment17.target=void\ testDivision4()
-comment18.params=
-comment18.target=void\ testDivision5()
-comment19.params=
-comment19.target=void\ testMultiplication()
-comment2.params=
-comment2.target=void\ testAdditions1()
-comment20.params=
-comment20.target=void\ testMultiplication1()
-comment21.params=
-comment21.target=void\ testMultiplication2()
-comment22.params=
-comment22.target=void\ testMultiplication3()
-comment23.params=
-comment23.target=void\ testMultiplication4()
-comment24.params=
-comment24.target=void\ testMultiplication5()
-comment25.params=
-comment25.target=void\ testReturnTrue()
-comment26.params=
-comment26.target=void\ testReturnFalse()
-comment3.params=
-comment3.target=void\ testAdditions2()
-comment4.params=
-comment4.target=void\ testAdditions4()
-comment5.params=
-comment5.target=void\ testAdditions5()
-comment6.params=
-comment6.target=void\ testAdditions6()
-comment7.params=
-comment7.target=void\ testSubtractions()
-comment8.params=
-comment8.target=void\ testSubtractions1()
-comment9.params=
-comment9.target=void\ testSubtractions2()
-numComments=27

MathUtilitiesTest.java

- 
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-/**
- * Created by dan on 6/14/17.
- */
-public class MathUtilitiesTest {
-    private static volatile MathUtilities primativeTypes = new MathUtilities();
-
-    @Test
-    public void testAdditions() {
-        // : Given
-        int baseValue = 20;
-        int addedValue = 7;
-        int expected = 27;
-        // : When
-        int actual = primativeTypes.add(baseValue, addedValue);
-        // : Then
-        assertEquals(expected,actual);
-    }
-    @Test
-    public void testAdditions1() {
-        // : Given
-        long baseValue = 228437266;
-        long difference = 228437265;
-        long expected = 456874531;
-        // : When
-        long actual = primativeTypes.add(baseValue, difference);
-        // : Then
-        assertEquals(expected,actual);
-    }
-    @Test
-    public void testAdditions2() {
-        // : Given
-        short baseValue = 16384;
-        short addedValue = 7;
-        short expected = 16391;
-        // : When
-        short actual = primativeTypes.add(baseValue, addedValue);
-        // : Then
-        assertEquals(expected,actual);
-    }
-
-    @Test
-    public void testAdditions4() {
-        // : Given
-        byte baseValue = 63;
-        byte addedValue = 64;
-        byte expected = 127;
-        // : When
-        byte actual = primativeTypes.add(baseValue, addedValue);
-        // : Then
-        assertEquals(expected,actual);
-    }
-    @Test
-    public void testAdditions5() {
-        // : Given
-        float baseValue = 750.585F;
-        float addedValue = 795.000F;
-        float expected = 1545.585F;
-        // : When
-        float actual = primativeTypes.add(baseValue, addedValue);
-        // : Then
-        assertEquals(expected,actual, 0);
-    }
-
-    @Test
-    public void testAdditions6() {
-        // : Given
-        double baseValue = 225.25;
-        double addedValue = 231;
-        double expected = 456.25;
-        // : When
-        double actual = primativeTypes.add(baseValue,addedValue);
-        // : Then
-        assertEquals(expected,actual, 0);
-    }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    @Test
-    public void testSubtractions(){
-        // : Given
-        int baseValue = 20;
-        int difference = 7;
-        int expectedInt = 13;
-        // : When
-        int actualInt = primativeTypes.subtract(baseValue,difference);
-        // : Then
-        assertEquals(expectedInt,actualInt);
-    }
-    @Test
-    public void testSubtractions1() {
-        // : Given
-        long baseValue = 228437266;
-        long difference = 228437265;
-        long expectedLong = 1;
-        // : When
-        long actualLong = primativeTypes.subtract(baseValue, difference);
-        // : Then
-        assertEquals(expectedLong,actualLong);
-    }
-    @Test
-    public void testSubtractions2() {
-        // : Given
-        short baseValue = 16384;
-        short difference = 16383;
-        short expectedShort = 1;
-        // : When
-        short actualShort = primativeTypes.subtract(baseValue, difference);
-        // : Then
-        assertEquals(expectedShort,actualShort);
-    }
-    @Test
-    public void testSubtractions3() {
-        // : Given
-        byte baseValue = 63;
-        byte difference = 64;
-        byte expectedByte = -1;
-        // : When
-        byte actualByte = primativeTypes.subtract(baseValue, difference);
-        // : Then
-        assertEquals(expectedByte,actualByte);
-    }
-    @Test
-    public void testSubtractions4() {
-        // : Given
-        float baseValue = 750.585F;
-        float difference = 795.0F;
-        float expectedFloat = -44.415F;
-        // : When
-        float actualFloat = primativeTypes.subtract(baseValue,difference);
-        // : Then
-        assertEquals(expectedFloat,actualFloat, 0.005);
-    }
-    @Test
-    public void testSubtractions5() {
-        // : Given
-        double baseValue = 225.25;
-        double difference = 231;
-        double expectedDouble = -5.75;
-        // : When
-        double actualDouble = primativeTypes.subtract(baseValue, difference);
-        // : Then
-        assertEquals(expectedDouble,actualDouble, 0);
-    }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    @Test
-    public void testDivision(){
-        // : Given
-        int dividend = 20;
-        int divisor = 2;
-        int expectedInt = 10;
-        // : When
-        int actualInt = primativeTypes.divide(dividend, divisor);
-        // : Then
-        assertEquals(expectedInt,actualInt);
-    }
-    @Test
-    public void testDivision1() {
-        // : Given
-        int dividend = 20000000;
-        int divisor = 1000;
-        long expectedLong = 20000;
-        // : When
-        long actualLong = primativeTypes.divide(dividend, divisor);
-        // : Then
-        assertEquals(expectedLong,actualLong);
-    }
-    @Test
-    public void testDivision2() {
-        // : Given
-        short dividend = 2;
-        short divisor = 1;
-        short expectedShort = 2;
-        // : When
-        short actualShort = primativeTypes.divide(dividend, divisor);
-        // : Then
-        assertEquals(expectedShort,actualShort);
-
-    }
-    @Test
-    public void testDivision3() {
-        // : Given
-        byte dividend = 64;
-        byte divisor = 32;
-        byte expectedByte = 2;
-        // : When
-        byte actualByte = primativeTypes.divide(dividend, divisor);
-        // : Then
-        assertEquals(expectedByte,actualByte);
-    }
-    @Test
-    public void testDivision4() {
-        // : Given
-        float dividend = 7.5F;
-        float divisor = 3;
-        float expectedFloat = 2.50F;
-        // : When
-        float actualFloat = primativeTypes.divide(dividend,divisor);
-        // : Then
-        assertEquals(expectedFloat,actualFloat, 0);
-    }
-    @Test
-    public void testDivision5() {
-        // : Given
-        double dividend = 5.0;
-        double divisor = 4.0;
-        double expectedDouble = 1.25;
-        // : When
-        double actualDouble = primativeTypes.divide(dividend,divisor);
-        // : Then
-        assertEquals(expectedDouble,actualDouble, 0);
-    }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    @Test
-    public void testMultiplication(){
-        // : Given
-        int multiplicand = 5;
-        int multiplier = 2;
-        int expectedInt = 10;
-        // : When
-        int actualInt = primativeTypes.multiply(multiplicand,multiplier);
-        // : Then
-        assertEquals(expectedInt,actualInt);
-    }
-    @Test
-    public void testMultiplication1() {
-        // : Given
-        long multiplicand = 20;
-        long multiplier = 1000;
-        long expectedLong = 20000;
-        // : When
-        long actualLong = primativeTypes.multiply(multiplicand, multiplier);
-        // : Then
-        assertEquals(expectedLong, actualLong);
-    }
-    @Test
-    public void testMultiplication2() {
-        // : Given
-        short multiplicand = 2;
-        short multiplier = 1;
-        short expectedShort = 2;
-        // : When
-        short actualShort = primativeTypes.multiply(multiplicand, multiplier);
-        // : Then
-        assertEquals(expectedShort, actualShort);
-    }
-    @Test
-    public void testMultiplication3() {
-        // : Given
-        byte multiplicand = 16;
-        byte multiplier = 4;
-        byte expectedByte = 64;
-        // : When
-        byte actualByte = primativeTypes.multiply(multiplicand, multiplier);
-        // : Then
-        assertEquals(expectedByte, actualByte);
-    }
-    @Test
-    public void testMultiplication4() {
-        // : Given
-        float multiplicand = 2.5F;
-        float multiplier = 1;
-        float expectedFloat = 2.50F;
-        // : When
-        float actualFloat =  primativeTypes.multiply(multiplicand,multiplier);
-        // : Then
-        assertEquals(expectedFloat, actualFloat, 0);
-    }
-    @Test
-    public void testMultiplication5() {
-        // : Given
-        double multiplicand = 3.25;
-        double multiplier = 3.0;
-        double expectedDouble = 9.75;
-        // : When
-        double actualDouble = primativeTypes.multiply(multiplicand,multiplier);
-        // : Then
-        assertEquals(expectedDouble, actualDouble, 0);
-    }
-
-    @Test
-    public void testReturnTrue(){
-        // : Given
-        // : When
-        // : Then
-        assertTrue(primativeTypes.returnTrue());
-    }
-
-    @Test
-    public void testReturnFalse(){
-        // : Given
-        // : When
-        // : Then
-        assertFalse(primativeTypes.returnFalse());
-    }
-
-}

PredicateUtilities.ctxt

 comment4.params=x\ y
 comment4.target=java.lang.Boolean\ isLessThanOrEqualTo(int,\ int)
 comment4.text=\n\ @param\ x\n\ @param\ y\n\ @return\ true\ if\ `x`\ is\ less\ than\ or\ equal\ to\ `y`\n
-numComments=5
+comment5.params=
+comment5.target=java.lang.Boolean\ returnTrue()
+comment5.text=\n\ @return\ true\n
+comment6.params=
+comment6.target=java.lang.Boolean\ returnFalse()
+comment6.text=\n\ @return\ false\n
+numComments=7

PredicateUtilities.java

     public Boolean isLessThanOrEqualTo(int x, int y) {
         return null;
     }
+    
+    
+       /**
+      * @return true
+     */
+    public Boolean returnTrue() {
+        return null;
+    }
+
+    /**
+     * @return false
+     */
+    public Boolean returnFalse() {
+        return null;
+    }
 }

PredicateUtilitiesTest.ctxt

 comment0.text=\n\ Created\ by\ dan\ on\ 6/14/17.\n
 comment1.params=
 comment1.target=void\ testGreaterThanTrue()
+comment10.params=
+comment10.target=void\ testReturnFalse()
 comment2.params=
 comment2.target=void\ testGreaterThanFalse()
 comment3.params=
 comment7.target=void\ testGreaterOrEqual1()
 comment8.params=
 comment8.target=void\ testGreaterOrEqual2()
-numComments=9
+comment9.params=
+comment9.target=void\ testReturnTrue()
+numComments=11

PredicateUtilitiesTest.java

  * Created by dan on 6/14/17.
  */
 public class PredicateUtilitiesTest {
-    private static volatile PredicateUtilities math = new PredicateUtilities();
+    private static volatile PredicateUtilities predicateUtils = new PredicateUtilities();
 
     @Test
     public void testGreaterThanTrue() {
 
 
         // : When
-        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isGreaterThan(greaterValue, lesserValue);
 
         // : Then
         assertTrue(outcome);
         int lesserValue = 350;
 
         // : When
-        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isGreaterThan(greaterValue, lesserValue);
 
         // : Then
         assertFalse(outcome);
         int lesserValue = 350;
 
         // : When
-        boolean outcome = math.isLessThan(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isLessThan(greaterValue, lesserValue);
 
         // : Then
         assertFalse(outcome);
         int lesserValue = 350;
 
         // : When
-        boolean outcome = math.isLessThan(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isLessThan(greaterValue, lesserValue);
 
         // : Then
         assertFalse(outcome);
         int lesserValue = 3;
 
         // : When
-        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isLessThanOrEqualTo(greaterValue, lesserValue);
 
         // : Then
         assertTrue(outcome);
         int lesserValue = 6;
 
         // : When
-        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isLessThanOrEqualTo(greaterValue, lesserValue);
 
         // : Then
         assertTrue(outcome);
         int lesserValue = 4;
 
         // : When
-        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isGreaterThanOrEqualTo(greaterValue, lesserValue);
 
         // : ThenP
         assertTrue(outcome);
         int lesserValue = 15;
 
         // : When
-        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
+        boolean outcome = predicateUtils.isGreaterThanOrEqualTo(greaterValue, lesserValue);
 
         // : Then
         assertFalse(outcome);
     }
+    
+    @Test
+    public void testReturnTrue() {
+        assertTrue(predicateUtils.returnTrue());
+    }
+    
+    
+    @Test
+    public void testReturnFalse() {
+        assertFalse(predicateUtils.returnFalse());
+    }
 }

TestAddition.ctxt

+#BlueJ class context
+comment0.target=TestAddition
+comment0.text=\n\ @author\ leon\ on\ 8/26/18.\n
+comment1.params=
+comment1.target=void\ testIntegerAddition()
+comment2.params=
+comment2.target=void\ testLongAddition()
+comment3.params=
+comment3.target=void\ testShortAddition()
+comment4.params=
+comment4.target=void\ testByteAddition()
+comment5.params=
+comment5.target=void\ testFloatAddition()
+comment6.params=
+comment6.target=void\ testDoubleAddition()
+numComments=7

TestAddition.java

+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author leon on 8/26/18.
+ */
+public class TestAddition {
+    private static volatile MathUtilities mathUtils = new MathUtilities();
+
+    @Test
+    public void testIntegerAddition() {
+        // : Given
+        int baseValue = 20;
+        int addedValue = 7;
+        int expected = 27;
+        // : When
+        int actual = mathUtils.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testLongAddition() {
+        // : Given
+        long baseValue = 228437266;
+        long difference = 228437265;
+        long expected = 456874531;
+        // : When
+        long actual = mathUtils.add(baseValue, difference);
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testShortAddition() {
+        // : Given
+        short baseValue = 16384;
+        short addedValue = 7;
+        short expected = 16391;
+        // : When
+        short actual = mathUtils.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testByteAddition() {
+        // : Given
+        byte baseValue = 63;
+        byte addedValue = 64;
+        byte expected = 127;
+        // : When
+        byte actual = mathUtils.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testFloatAddition() {
+        // : Given
+        float baseValue = 750.585F;
+        float addedValue = 795.000F;
+        float expected = 1545.585F;
+        // : When
+        float actual = mathUtils.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected, actual, 0);
+    }
+
+    @Test
+    public void testDoubleAddition() {
+        // : Given
+        double baseValue = 225.25;
+        double addedValue = 231;
+        double expected = 456.25;
+        // : When
+        double actual = mathUtils.add(baseValue, addedValue);
+        // : Then
+        assertEquals(expected, actual, 0);
+    }
+
+
+}

TestDivision.ctxt

+#BlueJ class context
+comment0.target=TestDivision
+comment0.text=\n\ @author\ leon\ on\ 8/26/18.\n
+comment1.params=
+comment1.target=void\ testIntegerDivision()
+comment2.params=
+comment2.target=void\ testLongDivision()
+comment3.params=
+comment3.target=void\ testShortDivision()
+comment4.params=
+comment4.target=void\ testByteDivision()
+comment5.params=
+comment5.target=void\ testFloatDivision()
+comment6.params=
+comment6.target=void\ testDoubleDivision()
+numComments=7

TestDivision.java

+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author leon on 8/26/18.
+ */
+public class TestDivision {
+    private static volatile MathUtilities mathUtils = new MathUtilities();
+
+
+    @Test
+    public void testIntegerDivision() {
+        // : Given
+        int dividend = 20;
+        int divisor = 2;
+        int expectedInt = 10;
+        // : When
+        int actualInt = mathUtils.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedInt, actualInt);
+    }
+
+    @Test
+    public void testLongDivision() {
+        // : Given
+        long dividend = 20000000L;
+        long divisor = 1000L;
+        long expectedLong = 20000;
+        // : When
+        long actualLong = mathUtils.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedLong, actualLong);
+    }
+
+    @Test
+    public void testShortDivision() {
+        // : Given
+        short dividend = 2;
+        short divisor = 1;
+        short expectedShort = 2;
+        // : When
+        short actualShort = mathUtils.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedShort, actualShort);
+
+    }
+
+    @Test
+    public void testByteDivision() {
+        // : Given
+        byte dividend = 64;
+        byte divisor = 32;
+        byte expectedByte = 2;
+        // : When
+        byte actualByte = mathUtils.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedByte, actualByte);
+    }
+
+    @Test
+    public void testFloatDivision() {
+        // : Given
+        float dividend = 7.5F;
+        float divisor = 3;
+        float expectedFloat = 2.50F;
+        // : When
+        float actualFloat = mathUtils.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedFloat, actualFloat, 0);
+    }
+
+    @Test
+    public void testDoubleDivision() {
+        // : Given
+        double dividend = 5.0;
+        double divisor = 4.0;
+        double expectedDouble = 1.25;
+        // : When
+        double actualDouble = mathUtils.divide(dividend, divisor);
+        // : Then
+        assertEquals(expectedDouble, actualDouble, 0);
+    }
+
+
+}

TestMultiplication.ctxt

+#BlueJ class context
+comment0.target=TestMultiplication
+comment0.text=\n\ @author\ leon\ on\ 8/26/18.\n
+comment1.params=
+comment1.target=void\ testIntegerMultiplication()
+comment2.params=
+comment2.target=void\ testLongMultiplication()
+comment3.params=
+comment3.target=void\ testShortMultiplication()
+comment4.params=
+comment4.target=void\ testByteMultiplication()
+comment5.params=
+comment5.target=void\ testFloatMultiplication()
+comment6.params=
+comment6.target=void\ testDoubleMultiplication()
+numComments=7

TestMultiplication.java

+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author leon on 8/26/18.
+ */
+public class TestMultiplication {
+
+    private static volatile MathUtilities mathUtils = new MathUtilities();
+
+
+    @Test
+    public void testIntegerMultiplication(){
+        // : Given
+        int multiplicand = 5;
+        int multiplier = 2;
+        int expectedInt = 10;
+        // : When
+        int actualInt = mathUtils.multiply(multiplicand,multiplier);
+        // : Then
+        assertEquals(expectedInt,actualInt);
+    }
+    @Test
+    public void testLongMultiplication() {
+        // : Given
+        long multiplicand = 20;
+        long multiplier = 1000;
+        long expectedLong = 20000;
+        // : When
+        long actualLong = mathUtils.multiply(multiplicand, multiplier);
+        // : Then
+        assertEquals(expectedLong, actualLong);
+    }
+    @Test
+    public void testShortMultiplication() {
+        // : Given
+        short multiplicand = 2;
+        short multiplier = 1;
+        short expectedShort = 2;
+        // : When
+        short actualShort = mathUtils.multiply(multiplicand, multiplier);
+        // : Then
+        assertEquals(expectedShort, actualShort);
+    }
+    @Test
+    public void testByteMultiplication() {
+        // : Given
+        byte multiplicand = 16;
+        byte multiplier = 14;
+        byte expectedByte = 64;
+        // : When
+        byte actualByte = mathUtils.multiply(multiplicand, multiplier);
+        // : Then
+        assertEquals(expectedByte, actualByte);
+    }
+    @Test
+    public void testFloatMultiplication() {
+        // : Given
+        float multiplicand = 2.5F;
+        float multiplier = 1;
+        float expectedFloat = 2.50F;
+        // : When
+        float actualFloat =  mathUtils.multiply(multiplicand,multiplier);
+        // : Then
+        assertEquals(expectedFloat, actualFloat, 0);
+    }
+    @Test
+    public void testDoubleMultiplication() {
+        // : Given
+        double multiplicand = 3.25;
+        double multiplier = 3.0;
+        double expectedDouble = 9.75;
+        // : When
+        double actualDouble = mathUtils.multiply(multiplicand,multiplier);
+        // : Then
+        assertEquals(expectedDouble, actualDouble, 0);
+    }
+}

TestSubtraction.ctxt

+#BlueJ class context
+comment0.target=TestSubtraction
+comment0.text=\n\ @author\ leon\ on\ 8/26/18.\n
+comment1.params=
+comment1.target=void\ testIntegerSubtraction()
+comment2.params=
+comment2.target=void\ testLongSubtraction()
+comment3.params=
+comment3.target=void\ testShortSubtraction()
+comment4.params=
+comment4.target=void\ testByteSubtraction()
+comment5.params=
+comment5.target=void\ testFloatSubtraction()
+comment6.params=
+comment6.target=void\ testDoubleSubtraction()
+numComments=7

TestSubtraction.java

+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author leon on 8/26/18.
+ */
+public class TestSubtraction {
+    private static volatile MathUtilities mathUtils = new MathUtilities();
+
+
+    @Test
+    public void testIntegerSubtraction(){
+        // : Given
+        int baseValue = 20;
+        int difference = 7;
+        int expectedInt = 13;
+        // : When
+        int actualInt = mathUtils.subtract(baseValue,difference);
+        // : Then
+        assertEquals(expectedInt,actualInt);
+    }
+    @Test
+    public void testLongSubtraction() {
+        // : Given
+        long baseValue = 228437266;
+        long difference = 228437265;
+        long expectedLong = 1;
+        // : When
+        long actualLong = mathUtils.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedLong,actualLong);
+    }
+    @Test
+    public void testShortSubtraction() {
+        // : Given
+        short baseValue = 16384;
+        short difference = 16383;
+        short expectedShort = 1;
+        // : When
+        short actualShort = mathUtils.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedShort,actualShort);
+    }
+    @Test
+    public void testByteSubtraction() {
+        // : Given
+        byte baseValue = 63;
+        byte difference = 64;
+        byte expectedByte = -1;
+        // : When
+        byte actualByte = mathUtils.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedByte,actualByte);
+    }
+    @Test
+    public void testFloatSubtraction() {
+        // : Given
+        float baseValue = 750.585F;
+        float difference = 795.0F;
+        float expectedFloat = -44.415F;
+        // : When
+        float actualFloat = mathUtils.subtract(baseValue,difference);
+        // : Then
+        assertEquals(expectedFloat,actualFloat, 0.005);
+    }
+    @Test
+    public void testDoubleSubtraction() {
+        // : Given
+        double baseValue = 225.25;
+        double difference = 231;
+        double expectedDouble = -5.75;
+        // : When
+        double actualDouble = mathUtils.subtract(baseValue, difference);
+        // : Then
+        assertEquals(expectedDouble,actualDouble, 0);
+    }
+
+
+}

package.bluej

 editor.fx.0.x=0
 editor.fx.0.y=0
 objectbench.height=129
-objectbench.width=1171
-package.divider.horizontal=0.6
-package.divider.vertical=0.7490774907749077
-package.editor.height=399
-package.editor.width=1069
-package.editor.x=59
-package.editor.y=63
-package.frame.height=600
-package.frame.width=1195
+objectbench.width=531
+package.divider.horizontal=0.6397146254458977
+package.divider.vertical=0.8697318007662835
+package.editor.height=901
+package.editor.width=727
+package.editor.x=1440
+package.editor.y=0
+package.frame.height=1080
+package.frame.width=861
 package.numDependencies=0
 package.numTargets=6
 package.showExtends=true
 target1.name=PredicateUtilities
 target1.showInterface=false
 target1.type=ClassTarget
+target1.typeParameters=
 target1.width=130
 target1.x=280
 target1.y=120
 target2.name=StringUtilitiesTest
 target2.showInterface=false
 target2.type=UnitTestTargetJunit4
+target2.typeParameters=
 target2.width=140
 target2.x=490
 target2.y=70
 target3.name=MathUtilities
 target3.showInterface=false
 target3.type=ClassTarget
+target3.typeParameters=
 target3.width=100
 target3.x=60
 target3.y=150
 target4.height=50
-target4.name=StringUtilities
+target4.name=PredicateUtilitiesTest
 target4.showInterface=false
-target4.type=ClassTarget
-target4.width=110
-target4.x=500
-target4.y=130
+target4.type=UnitTestTargetJunit4
+target4.typeParameters=
+target4.width=160
+target4.x=260
+target4.y=50
 target5.height=50
-target5.name=PredicateUtilitiesTest
+target5.name=StringUtilities
 target5.showInterface=false
-target5.type=UnitTestTargetJunit4
-target5.width=160
-target5.x=260
-target5.y=50
+target5.type=ClassTarget
+target5.typeParameters=
+target5.width=110
+target5.x=500
+target5.y=130
 target6.height=50
 target6.name=MathUtilitiesTest
 target6.showInterface=false
 target6.type=UnitTestTargetJunit4
+target6.typeParameters=
 target6.width=130
 target6.x=50
 target6.y=90