Merge pull request #28 from Zipcoder/feat/leon

Feat/leon

README-NumberUtilities.md

@@ -0,0 +1,252 @@
+# NumberUtilities
+* Ensure each of the test cases in the class [NumberUtilitiesTest]() successfully passes upon completion of each method stubs in the class [NumberUtilities]().
+    * `String getEvenNumbers(int start, int stop)` 
+    * `String getOddNumbers(int start, int stop)`
+    * `String getSquareNumbers(int start, int stop, int step)` 
+    * `String getRange(int start, int stop, int step)` 
+    * `String getExponentiations(int start, int stop, int step, int exponent)` 
+    
+
+
+
+
+
+
+## `String getRange(int stop)`
+* **Description**
+    * Given an integer, `stop`, return a `String` concatenation of all values between `0` and `stop` exclusively.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int stop = 11;
+    
+    // : When
+    String outcome = StringLoops.getRange(stop);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    012345678910
+    ```
+
+
+
+
+
+
+
+
+
+<br><br><br><br>
+## `String getRange(int start, int stop)`
+* **Description**
+    * Given two integers, `start`, and `stop`, return a `String` concatenation of all values between `start` and `stop` exclusively.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int start = 5;
+    int stop = 11;
+    
+    // : When
+    String outcome = StringLoops.getRange(start, stop);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    5678910
+    ```
+
+
+
+
+
+<br><br><br><br>
+## `String getRange(int start, int stop, int step)`
+* **Description**
+    * Given three integers, `start`, `stop`, and `step` return a `String` concatenation of all values between `start` and `stop` exclusively incrementing by `step`.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int start = 5;
+    int stop = 20;
+    int step = 5;
+    
+    // : When
+    String outcome = StringLoops.getRange(min, max, step);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    51015
+    ```
+    
+    
+    
+
+
+
+
+
+
+
+
+
+
+<br><br><br><br>
+## `String getEvenNumbers(int start, int stop)`
+* **Description**
+    * Given two integers, `start`, and `stop`, return a `String` concatenation of all even values between `start` and `stop` exclusively.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int start = 5;
+    int stop = 20;
+    
+    // : When
+    String outcome = StringLoops.getOddNumbers(min, max);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    681012141618
+    ```
+    
+
+<br><br><br><br>
+## `String getOddNumbers(int start, int stop)`
+* **Description**
+    * Given two integers, `start`, and `stop`, return a `String` concatenation of all even values between `start` and `stop` exclusively.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int start = 5;
+    int stop = 20;
+    
+    // : When
+    String outcome = StringLoops.getOddNumbers(min, max);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    5791113151719
+    ```
+
+
+
+
+
+
+
+
+
+
+
+
+
+    
+
+<br><br><br><br>
+## `String getSquareNumbers(int start, int stop)`
+* **Description**
+    * Given two integers, `start`, and `stop`, return a `String` concatenation of all values squared between `start` and `stop` exclusively.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int start = 5;
+    int stop = 20;
+    
+    // : When
+    String outcome = StringLoops.getOddNumbers(min, max);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    25100225
+    ```
+    
+    
+    
+    
+
+
+
+
+
+
+
+<br><br><br><br>
+## `String getExponentiations(int start, int stop, int step, int exponent)`
+* **Description**
+    * Given four integers, `start`, `stop`, `step`, and `exponent`, return a `String` concatenation of all values, raised to the specified `exponent`, between `start` and `stop` exclusively, incrementing by the specified `step`.
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int start = 5;
+    int stop = 20;
+    int step = 2;
+    int exponent = 2;
+    
+    // : When
+    String outcome = StringLoops.getOddNumbers(min, max);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    25100225
+    ```

README-TableUtilities.md

@@ -0,0 +1,234 @@
+# TableUtilities
+* Ensure each of the test cases in the class [TableUtilitiesTest]() successfully passes upon completion of each method stubs in the class [TableUtilities]().
+    * `String getLargeMultiplicationTable()`
+    * `String getSmallMultiplicationTable()`
+    * `String getMultiplicationTable(int width)`
+
+
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+
+
+
+
+
+
+## `String getSmallMultiplicationTable()`
+* **Description**
+    * Generate a `String` representation of a multiplication table whose dimensions are `4` by `4`
+	
+### Example 1
+* Sample Script
+
+    ```
+    // : Given    
+    // : When
+    String outcome = TableUtilities.getSmallMultiplicationTable();
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+      1 |  2 |  3 |  4 |
+      2 |  4 |  6 |  8 |
+      3 |  6 |  9 | 12 |
+      4 |  8 | 12 | 16 |
+    ```
+
+
+
+
+
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+## `String getLargeMultiplicationTable()`
+* **Description**
+    * Given one integer, `width`, generate a `String` representation of a multiplication table whose dimensions are `width` by `width`
+
+	
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int n = 3;
+    
+    // : When
+    String outcome = Tables.getLargeMultiplicationTable();
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 10 |
+    2 |  4 |  6 |  8 | 10 | 12 | 14 | 16 | 18 | 20 |
+    3 |  6 |  9 | 12 | 15 | 18 | 21 | 24 | 27 | 30 |
+    4 |  8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | 40 |
+    5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 |
+    6 | 12 | 18 | 24 | 30 | 36 | 42 | 48 | 54 | 60 |
+    7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63 | 70 |
+    8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 |
+    9 | 18 | 27 | 36 | 45 | 54 | 63 | 72 | 81 | 90 |
+   10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 |100 |
+   
+    ```
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+## `String getMultiplicationTable(int width)`
+* **Description**
+    * Given one integer, `width`, generate a `String` representation of a multiplication table whose dimensions are `width` by `width`
+
+	
+### Example 1
+* Sample Script
+
+    ```
+    // : Given
+    int n = 3;
+    
+    // : When
+    String outcome = Tables.getMultiplicationTable(n);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+      1 |  2 |  3 |
+      2 |  4 |  6 |
+      3 |  6 |  9 |
+    ```
+
+
+
+### Example 2
+* Sample Script
+
+    ```
+    // : Given
+    int n = 6;
+    
+    // : When
+    String outcome = Tables.getMultiplicationTable(n);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+     1 |  2 |  3 |  4 |  5 |  6 |
+     2 |  4 |  6 |  8 | 10 | 12 |
+     3 |  6 |  9 | 12 | 15 | 18 |
+     4 |  8 | 12 | 16 | 20 | 24 |
+     5 | 10 | 15 | 20 | 25 | 30 |
+     6 | 12 | 18 | 24 | 30 | 36 |
+    ```

README-TriangleUtilities.md

@@ -0,0 +1,156 @@
+# TriangleUtilities
+## `String getRow(int width)`
+* **Description**
+    * In the class, `Triangles` Write a method that returns a `String` representation of a row of asterisks whose length is equal to the `width` specified.
+    
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int width = 10;
+    
+    // : When
+    String outcome = Triangles.getRow(width);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    **********
+    ```
+    
+    
+    
+    
+    
+    
+
+
+
+
+
+
+
+
+<br><br><br><br>
+## `String getSmallTriangle()`
+* **Description**
+    * In the class, `Triangles` Write a method that returns a `String` representation of a small triangle, whose base height and base width is 4 asterisks.
+    
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    // : When
+    String outcome = Triangles.getSmallTriangle();
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    *
+    **
+    ***
+    ****
+    
+    ```
+    
+    
+    
+    
+    
+    
+
+<br><br><br><br>
+## `String getLargeTriangle()`
+* **Description**
+    * Write a method that returns a `String` representation of a large triangle, whose base height and base width is 10 asterisks.
+    
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    // : When
+    String outcome = Triangles.getLargeTriangle();
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    *
+    **
+    ***
+    ****
+    *****
+    ******
+    *******
+    ********
+    *********
+    
+    ```
+
+
+
+
+
+
+
+<br><br><br><br>
+## `String getTriangle(int n)`
+* **Description**
+    * Given one integer, `n`, generate a `String` representation of a triangle whose base height and width is equal to `n`.
+
+	
+### Example
+* Sample Script
+
+    ```
+    // : Given
+    int numberOfRows = 15;
+    
+    // : When
+    String outcome = Triangles.createTriangle(numberOfRows);
+    
+    // : Then
+    System.out.println(outcome);
+    ```
+
+
+
+* Sample Output
+
+    ```
+    *
+    **
+    ***
+    ****
+    *****
+    ******
+    *******
+    ********
+    *********
+    **********
+    ***********
+    ************
+    *************
+    **************
+    
+    ```

README.md

@@ -1,171 +1,25 @@
 # ZCW-MicroLabs-Loops
+* Read through each of the following `README` files and complete each of the asks.
+    * [README-NumberUtilities.md](./README-NumberUtilities.md)
+    * [README-TriangleUtilities.md](./README-NumberUtilities.md)
+    * [README-TableUtilities.md](./README-NumberUtilities.md)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-## 1) 1 to 10
-In the class **Numbers**, complete the method called **oneToTen()** so that it returns a string of the numbers 1 to 10. The Unit Test is provided for you.
-
-### Example<br>
-1: oneToTen()<br>
-2: *** Output ***<br>
-3: 0<br>
-4: 2<br>
-5: 3<br>
-6: 4<br>
-7: 5<br>
-8: 6<br>
-9: 7<br>
-10: 8<br>
-11: 9<br>
-12: 10
-
-## 2) Odd Numbers
-In the class **Numbers**, complete the method called **oddNumbers()** so that it returns a string of the positive odd numbers less than 20. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-1: oddNumbers()<br>
-2: *** Output *** <br>
-3: 1<br>
-4: 3<br>
-5: 5<br>
-6: 7<br>
-7: 9<br>
-8: 11<br>
-9: 13<br>
-10: 15<br>
-11: 17<br>
-12: 19<br>
-
-## 3) Square Numbers
-In the class **Numbers**, complete the method called **squares()** so that it returns a string of the square numbers up to 100. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-1: squares()<br>
-2: *** Output *** <br>
-3: 1<br>
-4: 4<br>
-5: 9<br>
-6: 16<br>
-7: 25<br>
-8: 36<br>
-9: 49<br>
-10: 64<br>
-11: 81<br>
-12: 100<br>
-
-
-~## 4) Random Numbers~ `// this problem is under maintainence; attempt at your own discretion.`
-In the class **Numbers**, complete the method called **random4()** so that it returns a string of out four random integers between 0 and 9. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-1: random4()<br>
-2: *** Output *** <br>
-3: 3<br>
-4: 5<br>
-5: 2<br>
-6: 8<br>
-
-## 5) Even Numbers < n
-
-In the class **Numbers**, complete the method called **even()** so that it returns a string of the positive even numbers less than n. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-1: even(20)<br>
-2: *** Output *** <br>
-3: 2<br>
-4: 4<br>
-5: 6<br>
-6: 8<br>
-7: 10<br>
-8: 12<br>
-9: 14<br>
-10: 16<br>
-11: 18<br>
-
-## 6) Powers of 2
-
-In the class **Numbers**, complete the method called **powers()** so that it returns a string of out the powers of 2 from 2^1 up to to 2^n. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-1: powers(8)<br>
-2: *** Output *** <br>
-3: 2<br>
-4: 4<br>
-5: 8<br>
-6: 16<br>
-7: 32<br>
-8: 64<br>
-9: 128<br>
-10: 256<br>
-
-## 7) Are we there yet?
-* Modify method `areWeThereYet` in the class `CarRide`.
-	* This method should  return `"Good!"` when receiving an argument of `"Yes"`.
-* Create class `CarRideTest`
-	* Create method `testAreWeThereYet1`
-		* The method should ensure the `areWeThereYet` method returns `"Good!"` upon passing an arugment of `"Yes"`.
-
-	* Create method `testAreWeThereYet2`
-		* The method should ensure the `areWeThereYet` method does not return `"Good!"` when receving an argument that is not `"Yes"`.
-
-* Create class `MainApplication`
-	* Using the `CarRide` class, continually prompt the user for input until they response with `"Yes"`.
-	* Upon termination, the application should display the value returned from invokation of `areWeThereYet`.
-
-
-### Sample Console Output<br>
-```
-1: Are we there yet?
-2: No
-3: Are we there yet?
-4: Spoons
-5: Are we there yet?
-6: Yes
-7: Good!
-```
-
-## 8) Triangle
-
-In the class **Shapes**, complete the method called **triangle()** so that it uses nested loops to produce the following pattern . The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-1: triangle()<br>
-2: *** Output *** <br>
-3: * <br>
-4: ** <br>
-5: *** <br>
-6: **** <br>
-7: ***** <br>
-
-## 9) Table Square
-
-In the class **Shapes**, complete the method called **tableSquare()** so that it uses nested loops to produce a 4x4 table square. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
-tableSquare()<br>
-*** Output *** <br>
-A 4 x 4 table square<br>
-
- ```
-|  1 |  2 |  3 |  4 |
-|  2 |  4 |  6 |  8 |
-|  3 |  6 |  9 | 12 |
-|  4 |  8 | 12 | 16 |
- ```
-
- ## 10) Table Squares
-
- In the class **Shapes**, extend your answer to the last question produce a method that will return string of characters out og ***n x n*** table square. The Unit Test is not provided for you, you must complete it.
-
-### Example<br>
- tableSquares(6)<br>
- *** Output *** <br>
- A 6 x 6 table square<br>
- 
- ```
-| 1 |  2 |  3 |  4 |  5 |  6 |
-| 2 |  4 |  6 |  8 | 10 | 12 |
-| 3 |  6 |  9 | 12 | 15 | 18 |
-| 4 |  8 | 12 | 16 | 20 | 24 |
-| 5 | 10 | 15 | 20 | 25 | 30 |
-| 6 | 12 | 18 | 24 | 30 | 36 |
-```
- 

pom.xml

@@ -17,4 +17,9 @@
         </dependency>
 
     </dependencies>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
 </project>

src/main/java/io/zipcoder/microlabs/mastering_loops/CarRide.java

@@ -1,9 +0,0 @@
-package io.zipcoder.microlabs.mastering_loops;
-
-public class CarRide {
-
-    public String areWeThereYetTest(){
-        return "";
-    }
-
-}

src/main/java/io/zipcoder/microlabs/mastering_loops/MainApp.java

@@ -0,0 +1,11 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+import java.util.Scanner;
+
+/**
+ * Created by leon on 1/31/18.
+ */
+public class MainApp {
+    public static void main(String[] args) {
+    }
+}

src/main/java/io/zipcoder/microlabs/mastering_loops/NumberUtilities.java

@@ -0,0 +1,38 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+
+public class NumberUtilities {
+    public static String getEvenNumbers(int start, int stop) {
+        int offset = start % 2 != 0 ? 0 : 1;
+        return getRange(start+offset, stop, 2);
+    }
+
+
+    public static String getOddNumbers(int start, int stop) {
+        int offset = start % 2 == 0 ? 0 : 1;
+        return getRange(start+offset, stop, 2);
+    }
+
+
+    public static String getSquareNumbers(int start, int stop, int step) {
+        return getExponentiations(start, stop, step, 2);
+    }
+
+
+    public static String getRange(int start, int stop, int step) {
+        String result = "";
+        for (int i = start; i < stop; i += step) {
+            result += i;
+        }
+        return result;
+    }
+
+
+    public static String getExponentiations(int start, int stop, int step, int exponent) {
+        String result = "";
+        for (int i = start; i < stop; i += step) {
+            result += (int) Math.pow(i, exponent);
+        }
+        return result;
+    }
+}

src/main/java/io/zipcoder/microlabs/mastering_loops/Numbers.java

@@ -1,30 +0,0 @@
-package io.zipcoder.microlabs.mastering_loops;
-
-
-public class Numbers {
-
-    public String oneToTen(){
-        return "";
-    }
-
-    public String oddNumbers(){
-        return "";
-    }
-
-    public String squares(){
-        return "";
-    }
-
-    public String random4(){
-        return "";
-    }
-
-    public String even(int n){
-        return "";
-    }
-
-    public String powers(int n){
-        return "";
-    }
-
-}

src/main/java/io/zipcoder/microlabs/mastering_loops/Shapes.java

@@ -1,17 +0,0 @@
-package io.zipcoder.microlabs.mastering_loops;
-
-
-public class Shapes {
-
-    public String triangle(){
-        return "";
-    }
-
-    public String tableSquare(){
-        return "";
-    }
-
-    public String tableSquares(int n){
-        return "";
-    }
-}

src/main/java/io/zipcoder/microlabs/mastering_loops/TableUtilities.java

@@ -0,0 +1,22 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+public class TableUtilities {
+    public static String getSmallMultiplicationTable() {
+        return getMultiplicationTable(5);
+    }
+
+    public static String getLargeMultiplicationTable() {
+        return getMultiplicationTable(10);
+    }
+
+    public static String getMultiplicationTable(int tableSize) {
+        String result = "";
+        for (int i = 1; i <= tableSize; i++) {
+            for (int j = 1; j <= tableSize; j++) {
+                result += String.format("%3d |", i * j);
+            }
+            result += "\n";
+        }
+        return result;
+    }
+}

src/main/java/io/zipcoder/microlabs/mastering_loops/TriangleUtilities.java

@@ -0,0 +1,29 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+public class TriangleUtilities {
+
+    public static String getTriangle(int numberOfRows) {
+        String result = "";
+        for(int i=1; i<numberOfRows; i++) {
+            result += getRow(i) + "\n";
+        }
+        return result;
+    }
+
+    public static String getRow(int numberOfStars) {
+        String result = "";
+        for(int k=0; k<numberOfStars; k++) {
+            result += "*";
+        }
+        return result;
+    }
+
+    public static String getSmallTriangle() {
+        return getTriangle(5);
+    }
+
+
+    public static String getLargeTriangle() {
+        return getTriangle(10);
+    }
+}

src/test/java/io/zipcoder/microlabs/mastering_loops/CarRideTest.java

@@ -1,9 +0,0 @@
-package io.zipcoder.microlabs.mastering_loops;
-
-
-import org.junit.Test;
-
-public class CarRideTest {
-
-
-}

src/test/java/io/zipcoder/microlabs/mastering_loops/NumberUtilitiesTest.java

@@ -0,0 +1,112 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class NumberUtilitiesTest {
+    @Test
+    public void testGetRange1() {
+        // : Given
+        String expected = "51015";
+        int start = 5;
+        int stop = 20;
+        int step = 5;
+
+        // : When
+        String actual = NumberUtilities.getRange(start, stop, step);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void testGetRange2() {
+        // : Given
+        String expected = "012345678910111213141516171819";
+        int start = 0;
+        int stop = 20;
+        int step = 1;
+
+        // : When
+        String actual = NumberUtilities.getRange(start, stop, step);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testGetEvenNumbers() {
+        // : Given
+        String expected = "5791113151719";
+        int start = 5;
+        int stop = 20;
+
+        // : When
+        String actual = NumberUtilities.getEvenNumbers(start, stop);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetOddNumbers() {
+        // : Given
+        String expected = "681012141618";
+        int start = 5;
+        int stop = 20;
+        int step = 5;
+
+        // : When
+        String actual = NumberUtilities.getOddNumbers(start, stop);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
+    @Test
+    public void testGetSquareNumbers() {
+        // : Given
+        String expected = "25100225";
+        int start = 5;
+        int stop = 20;
+        int step = 5;
+
+        // : When
+        String actual = NumberUtilities.getSquareNumbers(start, stop, step);
+
+        // : Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void testGetExponentiationNumbers() {
+        // : Given
+        String expected = "25100225";
+        int start = 5;
+        int stop = 20;
+        int step = 5;
+        int exponent = 2;
+
+        // : When
+        String actual = NumberUtilities.getExponentiations(start, stop, step, exponent);
+
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/io/zipcoder/microlabs/mastering_loops/NumbersTest.java

@@ -1,66 +0,0 @@
-package io.zipcoder.microlabs.mastering_loops;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class NumbersTest {
-
-    @Test
-    public void oneToTenTest(){
-        //: Given
-        Numbers numbers = new Numbers();
-        String expected = "*** Output ***\noneToTen()\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10";
-
-        //: When
-        String actual = numbers.oneToTen();
-
-        //: Then
-        Assert.assertEquals("The two strings are equal", expected, actual);
-    }
-
-    @Test
-    public void oddNumbersTest(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-
-    @Test
-    public void squaresTest(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-
-    @Test
-    public void random4Test(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-
-    @Test
-    public void evenTest(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-
-    @Test
-    public void powersTest(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-
-}

src/test/java/io/zipcoder/microlabs/mastering_loops/ShapesTest.java

@@ -1,28 +0,0 @@
-package io.zipcoder.microlabs.mastering_loops;
-
-
-import org.junit.Test;
-import org.junit.Assert;
-
-public class ShapesTest {
-
-
-
-    @Test
-    public void triangleTest(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-
-    @Test
-    public void tableSquareTest(){
-        //: Given
-
-        //: When
-
-        //: Then
-    }
-}

src/test/java/io/zipcoder/microlabs/mastering_loops/TableUtilitiesTest.java

@@ -0,0 +1,69 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Created by leon on 1/31/18.
+ */
+public class TableUtilitiesTest {
+    @Test
+    public void testGetLargeMultiplicationTable() {
+        String expected =
+                "  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 10 |\n" +
+                "  2 |  4 |  6 |  8 | 10 | 12 | 14 | 16 | 18 | 20 |\n" +
+                "  3 |  6 |  9 | 12 | 15 | 18 | 21 | 24 | 27 | 30 |\n" +
+                "  4 |  8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | 40 |\n" +
+                "  5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 |\n" +
+                "  6 | 12 | 18 | 24 | 30 | 36 | 42 | 48 | 54 | 60 |\n" +
+                "  7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63 | 70 |\n" +
+                "  8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 |\n" +
+                "  9 | 18 | 27 | 36 | 45 | 54 | 63 | 72 | 81 | 90 |\n" +
+                " 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 |100 |\n";
+
+        String actual = TableUtilities.getLargeMultiplicationTable();
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void testGetSmallMultiplicationTable() {
+        String expected =
+                        "  1 |  2 |  3 |  4 |  5 |\n" +
+                        "  2 |  4 |  6 |  8 | 10 |\n" +
+                        "  3 |  6 |  9 | 12 | 15 |\n" +
+                        "  4 |  8 | 12 | 16 | 20 |\n" +
+                        "  5 | 10 | 15 | 20 | 25 |\n";
+
+        String actual = TableUtilities.getSmallMultiplicationTable();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetMultiplicationTable() {
+        String expected =
+                "  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |\n" +
+                "  2 |  4 |  6 |  8 | 10 | 12 | 14 | 16 | 18 | 20 | 22 | 24 | 26 | 28 | 30 | 32 | 34 | 36 | 38 | 40 |\n" +
+                "  3 |  6 |  9 | 12 | 15 | 18 | 21 | 24 | 27 | 30 | 33 | 36 | 39 | 42 | 45 | 48 | 51 | 54 | 57 | 60 |\n" +
+                "  4 |  8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | 40 | 44 | 48 | 52 | 56 | 60 | 64 | 68 | 72 | 76 | 80 |\n" +
+                "  5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 | 55 | 60 | 65 | 70 | 75 | 80 | 85 | 90 | 95 |100 |\n" +
+                "  6 | 12 | 18 | 24 | 30 | 36 | 42 | 48 | 54 | 60 | 66 | 72 | 78 | 84 | 90 | 96 |102 |108 |114 |120 |\n" +
+                "  7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63 | 70 | 77 | 84 | 91 | 98 |105 |112 |119 |126 |133 |140 |\n" +
+                "  8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 |104 |112 |120 |128 |136 |144 |152 |160 |\n" +
+                "  9 | 18 | 27 | 36 | 45 | 54 | 63 | 72 | 81 | 90 | 99 |108 |117 |126 |135 |144 |153 |162 |171 |180 |\n" +
+                " 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 |100 |110 |120 |130 |140 |150 |160 |170 |180 |190 |200 |\n" +
+                " 11 | 22 | 33 | 44 | 55 | 66 | 77 | 88 | 99 |110 |121 |132 |143 |154 |165 |176 |187 |198 |209 |220 |\n" +
+                " 12 | 24 | 36 | 48 | 60 | 72 | 84 | 96 |108 |120 |132 |144 |156 |168 |180 |192 |204 |216 |228 |240 |\n" +
+                " 13 | 26 | 39 | 52 | 65 | 78 | 91 |104 |117 |130 |143 |156 |169 |182 |195 |208 |221 |234 |247 |260 |\n" +
+                " 14 | 28 | 42 | 56 | 70 | 84 | 98 |112 |126 |140 |154 |168 |182 |196 |210 |224 |238 |252 |266 |280 |\n" +
+                " 15 | 30 | 45 | 60 | 75 | 90 |105 |120 |135 |150 |165 |180 |195 |210 |225 |240 |255 |270 |285 |300 |\n" +
+                " 16 | 32 | 48 | 64 | 80 | 96 |112 |128 |144 |160 |176 |192 |208 |224 |240 |256 |272 |288 |304 |320 |\n" +
+                " 17 | 34 | 51 | 68 | 85 |102 |119 |136 |153 |170 |187 |204 |221 |238 |255 |272 |289 |306 |323 |340 |\n" +
+                " 18 | 36 | 54 | 72 | 90 |108 |126 |144 |162 |180 |198 |216 |234 |252 |270 |288 |306 |324 |342 |360 |\n" +
+                " 19 | 38 | 57 | 76 | 95 |114 |133 |152 |171 |190 |209 |228 |247 |266 |285 |304 |323 |342 |361 |380 |\n" +
+                " 20 | 40 | 60 | 80 |100 |120 |140 |160 |180 |200 |220 |240 |260 |280 |300 |320 |340 |360 |380 |400 |\n";
+        String actual = TableUtilities.getMultiplicationTable(20);
+        Assert.assertEquals(expected, actual);
+    }
+
+}

src/test/java/io/zipcoder/microlabs/mastering_loops/TriangleUtilitiesTest.java

@@ -0,0 +1,72 @@
+package io.zipcoder.microlabs.mastering_loops;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TriangleUtilitiesTest {
+
+    @Test
+    public void getRow() {
+        String expected = "********************";
+        int width = 20;
+        String actual = TriangleUtilities.getRow(width);
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void getTriangleTest1() {
+        String expected =
+                "*\n" +
+                        "**\n" +
+                        "***\n" +
+                        "****\n" +
+                        "*****\n" +
+                        "******\n" +
+                        "*******\n" +
+                        "********\n" +
+                        "*********\n";
+        String actual = TriangleUtilities.getTriangle(10);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void getTriangleTest2() {
+        String expected =
+                "*\n" +
+                        "**\n" +
+                        "***\n" +
+                        "****\n";
+        String actual = TriangleUtilities.getTriangle(5);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetLargeTriangle() {
+        String expected =
+                "*\n" +
+                "**\n" +
+                "***\n" +
+                "****\n" +
+                "*****\n" +
+                "******\n" +
+                "*******\n" +
+                "********\n" +
+                "*********\n";
+        String actual = TriangleUtilities.getLargeTriangle();
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void testGetSmallTriangle() {
+        String expected =
+                        "*\n" +
+                        "**\n" +
+                        "***\n" +
+                        "****\n";
+        String actual = TriangleUtilities.getSmallTriangle();
+        Assert.assertEquals(expected, actual);
+    }
+}