Fixing files

.gitignore

+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

README.md

+# Tech Connect Fundamentals Lab 1

pom.xml

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

+package HelloWorld;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class HelloWorld {
+
+    //Should return hello world as a string
+    public String helloWorld(){
+        return "Hello World";
+    }
+
+}

src/main/java/Math/Math.java

+package Math;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class Math {
+
+    //Get the remainder from division
+    public int remainder(int one, int two){
+        return one % two;
+    }
+
+    //Return true using greater than symbol
+    public boolean greaterThanTrue(int one, int two){
+        return one > two;
+    }
+
+    //Return false using greater than symbol
+    public boolean greaterThanFalse(int one, int two){
+        return one > two;
+    }
+
+    //Return true using less than symbol
+    public boolean lessThanTrue(int one, int two){
+        return one < two;
+    }
+
+    //Return false using less than symbol
+    public boolean lessThanFalse(int one, int two){
+        return one < two;
+    }
+
+    //Return true using greater or equal symbol
+    public boolean greaterOrEqualTrue(int one, int two){
+        return one >= two;
+    }
+
+    //Return false using greater or equal symbol
+    public boolean greaterOrEqualFalse(int one, int two){
+        return one >= two;
+    }
+
+    //Return true using less than or equal symbol
+    public boolean lessOrEqualTrue(int one, int two){
+        return one <= two;
+    }
+
+    //Return false using less than or equal symbol
+    public boolean lessOrEqualFalse(int one, int two){
+        return one <= two;
+    }
+
+    //Return true if the number in parameter is equal to 3 and less than 90
+    public boolean logicalAnd(Integer number){
+        if (number == 3 && number < 90){
+            return true;
+        }
+        else
+            return false;
+    }
+
+    //Return true if the number passed in is equal to 4 or greater than 100
+    public boolean logicalOr(Integer number){
+        if (number == 4 || number > 100){
+            return true;
+        }
+        else
+            return false;
+    }
+
+}

src/main/java/PrimativeTypes/PrimativeTypes.java

+package PrimativeTypes;
+
+/**
+ * Created by dan on 6/14/17.
+ */
+public class PrimativeTypes {
+
+    //Add two ints and return the answer
+    public int add(int x, int y){
+        return x + y;
+    }
+
+    //Add two long's and return the answer
+    public long add(long x, long y){
+        return x + y;
+    }
+
+    //Add two short's and return the answer Must Type Cast
+    public short add(short x, short y){
+        return (short) (x + y);
+    }
+    //Add two bytes and return the answer, Must Type Cast
+    public byte add(byte x, byte y){
+        return (byte) (x + y);
+    }
+
+    //Add two floats and return the answer
+    public float add(float x, float y){
+        return x + y;
+    }
+
+    //Add two doubles and return the answer
+    public double add(double x, double y){
+        return x + y;
+    }
+
+    //Subtract two ints and return the answer
+    public int subtract(int x, int y){
+        return x - y;
+    }
+
+    //Subtract two long's and return the answer
+    public long subtract(long x, long y){
+        return x - y;
+    }
+
+    //Subtract two short's and return the answer Must Type Cast
+    public short subtract(short x, short y){
+        return (short) (x - y);
+    }
+    //Subtract two bytes and return the answer, Must Type Cast
+    public byte subtract(byte x, byte y){
+        return (byte) (x - y);
+    }
+
+    //Subtract two floats and return the answer
+    public float subtract(float x, float y){
+        return x - y;
+    }
+
+    //Subtract two doubles and return the answer
+    public double subtract(double x, double y){
+        return x - y;
+    }
+
+    //Divide two ints and return the answer
+    public int divide(int x, int y){
+        return x / y;
+    }
+
+    //Divide two long's and return the answer
+    public long divide(long x, long y){
+        return x / y;
+    }
+
+    //Divide two short's and return the answer Must Type Cast
+    public short divide(short x, short y){
+        return (short) (x / y);
+    }
+    //Divide two bytes and return the answer, Must Type Cast
+    public byte divide(byte x, byte y){
+        return (byte) (x / y);
+    }
+
+    //Divide two floats and return the answer
+    public float divide(float x, float y){
+        return x / y;
+    }
+
+    //Divide two doubles and return the answer
+    public double divide(double x, double y){
+        return x / y;
+    }
+
+    //Multiply two ints and return the answer
+    public int multiply(int x, int y){
+        return x * y;
+    }
+
+    //Multiply two long's and return the answer
+    public long multiply(long x, long y){
+        return x * y;
+    }
+
+    //Multiply two short's and return the answer Must Type Cast
+    public short multiply(short x, short y){
+        return (short) (x * y);
+    }
+    //Multiply two bytes and return the answer, Must Type Cast
+    public byte multiply(byte x, byte y){
+        return (byte) (x * y);
+    }
+
+    //Multiply two floats and return the answer
+    public float multiply(float x, float y){
+        return x * y;
+    }
+
+    //Multiply two doubles and return the answer
+    public double multiply(double x, double y){
+        return x * y;
+    }
+
+    //Return true
+    public boolean returnTrue(){
+        return true;
+    }
+
+    //Return false
+    public boolean returnFalse(){
+        return false;
+    }
+
+}

src/main/java/Strings/Strings.java

+package Strings;
+
+/**
+ * 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 one + two;
+    }
+
+    //Concatenate a string and a integer together that are passed in the parameters
+    public String concatenation(int one, String two){
+        return one + two;
+    }
+
+    //Get the substring of the first three letters of a string
+    public String subStringBegin(String input){
+        return input.substring(0,3);
+    }
+
+    //Get the substring of a string "Hello" so it returns the last three letters only
+    public String subStringEnd(String input){
+        return input.substring(input.length() - 3, input.length());
+    }
+
+    //Compare the two strings using compareTo() and if they are return true, else false
+    public boolean compareTwoStrings(String one, String two){
+        int comparison = one.compareTo(two);
+        if (comparison == 0){
+            return true;
+        }
+        else
+            return false;
+    }
+
+    //Compare the two strings using equals() and if they are return true, else false
+    public boolean compareTwoStringsEqual(String one, String two){
+        return one.equals(two);
+    }
+
+    //Write a method that returns the middle character in the given string hint: use the .length and .charAt methods
+    public char getTheMiddleChar(String string){
+        Integer middle = string.length()/2;
+        return string.charAt(middle);
+    }
+
+    //Use the indexOf method to find the first space in a string and .substring() to return the first word
+    public String getTheFirstWord(String string){
+        Integer space = 0;
+        for (int i = 0; i < string.length(); i++){
+            if (string.charAt(i) == ' '){
+                space = i;
+            }
+        }
+        return string.substring(0, space);
+    }
+
+    //Use the same behavior to find the second word
+    public String getTheSecondWord(String string){
+        Integer space = 0;
+        for (int i = 0; i < string.length(); i++){
+            if (string.charAt(i) == ' '){
+                space = i;
+            }
+        }
+        return string.substring(space + 1, string.length());
+    }
+
+    //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){
+        StringBuilder sb = new StringBuilder();
+        sb.append(getTheSecondWord(string));
+        sb.append(" ");
+        sb.append(getTheFirstWord(string));
+        return sb.toString();
+    }
+
+}

src/test/java/HelloWorld/HelloWorldTest.java

+package HelloWorld;
+
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+/**
+ * Created by dan on 6/14/17.
+ */
+public class HelloWorldTest {
+
+    HelloWorld helloWorld;
+
+    @Before public void initialize(){
+        helloWorld = new HelloWorld();
+    }
+
+    @Test
+    public void TestHelloWorld(){
+        String expected = "Hello World";
+        String actual = this.helloWorld.helloWorld();
+
+        assertEquals(expected,actual);
+    }
+
+}

src/test/java/Math/MathTest.java

+package Math;
+
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+/**
+ * Created by dan on 6/14/17.
+ */
+public class MathTest {
+
+
+    Math math;
+
+    @Before public void initialize(){
+        math = new Math();
+    }
+
+    @Test
+    public void testRemainder(){
+        Integer one = 7, two = 3;
+        Integer expected = 1;
+        Integer actual = this.math.remainder(one, two);
+
+        assertTrue(expected == actual);
+    }
+
+    @Test
+    public void testGreaterThan(){
+        assertTrue(this.math.greaterThanTrue(456,23));
+        assertFalse(this.math.greaterThanFalse(1,3));
+    }
+
+    @Test
+    public void testLessThan(){
+        assertTrue(this.math.lessThanTrue(1 ,3));
+        assertFalse(this.math.lessThanFalse(4,1));
+    }
+
+    @Test
+    public void testLessOrEqual(){
+        assertTrue(this.math.lessOrEqualTrue(3 , 3));
+        assertTrue(this.math.lessOrEqualTrue(3, 6));
+        assertFalse(this.math.lessOrEqualFalse(3, 1));
+    }
+
+    @Test
+    public void testGreaterOrEqual(){
+        assertTrue(this.math.greaterOrEqualTrue(4, 4));
+        assertTrue(this.math.greaterOrEqualTrue(78, 5));
+        assertFalse(this.math.greaterOrEqualFalse(4, 56));
+    }
+
+    @Test
+    public void testLogicalAnd(){
+        assertTrue(this.math.logicalAnd(3));
+        assertFalse(this.math.logicalAnd(4));
+    }
+
+    @Test
+    public void testLogicalOr(){
+        assertTrue(this.math.logicalOr(4));
+        assertTrue(this.math.logicalOr(14564));
+        assertFalse(this.math.logicalOr(54));
+    }
+
+
+}

src/test/java/PrimativeTypes/PrimativeTypesTest.java

+package PrimativeTypes;
+
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+/**
+ * Created by dan on 6/14/17.
+ */
+public class PrimativeTypesTest {
+
+    PrimativeTypes primativeTypes;
+
+    @Before public void initialize(){
+        primativeTypes = new PrimativeTypes();
+    }
+
+    @Test
+    public void testAdditions(){
+        int expectedInt = 27;
+        int actualInt = this.primativeTypes.add(20,7);
+
+        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);
+
+        assertEquals(expectedInt,actualInt);
+        assertEquals(expectedLong,actualLong);
+        assertEquals(expectedShort,actualShort);
+        assertEquals(expectedByte,actualByte);
+        assertEquals(expectedFloat,actualFloat, 0);
+        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);
+
+        assertEquals(expectedInt,actualInt);
+        assertEquals(expectedLong,actualLong);
+        assertEquals(expectedShort,actualShort);
+        assertEquals(expectedByte,actualByte);
+        assertEquals(expectedFloat,actualFloat, 0);
+        assertEquals(expectedDouble,actualDouble, 0);
+    }
+
+    @Test
+    public void testMultiplication(){
+        int expectedInt = 10;
+        int actualInt = this.primativeTypes.multiply(5,2);
+
+        long expectedLong = 20000;
+        long actualLong = this.primativeTypes.multiply(20, 1000);
+
+        short expectedShort = 2;
+        short actualShort = (short) this.primativeTypes.multiply(2, 1);
+
+        byte expectedByte = 64;
+        byte actualByte = (byte) this.primativeTypes.multiply(16, 4);
+
+        float expectedFloat = (float) 2.50;
+        float actualFloat = (float) this.primativeTypes.multiply(2.50,1);
+
+        double expectedDouble = 9.75;
+        double actualDouble = this.primativeTypes.multiply(3.25,3.0);
+
+        assertEquals(expectedInt,actualInt);
+        assertEquals(expectedLong,actualLong);
+        assertEquals(expectedShort,actualShort);
+        assertEquals(expectedByte,actualByte);
+        assertEquals(expectedFloat,actualFloat, 0);
+        assertEquals(expectedDouble,actualDouble, 0);
+    }
+
+    @Test
+    public void testBoolean(){
+        assertTrue(this.primativeTypes.returnTrue());
+        assertFalse(this.primativeTypes.returnFalse());
+    }
+
+}

src/test/java/Strings/StringsTest.java

+package 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"));
+    }
+
+}