first commit

.gitignore

@@ -0,0 +1,57 @@
+er-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+### Intellij Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/sonarlint

.idea/.name

@@ -0,0 +1 @@
+ChapterOneMicro

.idea/compiler.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <annotationProcessing>
+      <profile name="Maven default annotation processors profile" enabled="true">
+        <sourceOutputDir name="target/generated-sources/annotations" />
+        <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
+        <outputRelativeToContentRoot value="true" />
+        <module name="ChapterOneMicro" />
+      </profile>
+    </annotationProcessing>
+    <bytecodeTargetLevel target="1.8">
+      <module name="ChapterOneMicro" target="1.8" />
+    </bytecodeTargetLevel>
+  </component>
+</project>

.idea/kotlinc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KotlinCommonCompilerArguments">
+    <option name="languageVersion" value="1.1" />
+    <option name="apiVersion" value="1.1" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectInspectionProfilesVisibleTreeState">
+    <entry key="Project Default">
+      <profile-state>
+        <expanded-state>
+          <State>
+            <id />
+          </State>
+        </expanded-state>
+        <selected-state>
+          <State>
+            <id>Android</id>
+          </State>
+        </selected-state>
+      </profile-state>
+    </entry>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/classes" />
+  </component>
+  <component name="masterDetails">
+    <states>
+      <state key="GlobalLibrariesConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="JdkListConfigurable.UI">
+        <settings>
+          <last-edited>1.8</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ProjectJDKs.UI">
+        <settings>
+          <last-edited>1.8</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ProjectLibrariesConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ScopeChooserConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+    </states>
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/ChapterOneMicro.iml" filepath="$PROJECT_DIR$/ChapterOneMicro.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

ChapterOneMicro.iml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8">
+    <output url="file://$MODULE_DIR$/target/classes" />
+    <output-test url="file://$MODULE_DIR$/target/test-classes" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.12" level="project" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
+  </component>
+</module>

README.md

@@ -0,0 +1,78 @@
+# Java Fundamentals
+* **Objective:**
+    * To complete the method stubs in each of the provided classes
+        * `MathUtilities`
+    	* `PredicateUtilities`
+    	* `StringUtilities`
+
+* **Purpose:**
+    * To establish familiarity with
+        * [primitive data-types](http://cs.fit.edu/~ryan/java/language/java-data.html)
+        * [method signatures and return statements](http://www.homeandlearn.co.uk/java/java_methods.html)
+        * [String operations](https://www.tutorialspoint.com/java/java_strings.htm)
+    
+* **Classes to be completed:**
+	* `MathUtilities`
+	* `PredicateUtilities`
+	* `StringUtilities`
+	
+* **Instructions**
+    * Complete each of the method stubs in the `main` classes provided.
+        * `main` classes are located in `src.main.java.com.zipcodewilmington.danny_do_better_exercises`
+    * There are comments above each method stub to describe the expected behavior.
+    * Upon completion, open and run the `TestSuite` class to ensure that all tests have 100% success.
+        * `TestSuite` is located in `src.test.java.com.zipcodewilmington.danny_do_better_exercises`
+
+## Predicate Utilities
+* A _predicate_ is a clause which states something about a subject. (_e.g., **is assigning**_ in _"Leon **is assigning** homework"_)
+* Ensure each of the test cases passes successfully in the class [TestPredicateUtilities](./src/test/java/com/zipcodewilmington/danny_do_better_exercises/TestPredicateUtilities.java) by completing each of the method stubs in the class [PredicateUtilities](./src/main/java/com/zipcodewilmington/danny_do_better_exercises/PredicateUtilities.java).
+* Method Stubs to be completed
+	* `boolean isGreaterThan(int x, int y)`
+	* `boolean isLessThan(int x, int y)`
+	* `boolean isGreaterThanOrEqualTo(int x, int y)`
+	* `boolean isLessThanOrEqualTo(int x, int y)`
+
+
+## Math Utilities
+* Ensure each of the test cases passes successfully in the class [TestMathUtilities](./src/test/java/com/zipcodewilmington/danny_do_better_exercises/TestMathUtilities.java) by completing each of the method stubs in the class [MathUtilities](./src/main/java/com/zipcodewilmington/danny_do_better_exercises/MathUtilities.java).
+* Method Stubs to be completed	
+	* `Integer add(int, int)`
+	* `Long add(long, long)`
+	* `Short add(short, short)`
+	* `Byte add(byte, byte)`
+	* `Float add(float, float)`
+	* `Double add(double, double)`
+	* `Integer subtract(int, int)`
+	* `Long subtract(long, long)`
+	* `Short subtract(short, short)`
+	* `Byte subtract(byte, byte)`
+	* `Float subtract(float, float)`
+	* `Double subtract(double, double)`
+	* `Integer divide(int, int)`
+	* `Long divide(long, long)`
+	* `Short divide(short, short)`
+	* `Byte divide(byte, byte)`
+	* `Float divide(float, float)`
+	* `Double divide(double, double)`
+	* `Integer multiply(int, int)`
+	* `Long multiply(long, long)`
+	* `Short multiply(short, short)`
+	* `Byte multiply(byte, byte)`
+	* `Float multiply(float, float)`
+	* `Double multiply(double, double)`
+	* `Boolean returnTrue`
+	* `Boolean returnFalse`
+
+
+## String Utilities
+* Ensure each of the test cases passes successfully in the class [TestStringUtilities](./src/test/java/com/zipcodewilmington/danny_do_better_exercises/TestStringUtilities.java) by completing each of the method stubs in the class [StringUtilities](./src/main/java/com/zipcodewilmington/danny_do_better_exercises/StringUtilities.java).
+* Method Stubs to be completed
+	* `String concatenation(String, String)`
+	* `String concatenation(int, String)`
+	* `String getPrefix(String)`
+	* `String getSuffix(String)`
+	* `String compareTwoStrings(String)`
+	* `Character getMiddleCharacter(String)`
+	* `String getFirstWord(String)`
+	* `String getSecondWord(String)`
+	* `String reverseTheTwo(String)`

pom.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>zipcoder.io</groupId>
+    <artifactId>ChapterOneMicro</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.6.0</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+
+</project>

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

@@ -0,0 +1,240 @@
+package com.zipcodewilmington.danny_do_better_exercises;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class MathUtilities {
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to add to starting value
+     * @return sum of `baseValue` and `difference`
+     */
+    public Integer add(int baseValue, int difference) {
+        return null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @param baseValue  starting value
+     * @param difference value to subtract from starting value
+     * @return difference between `baseValue` and `difference`
+     */
+    public Integer subtract(int baseValue, int difference) {
+        return null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+
+    /**
+     * @param dividend value to be divided
+     * @param divisor value to divide by
+     * @return division of `dividend` by `divisor
+     */
+    public Integer divide(int dividend, int divisor) {
+        return null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+
+    /**
+     * @param multiplicand value to be multiplied
+     * @param multiplier value to multiply by
+     * @return product of `multiplicand` by `multiplier`
+     */
+    public Integer multiply(int multiplicand, int multiplier) {
+        return null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+    /**
+     * @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 null;
+    }
+
+
+    /**
+      * @return true
+     */
+    public Boolean returnTrue() {
+        return null;
+    }
+
+    /**
+     * @return false
+     */
+    public Boolean returnFalse() {
+        return null;
+    }
+
+}

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

@@ -0,0 +1,42 @@
+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_exercises/StringUtilities.java

@@ -0,0 +1,88 @@
+package com.zipcodewilmington.danny_do_better_exercises;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class StringUtilities {
+    /**
+     * @return `Hello World` as a string
+     */
+    public static String getHelloWorld() {
+        return null;
+    }
+
+    /**
+     * @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_exercises/TestMathUtilities.java

@@ -0,0 +1,344 @@
+package com.zipcodewilmington.danny_do_better_exercises;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+/**
+ * Created by dan on 6/14/17.
+ */
+public class TestMathUtilities {
+    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 = 32767;
+        // : 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);
+    }
+    @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 = 14;
+        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());
+    }
+
+}

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

@@ -0,0 +1,121 @@
+package com.zipcodewilmington.danny_do_better_exercises;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+/**
+ * Created by dan on 6/14/17.
+ */
+public class TestPredicateUtilities {
+    private static volatile PredicateUtilities math = new PredicateUtilities();
+
+    @Test
+    public void testGreaterThanTrue(){
+        // : Given
+        int greaterValue = 450;
+        int lesserValue = 350;
+
+
+        // : When
+        boolean outcome = math.isGreaterThan(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+
+    @Test
+    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 testLessOrEqual1(){
+        // : Given
+        int greaterValue = 3;
+        int lesserValue = 3;
+
+        // : When
+        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+    @Test
+    public void testLessOrEqual2(){
+        // : Given
+        int greaterValue = 3;
+        int lesserValue = 6;
+
+        // : When
+        boolean outcome = math.isLessThanOrEqualTo(greaterValue, lesserValue);
+
+        // : Then
+        assertTrue(outcome);
+    }
+
+    @Test
+    public void testGreaterOrEqual1(){
+        // : Given
+        int greaterValue = 4;
+        int lesserValue = 4;
+
+        // : When
+        boolean outcome = math.isGreaterThanOrEqualTo(greaterValue, lesserValue);
+
+        // : ThenP
+        assertTrue(outcome);
+    }
+
+
+    @Test
+    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_exercises/TestStringUtilities.java

@@ -0,0 +1,176 @@
+package com.zipcodewilmington.danny_do_better_exercises;
+
+import org.junit.Assert;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class TestStringUtilities {
+    @Test
+    public void getHelloWorldTest() {
+        // : Given
+        String expected = "Hello World";
+
+        // : When
+        String actual = StringUtilities.getHelloWorld();
+
+        // : Then
+        assertEquals(expected, actual);
+
+    }
+
+    @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 getTheMiddleChar1(){
+        // : Given
+        String input = "Zipcode";
+        char expected = 'c';
+
+        // : When
+        char actual = StringUtilities.getMiddleCharacter(input);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void getTheMiddleChar2(){
+        // : 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_exercises/TestSuite.java

@@ -0,0 +1,17 @@
+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({
+        TestPredicateUtilities.class,
+        TestMathUtilities.class,
+        TestStringUtilities.class,
+})
+public class TestSuite {
+}