first commit

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

-package com.zipcodewilmington.danny_do_better;
-
-/**
- * Created by leon on 2/1/18.
- */
-public class HelloWorld {
-    //Should return `Hello World` as a string
-    public String helloWorld(){
-        return null;
-    }
-}

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

-package com.zipcodewilmington.danny_do_better;
-
-/**
- * Created by dan on 6/14/17.
- */
-public class MathUtilities {
-    //Get the remainder from division
-    public int remainder(int dividend, int divisor){
-        return 0;
-    }
-
-    //Evaluate the equality of `greaterValue` and `lesserValue` using greater than operation.
-    public boolean isGreaterThan(int greaterValue, int lesserValue){
-        return greaterValue > lesserValue;
-    }
-
-    //Return true using less than symbol
-    public boolean isLessThan(int greaterValue, int lesserValue){
-        return false;
-    }
-
-    //Return true using greater or equal symbol
-    public boolean isGreaterThanOrEqualTo(int greaterValue, int lesserValue){
-        return false;
-    }
-
-    //Return true using less than or equal symbol
-    public boolean isLessThanOrEqualTo(int greaterValue, int lesserValue){
-        return false;
-    }
-
-    //Return true if the number in parameter is equal to 3 and less than 90
-    public boolean isBoth(Integer number){
-        return false;
-    }
-
-    //Return true if the number passed in is equal to 4 or greater than 100
-    public boolean logicalOr(Integer number){
-        return false;
-    }
-}

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_exercises/HelloWorld.java

+package com.zipcodewilmington.danny_do_better_exercises;
+
+/**
+ * Created by leon on 2/1/18.
+ */
+public class HelloWorld {
+    /**
+     * @return 'Hello World' as a string
+     */
+    public String toString(){
+        return null;
+    }
+}

src/main/java/com/zipcodewilmington/danny_do_better_exercises/PredicateUtilities.java

+package com.zipcodewilmington.danny_do_better_exercises;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class PredicateUtilities {
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is greater than `y`
+     */
+    public Boolean isGreaterThan(int x, int y) {
+        return null;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is less than `y`
+     */
+    public Boolean isLessThan(int x, int y) {
+        return null;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is greater than or equal to `y`
+     */
+    public Boolean isGreaterThanOrEqualTo(int x, int y) {
+        return null;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @return true if `x` is less than or equal to `y`
+     */
+    public Boolean isLessThanOrEqualTo(int x, int y) {
+        return null;
+    }
+}

src/main/java/com/zipcodewilmington/danny_do_better/PrimativeTypes.java → src/main/java/com/zipcodewilmington/danny_do_better_exercises/PrimitiveTypes.java

-package com.zipcodewilmington.danny_do_better;
+package com.zipcodewilmington.danny_do_better_exercises;
 
 /**
  * Created by dan on 6/14/17.
  */
-public class PrimativeTypes {
+public class PrimitiveTypes {
 
     /**
      * @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;
+    public Integer add(int baseValue, int difference) {
+        return null;
     }
 
     /**
      * @param difference value to add to starting value
      * @return sum of `baseValue` and `difference`
      */
-    public long add(long baseValue, long difference) {
-        return 0;
+    public Long add(long baseValue, long difference) {
+        return null;
     }
 
     /**
      * @param difference value to add to starting value
      * @return sum of `baseValue` and `difference`
      */
-    public short add(short baseValue, short difference) {
-        return 0;
+    public Short add(short baseValue, short difference) {
+        return null;
     }
 
     /**
      * @param difference value to add to starting value
      * @return sum of `baseValue` and `difference`
      */
-    public byte add(byte baseValue, byte difference) {
-        return 0;
+    public Byte add(byte baseValue, byte difference) {
+        return null;
     }
 
     /**
      * @param difference value to add to starting value
      * @return sum of `baseValue` and `difference`
      */
-    public float add(float baseValue, float difference) {
-        return 0;
+    public Float add(float baseValue, float difference) {
+        return null;
     }
 
     /**
      * @param difference value to add to starting value
      * @return sum of `baseValue` and `difference`
      */
-    public double add(double baseValue, double difference) {
-        return 0;
+    public Double add(double baseValue, double difference) {
+        return null;
     }
 
     /**
      * @param difference value to subtract from starting value
      * @return difference between `baseValue` and `difference`
      */
-    public int subtract(int baseValue, int difference) {
-        return 0;
+    public Integer subtract(int baseValue, int difference) {
+        return null;
     }
 
     /**
      * @param difference value to subtract from starting value
      * @return difference between `baseValue` and `difference`
      */
-    public long subtract(long baseValue, long difference) {
-        return 0;
+    public Long subtract(long baseValue, long difference) {
+        return null;
     }
 
     /**
      * @param difference value to subtract from starting value
      * @return difference between `baseValue` and `difference`
      */
-    public short subtract(short baseValue, short difference) {
-        return 0;
+    public Short subtract(short baseValue, short difference) {
+        return null;
     }
 
     /**
      * @param difference value to subtract from starting value
      * @return difference between `baseValue` and `difference`
      */
-    public byte subtract(byte baseValue, byte difference) {
-        return 0;
+    public Byte subtract(byte baseValue, byte difference) {
+        return null;
     }
 
     /**
      * @param difference value to subtract from starting value
      * @return difference between `baseValue` and `difference`
      */
-    public float subtract(float baseValue, float difference) {
-        return 0;
+    public Float subtract(float baseValue, float difference) {
+        return null;
     }
 
     /**
      * @param difference value to subtract from starting value
      * @return difference between `baseValue` and `difference`
      */
-    public double subtract(double baseValue, double difference) {
-        return 0;
+    public Double subtract(double baseValue, double difference) {
+        return null;
     }
 
 
      * @param divisor value to divide by
      * @return division of `dividend` by `divisor
      */
-    public int divide(int dividend, int divisor) {
-        return 0;
+    public Integer divide(int dividend, int divisor) {
+        return null;
     }
 
     /**
      * @param divisor value to divide by
      * @return division of `dividend` by `divisor
      */
-    public long divide(long dividend, long divisor) {
-        return 0;
+    public Long divide(long dividend, long divisor) {
+        return null;
     }
 
     /**
      * @param divisor value to divide by
      * @return division of `dividend` by `divisor
      */
-    public short divide(short dividend, short divisor) {
-        return 0;
+    public Short divide(short dividend, short divisor) {
+        return null;
     }
 
     /**
      * @param divisor value to divide by
      * @return division of `dividend` by `divisor
      */
-    public byte divide(byte dividend, byte divisor) {
-        return 0;
+    public Byte divide(byte dividend, byte divisor) {
+        return null;
     }
 
     /**
      * @param divisor value to divide by
      * @return division of `dividend` by `divisor
      */
-    public float divide(float dividend, float divisor) {
-        return 0;
+    public Float divide(float dividend, float divisor) {
+        return null;
     }
 
     /**
      * @param divisor value to divide by
      * @return division of `dividend` by `divisor
      */
-    public double divide(double dividend, double divisor) {
-        return 0;
+    public Double divide(double dividend, double divisor) {
+        return null;
     }
 
 
      * @param multiplier value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
-    public int multiply(int multiplicand, int multiplier) {
-        return 0;
+    public Integer multiply(int multiplicand, int multiplier) {
+        return null;
     }
 
     /**
      * @param multiplier value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
-    public long multiply(long multiplicand, long multiplier) {
-        return 0;
+    public Long multiply(long multiplicand, long multiplier) {
+        return null;
     }
 
     /**
      * @param multiplier value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
-    public short multiply(short multiplicand, short multiplier) {
-        return 0;
+    public Short multiply(short multiplicand, short multiplier) {
+        return null;
     }
     /**
      * @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;
+    public Byte multiply(byte multiplicand, byte multiplier) {
+        return null;
     }
 
     /**
      * @param multiplier value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
-    public float multiply(float multiplicand, float multiplier) {
-        return 0;
+    public Float multiply(float multiplicand, float multiplier) {
+        return null;
     }
 
     /**
      * @param multiplier value to multiply by
      * @return product of `multiplicand` by `multiplier`
      */
-    public double multiply(double multiplicand, double multiplier) {
-        return 0;
+    public Double multiply(double multiplicand, double multiplier) {
+        return null;
     }
 
 
     /**
       * @return true
      */
-    public boolean returnTrue() {
-        return false;
+    public Boolean returnTrue() {
+        return null;
     }
 
     /**
      * @return false
      */
-    public boolean returnFalse() {
-        return true;
+    public Boolean returnFalse() {
+        return null;
     }
 
 }

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

+package com.zipcodewilmington.danny_do_better_exercises;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class StringUtilities {
+
+    /**
+     * @param firstSegment a string to be added to
+     * @param secondSegment a string to add
+     * @return the concatenation of two strings, `firstSegment`, and `secondSegment`
+     */
+    public static String concatenation(String firstSegment, String secondSegment){
+        return null;
+    }
+
+    /**
+     * @param firstSegment a string to be added to
+     * @param secondSegment a string to add
+     * @return the concatenation of an integer, `firstSegment`, and a String, `secondSegment`
+     */
+    public static String concatenation(int firstSegment, String secondSegment){
+        return null;
+    }
+
+    /**
+     * @param input a string to be manipulated
+     * @return the first 3 characters of `input`
+     */
+    public static String getPrefix(String input){
+        return null;
+    }
+
+    /**
+     * @param input a string to be manipulated
+     * @return the last 3 characters of `input`
+     */
+    public static String getSuffix(String input){
+        return null;
+    }
+
+    /**
+     * @param inputValue the value to be compared
+     * @param comparableValue the value to be compared against
+     * @return the equivalence of two strings, `inputValue` and `comparableValue`
+     */
+    public static Boolean compareTwoStrings(String inputValue, String comparableValue){
+        return null;
+    }
+
+    /**
+     * @param inputValue the value input from user
+     * @return the middle character of `inputValue`
+     */
+    public static Character getMiddleCharacter(String inputValue){
+        return null;
+    }
+
+    /**
+     * @param spaceDelimitedString a string, representative of a sentence, containing spaces
+     * @return the first sequence of characters
+     */
+    public static String getFirstWord(String spaceDelimitedString){
+        return null;
+    }
+
+    /**
+     * @param spaceDelimitedString a string delimited by spaces
+     * @return the second word of a string delimited by spaces.
+     */
+    public static String getSecondWord(String spaceDelimitedString){
+        return null;
+    }
+
+    /**
+     * @param stringToReverse
+     * @return an identical string with characters in reverse order.
+     */
+    public static String reverseTheTwo(String stringToReverse){
+        return null;
+    }
+}

src/test/java/com/zipcodewilmington/danny_do_better/HelloWorldTest.java → src/test/java/com/zipcodewilmington/danny_do_better_exercises/HelloWorldTest.java

-package com.zipcodewilmington.danny_do_better;
+package com.zipcodewilmington.danny_do_better_exercises;
 
 import org.junit.Test;
 

src/test/java/com/zipcodewilmington/danny_do_better/MathUtilitiesTest.java → src/test/java/com/zipcodewilmington/danny_do_better_exercises/PredicateUtilitiesTest.java

-package com.zipcodewilmington.danny_do_better;
+package com.zipcodewilmington.danny_do_better_exercises;
 
-import org.junit.Before;
 import org.junit.Test;
 import static org.junit.Assert.*;
 /**
  * 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;
-
-        // : When
-        Integer actual = math.remainder(dividend, divisor);
-
-        // : Then
-        assertEquals(expected, actual);
-    }
-
-
-    @Test
-    public void testRemainder2(){
-        // : Given
-        Integer dividend = 8;
-        Integer divisor = 3;
-        Integer expected = 2;
-
-        // : When
-        Integer actual = math.remainder(dividend, divisor);
-
-        // : Then
-        assertEquals(expected, actual);
-    }
+public class PredicateUtilitiesTest {
+    private static volatile PredicateUtilities math = new PredicateUtilities();
 
     @Test
     public void testGreaterThanTrue(){
         int greaterValue = 450;
         int lesserValue = 350;
 
-
         // : When
         boolean outcome = math.isLessThan(greaterValue, lesserValue);
 
         int greaterValue = 450;
         int lesserValue = 350;
 
-
         // : When
         boolean outcome = math.isLessThan(greaterValue, lesserValue);
 
 
 
     @Test
-    public void testLessOrEqual(){
-        assertTrue(math.isLessThanOrEqualTo(3 , 3));
-        assertTrue(math.isLessThanOrEqualTo(3, 6));
+    public void testLessOrEqual1(){
+        // : Given
+        int greaterValue = 3;
+        int lesserValue = 3;
+
+        // : When
+        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
     }
 
     @Test
-    public void testGreaterOrEqual(){
-        assertTrue(math.isGreaterThanOrEqualTo(4, 4));
-        assertTrue(math.isGreaterThanOrEqualTo(78, 5));
+    public void testLessOrEqual2(){
+        // : Given
+        int greaterValue = 3;
+        int lesserValue = 6;
+
+        // : When
+        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
     }
 
     @Test
-    public void testLogicalAnd(){
-        assertTrue(math.isBoth(3));
-        assertFalse(math.isBoth(4));
+    public void testGreaterOrEqual1(){
+        // : Given
+        int greaterValue = 4;
+        int lesserValue = 4;
+
+        // : When
+        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
+
+        // : ThenP
+        assertTrue(outcome);
     }
 
+
     @Test
-    public void testLogicalOr(){
-        assertTrue(math.logicalOr(4));
-        assertTrue(math.logicalOr(14564));
-        assertFalse(math.logicalOr(54));
-    }
+    public void testGreaterOrEqual2(){
+        // : Given
+        int greaterValue = 8;
+        int lesserValue = 15;
 
+        // : When
+        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
 
+        // : Then
+        assertTrue(outcome);
+    }
 }

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

-package com.zipcodewilmington.danny_do_better;
+package com.zipcodewilmington.danny_do_better_exercises;
 
 import org.junit.Test;
 
  * Created by dan on 6/14/17.
  */
 public class PrimativeTypesTest {
-    private PrimativeTypes primativeTypes = new PrimativeTypes();
+    private static volatile PrimitiveTypes primativeTypes = new PrimitiveTypes();
 
     @Test
     public void testAdditions() {

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

-package com.zipcodewilmington.danny_do_better;
+package com.zipcodewilmington.danny_do_better_exercises;
 
 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(){
         String expected = "Hello Java";
 
         // : When
-        String actual = stringUtilities.concatenation(one,two);
+        String actual = StringUtilities.concatenation(one,two);
 
 
         // : Then
         String expected = "1 Java";
 
         // : When
-        String actual = stringUtilities.concatenation(one,two);
+        String actual = StringUtilities.concatenation(one,two);
 
 
         // : Then
         String expected = "olleH";
 
         // : When
-        String actual = stringUtilities.getPrefix(input);
+        String actual = StringUtilities.getPrefix(input);
 
         // : Then
         assertEquals(expected, actual);
         String expected = "llo";
 
         // : When
-        String actual = stringUtilities.getSuffix("Hello");
+        String actual = StringUtilities.getSuffix("Hello");
 
         // : Then
         assertEquals(expected, actual);
         String comparableValue = "Zipcode";
 
         // : When
-        boolean actual = stringUtilities.compareTwoStrings(inputValue, comparableValue);
+        boolean actual = StringUtilities.compareTwoStrings(inputValue, comparableValue);
 
         // : Then
         assertTrue(actual);
         String comparableValue = "Zipcodee";
 
         // : When
-        boolean actual = stringUtilities.compareTwoStrings(inputValue, comparableValue);
+        boolean actual = StringUtilities.compareTwoStrings(inputValue, comparableValue);
 
         // : Then
         assertFalse(actual);
     }
 
     @Test
-    public void getTheMiddleChar(){
+    public void getTheMiddleChar1(){
         // : Given
         String input = "Zipcode";
         char expected = 'c';
 
         // : When
-        char actual = stringUtilities.getMiddleCharacter(input);
+        char actual = StringUtilities.getMiddleCharacter(input);
 
         // : Then
         Assert.assertEquals(expected, actual);
 
 
     @Test
-    public void getTheMiddleCharr(){
+    public void getTheMiddleChar2(){
         // : Given
         String input = "Zipcoder";
         Character expected = 'c';
 
         // : When
-        Character actual = stringUtilities.getMiddleCharacter(input);
+        Character actual = StringUtilities.getMiddleCharacter(input);
 
         // : Then
         Assert.assertEquals(expected.toString(), actual.toString());
         String expected = "Zipcode";
 
         // : When
-        String actual = stringUtilities.getFirstWord(input);
+        String actual = StringUtilities.getFirstWord(input);
 
         // : Then
         assertEquals(expected, actual);
         String expected = "Wilmington";
 
         // : When
-        String actual = stringUtilities.getFirstWord(input);
+        String actual = StringUtilities.getFirstWord(input);
 
         // : Then
         assertEquals(expected, actual);
 
 
         // : When
-        String actual = stringUtilities.reverseTheTwo(input);
+        String actual = StringUtilities.reverseTheTwo(input);
 
         // : Then
         assertEquals(expected, actual);

src/test/java/com/zipcodewilmington/danny_do_better_exercises/TestSuite.java

+package com.zipcodewilmington.danny_do_better_exercises;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Created by leon on 2/5/18.
+ */
+@RunWith(Suite.class)
+
+@Suite.SuiteClasses({
+        HelloWorldTest.class,
+        PredicateUtilitiesTest.class,
+        PrimativeTypesTest.class,
+        StringUtilitiesTest.class,
+})
+public class TestSuite {
+}