update

.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>

src/main/java/rocks/zipcode/io/quiz3/arrays/TicTacToe.java

@@ -22,7 +22,7 @@ public class TicTacToe {
         return null;
     }
 
-    public Boolean isColumnHomogenous(Integer value) {
+    public Boolean isColumnHomogeneous(Integer value) {
         return null;
     }
 

src/main/java/rocks/zipcode/io/quiz3/arrays/WaveGenerator.java

@@ -10,6 +10,7 @@ import java.util.List;
  */
 public class WaveGenerator {
     public static String[] wave(String str) {
+        str = str.toLowerCase();
         List<String> list = new ArrayList<>();
         for (int i = 0; i < str.length(); i++) {
             String currentCharacter = String.valueOf(str.charAt(i));

src/main/java/rocks/zipcode/io/quiz3/collections/ShoeFitter.java

@@ -6,10 +6,6 @@ import java.util.Map;
  * @author leon on 09/12/2018.
  */
 public class ShoeFitter {
-    public ShoeFitter(Map<Person, ShoeSize> shoeSizeMap) {
-
-    }
-
     public ShoeFitter() {
     }
 

src/main/java/rocks/zipcode/io/quiz3/fundamentals/StringUtils.java

@@ -4,11 +4,15 @@ package rocks.zipcode.io.quiz3.fundamentals;
  * @author leon on 09/12/2018.
  */
 public class StringUtils {
-    public static String capitalizeNthCharacter(String baseString, Integer indexToCapitalize) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+    public static String capitalizeNthCharacter(String str, Integer indexToCapitalize) {
+        String prefix = str.substring(0, indexToCapitalize);
+        String suffix = str.substring(indexToCapitalize+1, str.length());
+        String charToCapitalize = String.valueOf(str.charAt(indexToCapitalize));
+        String result = prefix + charToCapitalize.toUpperCase() + suffix + "";
+        return result;
     }
 
-    public static Boolean isCharacterAtIndex(String baseString, char c) {
+    public static Boolean isCharacterAtIndex(String baseString, Character characterToCheckFor, Integer indexOfString) {
         return null;
     }
 }

src/test/java/rocks/zipcode/io/quiz3/arrays/squarearrayanalyzer/CompareAssortedArrays.java

@@ -0,0 +1,52 @@
+package rocks.zipcode.io.quiz3.arrays.squarearrayanalyzer;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.arrays.SquareArrayAnalyzer;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class CompareAssortedArrays {
+
+    @Test
+    public void test1() {
+        Integer[] array = {1, 2, 3};
+        Integer[] arraySquared = {1, 4, 9};
+        assortAndCompare(array, arraySquared);
+    }
+
+    @Test
+    public void test2() {
+        Integer[] array = {3, 4, 5};
+        Integer[] arraySquared = {9, 16, 25};
+        assortAndCompare(array, arraySquared);
+    }
+
+    @Test
+    public void test3() {
+        Integer[] array = {121, 144, 19, 161, 19, 144, 19, 11};
+        Integer[] arraySquared = {121, 14641, 20736, 361, 25921, 361, 20736, 361};
+        assortAndCompare(array, arraySquared);
+    }
+    
+    private void assortAndCompare(Integer[] array1, Integer[] array2) {
+        List<Integer> intList1 = Arrays.asList(array1);
+        List<Integer> intList2 = Arrays.asList(array2);
+        
+        Collections.shuffle(intList1);
+        Collections.shuffle(intList2);
+        
+        array1 = intList1.toArray(new Integer[intList1.size()]);
+        array2 = intList2.toArray(new Integer[intList2.size()]);
+        
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array1, array2));
+    }
+    
+    
+
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/squarearrayanalyzer/CompareSortedArrays.java

@@ -0,0 +1,53 @@
+package rocks.zipcode.io.quiz3.arrays.squarearrayanalyzer;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.arrays.SquareArrayAnalyzer;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class CompareSortedArrays {
+
+    @Test
+    public void test0() {
+        Integer[] array = {1};
+        Integer[] arraySquared = {1};
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array, arraySquared));
+    }
+
+    @Test
+    public void test1() {
+        Integer[] array = {2};
+        Integer[] arraySquared = {4};
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array, arraySquared));
+    }
+
+    @Test
+    public void test2() {
+        Integer[] array = {3};
+        Integer[] arraySquared = {9};
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array, arraySquared));
+    }
+
+    @Test
+    public void test3() {
+        Integer[] array = {1,2,3};
+        Integer[] arraySquared = {1,4,9};
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array, arraySquared));
+    }
+
+    @Test
+    public void test4() {
+        Integer[] array = {3,4,5,};
+        Integer[] arraySquared = {9,16,25};
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array, arraySquared));
+    }
+
+    @Test
+    public void test5() {
+        Integer[] array = {121, 144, 19, 161, 19, 144, 19, 11};
+        Integer[] arraySquared = {121, 14641, 20736, 361, 25921, 361, 20736, 361};
+        Assert.assertTrue(SquareArrayAnalyzer.compare(array, arraySquared));
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/tictactoe/ConstructorTest.java

@@ -0,0 +1,22 @@
+package rocks.zipcode.io.quiz3.arrays.tictactoe;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.arrays.TicTacToe;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class ConstructorTest {
+    //    @Test
+    public void nullaryConstructor() {
+    }
+
+    @Test
+    public void parametrizedConstructor() {
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/tictactoe/GetColumnTest.java

@@ -0,0 +1,64 @@
+package rocks.zipcode.io.quiz3.arrays.tictactoe;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.TestUtils;
+import rocks.zipcode.io.quiz3.arrays.TicTacToe;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class GetColumnTest {
+    @Test
+    public void test1() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndexToFetch = 0;
+        String[] expected = {"X", "O", "O"};
+
+        // when
+        String[] actual = ticTacToe.getColumn(columnIndexToFetch);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndexToFetch = 1;
+        String[] expected = {"O", "X", "X"};
+
+        // when
+        String[] actual = ticTacToe.getColumn(columnIndexToFetch);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "X"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndexToFetch = 2;
+        String[] expected = {"X", "X", "O"};
+
+        // when
+        String[] actual = ticTacToe.getColumn(columnIndexToFetch);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/tictactoe/GetRowTest.java

@@ -0,0 +1,64 @@
+package rocks.zipcode.io.quiz3.arrays.tictactoe;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.TestUtils;
+import rocks.zipcode.io.quiz3.arrays.TicTacToe;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class GetRowTest {
+    @Test
+    public void test1() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer indexToFetch = 0;
+        String[] expected = row1;
+
+        // when
+        String[] actual = ticTacToe.getRow(indexToFetch);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer indexToFetch = 1;
+        String[] expected = row2;
+
+        // when
+        String[] actual = ticTacToe.getRow(indexToFetch);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer indexToFetch = 2;
+        String[] expected = row3;
+
+        // when
+        String[] actual = ticTacToe.getRow(indexToFetch);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/tictactoe/GetWinner.java

@@ -0,0 +1,39 @@
+package rocks.zipcode.io.quiz3.arrays.tictactoe;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.arrays.TicTacToe;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class GetWinner {
+    @Test
+    public void test1() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/tictactoe/IsColumnHomogeneousTest.java

@@ -0,0 +1,64 @@
+package rocks.zipcode.io.quiz3.arrays.tictactoe;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.arrays.TicTacToe;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class IsColumnHomogeneousTest {
+    @Test
+    public void test1() {
+        // given
+        String[] row1 = {"O", "X", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndex = 0;
+
+        Assert.assertTrue(ticTacToe.isColumnHomogeneous(columnIndex));
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] row1 = {"O", "X", "X"};
+        String[] row2 = {"X", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndex = 0;
+
+        Assert.assertFalse(ticTacToe.isColumnHomogeneous(columnIndex));
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String[] row1 = {"O", "X", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndex = 1;
+
+        Assert.assertTrue(ticTacToe.isColumnHomogeneous(columnIndex));
+    }
+
+    @Test
+    public void test4() {
+        // given
+        String[] row1 = {"O", "X", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer columnIndex = 2;
+
+        Assert.assertFalse(ticTacToe.isColumnHomogeneous(columnIndex));
+    }
+
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/tictactoe/IsRowHomogeneousTest.java

@@ -0,0 +1,64 @@
+package rocks.zipcode.io.quiz3.arrays.tictactoe;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.arrays.TicTacToe;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class IsRowHomogeneousTest {
+    @Test
+    public void test1() {
+        // given
+        String[] row1 = {"X", "X", "X"};
+        String[] row2 = {"O", "O", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer rowIndex = 0;
+
+        Assert.assertTrue(ticTacToe.isRowHomogenous(rowIndex));
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] row1 = {"X", "X", "X"};
+        String[] row2 = {"O", "O", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer rowIndex = 1;
+
+        Assert.assertTrue(ticTacToe.isRowHomogenous(rowIndex));
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String[] row1 = {"X", "X", "X"};
+        String[] row2 = {"O", "O", "O"};
+        String[] row3 = {"O", "X", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer rowIndex = 2;
+
+        Assert.assertFalse(ticTacToe.isRowHomogenous(rowIndex));
+    }
+
+
+    @Test
+    public void test4() {
+        // given
+        String[] row1 = {"X", "O", "X"};
+        String[] row2 = {"O", "X", "O"};
+        String[] row3 = {"O", "O", "O"};
+        String[][] board = {row1, row2, row3};
+        TicTacToe ticTacToe = new TicTacToe(board);
+        Integer rowIndex = 2;
+
+        Assert.assertTrue(ticTacToe.isRowHomogenous(rowIndex));
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/arrays/wavegenerator/WaveTest.java

@@ -0,0 +1,151 @@
+package rocks.zipcode.io.quiz3.arrays.wavegenerator;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.TestUtils;
+import rocks.zipcode.io.quiz3.arrays.WaveGenerator;
+
+/**
+ * @author leon on 10/12/2018.
+ */
+public class WaveTest {
+    @Test
+    public void test0() {
+        // given
+        String input = "AAAAAAA";
+        String[] expected = {
+                "Aaaaaaa",
+                "aAaaaaa",
+                "aaAaaaa",
+                "aaaAaaa",
+                "aaaaAaa",
+                "aaaaaAa",
+                "aaaaaaA"};
+
+        // when
+        String[] actual = WaveGenerator.wave(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test1() {
+        // given
+        String input = "aaaaaaa";
+        String[] expected = {
+                "Aaaaaaa",
+                "aAaaaaa",
+                "aaAaaaa",
+                "aaaAaaa",
+                "aaaaAaa",
+                "aaaaaAa",
+                "aaaaaaA"};
+
+        // when
+        String[] actual = WaveGenerator.wave(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String input = "A_A_A";
+        String[] expected = {
+                "A_a_a",
+                "a_A_a",
+                "a_a_A"};
+
+        // when
+        String[] actual = WaveGenerator.wave(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test4() {
+        // given
+        String input = "Radioactivity";
+        String[] expected = {
+                "Radioactivity",
+                "rAdioactivity",
+                "raDioactivity",
+                "radIoactivity",
+                "radiOactivity",
+                "radioActivity",
+                "radioaCtivity",
+                "radioacTivity",
+                "radioactIvity",
+                "radioactiVity",
+                "radioactivIty",
+                "radioactiviTy",
+                "radioactivitY"};
+
+        // when
+        String[] actual = WaveGenerator.wave(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test5() {
+        // given
+        String input = "the quick brown fox";
+        String[] expected = {
+                "The quick brown fox",
+                "tHe quick brown fox",
+                "thE quick brown fox",
+                "the Quick brown fox",
+                "the qUick brown fox",
+                "the quIck brown fox",
+                "the quiCk brown fox",
+                "the quicK brown fox",
+                "the quick Brown fox",
+                "the quick bRown fox",
+                "the quick brOwn fox",
+                "the quick broWn fox",
+                "the quick browN fox",
+                "the quick brown Fox",
+                "the quick brown fOx",
+                "the quick brown foX"};
+
+        // when
+        String[] actual = WaveGenerator.wave(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test6() {
+        // given
+        String input = "the quick brown f0x!";
+        String[] expected = {
+                "The quick brown f0x!",
+                "tHe quick brown f0x!",
+                "thE quick brown f0x!",
+                "the Quick brown f0x!",
+                "the qUick brown f0x!",
+                "the quIck brown f0x!",
+                "the quiCk brown f0x!",
+                "the quicK brown f0x!",
+                "the quick Brown f0x!",
+                "the quick bRown f0x!",
+                "the quick brOwn f0x!",
+                "the quick broWn f0x!",
+                "the quick browN f0x!",
+                "the quick brown F0x!",
+                "the quick brown f0X!"};
+
+        // when
+        String[] actual = WaveGenerator.wave(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz3/fundamentals/stringutils/IsCharacterAtIndex.java

@@ -1,7 +1,56 @@
 package rocks.zipcode.io.quiz3.fundamentals.stringutils;
 
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.fundamentals.StringUtils;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class IsCharacterAtIndex {
+    @Test
+    public void test1() {
+        // given
+        String string = "Quickly";
+        Character character = 'q';
+        Integer index = 0;
+
+        // then
+        Assert.assertTrue(StringUtils.isCharacterAtIndex(string, character, index));
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String string = "Quickly";
+        Character character = 'Q';
+        Integer index = 0;
+
+        // then
+        Assert.assertFalse(StringUtils.isCharacterAtIndex(string, character, index));
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String string = "Quickly";
+        Character character = 'y';
+        Integer index = 6;
+
+        // then
+        Assert.assertTrue(StringUtils.isCharacterAtIndex(string, character, index));
+    }
+
+    @Test
+    public void test4() {
+        // given
+        String string = "Quickly";
+        Character character = 'Y';
+        Integer index = 6;
+
+        // then
+        Assert.assertFalse(StringUtils.isCharacterAtIndex(string, character, index));
+    }
+
 }

src/test/java/rocks/zipcode/io/quiz3/fundamentals/vowelutils/GetIndexOfFirstVowel.java

@@ -1,7 +1,50 @@
 package rocks.zipcode.io.quiz3.fundamentals.vowelutils;
 
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.fundamentals.VowelUtils;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class GetIndexOfFirstVowel {
+    @Test
+    public void test1() {
+        // given
+        String input = "Psychological Warfare";
+        Integer expected = 5;
+
+        // when
+        Integer actual = VowelUtils.getIndexOfFirstVowel(input);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String input = "Psych!";
+        Integer expected = null;
+
+        // when
+        Integer actual = VowelUtils.getIndexOfFirstVowel(input);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String input = "Pterodactyl";
+        Integer expected = 2;
+
+        // when
+        Integer actual = VowelUtils.getIndexOfFirstVowel(input);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
 }

src/test/java/rocks/zipcode/io/quiz3/fundamentals/vowelutils/HasVowels.java

@@ -1,7 +1,28 @@
 package rocks.zipcode.io.quiz3.fundamentals.vowelutils;
 
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.fundamentals.VowelUtils;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class HasVowels {
+    @Test
+    public void test1() {
+        String input = "qwrtypsdfghjklzxcvbnm";
+        Assert.assertFalse(VowelUtils.hasVowels(input));
+    }
+
+    @Test
+    public void test2() {
+        String input = "qwrtypsdfghjklzxcvbnma";
+        Assert.assertTrue(VowelUtils.hasVowels(input));
+    }
+
+    @Test
+    public void test3() {
+        String input = "qwrtypsdfghjklzxcvbnm_";
+        Assert.assertFalse(VowelUtils.hasVowels(input));
+    }
 }

src/test/java/rocks/zipcode/io/quiz3/fundamentals/vowelutils/IsVowel.java

@@ -1,7 +1,40 @@
 package rocks.zipcode.io.quiz3.fundamentals.vowelutils;
 
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz3.fundamentals.VowelUtils;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class IsVowel {
+    @Test
+    public void test1() {
+        Assert.assertTrue(VowelUtils.isVowel('a'));
+    }
+
+    @Test
+    public void test2() {
+        Assert.assertTrue(VowelUtils.isVowel('A'));
+    }
+
+    @Test
+    public void test3() {
+        Assert.assertTrue(VowelUtils.isVowel('E'));
+    }
+
+    @Test
+    public void test4() {
+        Assert.assertTrue(VowelUtils.isVowel('e'));
+    }
+
+    @Test
+    public void test5() {
+        Assert.assertTrue(VowelUtils.isVowel('I'));
+    }
+
+    @Test
+    public void test6() {
+        Assert.assertTrue(VowelUtils.isVowel('i'));
+    }
 }