first commit

.gitignore

+# Created by .ignore support plugin (hsz.mobi)
+### Java template
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+### Eclipse template
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+### macOS template
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+#Intellij files
+.idea
+*.iml
+
+#maven build target
+target/

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>rocks.zipcode.io</groupId>
+    <artifactId>quiz4</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+
+</project>

src/main/java/rocks/zipcode/io/quiz4/collections/ComparableTreeSet.java

+package rocks.zipcode.io.quiz4.collections;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class ComparableTreeSet<_> {
+    public ComparableTreeSet(_... arr) {
+    }
+
+
+    public ComparableTreeSet() {
+    }
+
+    public Integer compareTo(ComparableTreeSet<_> o) {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/collections/SimpleStringGroup.java

+package rocks.zipcode.io.quiz4.collections;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class SimpleStringGroup {
+    public SimpleStringGroup() {
+        throw new UnsupportedOperationException("Method not yet implemented");
+    }
+
+    public Integer count() {
+        return null;
+    }
+
+    public void insert(String string) {
+    }
+
+    public Boolean has(String valueToInsert) {
+        return null;
+    }
+
+    public String fetch(int indexOfValue) {
+        return null;
+    }
+
+    public void delete(String valueToInsert) {
+    }
+
+    public void clear() {
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/collections/ZipCodeWilmington.java

+package rocks.zipcode.io.quiz4.collections;
+
+import rocks.zipcode.io.quiz4.objectorientation.Student;
+
+import java.util.Map;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class ZipCodeWilmington {
+    public void enroll(Student student) {
+    }
+
+    public Boolean isEnrolled(Student student) {
+        return null;
+    }
+
+    public void lecture(double numberOfHours) {
+    }
+
+    public Map<Student, Double> getStudyMap() {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/fundamentals/PalindromeEvaluator.java

+package rocks.zipcode.io.quiz4.fundamentals;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class PalindromeEvaluator {
+    public static String[] getAllPalindromes(String string) {
+        return null;
+    }
+
+    public static Boolean isPalindrome(String string) {
+        return null;
+    }
+
+    public static String reverseString(String string) {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/fundamentals/StringEvaluator.java

+package rocks.zipcode.io.quiz4.fundamentals;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringEvaluator {
+    public static String[] getAllPrefixes(String string) {
+        return null;
+    }
+
+    public static String[] getCommonPrefixes(String string1, String string2) {
+        return null;
+    }
+
+    public static String getLargestCommonPrefix(String string1, String string2) {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/generics/GenericUtils.java

+package rocks.zipcode.io.quiz4.generics;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GenericUtils {
+    public static <_ extends Comparable> Iterable<Iterable<_>> powerSet(Set<_> originalSet) {
+        return null;
+    }
+
+    public static <_ extends Comparable> Iterable<Iterable<_>> powerSet(_... originalSet) {
+        return powerSet(new TreeSet<>(Arrays.asList(originalSet)));
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/generics/Group.java

+package rocks.zipcode.io.quiz4.generics;
+
+import java.util.Iterator;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class Group<_> {
+    public Group() {
+        throw new UnsupportedOperationException("Method not yet implemented");
+    }
+
+    public Integer count() {
+        return null;
+    }
+
+    public void insert(_ value) {
+    }
+
+    public Boolean has(_ value) {
+        return null;
+    }
+
+    public _ fetch(int indexOfValue) {
+        return null;
+    }
+
+    public void delete(_ value) {
+    }
+
+    public void clear() {
+    }
+
+    public Iterator<_> iterator() {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/generics/GroupInterface.java

+package rocks.zipcode.io.quiz4.generics;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public interface GroupInterface<_> extends Iterable<_> {
+    Integer count();
+    Boolean has(_ valueToInsert);
+    _ fetch(int indexOfValue);
+    void insert(_ string);
+    void delete(_ valueToInsert);
+    void clear();
+}

src/main/java/rocks/zipcode/io/quiz4/generics/MyStack.java

+package rocks.zipcode.io.quiz4.generics;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class MyStack<SomeType> {
+    public MyStack() {
+        throw new UnsupportedOperationException("Method not yet implemented");
+    }
+
+    public Boolean isEmpty() {
+        return null;
+    }
+
+    public void push(SomeType i) {
+    }
+
+    public SomeType peek() {
+        throw new UnsupportedOperationException("Method not yet implemented");
+    }
+
+    public SomeType pop() {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/generics/SortedGroup.java

+package rocks.zipcode.io.quiz4.generics;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class SortedGroup<_> extends Group<_> {
+    @Override
+    public void insert(_ value) {
+    }
+
+    @Override
+    public void delete(_ value) {
+    }
+
+    public Integer indexOf(_ firstValue) {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/objectorientation/PalindromeObject.java

+package rocks.zipcode.io.quiz4.objectorientation;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class PalindromeObject {
+    public PalindromeObject(String input) {
+    }
+
+    public String[] getAllPalindromes(){
+        return null;
+    }
+
+    public Boolean isPalindrome(){
+        return null;
+    }
+
+    public String reverseString(){
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/objectorientation/StringAssembler.java

+package rocks.zipcode.io.quiz4.objectorientation;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringAssembler {
+    public StringAssembler(Character delimeter) {
+    }
+
+    public StringAssembler append(String str) {
+        return null;
+    }
+
+    public String assemble() {
+        return null;
+    }
+}

src/main/java/rocks/zipcode/io/quiz4/objectorientation/Student.java

+package rocks.zipcode.io.quiz4.objectorientation;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class Student {
+    public Student() {
+        this(null);
+    }
+
+    public Student(Integer id) {
+    }
+
+    public void learn(Double amountOfHours) {
+    }
+
+    public Double getTotalStudyTime() {
+        return null;
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/ComparableTreeSetPolymorphismTest.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+import java.util.TreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class ComparableTreeSetPolymorphismTest {
+    @Test
+    public void test1() {
+        Assert.assertTrue((Object)new ComparableTreeSet() instanceof TreeSet);
+    }
+
+    @Test
+    public void test2() {
+        Assert.assertTrue(new ComparableTreeSet() instanceof Comparable);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/ToStringTest.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class ToStringTest {
+    @Test
+    public void test1() {
+        // given
+        String[] input = "qwertyuiop".split("");
+        ComparableTreeSet<String> set = new ComparableTreeSet<>(input);
+        String expected = "[e, i, o, p, q, r, t, u, w, y]";
+
+        // when
+        String actual = set.toString();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] input = "asdfghjk".split("");
+        ComparableTreeSet<String> set = new ComparableTreeSet<>(input);
+        String expected = "[a, d, f, g, h, j, k, s]";
+
+        // when
+        String actual = set.toString();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/flatset/multipleelement/CompareMultipleElementNegative.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.flatset.multipleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CompareMultipleElementNegative {
+
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Arty", "Fee", "Shawl");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Burt", "Bot", "Boi");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Candy", "Cane");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Corny", "Carl");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/flatset/multipleelement/CompareMultipleElementNeutral.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.flatset.multipleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CompareMultipleElementNeutral {
+
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Arty", "Fee", "Shawl");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Fee", "Shawl", "Arty");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual == 0);
+    }
+
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("The", "Quick", "Brown", "Fox", "Jumps");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Jumps", "Brown", "Fox", "Quick", "The");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual == 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/flatset/multipleelement/CompareMultipleElementPositive.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.flatset.multipleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CompareMultipleElementPositive {
+
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Burt", "Belly", "Bot");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Arty", "Fee", "Shawl");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Corny", "Carl", "Cart");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Candy", "Cane", "Corks");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Corny", "Carl", "Cart");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("", "a", "z");
+
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/flatset/singleelement/CompareSingleElementNeutral.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.flatset.singleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CompareSingleElementNeutral {
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("a");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("a");
+        Integer expected = 0;
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("b");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("b");
+        Integer expected = 0;
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("c");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("c");
+        Integer expected = 0;
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/flatset/singleelement/CompareSingleElementSetNegative.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.flatset.singleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CompareSingleElementSetNegative {
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> a = new ComparableTreeSet<>("a");
+        ComparableTreeSet<String> b = new ComparableTreeSet<>("b");
+
+        // when
+        Integer actual = a.compareTo(b);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> a = new ComparableTreeSet<>("a");
+        ComparableTreeSet<String> c = new ComparableTreeSet<>("c");
+
+        // when
+        Integer actual = a.compareTo(c);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        ComparableTreeSet<String> a = new ComparableTreeSet<>("a");
+        ComparableTreeSet<String> d = new ComparableTreeSet<>("d");
+
+        // when
+        Integer actual = a.compareTo(d);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/flatset/singleelement/CompareSingleElementSetPositive.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.flatset.singleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CompareSingleElementSetPositive {
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("b");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("a");
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("c");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("a");
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("d");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("a");
+        // when
+        Integer actual = set1.compareTo(set2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/nestedset/multipleelement/NestedSetCompareMultipleElementNegative.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.nestedset.multipleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class NestedSetCompareMultipleElementNegative {
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Arty", "Fee", "Shawl");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Burt", "Bot");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset1 = new ComparableTreeSet<>(set1, set2);
+
+        ComparableTreeSet<String> set3 = new ComparableTreeSet<>("Candy", "Cane");
+        ComparableTreeSet<String> set4 = new ComparableTreeSet<>("Corny", "Carl");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset2 = new ComparableTreeSet<>(set3, set4);
+
+        // when
+        Integer actual = powerset1.compareTo(powerset2);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Froilan", "Miranda");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Wilhem", "Alcivar");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset1 = new ComparableTreeSet<>(set1, set2);
+
+        ComparableTreeSet<String> set3 = new ComparableTreeSet<>("Leon", "Hunter");
+        ComparableTreeSet<String> set4 = new ComparableTreeSet<>("Nhu", "Nguyen");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset2 = new ComparableTreeSet<>(set3, set4);
+
+        // when
+        Integer actual = powerset1.compareTo(powerset2);
+
+        // then
+        Assert.assertTrue(actual < 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/nestedset/multipleelement/NestedSetCompareMultipleElementNeutral.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.nestedset.multipleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class NestedSetCompareMultipleElementNeutral {
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Wilhem", "Alcivar");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Leon", "Hunter");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset1 = new ComparableTreeSet<>(set1, set2);
+
+        ComparableTreeSet<String> set3 = new ComparableTreeSet<>("Leon", "Hunter");
+        ComparableTreeSet<String> set4 = new ComparableTreeSet<>("Wilhem", "Alcivar");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset2 = new ComparableTreeSet<>(set3, set4);
+
+        // when
+        Integer actual = powerset1.compareTo(powerset2);
+
+        // then
+        Assert.assertTrue(actual == 0);
+    }
+
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("The", "Quick", "Brown", "Fox", "Jumps");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Over", "The", "Lazy", "Dog");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset1 = new ComparableTreeSet<>(set1, set2);
+
+        ComparableTreeSet<String> set3 = new ComparableTreeSet<>("Brown", "Jumps", "Fox", "Quick", "The");
+        ComparableTreeSet<String> set4 = new ComparableTreeSet<>("The", "Lazy", "Dog", "Over");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset2 = new ComparableTreeSet<>(set3, set4);
+
+        // when
+        Integer actual = powerset1.compareTo(powerset2);
+
+        // then
+        Assert.assertTrue(actual == 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/nestedset/multipleelement/NestedSetCompareMultipleElementPositive.java

+package rocks.zipcode.io.quiz4.collections.comparabletreeset.compareto.nestedset.multipleelement;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class NestedSetCompareMultipleElementPositive {
+    @Test
+    public void test1() {
+        // given
+        ComparableTreeSet<String> set3 = new ComparableTreeSet<>("Froilan", "Miranda");
+        ComparableTreeSet<String> set4 = new ComparableTreeSet<>("Nhu", "Nguyen");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset1 = new ComparableTreeSet<>(set3, set4);
+
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Wilhem", "Alcivar");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Leon", "Hunter");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset2 = new ComparableTreeSet<>(set1, set2);
+
+        // when
+        Integer actual = powerset1.compareTo(powerset2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+
+
+    @Test
+    public void test2() {
+        // given
+        ComparableTreeSet<String> set3 = new ComparableTreeSet<>("Kris", "Younger");
+        ComparableTreeSet<String> set4 = new ComparableTreeSet<>("Leon", "Hunter");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset1 = new ComparableTreeSet<>(set3, set4);
+
+        ComparableTreeSet<String> set1 = new ComparableTreeSet<>("Nhu", "Nguyen");
+        ComparableTreeSet<String> set2 = new ComparableTreeSet<>("Wilhem", "Alcivar");
+        ComparableTreeSet<ComparableTreeSet<String>> powerset2 = new ComparableTreeSet<>(set1, set2);
+
+        // when
+        Integer actual = powerset1.compareTo(powerset2);
+
+        // then
+        Assert.assertTrue(actual > 0);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/ClearTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class ClearTest {
+    @Test
+    public void test1() {
+        test("first", "clear", "test");
+    }
+
+    @Test
+    public void test2() {
+        test("an", "additional", "test", "here");
+    }
+
+    @Test
+    public void test3() {
+        test("a", "dash", "of", "anonymity");
+    }
+
+    private void test(String... valuesToInsert) {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+        for(String valueToInsert : valuesToInsert) {
+            group.insert(valueToInsert);
+            Assert.assertTrue(group.has(valueToInsert));
+        }
+
+        // when
+        group.clear();
+
+
+        // then
+        for(String valueToInsert : valuesToInsert) {
+            Assert.assertFalse(group.has(valueToInsert));
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/CountTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+import java.util.UUID;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class CountTest {
+    @Test
+    public void test1() {
+        test(1);
+    }
+
+    @Test
+    public void test2() {
+        test(2);
+    }
+
+
+    @Test
+    public void test3() {
+        test(3);
+    }
+
+    public void test(Integer numberOfItemsToAdd) {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+
+        // when
+        for (int i = 0; i < numberOfItemsToAdd; i++) {
+            String itemToAdd = UUID.randomUUID().toString();
+            group.insert(itemToAdd);
+        }
+
+        // then
+        Assert.assertEquals(group.count(), numberOfItemsToAdd);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/DeleteTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class DeleteTest {
+    @Test
+    public void test1() {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+        String valueToInsert = "first test";
+
+        // when
+        group.insert(valueToInsert);
+        group.delete(valueToInsert);
+
+        Assert.assertFalse(group.has(valueToInsert));
+    }
+
+    @Test
+    public void test2() {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+        String valueToInsert = "second test";
+
+        // when
+        group.insert(valueToInsert);
+        group.delete(valueToInsert);
+
+        // then
+        Assert.assertFalse(group.has(valueToInsert));
+    }
+
+    @Test
+    public void test3() {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+        String valueToInsert = "third test";
+
+        // when
+        group.insert(valueToInsert);
+        group.delete(valueToInsert);
+
+        // then
+        Assert.assertFalse(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/DistinctTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class DistinctTest {
+    @Test
+    public void test1() {
+        test("first test");
+    }
+
+    @Test
+    public void test2() {
+        test("second test");
+    }
+
+    @Test
+    public void test3() {
+        test("third test");
+    }
+
+    private void test(String valueToInsert) {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+
+        // when
+        Assert.assertFalse(group.has(valueToInsert));
+        group.insert(valueToInsert);
+
+        // then
+        Assert.assertTrue(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/GetTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GetTest {
+    @Test
+    public void test1() {
+        test("first test");
+    }
+
+    @Test
+    public void test2() {
+        test("second test");
+    }
+
+    @Test
+    public void test3() {
+        test("third test");
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void test4() {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+
+        // when
+        group.fetch(10);
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void test5() {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+
+        // when
+        group.fetch(15);
+    }
+
+
+    private void test(String... stringsToInsert) {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+        List<String> simpleStringGroupContents = Arrays.asList(stringsToInsert);
+        simpleStringGroupContents.forEach(string -> group.insert(string));
+
+        // when
+        for (int i = 0; i < stringsToInsert.length; i++) {
+            Assert.assertEquals(stringsToInsert[i], group.fetch(i));
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/InsertTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class InsertTest {
+    @Test
+    public void test1() {
+        test("first test");
+    }
+
+    @Test
+    public void test2() {
+        test("second test");
+    }
+
+    @Test
+    public void test3() {
+        test("third test");
+    }
+
+    private void test(String valueToInsert) {
+        // given
+        SimpleStringGroup group = new SimpleStringGroup();
+
+        // when
+        Assert.assertFalse(group.has(valueToInsert));
+        group.insert(valueToInsert);
+
+        // then
+        Assert.assertTrue(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/IterableTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IterableTest {
+    @Test
+    public void test1() {
+        test("the");
+    }
+
+    @Test
+    public void test2() {
+        test("the", "quick");
+    }
+
+    @Test
+    public void test3() {
+        test("the", "quick", "brown");
+    }
+
+
+    @Test
+    public void test4() {
+        test("the", "quick", "brown", "fox");
+    }
+
+    @Test
+    public void test5() {
+        test("the", "quick", "brown", "fox", "jumps");
+    }
+
+    private void test(String... stringsToInsert) {
+        // given
+        List<String> result = new ArrayList<>();
+        SimpleStringGroup group = new SimpleStringGroup();
+        List<String> simpleStringGroupContents = Arrays.asList(stringsToInsert);
+        simpleStringGroupContents.forEach(string -> group.insert(string));
+        Iterable<String> simpleStringGroup = (Iterable<String>)group;
+
+        // when
+        simpleStringGroup.forEach(string -> result.add(string));
+
+        // then
+        Assert.assertEquals(group.count().intValue(), result.size());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/SimpleStringGroupPolymorphismTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+
+import java.util.Collection;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class SimpleStringGroupPolymorphismTest {
+    @Test
+    public void test1() {
+        Assert.assertTrue(new SimpleStringGroup() instanceof Iterable);
+    }
+
+    @Test
+    public void test2() {
+        Assert.assertFalse(new SimpleStringGroup() instanceof Collection);
+    }
+
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/ToStringTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class ToStringTest {
+}

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/WhereTest.java

+package rocks.zipcode.io.quiz4.collections.simplestringgroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class WhereTest {
+}

src/test/java/rocks/zipcode/io/quiz4/collections/zipcodewilmington/EnrollTest.java

+package rocks.zipcode.io.quiz4.collections.zipcodewilmington;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ZipCodeWilmington;
+import rocks.zipcode.io.quiz4.objectorientation.Student;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class EnrollTest {
+    @Test
+    public void test1() {
+        test(new Student());
+    }
+
+    @Test
+    public void test2() {
+        test(
+                new Student(),
+                new Student());
+    }
+
+    @Test
+    public void test3() {
+        test(
+                new Student(),
+                new Student(),
+                new Student());
+    }
+
+    public void test(Student... students) {
+        // given
+        ZipCodeWilmington zipCodeWilmington = new ZipCodeWilmington();
+
+        for (Student student : students) {
+            // when
+            zipCodeWilmington.enroll(student);
+
+            // then
+            Assert.assertTrue(zipCodeWilmington.isEnrolled(student));
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/zipcodewilmington/GetStudyMapTest.java

+package rocks.zipcode.io.quiz4.collections.zipcodewilmington;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ZipCodeWilmington;
+import rocks.zipcode.io.quiz4.objectorientation.Student;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GetStudyMapTest {
+    @Test
+    public void test1() {
+        // given
+        ZipCodeWilmington zipCodeWilmington = new ZipCodeWilmington();
+        Student expectedStudent1 = new Student();
+        Double expectedStudyTime1 = expectedStudent1.getTotalStudyTime();
+        zipCodeWilmington.enroll(expectedStudent1);
+
+
+
+        // when
+        Map<Student, Double> studyMap = zipCodeWilmington.getStudyMap();
+        List<Map.Entry<Student, Double>> entrySet = new ArrayList<>(studyMap.entrySet());
+        Map.Entry<Student, Double> firstEntry = entrySet.get(0);
+
+        Student actualStudent1 = firstEntry.getKey();
+        Double actualStudyTime1 = firstEntry.getValue();
+
+
+
+        // then
+        Assert.assertEquals(expectedStudent1, actualStudent1);
+        Assert.assertEquals(expectedStudyTime1, actualStudyTime1);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        ZipCodeWilmington zipCodeWilmington = new ZipCodeWilmington();
+        Student expectedStudent1 = new Student(1);
+        Student expectedStudent2 = new Student(2);
+
+        zipCodeWilmington.enroll(expectedStudent1);
+        zipCodeWilmington.enroll(expectedStudent2);
+
+        Double expectedStudyTime1 = 500.0;
+        Double expectedStudyTime2 = 250.0;
+
+        expectedStudent1.learn(expectedStudyTime1);
+        expectedStudent2.learn(expectedStudyTime2);
+
+
+
+        // when
+        Map<Student, Double> studyMap = zipCodeWilmington.getStudyMap();
+        List<Map.Entry<Student, Double>> entrySet = new ArrayList<>(studyMap.entrySet());
+        Map.Entry<Student, Double> firstEntry = entrySet.get(0);
+        Map.Entry<Student, Double> secondEntry = entrySet.get(1);
+
+        Student actualStudent1 = firstEntry.getKey();
+        Student actualStudent2 = secondEntry.getKey();
+
+        Double actualStudyTime1 = firstEntry.getValue();
+        Double actualStudyTime2 = secondEntry.getValue();
+
+
+
+        // then
+        Assert.assertEquals(expectedStudent1, actualStudent1);
+        Assert.assertEquals(expectedStudyTime1, actualStudyTime1);
+
+
+        Assert.assertEquals(expectedStudent2, actualStudent2);
+        Assert.assertEquals(expectedStudyTime2, actualStudyTime2);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        ZipCodeWilmington zipCodeWilmington = new ZipCodeWilmington();
+        Student expectedStudent1 = new Student(3);
+        Student expectedStudent2 = new Student(4);
+        Student expectedStudent3 = new Student(5);
+
+        zipCodeWilmington.enroll(expectedStudent1);
+        zipCodeWilmington.enroll(expectedStudent2);
+        zipCodeWilmington.enroll(expectedStudent3);
+
+        Double expectedStudyTime1 = 500.0;
+        Double expectedStudyTime2 = 250.0;
+        Double expectedStudyTime3 = 125.0;
+
+        expectedStudent1.learn(expectedStudyTime1);
+        expectedStudent2.learn(expectedStudyTime2);
+        expectedStudent3.learn(expectedStudyTime3);
+
+
+
+        // when
+        Map<Student, Double> studyMap = zipCodeWilmington.getStudyMap();
+        List<Map.Entry<Student, Double>> entrySet = new ArrayList<>(studyMap.entrySet());
+        Map.Entry<Student, Double> firstEntry = entrySet.get(0);
+        Map.Entry<Student, Double> secondEntry = entrySet.get(1);
+        Map.Entry<Student, Double> thirdEntry = entrySet.get(2);
+
+        Student actualStudent1 = firstEntry.getKey();
+        Student actualStudent2 = secondEntry.getKey();
+        Student actualStudent3 = thirdEntry.getKey();
+
+        Double actualStudyTime1 = firstEntry.getValue();
+        Double actualStudyTime2 = secondEntry.getValue();
+        Double actualStudyTime3 = thirdEntry.getValue();
+
+
+
+        // then
+        Assert.assertEquals(expectedStudent1, actualStudent1);
+        Assert.assertEquals(expectedStudyTime1, actualStudyTime1);
+
+
+        Assert.assertEquals(expectedStudent2, actualStudent2);
+        Assert.assertEquals(expectedStudyTime2, actualStudyTime2);
+
+
+        Assert.assertEquals(expectedStudent3, actualStudent3);
+        Assert.assertEquals(expectedStudyTime3, actualStudyTime3);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/collections/zipcodewilmington/LectureTest.java

+package rocks.zipcode.io.quiz4.collections.zipcodewilmington;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.ZipCodeWilmington;
+import rocks.zipcode.io.quiz4.objectorientation.Student;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class LectureTest {
+    @Test
+    public void test1() {
+        test(200.0,
+                new Student());
+    }
+
+    @Test
+    public void test2() {
+        test(150.0,
+                new Student(),
+                new Student());
+    }
+
+    @Test
+    public void test3() {
+        test(100.0,
+                new Student(),
+                new Student(),
+                new Student());
+    }
+
+    public void test(Double lectureTime, Student... students) {
+        // given
+        ZipCodeWilmington zipCodeWilmington = new ZipCodeWilmington();
+        for (Student student : students) {
+            zipCodeWilmington.enroll(student);
+            Assert.assertEquals(0.0, student.getTotalStudyTime().doubleValue(), 0);
+        }
+
+        // when
+        zipCodeWilmington.lecture(lectureTime);
+
+        // then
+        for (Student student : students) {
+            Assert.assertEquals(student.getTotalStudyTime(), lectureTime, 0);
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/fundamentals/stringevaluator/GetAllPrefixes.java

+package rocks.zipcode.io.quiz4.fundamentals.stringevaluator;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
+import rocks.zipcode.io.quiz4.utils.TestUtils;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GetAllPrefixes {
+    @Test
+    public void test1() {
+        // given
+        String input = "A";
+        String[] expected = {input};
+
+        // when
+        String[] actual = StringEvaluator.getAllPrefixes(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String input = "B";
+        String[] expected = {input};
+
+        // when
+        String[] actual = StringEvaluator.getAllPrefixes(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String input = "AB";
+        String[] expected = {"A", "B", "AB"};
+
+        // when
+        String[] actual = StringEvaluator.getAllPrefixes(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test4() {
+        // given
+        String input = "ABB";
+        String[] expected = {"A", "AB", "ABB", "B", "BB"};
+
+        // when
+        String[] actual = StringEvaluator.getAllPrefixes(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test5() {
+        // given
+        String input = "AABB";
+        String[] expected = {"A", "AA", "AAB", "AABB", "AB", "ABB", "B", "BB"};
+
+        // when
+        String[] actual = StringEvaluator.getAllPrefixes(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test6() {
+        // given
+        String input = "AnotherMethodToTest";
+        String[] expected = {
+                "A", "An", "Ano", "Anot", "Anoth", "Anothe", "Another", "AnotherM", "AnotherMe", "AnotherMet", "AnotherMeth", "AnotherMetho", "AnotherMethod", "AnotherMethodT", "AnotherMethodTo", "AnotherMethodToT", "AnotherMethodToTe", "AnotherMethodToTes", "AnotherMethodToTest",
+                "n", "no", "not", "noth", "nothe", "nother", "notherM", "notherMe", "notherMet", "notherMeth", "notherMetho", "notherMethod", "notherMethodT", "notherMethodTo", "notherMethodToT", "notherMethodToTe", "notherMethodToTes", "notherMethodToTest",
+                "o", "oT", "oTe", "oTes", "oTest", "od", "odT", "odTo", "odToT", "odToTe", "odToTes", "odToTest", "ot", "oth", "othe", "other", "otherM", "otherMe", "otherMet", "otherMeth", "otherMetho", "otherMethod", "otherMethodT", "otherMethodTo", "otherMethodToT", "otherMethodToTe", "otherMethodToTes", "otherMethodToTest",
+                "t", "th", "the", "ther", "therM", "therMe", "therMet", "therMeth", "therMetho", "therMethod", "therMethodT", "therMethodTo", "therMethodToT", "therMethodToTe", "therMethodToTes", "therMethodToTest", "tho", "thod", "thodT", "thodTo", "thodToT", "thodToTe", "thodToTes", "thodToTest",
+                "h", "he", "her", "herM", "herMe", "herMet", "herMeth", "herMetho", "herMethod", "herMethodT", "herMethodTo", "herMethodToT", "herMethodToTe", "herMethodToTes", "herMethodToTest", "ho", "hod", "hodT", "hodTo", "hodToT", "hodToTe", "hodToTes", "hodToTest",
+                "e", "er", "erM", "erMe", "erMet", "erMeth", "erMetho", "erMethod", "erMethodT", "erMethodTo", "erMethodToT", "erMethodToTe", "erMethodToTes", "erMethodToTest", "es", "est", "et", "eth", "etho", "ethod", "ethodT", "ethodTo", "ethodToT", "ethodToTe", "ethodToTes", "ethodToTest",
+                "r", "rM", "rMe", "rMet", "rMeth", "rMetho", "rMethod", "rMethodT", "rMethodTo", "rMethodToT", "rMethodToTe", "rMethodToTes", "rMethodToTest",
+                "M", "Me", "Met", "Meth", "Metho", "Method", "MethodT", "MethodTo", "MethodToT", "MethodToTe", "MethodToTes", "MethodToTest",
+                "T", "Te", "Tes", "Test", "To", "ToT", "ToTe", "ToTes", "ToTest",
+                "d", "dT", "dTo", "dToT", "dToTe", "dToTes", "dToTest",
+                "s", "st"};
+
+        // when
+        String[] actual = StringEvaluator.getAllPrefixes(input);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/fundamentals/stringevaluator/GetCommonSuffixesTest.java

+package rocks.zipcode.io.quiz4.fundamentals.stringevaluator;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
+import rocks.zipcode.io.quiz4.utils.TestUtils;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GetCommonSuffixesTest {
+    @Test
+    public void test1() {
+        // given
+        String firstInput = "AAB";
+        String secondInput = "AAAB";
+        String[] expected = {"A", "AA", "AAB", "AB", "B"};
+
+        // when
+        String[] actual = StringEvaluator.getCommonPrefixes(firstInput, secondInput);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String firstInput = "AAZB";
+        String secondInput = "AAAB";
+        String[] expected = {"A", "AA", "B"};
+
+        // when
+        String[] actual = StringEvaluator.getCommonPrefixes(firstInput, secondInput);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String firstInput = "Zapple";
+        String secondInput = "Candy apples!";
+        String[] expected = {"a", "ap", "app", "appl", "apple", "e", "l", "le", "p", "pl", "ple", "pp", "ppl", "pple"};
+
+        // when
+        String[] actual = StringEvaluator.getCommonPrefixes(firstInput, secondInput);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+
+
+    @Test
+    public void tes4() {
+        // given
+        String firstInput = "Irreducible complexity";
+        String secondInput = "Deductive operations";
+        String[] expected = {" ", "c", "d", "du", "duc", "e", "e ", "ed", "edu", "educ", "i", "o", "p", "r", "t", "u", "uc"};
+
+        // when
+        String[] actual = StringEvaluator.getCommonPrefixes(firstInput, secondInput);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void test5() {
+        // given
+        String firstInput = "Peter piper picked a pepper";
+        String secondInput = "Jimmy neutron was a fancy scientist";
+        String[] expected = {" ", " a", " a ", "a", "a ", "c", "e", "i", "r", "t"};
+
+        // when
+        String[] actual = StringEvaluator.getCommonPrefixes(firstInput, secondInput);
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+
+}

src/test/java/rocks/zipcode/io/quiz4/fundamentals/stringevaluator/GetLargestCommonSuffixTest.java

+package rocks.zipcode.io.quiz4.fundamentals.stringevaluator;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GetLargestCommonSuffixTest {
+    @Test
+    public void test1() {
+        // given
+        String firstInput = "AAB";
+        String secondInput = "AAAB";
+        String expected = "AAB";
+
+        // when
+        String actual = StringEvaluator.getLargestCommonPrefix(firstInput, secondInput);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String firstInput = "AAZB";
+        String secondInput = "AAAB";
+        String expected = "AA";
+
+        // when
+        String actual = StringEvaluator.getLargestCommonPrefix(firstInput, secondInput);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
+    @Test
+    public void test3() {
+        // given
+        String firstInput = "Zapple";
+        String secondInput = "Candy apples!";
+        String expected = "apple";
+
+        // when
+        String actual = StringEvaluator.getLargestCommonPrefix(firstInput, secondInput);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
+    @Test
+    public void test4() {
+        // given
+        String firstInput = "Irreducible complexity";
+        String secondInput = "Deductive operations";
+        String expected = "educ";
+
+        // when
+        String actual = StringEvaluator.getLargestCommonPrefix(firstInput, secondInput);
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/genericarrayutils/powerset/PowerSetOfThreeElements.java

+package rocks.zipcode.io.quiz4.generics.genericarrayutils.powerset;
+
+import org.junit.Test;
+
+/**
+ * @author leon on 15/12/2018.
+ */
+public class PowerSetOfThreeElements {
+    @Test
+    public void test1() {
+        // given
+        String[] input = {"a", "b", "c"};
+        String expectedString = "[[a, b, c], [a, b], [a, c], [a], [b, a], [b, c], [b], [c, a], [c, b], [c], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] input = {"1", "2", "3"};
+        String expectedString = "[[1, 2, 3], [1, 2], [1, 3], [1], [2, 1], [2, 3], [2], [3, 1], [3, 2], [3], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        String[] input = {"x", "y", "z"};
+        String expectedString = "[[x, y, z], [x, y], [x, z], [x], [y, x], [y, z], [y], [z, x], [z, y], [z], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+    @Test
+    public void test4() {
+        // given
+        String[] input = {"aFIRST", "bSECOND", "cTHIRD"};
+        String eaFIRSTpectedString = "[[aFIRST, bSECOND, cTHIRD], [aFIRST, bSECOND], [aFIRST, cTHIRD], [aFIRST], [bSECOND, aFIRST], [bSECOND, cTHIRD], [bSECOND], [cTHIRD, aFIRST], [cTHIRD, bSECOND], [cTHIRD], []]";
+        PowerSetTest.test(input, eaFIRSTpectedString);
+    }
+
+
+    @Test
+    public void test5() {
+        // given
+        String[] input = {"1WATER", "2FIRE", "3LIGHTNING"};
+        String e1WATERpectedString = "[[1WATER, 2FIRE, 3LIGHTNING], [1WATER, 2FIRE], [1WATER, 3LIGHTNING], [1WATER], [2FIRE, 1WATER], [2FIRE, 3LIGHTNING], [2FIRE], [3LIGHTNING, 1WATER], [3LIGHTNING, 2FIRE], [3LIGHTNING], []]";
+        PowerSetTest.test(input, e1WATERpectedString);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/genericarrayutils/powerset/PowerSetOfTwoElements.java

+package rocks.zipcode.io.quiz4.generics.genericarrayutils.powerset;
+
+import org.junit.Test;
+
+/**
+ * @author leon on 15/12/2018.
+ */
+public class PowerSetOfTwoElements {
+    @Test
+    public void test1() {
+        // given
+        String[] input = {"1", "2"};
+        String expectedString = "[[1, 2], [1], [2], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String[] input = {"1", "0"};
+        String expectedString = "[[0, 1], [0], [1], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        String[] input = {"a", "b"};
+        String expectedString = "[[a, b], [a], [b], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+    @Test
+    public void test4() {
+        // given
+        String[] input = {"x", "y"};
+        String expectedString = "[[x, y], [x], [y], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+
+
+    @Test
+    public void test5() {
+        // given
+        String[] input = {"red", "blue"};
+        String expectedString = "[[blue, red], [blue], [red], []]";
+        PowerSetTest.test(input, expectedString);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/genericarrayutils/powerset/PowerSetTest.java

+package rocks.zipcode.io.quiz4.generics.genericarrayutils.powerset;
+
+import org.junit.Assert;
+import rocks.zipcode.io.quiz4.generics.GenericUtils;
+
+/**
+ * @author leon on 15/12/2018.
+ */
+public class PowerSetTest {
+    public static void test(String[] input, String expectedString) {
+        // given
+
+        // when
+        Iterable<? extends Iterable<? extends String>> actualSet = GenericUtils.powerSet(input);
+        String actualString = actualSet.toString();
+
+        // then
+        Assert.assertEquals(expectedString, actualString);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/GroupPolymorphismTest.java

+package rocks.zipcode.io.quiz4.generics.group;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+import rocks.zipcode.io.quiz4.generics.GroupInterface;
+
+import java.util.Collection;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GroupPolymorphismTest {
+    @Test
+    public void test1() {
+        Assert.assertTrue(new Group() instanceof Iterable);
+    }
+
+    @Test
+    public void test3() {
+        Assert.assertTrue(new Group() instanceof GroupInterface);
+    }
+
+    @Test
+    public void test2() {
+        Assert.assertFalse(new Group() instanceof Collection);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/GroupToStringTest.java

+package rocks.zipcode.io.quiz4.generics.group;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class GroupToStringTest {
+    @Test
+    public void test1() {
+        String expected = "[the, quick, brown, fox]";
+        Group<String> group = new Group<>();
+        group.insert("the");
+        group.insert("quick");
+        group.insert("brown");
+        group.insert("fox");
+
+        // when
+        String actual = group.toString();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        String expected = "[123, 456, 789, 101112]";
+        Group<Number> group = new Group<>();
+        group.insert(123);
+        group.insert(456);
+        group.insert(789);
+        group.insert(101112);
+
+        // when
+        String actual = group.toString();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test3() {
+        String expected = "[a, b, c, d]";
+        Group<Character> group = new Group<>();
+        group.insert('a');
+        group.insert('b');
+        group.insert('c');
+        group.insert('d');
+
+        // when
+        String actual = group.toString();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/integergroup/IntegerGroupClearTest.java

+package rocks.zipcode.io.quiz4.generics.group.integergroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerGroupClearTest {
+    @Test
+    public void test1() {
+        test(1, 2, 3);
+    }
+
+    @Test
+    public void test2() {
+        test(7, 8, 9);
+    }
+
+    @Test
+    public void test3() {
+        test(4, 5, 6);
+    }
+
+    private void test(Integer... valuesToInsert) {
+        // given
+        Group<Integer> group = new Group<>();
+        for (Integer valueToInsert : valuesToInsert) {
+            group.insert(valueToInsert);
+            Assert.assertTrue(group.has(valueToInsert));
+        }
+
+        // when
+        group.clear();
+
+
+        // then
+        for (Integer valueToInsert : valuesToInsert) {
+            Assert.assertFalse(group.has(valueToInsert));
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/integergroup/IntegerGroupCountTest.java

+package rocks.zipcode.io.quiz4.generics.group.integergroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+import java.util.UUID;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerGroupCountTest {
+    @Test
+    public void test1() {
+        test(1);
+    }
+
+    @Test
+    public void test2() {
+        test(2);
+    }
+
+
+    @Test
+    public void test3() {
+        test(3);
+    }
+
+    public void test(Integer numberOfItemsToAdd) {
+        // given
+        Group<String> group = new Group<>();
+
+        // when
+        for (int i = 0; i < numberOfItemsToAdd; i++) {
+            String itemToAdd = UUID.randomUUID().toString();
+            group.insert(itemToAdd);
+        }
+
+        // then
+        Assert.assertEquals(group.count(), numberOfItemsToAdd);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/integergroup/IntegerGroupDistinctTest.java

+package rocks.zipcode.io.quiz4.generics.group.integergroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerGroupDistinctTest {
+    @Test
+    public void test1() {
+        test(1);
+    }
+
+    @Test
+    public void test2() {
+        test(2);
+    }
+
+    @Test
+    public void test3() {
+        test(3);
+    }
+
+    private void test(Integer valueToInsert) {
+        // given
+        Group<Integer> group = new Group<>();
+
+        // when
+        Assert.assertFalse(group.has(valueToInsert));
+        group.insert(valueToInsert);
+
+        // then
+        Assert.assertTrue(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/integergroup/IntegerGroupIterableTest.java

+package rocks.zipcode.io.quiz4.generics.group.integergroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerGroupIterableTest {
+    @Test
+    public void test1() {
+        test(9);
+    }
+
+    @Test
+    public void test2() {
+        test(9, 99);
+    }
+
+    @Test
+    public void test3() {
+        test(9, 99, 999);
+    }
+
+
+    @Test
+    public void test4() {
+        test(9, 99, 999, 999);
+    }
+
+    @Test
+    public void test5() {
+        test(9, 99, 999, 999, 9999);
+    }
+
+    private void test(Integer... valuesToInsert) {
+        // given
+        Group<Integer> group = new Group<>();
+        List<Integer> result = new ArrayList<>();
+        List<Integer> contents = Arrays.asList(valuesToInsert);
+        contents.forEach(value -> group.insert(value));
+        Iterable<Integer> iterableGroup = (Iterable<Integer>)group;
+
+        // when
+        iterableGroup.forEach(string -> result.add(string));
+
+        // then
+        Assert.assertEquals(group.count().intValue(), contents.size());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/integergroup/IntegerGroupWhereTest.java

+package rocks.zipcode.io.quiz4.generics.group.integergroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerGroupWhereTest {
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupClearTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupClearTest {
+    @Test
+    public void test1() {
+        test("first", "clear", "test");
+    }
+
+    @Test
+    public void test2() {
+        test("an", "additional", "test", "here");
+    }
+
+    @Test
+    public void test3() {
+        test("a", "dash", "of", "anonymity");
+    }
+
+    private void test(String... valuesToInsert) {
+        // given
+        Group<String> group = new Group<>();
+        for(String valueToInsert : valuesToInsert) {
+            group.insert(valueToInsert);
+            Assert.assertTrue(group.has(valueToInsert));
+        }
+
+        // when
+        group.clear();
+
+
+        // then
+        for(String valueToInsert : valuesToInsert) {
+            Assert.assertFalse(group.has(valueToInsert));
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupCountTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+import java.util.UUID;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupCountTest {
+    @Test
+    public void test1() {
+        test(1);
+    }
+
+    @Test
+    public void test2() {
+        test(2);
+    }
+
+
+    @Test
+    public void test3() {
+        test(3);
+    }
+
+    public void test(Integer numberOfItemsToAdd) {
+        // given
+        Group<String> group = new Group<>();
+
+        // when
+        for (int i = 0; i < numberOfItemsToAdd; i++) {
+            String itemToAdd = UUID.randomUUID().toString();
+            group.insert(itemToAdd);
+        }
+
+        // then
+        Assert.assertEquals(group.count(), numberOfItemsToAdd);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupDeleteTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupDeleteTest {
+    @Test
+    public void test1() {
+        // given
+        Group<String> group = new Group<>();
+        String valueToInsert = "first test";
+
+        // when
+        group.insert(valueToInsert);
+        group.delete(valueToInsert);
+
+        Assert.assertFalse(group.has(valueToInsert));
+    }
+
+    @Test
+    public void test2() {
+        // given
+        Group<String> group = new Group<>();
+        String valueToInsert = "second test";
+
+        // when
+        group.insert(valueToInsert);
+        group.delete(valueToInsert);
+
+        // then
+        Assert.assertFalse(group.has(valueToInsert));
+    }
+
+    @Test
+    public void test3() {
+        // given
+        Group<String> group = new Group<>();
+        String valueToInsert = "third test";
+
+        // when
+        group.insert(valueToInsert);
+        group.delete(valueToInsert);
+
+        // then
+        Assert.assertFalse(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupDistinctTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupDistinctTest {
+    @Test
+    public void test1() {
+        test("first test");
+    }
+
+    @Test
+    public void test2() {
+        test("second test");
+    }
+
+    @Test
+    public void test3() {
+        test("third test");
+    }
+
+    private void test(String valueToInsert) {
+        // given
+        Group<String> group = new Group<>();
+
+        // when
+        Assert.assertFalse(group.has(valueToInsert));
+        group.insert(valueToInsert);
+
+        // then
+        Assert.assertTrue(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupFetchTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupFetchTest {
+    @Test
+    public void test1() {
+        test("first test");
+    }
+
+    @Test
+    public void test2() {
+        test("second test");
+    }
+
+    @Test
+    public void test3() {
+        test("third test");
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void test4() {
+        // given
+        Group<String> group = new Group<>();
+
+        // when
+        group.fetch(10);
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void test5() {
+        // given
+        Group<String> group = new Group<>();
+
+        // when
+        group.fetch(15);
+    }
+
+
+    private void test(String... stringsToInsert) {
+        // given
+        Group<String> group = new Group<>();
+        List<String> simpleStringGroupContents = Arrays.asList(stringsToInsert);
+        simpleStringGroupContents.forEach(string -> group.insert(string));
+
+        // when
+        for (int i = 0; i < stringsToInsert.length; i++) {
+            Assert.assertEquals(stringsToInsert[i], group.fetch(i));
+        }
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupInsertTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupInsertTest {
+    @Test
+    public void test1() {
+        test("first test");
+    }
+
+    @Test
+    public void test2() {
+        test("second test");
+    }
+
+    @Test
+    public void test3() {
+        test("third test");
+    }
+
+    private void test(String valueToInsert) {
+        // given
+        Group<String> group = new Group<>();
+
+        // when
+        Assert.assertFalse(group.has(valueToInsert));
+        group.insert(valueToInsert);
+
+        // then
+        Assert.assertTrue(group.has(valueToInsert));
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupIterableTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.collections.SimpleStringGroup;
+import rocks.zipcode.io.quiz4.generics.Group;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupIterableTest {
+    @Test
+    public void test1() {
+        test("the");
+    }
+
+    @Test
+    public void test2() {
+        test("the", "quick");
+    }
+
+    @Test
+    public void test3() {
+        test("the", "quick", "brown");
+    }
+
+
+    @Test
+    public void test4() {
+        test("the", "quick", "brown", "fox");
+    }
+
+    @Test
+    public void test5() {
+        test("the", "quick", "brown", "fox", "jumps");
+    }
+
+    private void test(String... valuesToInsert) {
+        // given
+        Group<String> group = new Group<>();
+        List<String> result = new ArrayList<>();
+        List<String> contents = Arrays.asList(valuesToInsert);
+        contents.forEach(value -> group.insert(value));
+        Iterable<String> iterableGroup = (Iterable<String>)group;
+
+        // when
+        iterableGroup.forEach(string -> result.add(string));
+
+        // then
+        Assert.assertEquals(group.count().intValue(), contents.size());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/group/stringgroup/StringGroupWhereTest.java

+package rocks.zipcode.io.quiz4.generics.group.stringgroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringGroupWhereTest {
+}

src/test/java/rocks/zipcode/io/quiz4/generics/sortedgroup/SortedGroupPolymorphismTest.java

+package rocks.zipcode.io.quiz4.generics.sortedgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.GroupInterface;
+import rocks.zipcode.io.quiz4.generics.SortedGroup;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class SortedGroupPolymorphismTest {
+    @Test
+    public void test1() {
+        Assert.assertTrue(new SortedGroup() instanceof GroupInterface);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/sortedgroup/integersortedgroup/IntegerSortedGroupDeleteTest.java

+package rocks.zipcode.io.quiz4.generics.sortedgroup.integersortedgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.SortedGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerSortedGroupDeleteTest {
+    @Test
+    public void test1() {
+        // given
+        SortedGroup<Integer> group = new SortedGroup<>();
+        Integer firstValue = 1;
+        Integer secondValue = 2;
+        Integer thirdValue = 3;
+        Integer fourthValue = 4;
+
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        // when
+        group.delete(firstValue);
+
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(secondValueIndex, 0);
+        Assert.assertEquals(thirdValueIndex, 1);
+        Assert.assertEquals(fourthValueIndex, 2);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        SortedGroup<Integer> group = new SortedGroup<>();
+        Integer firstValue = 1;
+        Integer secondValue = 2;
+        Integer thirdValue = 3;
+        Integer fourthValue = 4;
+
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        // when
+        group.delete(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(thirdValueIndex, 1);
+        Assert.assertEquals(fourthValueIndex, 2);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        SortedGroup<Integer> group = new SortedGroup<>();
+        Integer firstValue = 1;
+        Integer secondValue = 2;
+        Integer thirdValue = 3;
+        Integer fourthValue = 4;
+
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        // when
+        group.delete(thirdValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(fourthValueIndex, 2);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/sortedgroup/integersortedgroup/IntegerSortedGroupInsertTest.java

+package rocks.zipcode.io.quiz4.generics.sortedgroup.integersortedgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.omg.CORBA.INTERNAL;
+import rocks.zipcode.io.quiz4.generics.Group;
+import rocks.zipcode.io.quiz4.generics.SortedGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerSortedGroupInsertTest {
+    @Test
+    public void test1() {
+        // given
+        SortedGroup<Integer> group = new SortedGroup<>();
+        Integer firstValue = 1;
+        Integer secondValue = 2;
+        Integer thirdValue = 3;
+        Integer fourthValue = 4;
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(thirdValueIndex, 2);
+        Assert.assertEquals(fourthValueIndex, 3);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        SortedGroup<Integer> group = new SortedGroup<>();
+        Integer firstValue = 98;
+        Integer secondValue = 102;
+        Integer thirdValue = 362;
+        Integer fourthValue = 999;
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(thirdValueIndex, 2);
+        Assert.assertEquals(fourthValueIndex, 3);
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        SortedGroup<Integer> group = new SortedGroup<>();
+        Integer firstValue = Integer.MIN_VALUE;
+        Integer secondValue = firstValue + 1;
+        Integer thirdValue = secondValue + 1;
+        Integer fourthValue = Integer.MAX_VALUE;
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(thirdValueIndex, 2);
+        Assert.assertEquals(fourthValueIndex, 3);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/sortedgroup/stringsortedgroup/StringSortedGroupDeleteTest.java

+package rocks.zipcode.io.quiz4.generics.sortedgroup.stringsortedgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.SortedGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringSortedGroupDeleteTest {
+    @Test
+    public void test1() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "1";
+        String secondValue = "2";
+        String thirdValue = "3";
+        String fourthValue = "4";
+
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        // when
+        group.delete(firstValue);
+
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(secondValueIndex, 0);
+        Assert.assertEquals(thirdValueIndex, 1);
+        Assert.assertEquals(fourthValueIndex, 2);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "1";
+        String secondValue = "2";
+        String thirdValue = "3";
+        String fourthValue = "4";
+
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        // when
+        group.delete(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(thirdValueIndex, 1);
+        Assert.assertEquals(fourthValueIndex, 2);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "1";
+        String secondValue = "2";
+        String thirdValue = "3";
+        String fourthValue = "4";
+
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        // when
+        group.delete(thirdValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(fourthValueIndex, 2);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/sortedgroup/stringsortedgroup/StringSortedGroupInsertTest.java

+package rocks.zipcode.io.quiz4.generics.sortedgroup.stringsortedgroup;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.SortedGroup;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringSortedGroupInsertTest {
+
+    @Test
+    public void test1() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "A";
+        String secondValue = "B";
+        String thirdValue = "C";
+        String fourthValue = "D";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int indexOfFirstValue = group.indexOf(firstValue);
+        int indexOfSecondValue = group.indexOf(secondValue);
+        int indexOfThirdValue = group.indexOf(thirdValue);
+        int indexOfFourthValue = group.indexOf(fourthValue);
+        System.out.println(group);
+        // then
+        Assert.assertEquals(indexOfFirstValue, 0);
+        Assert.assertEquals(indexOfSecondValue, 1);
+        Assert.assertEquals(indexOfThirdValue, 2);
+        Assert.assertEquals(indexOfFourthValue, 3);
+    }
+    @Test
+    public void test2() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "a";
+        String secondValue = "b";
+        String thirdValue = "c";
+        String fourthValue = "d";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int indexOfFirstValue = group.indexOf(firstValue);
+        int indexOfSecondValue = group.indexOf(secondValue);
+        int indexOfThirdValue = group.indexOf(thirdValue);
+        int indexOfFourthValue = group.indexOf(fourthValue);
+        System.out.println(group);
+        // then
+        Assert.assertEquals(indexOfFirstValue, 0);
+        Assert.assertEquals(indexOfSecondValue, 1);
+        Assert.assertEquals(indexOfThirdValue, 2);
+        Assert.assertEquals(indexOfFourthValue, 3);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "A";
+        String secondValue = "B";
+        String thirdValue = "a";
+        String fourthValue = "b";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int indexOfFirstValue = group.indexOf(firstValue);
+        int indexOfSecondValue = group.indexOf(secondValue);
+        int indexOfThirdValue = group.indexOf(thirdValue);
+        int indexOfFourthValue = group.indexOf(fourthValue);
+        System.out.println(group);
+        // then
+        Assert.assertEquals(indexOfFirstValue, 0);
+        Assert.assertEquals(indexOfSecondValue, 1);
+        Assert.assertEquals(indexOfThirdValue, 2);
+        Assert.assertEquals(indexOfFourthValue, 3);
+    }
+
+
+    @Test
+    public void test4() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "Astro";
+        String secondValue = "Bicycle";
+        String thirdValue = "Carnations";
+        String fourthValue = "Dinosaur";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int indexOfFirstValue = group.indexOf(firstValue);
+        int indexOfSecondValue = group.indexOf(secondValue);
+        int indexOfThirdValue = group.indexOf(thirdValue);
+        int indexOfFourthValue = group.indexOf(fourthValue);
+        System.out.println(group);
+        // then
+        Assert.assertEquals(indexOfFirstValue, 0);
+        Assert.assertEquals(indexOfSecondValue, 1);
+        Assert.assertEquals(indexOfThirdValue, 2);
+        Assert.assertEquals(indexOfFourthValue, 3);
+    }
+
+    @Test
+    public void test6() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "Astro";
+        String secondValue = "Carnations";
+        String thirdValue = "bicycle";
+        String fourthValue = "dinosaur";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int indexOfFirstValue = group.indexOf(firstValue);
+        int indexOfSecondValue = group.indexOf(secondValue);
+        int indexOfThirdValue = group.indexOf(thirdValue);
+        int indexOfFourthValue = group.indexOf(fourthValue);
+        System.out.println(group);
+        // then
+        Assert.assertEquals(indexOfFirstValue, 0);
+        Assert.assertEquals(indexOfSecondValue, 1);
+        Assert.assertEquals(indexOfThirdValue, 2);
+        Assert.assertEquals(indexOfFourthValue, 3);
+    }
+
+
+    @Test
+    public void test7() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "1";
+        String secondValue = "2";
+        String thirdValue = "3";
+        String fourthValue = "4";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(thirdValueIndex, 2);
+        Assert.assertEquals(fourthValueIndex, 3);
+    }
+
+    @Test
+    public void test8() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = "102";
+        String secondValue = "362";
+        String thirdValue = "98";
+        String fourthValue = "999";
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int indexOfFirstValue = group.indexOf(firstValue);
+        int indexOfSecondValue = group.indexOf(secondValue);
+        int indexOfThirdValue = group.indexOf(thirdValue);
+        int indexOfFourthValue = group.indexOf(fourthValue);
+        System.out.println(group);
+        // then
+        Assert.assertEquals(indexOfFirstValue, 0);
+        Assert.assertEquals(indexOfSecondValue, 1);
+        Assert.assertEquals(indexOfThirdValue, 2);
+        Assert.assertEquals(indexOfFourthValue, 3);
+    }
+
+
+    @Test
+    public void test9() {
+        // given
+        SortedGroup<String> group = new SortedGroup<>();
+        String firstValue = String.valueOf(Integer.MIN_VALUE + 2);
+        String secondValue = String.valueOf(Integer.MIN_VALUE + 1);
+        String thirdValue = String.valueOf(Integer.MIN_VALUE);
+        String fourthValue = String.valueOf(Integer.MAX_VALUE);
+
+        // when
+        group.insert(fourthValue);
+        group.insert(firstValue);
+        group.insert(thirdValue);
+        group.insert(secondValue);
+
+        int firstValueIndex = group.indexOf(firstValue);
+        int secondValueIndex = group.indexOf(secondValue);
+        int thirdValueIndex = group.indexOf(thirdValue);
+        int fourthValueIndex = group.indexOf(fourthValue);
+
+        // then
+        Assert.assertEquals(firstValueIndex, 0);
+        Assert.assertEquals(secondValueIndex, 1);
+        Assert.assertEquals(thirdValueIndex, 2);
+        Assert.assertEquals(fourthValueIndex, 3);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/StackPolymorphismTest.java

+package rocks.zipcode.io.quiz4.generics.stack;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+
+import java.util.Collection;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StackPolymorphismTest {
+    @Test
+    public void ensureStackIsIterable() {
+        Assert.assertTrue(new MyStack<>() instanceof Iterable);
+    }
+
+    @Test
+    public void ensureStackIsNotCollection() {
+        Assert.assertFalse(new MyStack<>() instanceof Collection);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/integerstack/IntegerStackIsEmptyTest.java

+package rocks.zipcode.io.quiz4.generics.stack.integerstack;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerStackIsEmptyTest {
+    private MyStack<Integer> stack;
+
+    @Before
+    public void setup() {
+        this.stack = new MyStack<>();
+    }
+
+    @Test
+    public void test1() {
+        Assert.assertTrue(stack.isEmpty());
+    }
+
+    @Test
+    public void test2() {
+        stack.push(0);
+        Assert.assertFalse(stack.isEmpty());
+    }
+
+    @Test
+    public void test3() {
+        stack.push(1);
+        Assert.assertFalse(stack.isEmpty());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/integerstack/IntegerStackPopTest.java

+package rocks.zipcode.io.quiz4.generics.stack.integerstack;
+
+import org.junit.Before;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+import rocks.zipcode.io.quiz4.utils.TestUtils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EmptyStackException;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerStackPopTest {
+    private MyStack<Integer> stack;
+
+    @Before
+    public void setup() {
+        this.stack = new MyStack<>();
+    }
+
+    @Test(expected = EmptyStackException.class)
+    public void test1() {
+        stack.pop();
+    }
+
+    @Test
+    public void test2() {
+        test(765, 321, 9, 342, 98, 132);
+    }
+    
+    @Test
+    public void test3() {
+        test(1123, 65, 4568, 21, 3154);
+    }
+
+    private void test(Integer... elementsToBePushed) {
+        List<Integer> listOfElementsTobePushed = Arrays.asList(elementsToBePushed);
+        List<Integer> result = new ArrayList<>();
+        for (Integer elementToBePushed : listOfElementsTobePushed) {
+            stack.push(elementToBePushed);
+        }
+
+        for (Integer elementToBePopped : listOfElementsTobePushed) {
+            result.add(stack.pop());
+        }
+
+        Integer[] actual = TestUtils.reveseList(result).toArray(Integer[]::new);
+        Integer[] expected = listOfElementsTobePushed.stream().toArray(Integer[]::new);
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/integerstack/IntegerStackPushTest.java

+package rocks.zipcode.io.quiz4.generics.stack.integerstack;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class IntegerStackPushTest {
+    private MyStack<Integer> stack;
+
+    @Before
+    public void setup() {
+        this.stack = new MyStack<>();
+    }
+
+    @Test
+    public void test1() {
+        Assert.assertNull(stack.peek());
+    }
+
+    @Test
+    public void test2() {
+        Integer expected = 0;
+        stack.push(expected);
+        Assert.assertEquals(stack.peek(), expected);
+    }
+
+    @Test
+    public void test3() {
+        Integer expected = 1;
+        stack.push(expected);
+        Assert.assertEquals(stack.peek(), expected);
+    }
+
+    @Test
+    public void test4() {
+        Integer val1 = 10;
+        Integer val2 = 15;
+        Integer val3 = 20;
+        Integer expected = 25;
+
+        stack.push(val1);
+        stack.push(val2);
+        stack.push(val3);
+        stack.push(expected);
+
+        Assert.assertEquals(stack.peek(), expected);
+    }
+
+    @Test
+    public void test5() {
+        Integer  val1 = 30;
+        Integer  val2 = 30;
+        Integer  val3 = 40;
+        Integer  expected = 45;
+
+        stack.push(val1);
+        stack.push(val2);
+        stack.push(val3);
+        stack.push(expected);
+
+        Assert.assertEquals(stack.peek(), expected);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/stringstack/StringStackIsEmptyTest.java

+package rocks.zipcode.io.quiz4.generics.stack.stringstack;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringStackIsEmptyTest {
+    private MyStack<String> stack;
+
+    @Before
+    public void setup() {
+        this.stack = new MyStack<>();
+    }
+
+    @Test
+    public void test1() {
+        Assert.assertTrue(stack.isEmpty());
+    }
+
+    @Test
+    public void test2() {
+        stack.push("0");
+        Assert.assertFalse(stack.isEmpty());
+    }
+
+    @Test
+    public void test3() {
+        stack.push("1");
+        Assert.assertFalse(stack.isEmpty());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/stringstack/StringStackPopTest.java

+package rocks.zipcode.io.quiz4.generics.stack.stringstack;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+import rocks.zipcode.io.quiz4.utils.TestUtils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EmptyStackException;
+import java.util.List;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringStackPopTest {
+    private MyStack<String> stack;
+
+    @Before
+    public void setup() {
+        this.stack = new MyStack<>();
+    }
+
+    @Test(expected = EmptyStackException.class)
+    public void test1() {
+        stack.pop();
+    }
+
+    @Test
+    public void test2() {
+        test("765", "321", "9", "342", "98", "132");
+    }
+    
+    @Test
+    public void test3() {
+        test("1123", "65", "4568", "21", "3154");
+    }
+
+    private void test(String... elementsToBePushed) {
+        List<String> listOfElementsTobePushed = Arrays.asList(elementsToBePushed);
+        List<String> result = new ArrayList<>();
+        for (String elementToBePushed : listOfElementsTobePushed) {
+            stack.push(elementToBePushed);
+        }
+
+        for (String elementToBePopped : listOfElementsTobePushed) {
+            result.add(stack.pop());
+        }
+
+        String[] actual = TestUtils.reveseList(result).toArray(String[]::new);
+        String[] expected = listOfElementsTobePushed.stream().toArray(String[]::new);
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/generics/stack/stringstack/StringStackPushTest.java

+package rocks.zipcode.io.quiz4.generics.stack.stringstack;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.generics.MyStack;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class StringStackPushTest {
+    private MyStack<String> stack;
+
+    @Before
+    public void setup() {
+        this.stack = new MyStack<>();
+    }
+
+    @Test
+    public void test1() {
+        Assert.assertNull(stack.peek());
+    }
+
+    @Test
+    public void test2() {
+        String expected = "0";
+        stack.push(expected);
+        Assert.assertEquals(stack.peek(), expected);
+    }
+
+    @Test
+    public void test3() {
+        String expected = "1";
+        stack.push(expected);
+        Assert.assertEquals(stack.peek(), expected);
+    }
+
+    @Test
+    public void test4() {
+        String val1 = "10";
+        String val2 = "15";
+        String val3 = "20";
+        String expected = "25";
+
+        stack.push(val1);
+        stack.push(val2);
+        stack.push(val3);
+        stack.push(expected);
+
+        Assert.assertEquals(stack.peek(), expected);
+    }
+
+    @Test
+    public void test5() {
+        String  val1 = "30";
+        String  val2 = "35";
+        String  val3 = "40";
+        String  expected = "45";
+
+        stack.push(val1);
+        stack.push(val2);
+        stack.push(val3);
+        stack.push(expected);
+
+        Assert.assertEquals(stack.peek(), expected);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/objectorientation/palindromeobject/PalindromeObjectGetAllPalindromesTest.java

+package rocks.zipcode.io.quiz4.objectorientation.palindromeobject;
+
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.fundamentals.PalindromeEvaluator;
+import rocks.zipcode.io.quiz4.objectorientation.PalindromeObject;
+import rocks.zipcode.io.quiz4.utils.TestUtils;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class PalindromeObjectGetAllPalindromesTest {
+    @Test
+    public void test1() {
+        // given
+        String input = "racecar";
+        String[] expected = new String[]{"a", "aceca", "c", "cec", "e", "r", "racecar"};
+        test(input, expected);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        String input = "redder";
+        String[] expected = new String[]{"d", "dd", "e", "edde", "r", "redder"};
+        test(input, expected);
+    }
+
+
+    @Test
+    public void test3() {
+        // given
+        String input = "rotor";
+        String[] expected = new String[]{"o", "oto", "r", "rotor", "t"};
+        test(input, expected);
+    }
+
+    @Test
+    public void test4() {
+        // given
+        String input = "civic";
+        String[] expected = new String[]{"c", "civic", "i", "ivi", "v"};
+        test(input, expected);
+    }
+
+    public void test(String input, String... expected) {
+        // when
+        String[] actual = new PalindromeObject(input).getAllPalindromes();
+
+        // then
+        TestUtils.assertArrayEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/objectorientation/palindromeobject/PalindromeObjectIsPalindromeTestNegative.java

+package rocks.zipcode.io.quiz4.objectorientation.palindromeobject;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.fundamentals.PalindromeEvaluator;
+import rocks.zipcode.io.quiz4.objectorientation.PalindromeObject;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class PalindromeObjectIsPalindromeTestNegative {
+    @Test
+    public void test1() {
+        test("Racecar");
+    }
+
+    @Test
+    public void test2() {
+        test("Redder");
+    }
+
+    @Test
+    public void test3() {
+        test("Redrum murder");
+    }
+
+    public void test(String input) {
+        Assert.assertTrue(new PalindromeObject(input).isPalindrome());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/objectorientation/palindromeobject/PalindromeObjectIsPalindromeTestPositive.java

+package rocks.zipcode.io.quiz4.objectorientation.palindromeobject;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.objectorientation.PalindromeObject;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class PalindromeObjectIsPalindromeTestPositive {
+    @Test
+    public void test1() {
+        test("racecar");
+    }
+
+    @Test
+    public void test2() {
+        test("racEcar");
+    }
+    
+    @Test
+    public void test3() {
+        test("redder");
+    }
+    
+    @Test
+    public void test4() {
+        test("redrum murder");
+    }
+    
+    public void test(String input) {
+        Assert.assertTrue(new PalindromeObject(input).isPalindrome());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/objectorientation/palindromeobject/PalindromeObjectReverseTest.java

+package rocks.zipcode.io.quiz4.objectorientation.palindromeobject;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.fundamentals.PalindromeEvaluator;
+import rocks.zipcode.io.quiz4.objectorientation.PalindromeObject;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class PalindromeObjectReverseTest {
+    @Test
+    public void test1() {
+        test("leon", "noel");
+    }
+
+    @Test
+    public void test2() {
+        test("Jerry", "yrreJ");
+    }
+
+    @Test
+    public void test3() {
+        test("KJack", "kcaJK");
+    }
+
+    @Test
+    public void test4() {
+        test("redrum murder", "redrum murder");
+    }
+
+    public void test(String input, String expected) {
+        String actual =  new PalindromeObject(input).reverseString();
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/objectorientation/stringassembler/AppendTest.java

+package rocks.zipcode.io.quiz4.objectorientation.stringassembler;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.objectorientation.StringAssembler;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class AppendTest {
+    @Test
+    public void test1() {
+        // given
+        Character delimeter = ' ';
+        String expected = "The quick brown fox jumps";
+
+        // when
+        String actual = new StringAssembler(delimeter)
+                .append("The")
+                .append("quick")
+                .append("brown")
+                .append("fox")
+                .append("jumps")
+                .assemble();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        // given
+        Character delimeter = '\n';
+        String expected = "The\nquick\nbrown\nfox\njumps";
+
+        // when
+        String actual = new StringAssembler(delimeter)
+                .append("The")
+                .append("quick")
+                .append("brown")
+                .append("fox")
+                .append("jumps")
+                .assemble();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test3() {
+        // given
+        Character delimeter = '_';
+        String expected = "The_quick_brown_fox_jumps";
+
+        // when
+        String actual = new StringAssembler(delimeter)
+                .append("The")
+                .append("quick")
+                .append("brown")
+                .append("fox")
+                .append("jumps")
+                .assemble();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test4() {
+        // given
+        Character delimeter = ';';
+        String expected = "The;quick;brown;fox;jumps";
+
+        // when
+        String actual = new StringAssembler(delimeter)
+                .append("The")
+                .append("quick")
+                .append("brown")
+                .append("fox")
+                .append("jumps")
+                .assemble();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+}

src/test/java/rocks/zipcode/io/quiz4/objectorientation/student/LearnTest.java

+package rocks.zipcode.io.quiz4.objectorientation.student;
+
+import org.junit.Assert;
+import org.junit.Test;
+import rocks.zipcode.io.quiz4.objectorientation.Student;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class LearnTest {
+    @Test
+    public void test1() {
+        Student student = new Student();
+        Double expected = 15.0;
+
+        // when
+        student.learn(expected);
+        Double actual = student.getTotalStudyTime();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        Student student = new Student();
+        Double expected = 30.0;
+
+        // when
+        student.learn(expected);
+        Double actual = student.getTotalStudyTime();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test3() {
+        Student student = new Student();
+        Double firstLecture = 15.0;
+        Double secondLecture = 25.0;
+        Double expected = firstLecture + secondLecture;
+
+        // when
+        student.learn(firstLecture);
+        student.learn(secondLecture);
+        Double actual = student.getTotalStudyTime();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void test4() {
+        Student student = new Student();
+        Double firstLecture = 35.0;
+        Double secondLecture = 25.0;
+        Double expected = firstLecture + secondLecture;
+
+        // when
+        student.learn(firstLecture);
+        student.learn(secondLecture);
+        Double actual = student.getTotalStudyTime();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
+    @Test
+    public void test5() {
+        Student student = new Student();
+        Double firstLecture = 98.0;
+        Double secondLecture = 72.0;
+        Double expected = firstLecture + secondLecture;
+
+        // when
+        student.learn(firstLecture);
+        student.learn(secondLecture);
+        Double actual = student.getTotalStudyTime();
+
+        // then
+        Assert.assertEquals(expected, actual);
+    }
+
+}

src/test/java/rocks/zipcode/io/quiz4/utils/MyTestClass.java

+package rocks.zipcode.io.quiz4.utils;
+
+import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
+
+import java.util.*;
+
+/**
+ * @author leon on 18/12/2018.
+ */
+public class MyTestClass {
+
+    public static <E> Set<Set<E>> findPowerSet(Set<E> set) {
+        Set<Set<E>> ret = new TreeSet<>();
+        ret.add(set);
+        if (set.isEmpty()) {
+            return ret;
+        }
+        Iterator<E> it = set.iterator();
+        while (it.hasNext()) {
+            Set<E> tmp = (Set)new ComparableTreeSet(set);   //create a copy of current set
+            tmp.remove(it.next());              //remove current element from copy set
+            ret.add(tmp);                       //add the remaining set to result
+            ret.addAll(findPowerSet(tmp));      //recursively find subsets of copy set
+        }
+        return ret;
+    }
+
+    public static void main(String[] args) {
+        Set<Character> set = (Set)new ComparableTreeSet<Character>();
+        set.add('x');
+        set.add('y');
+        set.add('z');
+        set.add('t');
+        System.out.println("Input set");
+        printSet(set);
+        System.out.println("\nsub sets");
+        findPowerSet(set).stream().forEach(MyTestClass::printSet);
+    }
+
+
+    public static <E> void printSet(E... val) {
+        printSet(new TreeSet<>(Arrays.asList(val)));
+    }
+
+    public static <E> void printSet(Set<E> set) {
+        StringBuilder sb = new StringBuilder(set.size() == 0 ? "{}\n" : "{");
+        Iterator<E> it = set.iterator();
+        while (it.hasNext()) {
+            sb.append(it.next().toString())
+                    .append(it.hasNext() ? ", " : "}\n");
+        }
+        System.out.print(sb.toString());
+    }
+}

src/test/java/rocks/zipcode/io/quiz4/utils/TestUtils.java

+package rocks.zipcode.io.quiz4.utils;
+
+import org.junit.Assert;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+/**
+ * @author leon on 11/12/2018.
+ */
+public class TestUtils {
+    public static <ObjectType> void assertArrayEquals(ObjectType[] array1, ObjectType[] array2) {
+        Arrays.sort(array1);
+        Arrays.sort(array2);
+        Assert.assertEquals(Arrays.toString(array1), Arrays.toString(array2));
+    }
+
+
+    public static <ArgType1, ReturnType> void constrainMethodPerformance(
+            Function<ArgType1, ReturnType> function,
+            ArgType1 arg1,
+            Long maxTimeInMilliseconds) {
+        constrainMethodPerformance((val1, val2) -> function.apply(val1), arg1, null, maxTimeInMilliseconds);
+    }
+
+    public static <ArgType1, ArgType2, ReturnType> void constrainMethodPerformance(
+            BiFunction<ArgType1, ArgType2, ReturnType> function,
+            ArgType1 arg1, ArgType2 arg2, Long maxTimeInMilliseconds) {
+        if (timeMethod(function, arg1, arg2) > maxTimeInMilliseconds) {
+            Throwable timeoutException = new TimeoutException("Method must perform in under " + maxTimeInMilliseconds + "millseconds");
+            ;
+            throw new Error(timeoutException);
+        }
+    }
+
+
+    public static <ArgType1, ReturnType> Long timeMethod(Function<ArgType1, ReturnType> function, ArgType1 arg1) {
+        return timeMethod((val1, val2) -> function.apply(val1), arg1, null);
+    }
+
+    public static <ArgType1, ArgType2, ReturnType> Long timeMethod(
+            BiFunction<ArgType1, ArgType2, ReturnType> function,
+            ArgType1 arg1, ArgType2 arg2) {
+        Long startTime = System.currentTimeMillis();
+        function.apply(arg1, arg2);
+        Long endTime = System.currentTimeMillis();
+        Long delta = endTime - startTime;
+        return delta;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> Stream<T> reveseList(List<T> input) {
+        Object[] temp = input.toArray();
+        return (Stream<T>) IntStream.range(0, temp.length)
+                .mapToObj(i -> temp[temp.length - i - 1]);
+    }
+
+}