updated junit tests; MathUtilitiesTest

src/main/java/com/zipcodewilmington/danny_do_better/PrimativeTypes.java

  */
 public class PrimativeTypes {
 
-    //Add two ints and return the answer
-    public int add(int x, int y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public int add(int baseValue, int difference) {
         return 0;
     }
 
-    //Add two long's and return the answer
-    public long add(long x, long y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public long add(long baseValue, long difference) {
         return 0;
     }
 
-    //Add two short's and return the answer Must Type Cast
-    public short add(short x, short y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public short add(short baseValue, short difference) {
         return 0;
     }
-    //Add two bytes and return the answer, Must Type Cast
-    public byte add(byte x, byte y){
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public byte add(byte baseValue, byte difference) {
         return 0;
     }
 
-    //Add two floats and return the answer
-    public float add(float x, float y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public float add(float baseValue, float difference) {
         return 0;
     }
 
-    //Add two doubles and return the answer
-    public double add(double x, double y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public double add(double baseValue, double difference) {
         return 0;
     }
 
-    //Subtract two ints and return the answer
-    public int subtract(int x, int y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public int subtract(int baseValue, int difference) {
         return 0;
     }
 
-    //Subtract two long's and return the answer
-    public long subtract(long x, long y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public long subtract(long baseValue, long difference) {
         return 0;
     }
 
-    //Subtract two short's and return the answer Must Type Cast
-    public short subtract(short x, short y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public short subtract(short baseValue, short difference) {
         return 0;
     }
-    //Subtract two bytes and return the answer, Must Type Cast
-    public byte subtract(byte x, byte y){
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public byte subtract(byte baseValue, byte difference) {
         return 0;
     }
 
-    //Subtract two floats and return the answer
-    public float subtract(float x, float y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public float subtract(float baseValue, float difference) {
         return 0;
     }
 
-    //Subtract two doubles and return the answer
-    public double subtract(double x, double y){
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public double subtract(double baseValue, double difference) {
         return 0;
     }
 
-    //Divide two ints and return the answer
-    public int divide(int x, int y){
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public int divide(int dividend, int divisor) {
         return 0;
     }
 
-    //Divide two long's and return the answer
-    public long divide(long x, long y){
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public long divide(long dividend, long divisor) {
         return 0;
     }
 
-    //Divide two short's and return the answer Must Type Cast
-    public short divide(short x, short y){
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public short divide(short dividend, short divisor) {
         return 0;
     }
-    //Divide two bytes and return the answer, Must Type Cast
-    public byte divide(byte x, byte y){
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public byte divide(byte dividend, byte divisor) {
         return 0;
     }
 
-    //Divide two floats and return the answer
-    public float divide(float x, float y){
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public float divide(float dividend, float divisor) {
         return 0;
     }
 
-    //Divide two doubles and return the answer
-    public double divide(double x, double y){
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public double divide(double dividend, double divisor) {
         return 0;
     }
 
-    //Multiply two ints and return the answer
-    public int multiply(int x, int y){
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public int multiply(int multiplicand, int multiplier) {
         return 0;
     }
 
-    //Multiply two long's and return the answer
-    public long multiply(long x, long y){
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public long multiply(long multiplicand, long multiplier) {
         return 0;
     }
 
-    //Multiply two short's and return the answer Must Type Cast
-    public short multiply(short x, short y){
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public short multiply(short multiplicand, short multiplier) {
         return 0;
     }
-    //Multiply two bytes and return the answer, Must Type Cast
-    public byte multiply(byte x, byte y){
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public byte multiply(byte multiplicand, byte multiplier) {
         return 0;
     }
 
-    //Multiply two floats and return the answer
-    public float multiply(float x, float y){
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public float multiply(float multiplicand, float multiplier) {
         return 0;
     }
 
-    //Multiply two doubles and return the answer
-    public double multiply(double x, double y){
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public double multiply(double multiplicand, double multiplier) {
         return 0;
     }
 
-    //Return true
-    public boolean returnTrue(){
+
+    /**
+      * @return true
+     */
+    public boolean returnTrue() {
         return false;
     }
 
-    //Return false
-    public boolean returnFalse(){
+    /**
+     * @return false
+     */
+    public boolean returnFalse() {
         return true;
     }
 

src/main/java/com/zipcodewilmington/danny_do_better/StringUtilities.java

+package com.zipcodewilmington.danny_do_better;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class StringUtilities {
+
+    // Return the concatenation of two strings, `firstSegment`, and `secondSegment`
+    public String concatenation(String firstSegment, String secondSegment){
+        return null;
+    }
+
+    // Return the concatenation of an integer and a string, `firstSegment`, and `secondSegment`
+    public String concatenation(int firstSegment, String secondSegment){
+        return null;
+    }
+
+    // Return a substring of the first three characters of a string
+    public String getPrefix(String input){
+        return null;
+    }
+
+    // Return a substring of the last three characters of a string
+    public String getSuffix(String input){
+        return null;
+    }
+
+    // Return the equivalence of two strings as a boolean
+    public boolean compareTwoStrings(String inputValue, String comparableValue){
+        return false;
+    }
+
+    // Return the center character of a provided string
+    public Character getMiddleCharacter(String input){
+        int length = input.length();
+        int centerIndex = length /2;
+        char centerCharacter = input.charAt(centerIndex);
+        return centerCharacter;
+    }
+
+    // Return the first word of a string delimited by spaces.
+    public String getFirstWord(String spaceDelimitedString){
+        return null;
+    }
+
+    // Return the second word of a string delimited by spaces.
+    public String getTheSecondWord(String spaceDelimitedString){
+        return null;
+    }
+
+    // Return an identical string with characters in reverse order.
+    public String reverseTheTwo(String stringToReverse){
+        return null;
+    }
+}

src/main/java/com/zipcodewilmington/danny_do_better/Strings.java

-package com.zipcodewilmington.danny_do_better;
-
-/**
- * Created by dan on 6/14/17.
- */
-public class Strings {
-
-    //Concatenate two strings together that are passed in the parameters
-    public String concatenation(String one, String two){
-        return null;
-    }
-
-    //Concatenate a string and a integer together that are passed in the parameters
-    public String concatenation(int one, String two){
-        return null;
-    }
-
-    //Get the substring of the first three letters of a string
-    public String subStringBegin(String input){
-        return null;
-    }
-
-    //Get the substring of a string "Hello" so it returns the last three letters only
-    public String subStringEnd(String input){
-        return null;
-    }
-
-    //Compare the two strings using compareTo() and if they are return true, else false
-    public boolean compareTwoStrings(String one, String two){
-        return false;
-    }
-
-    //Compare the two strings using equals() and if they are return true, else false
-    public boolean compareTwoStringsEqual(String one, String two){
-        return false;
-    }
-
-    //Write a method that returns the middle character in the given string hint: use the .length and .charAt methods
-    public char getTheMiddleChar(String string){
-        return ' ';
-    }
-
-    //Use the indexOf method to find the first space in a string and .substring() to return the first word
-    public String getTheFirstWord(String string){
-        return null;
-    }
-
-    //Use the same behavior to find the second word
-    public String getTheSecondWord(String string){
-        return null;
-    }
-
-    //Create a method that uses the above methods to return a string consisting of the second and first word in reversed order
-    public String reverseTheTwo(String string){
-        return null;
-    }
-
-}

src/test/java/com/zipcodewilmington/danny_do_better/MathUtilitiesTest.java

  * Created by dan on 6/14/17.
  */
 public class MathUtilitiesTest {
+    private static volatile MathUtilities math = new MathUtilities();
 
+    @Test
+    public void testRemainder1(){
+        // : Given
+        Integer dividend = 7;
+        Integer divisor = 3;
+        Integer expected = 1;
 
-    MathUtilities math;
+        // : When
+        Integer actual = math.remainder(dividend, divisor);
 
-    @Before public void initialize(){
-        math = new MathUtilities();
+        // : Then
+        assertEquals(expected, actual);
     }
 
+
     @Test
-    public void testRemainder(){
-        Integer dividend = 7;
+    public void testRemainder2(){
+        // : Given
+        Integer dividend = 8;
         Integer divisor = 3;
-        Integer expected = 1;
+        Integer expected = 2;
 
-        Integer actual = this.math.remainder(dividend, divisor);
+        // : When
+        Integer actual = math.remainder(dividend, divisor);
 
-        assertTrue(expected == actual);
+        // : Then
+        assertEquals(expected, actual);
     }
 
     @Test
-    public void testGreaterThan(){
-        assertTrue(this.math.isGreaterThan(456,23));
+    public void testGreaterThanTrue(){
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+
+        // : When
+        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
     }
 
+
     @Test
-    public void testLessThan(){
-        assertTrue(this.math.isLessThan(1 ,3));
+    public void testGreaterThanFalse(){
+        // : Given
+        int greaterValue = 350;
+        int lesserValue = 350;
+
+        // : When
+        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
     }
 
+
+    @Test
+    public void testLessThanTrue(){
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+
+        // : When
+        boolean outcome = math.isLessThan(greaterValue, lesserValue);
+
+        // : Then
+        assertFalse(outcome);
+    }
+
+
+
+    @Test
+    public void testLessThan1(){
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+
+        // : When
+        boolean outcome = math.isLessThan(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+
     @Test
     public void testLessOrEqual(){
-        assertTrue(this.math.isLessThanOrEqualTo(3 , 3));
-        assertTrue(this.math.isLessThanOrEqualTo(3, 6));
+        assertTrue(math.isLessThanOrEqualTo(3 , 3));
+        assertTrue(math.isLessThanOrEqualTo(3, 6));
     }
 
     @Test
     public void testGreaterOrEqual(){
-        assertTrue(this.math.isGreaterThanOrEqualTo(4, 4));
-        assertTrue(this.math.isGreaterThanOrEqualTo(78, 5));
+        assertTrue(math.isGreaterThanOrEqualTo(4, 4));
+        assertTrue(math.isGreaterThanOrEqualTo(78, 5));
     }
 
     @Test
     public void testLogicalAnd(){
-        assertTrue(this.math.isBoth(3));
-        assertFalse(this.math.isBoth(4));
+        assertTrue(math.isBoth(3));
+        assertFalse(math.isBoth(4));
     }
 
     @Test
     public void testLogicalOr(){
-        assertTrue(this.math.logicalOr(4));
-        assertTrue(this.math.logicalOr(14564));
-        assertFalse(this.math.logicalOr(54));
+        assertTrue(math.logicalOr(4));
+        assertTrue(math.logicalOr(14564));
+        assertFalse(math.logicalOr(54));
     }
 
 

src/test/java/com/zipcodewilmington/danny_do_better/PrimativeTypesTest.java

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

src/test/java/com/zipcodewilmington/danny_do_better/StringUtilitiesTest.java

+package com.zipcodewilmington.danny_do_better;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class StringUtilitiesTest {
+    private static StringUtilities stringUtilities = new StringUtilities();
+
+    @Test
+    public void concatenationStringTest(){
+        // : Given
+        String one = "Hello";
+        String two = " Java";
+        String expected = "Hello Java";
+
+        // : When
+        String actual = stringUtilities.concatenation(one,two);
+
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void concatenationStringAndIntegerTest(){
+        // : Given
+        int one = 1;
+        String two = " Java";
+        String expected = "1 Java";
+
+        // : When
+        String actual = stringUtilities.concatenation(one,two);
+
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void substringBeginTest(){
+        // : Given
+        String input = "Hello";
+        String expected = "olleH";
+
+        // : When
+        String actual = stringUtilities.getPrefix(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void substringEndTest(){
+        // : Given
+        String input = "Hello";
+        String expected = "llo";
+
+        // : When
+        String actual = stringUtilities.getSuffix("Hello");
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void compareToTestEquals(){
+        // : Given
+        String inputValue = "Zipcode";
+        String comparableValue = "Zipcode";
+
+        // : When
+        boolean actual = stringUtilities.compareTwoStrings(inputValue, comparableValue);
+
+        // : Then
+        assertTrue(actual);
+    }
+
+
+    @Test
+    public void compareToTestNotEquals(){
+        // : Given
+        String inputValue = "Zipcode";
+        String comparableValue = "Zipcodee";
+
+        // : When
+        boolean actual = stringUtilities.compareTwoStrings(inputValue, comparableValue);
+
+        // : Then
+        assertFalse(actual);
+    }
+
+    @Test
+    public void getTheMiddleChar(){
+        // : Given
+        String input = "Zipcode";
+        char expected = 'c';
+
+        // : When
+        char actual = stringUtilities.getMiddleCharacter(input);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void getTheMiddleCharr(){
+        // : Given
+        String input = "Zipcoder";
+        Character expected = 'c';
+
+        // : When
+        Character actual = stringUtilities.getMiddleCharacter(input);
+
+        // : Then
+        Assert.assertEquals(expected.toString(), actual.toString());
+    }
+
+
+    @Test
+    public void getTheFirstWord(){
+        // : Given
+        String input = "Zipcode Wilmington";
+        String expected = "Zipcode";
+
+        // : When
+        String actual = stringUtilities.getFirstWord(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void getTheSecondWord(){
+        // : Given
+        String input = "Zipcode Wilmington";
+        String expected = "Wilmington";
+
+        // : When
+        String actual = stringUtilities.getFirstWord(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void reverseThem(){
+        // : Given
+        String input = "Zipcode Wilmington";
+        String expected = "notgnimliW edocpiZ";
+
+
+        // : When
+        String actual = stringUtilities.reverseTheTwo(input);
+
+        // : Then
+        assertEquals(expected, actual);
+    }
+}

src/test/java/com/zipcodewilmington/danny_do_better/StringsTest.java

-package com.zipcodewilmington.danny_do_better;
-
-import com.zipcodewilmington.danny_do_better.Strings;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-/**
- * Created by dan on 6/14/17.
- */
-public class StringsTest {
-
-    Strings strings;
-
-    @Before public void initialize(){
-        strings = new Strings();
-    }
-
-    @Test
-    public void concatenationStringTest(){
-        String one = "Hello", two = " Java";
-        assertTrue(this.strings.concatenation(one,two).equals("Hello Java"));
-    }
-
-    @Test
-    public void concatenationStringAndIntegerTest(){
-        int one = 21;
-        String two = " Years Old";
-        assertTrue(this.strings.concatenation(one, two).equals("21 Years Old"));
-    }
-
-    @Test
-    public void substringBeginTest(){
-        String string = "Hello";
-        assertTrue(this.strings.subStringBegin(string).equals("Hel"));
-    }
-
-    @Test
-    public void substringEndTest(){
-        String string = "Hello";
-        assertTrue(this.strings.subStringEnd(string).equals("llo"));
-    }
-
-    @Test
-    public void compareToTest(){
-        String one = "Zipcode", two = "Zipcode", three ="Wilmington";
-        assertTrue(this.strings.compareTwoStrings(one,two));
-        assertFalse(this.strings.compareTwoStrings(one,three));
-    }
-
-    @Test
-    public void equalToTest(){
-        String one = "Zipcode", two = "Zipcode", three = "Wilmington";
-        assertTrue(this.strings.compareTwoStringsEqual(one, two));
-        assertFalse(this.strings.compareTwoStringsEqual(three, two));
-    }
-
-    @Test
-    public void getTheMiddleChar(){
-        String one = "Zipcode";
-        assertTrue('c' == this.strings.getTheMiddleChar(one));
-    }
-
-    @Test
-    public void getTheFirstWord(){
-        String string = "Zipcode Wilmington";
-        assertTrue(this.strings.getTheFirstWord(string).equals("Zipcode"));
-    }
-
-    @Test
-    public void getTheSecondWord(){
-        String string = "Zipcode Wilmington";
-        assertTrue(this.strings.getTheSecondWord(string).equals("Wilmington"));
-    }
-
-    @Test
-    public void reverseThem(){
-        String string = "Zipcode Wilmington";
-        assertTrue(this.strings.reverseTheTwo(string).equals("Wilmington Zipcode"));
-    }
-
-}