diff --git a/.gitignore b/.gitignore
index 32858aa..06bc58a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,16 @@
 *.ear
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
+hs_err_pid
+
+# Intellij
+.idea/
+*.iml
+*.iws
+
+# Mac
+.DS_Store
+
+# Maven
+log/
+target/*
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..9ac419d
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,26 @@
+<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>zygmundfelt.dan.typeinformation</groupId>
+  <artifactId>TypeInformation</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <name>TypeInformation</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencies>
+    <!-- https://mvnrepository.com/artifact/junit/junit -->
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+    </dependency>
+  </dependencies>
+
+</project>
diff --git a/src/main/java/zygmundfelt/dan/typeinformation/Part1/ClassImplementsInterface.java b/src/main/java/zygmundfelt/dan/typeinformation/Part1/ClassImplementsInterface.java
new file mode 100644
index 0000000..77f57f1
--- /dev/null
+++ b/src/main/java/zygmundfelt/dan/typeinformation/Part1/ClassImplementsInterface.java
@@ -0,0 +1,39 @@
+package zygmundfelt.dan.typeinformation.Part1;
+
+public class ClassImplementsInterface {
+
+    static boolean classImplementsInterface(Class implementor, Class implemented) {
+        Class[] interfaces = implementor.getInterfaces();
+        for (Class cl : interfaces) {
+            if (cl == implemented) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static boolean classImplementsInterface(Object implementor, Class implemented) {
+        Class[] interfaces = implementor.getClass().getInterfaces();
+        for (Class cl : interfaces) {
+            if (cl == implemented) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static boolean classImplementsInterface(String implementor, Class implemented) {
+        try {
+            Class[] interfaces = Class.forName(implementor).getInterfaces();
+            for (Class cl : interfaces) {
+                if (cl == implemented) {
+                    return true;
+                }
+            }
+        } catch(Exception e) {
+            return false;
+        }
+        return false;
+    }
+
+}
diff --git a/src/main/java/zygmundfelt/dan/typeinformation/Part1/GetClassHierarchy.java b/src/main/java/zygmundfelt/dan/typeinformation/Part1/GetClassHierarchy.java
new file mode 100644
index 0000000..4f181c3
--- /dev/null
+++ b/src/main/java/zygmundfelt/dan/typeinformation/Part1/GetClassHierarchy.java
@@ -0,0 +1,28 @@
+package zygmundfelt.dan.typeinformation.Part1;
+
+import java.util.ArrayList;
+
+public class GetClassHierarchy {
+
+    static String getClassHierarchy(Object o) {
+        Class cl = o.getClass();
+        ArrayList<Class> classArrayList = new ArrayList<Class>();
+        String result = "";
+
+        do {
+            classArrayList.add(cl);
+            cl = cl.getSuperclass();
+        } while(cl != null);
+
+        int len = classArrayList.size();
+
+        for(int i = 0; i < len; i++) {
+            for(int j = 0; j < i; j++) {
+                result += "  ";
+            }
+            result += classArrayList.get(len - 1 - i).getName() + "\n";
+        }
+
+        return result;
+    }
+}
diff --git a/src/main/java/zygmundfelt/dan/typeinformation/Part1/InstantiateClassHierarchy.java b/src/main/java/zygmundfelt/dan/typeinformation/Part1/InstantiateClassHierarchy.java
new file mode 100644
index 0000000..cf714db
--- /dev/null
+++ b/src/main/java/zygmundfelt/dan/typeinformation/Part1/InstantiateClassHierarchy.java
@@ -0,0 +1,51 @@
+package zygmundfelt.dan.typeinformation.Part1;
+
+import java.util.ArrayList;
+import java.util.TreeMap;
+
+public class InstantiateClassHierarchy {
+
+    static ArrayList<Object> instantiateClassHierarchy(Object o) {
+        Class cl = o.getClass();
+        ArrayList<Object> classInstanceArrayList = new ArrayList<Object>();
+
+        do {
+            try{
+                Object object = cl.newInstance();
+                classInstanceArrayList.add(object);
+                cl = cl.getSuperclass();
+            }
+            catch (Exception e) {
+                cl = cl.getSuperclass();
+            }
+        } while(cl != null);
+
+        for(Object object : classInstanceArrayList) {
+            int modifier = object.getClass().getModifiers();
+            if(modifier == 0 || modifier == 2) {
+                classInstanceArrayList.remove(object);
+            }
+        }
+
+        return classInstanceArrayList;
+    }
+
+    public static void main(String[] args) {
+        TreeMap map = new TreeMap();
+        ArrayList list = new ArrayList();
+
+        ArrayList<Object> forTreeMap = instantiateClassHierarchy(map);
+        ArrayList<Object> forList = instantiateClassHierarchy(list);
+
+        for(Object o : forTreeMap) {
+            System.out.println(o.getClass());
+        }
+
+        System.out.println();
+
+        for(Object o : forList) {
+            System.out.println(o.getClass());
+        }
+    }
+
+}
diff --git a/src/main/java/zygmundfelt/dan/typeinformation/Part1/ListAllMembers.java b/src/main/java/zygmundfelt/dan/typeinformation/Part1/ListAllMembers.java
new file mode 100644
index 0000000..e4a3bea
--- /dev/null
+++ b/src/main/java/zygmundfelt/dan/typeinformation/Part1/ListAllMembers.java
@@ -0,0 +1,63 @@
+package zygmundfelt.dan.typeinformation.Part1;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.LinkedList;
+
+/* The Arrays.sort methods below are adapted from
+http://stackoverflow.com/questions/1097807/java-reflection-is-the-order-of-class-fields-and-methods-standardized
+ */
+
+public class ListAllMembers {
+
+    static String listAllMembers(Object o) {
+        String summary = "";
+        Class cl = o.getClass();
+        do {
+            summary += cl + "\n";
+            Field[] fields = cl.getDeclaredFields();
+            Arrays.sort(fields, new Comparator<Field>() {
+                public int compare(Field o1, Field o2) {
+                    return o1.getName().compareTo(o2.getName());
+                }
+            });
+            for(Field f : fields) {
+                summary += f + "\n";
+            }
+            System.out.println("\n");
+            Constructor[] constructors = cl.getConstructors();
+            Arrays.sort(constructors, new Comparator<Constructor>() {
+                public int compare(Constructor o1, Constructor o2) {
+                    return o1.getName().compareTo(o2.getName());
+                }
+            });
+            for(Constructor c : constructors) {
+                summary += c + "\n";
+            }
+            System.out.println("\n");
+            Method[] methods = cl.getDeclaredMethods();
+            Arrays.sort(methods, new Comparator<Method>() {
+                public int compare(Method o1, Method o2) {
+                    return o1.getName().compareTo(o2.getName());
+                }
+            });
+            for(Method m : methods) {
+                summary += m + "\n";
+            }
+            System.out.println("\n");
+            summary += "\n";
+            cl = cl.getSuperclass();
+        } while (cl != null);
+
+        return summary;
+    }
+
+    public static void main(String[] args) {
+        LinkedList list = new LinkedList();
+        System.out.println(listAllMembers(list));
+    }
+
+}
diff --git a/src/main/java/zygmundfelt/dan/typeinformation/unitCorn/Result.java b/src/main/java/zygmundfelt/dan/typeinformation/unitCorn/Result.java
new file mode 100644
index 0000000..164c3d7
--- /dev/null
+++ b/src/main/java/zygmundfelt/dan/typeinformation/unitCorn/Result.java
@@ -0,0 +1,25 @@
+package zygmundfelt.dan.typeinformation.unitCorn;
+
+public class Result {
+
+    String methodName;
+    String result;
+
+    Result(String methodName, String result) {
+        this.methodName = methodName;
+        this.result = result;
+    }
+
+    public String getResult() {
+        return result;
+    }
+
+    public String getMethodName() {
+        return methodName;
+    }
+
+    public String toString() {
+        return "The result of testing " + methodName + " was " + result + ".\n";
+    }
+
+}
diff --git a/src/main/java/zygmundfelt/dan/typeinformation/unitCorn/UnitCornTestRunner.java b/src/main/java/zygmundfelt/dan/typeinformation/unitCorn/UnitCornTestRunner.java
new file mode 100644
index 0000000..d1c86f4
--- /dev/null
+++ b/src/main/java/zygmundfelt/dan/typeinformation/unitCorn/UnitCornTestRunner.java
@@ -0,0 +1,89 @@
+package zygmundfelt.dan.typeinformation.unitCorn;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import org.junit.*;
+
+
+public class UnitCornTestRunner {
+
+    ArrayList<Result> results;
+
+    static Result runTest(Class cls, String methodName) {
+
+        Object o;
+        try {
+            o = cls.newInstance();
+        } catch(Exception e) {
+            return new Result(methodName, e.toString());
+        }
+
+        Method method = getMethod(cls, methodName);
+
+        try {
+            method.invoke(o);
+        } catch (Exception e) {
+            return new Result(methodName, e.toString());
+        }
+
+        return new Result(methodName, "success");
+    }
+
+    static Method getMethod(Class cls, String methodName) {
+        Method[] methods = cls.getDeclaredMethods();
+        for(Method m : methods) {
+            if(m.getName().equals(methodName)) {
+                return m;
+            }
+        }
+        return null;
+    }
+
+    /*
+    For testing in test class and testing in main class below
+     */
+    @Test
+    static String runTests(Class cls) {
+        StringBuilder sb = new StringBuilder();
+        ArrayList<String> annotatedMethods = getJUnitAnnotatedMethods(cls);
+
+        for(String s : annotatedMethods) {
+            Result result = runTest(cls, s);
+            sb.append(result.toString());
+        }
+
+        return sb.toString();
+    }
+
+    /*
+    For testing in test class and testing in main class below
+     */
+    @Test
+    static ArrayList<String> getJUnitAnnotatedMethods(Class cls) {
+        Method[] methods = cls.getDeclaredMethods();
+        ArrayList<String> annotatedMethods = new ArrayList<String>();
+
+        for(Method m : methods) {
+            Annotation[] annotations = m.getAnnotations();
+            for(Annotation a : annotations) {
+                if(a.toString().substring(0, 15).equals("@org.junit.Test")) {
+                    annotatedMethods.add(m.getName());
+                }
+            }
+        }
+
+        return annotatedMethods;
+    }
+
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.UnitCornTestRunner");
+            System.out.println(runTests(cls));
+        } catch (Exception e) {
+            System.out.println("BOOOO.");
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/zygmundfelt/dan/typeinformation/Part1/ClassImplementsInterfaceTest.java b/src/test/java/zygmundfelt/dan/typeinformation/Part1/ClassImplementsInterfaceTest.java
new file mode 100644
index 0000000..aecbb94
--- /dev/null
+++ b/src/test/java/zygmundfelt/dan/typeinformation/Part1/ClassImplementsInterfaceTest.java
@@ -0,0 +1,74 @@
+package zygmundfelt.dan.typeinformation.Part1;
+import org.junit.*;
+import java.util.*;
+
+public class ClassImplementsInterfaceTest {
+
+    @Test
+    public void classImplementsInterfaceClassTrueTest () {
+        //Given
+        Class implementor = ArrayList.class;
+        Class implemented = List.class;
+        //When
+        boolean result = ClassImplementsInterface.classImplementsInterface(implementor, implemented);
+        //Then
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void classImplementsInterfaceClassFalseTest() {
+        //Given
+        Class implementor = Math.class;
+        Class implemented = List.class;
+        //When
+        boolean result = ClassImplementsInterface.classImplementsInterface(implementor, implemented);
+        //Then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void classImplementsInterfaceObjectTrueTest () {
+        //Given
+        ArrayList implementor = new ArrayList();
+        Class implemented = List.class;
+        //When
+        boolean result = ClassImplementsInterface.classImplementsInterface(implementor, implemented);
+        //Then
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void classImplementsInterfaceObjectFalseTest() {
+        //Given
+        Integer implementor = 45;
+        Class implemented = List.class;
+        //When
+        boolean result = ClassImplementsInterface.classImplementsInterface(implementor, implemented);
+        //Then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void classImplementsInterfaceStringTrueTest () {
+        //Given
+        String implementor = "java.util.ArrayList";
+        Class implemented = List.class;
+        ArrayList list = new ArrayList();
+        //When
+        boolean result = ClassImplementsInterface.classImplementsInterface(implementor, implemented);
+        //Then
+        Assert.assertEquals(implementor,list.getClass().getName());
+        //Assert.assertTrue(result);
+    }
+
+    @Test
+    public void classImplementsInterfaceStringFalseTest() {
+        //Given
+        String implementor = "java.lang.Object";
+        Class implemented = List.class;
+        //When
+        boolean result = ClassImplementsInterface.classImplementsInterface(implementor, implemented);
+        //Then
+        Assert.assertFalse(result);
+    }
+}
diff --git a/src/test/java/zygmundfelt/dan/typeinformation/Part1/GetClassHierarchyTest.java b/src/test/java/zygmundfelt/dan/typeinformation/Part1/GetClassHierarchyTest.java
new file mode 100644
index 0000000..c9f3919
--- /dev/null
+++ b/src/test/java/zygmundfelt/dan/typeinformation/Part1/GetClassHierarchyTest.java
@@ -0,0 +1,28 @@
+package zygmundfelt.dan.typeinformation.Part1;
+import org.junit.*;
+
+public class GetClassHierarchyTest {
+
+    @Test
+    public void GetClassHierarchyIntegerTest() {
+        //Given
+        Integer integer = 30;
+        String expected = "java.lang.Object\n  java.lang.Number\n    java.lang.Integer\n";
+        //When
+        String actual = GetClassHierarchy.getClassHierarchy(integer);
+        //Then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void GetClassHierarchyObjectTest() {
+        //Given
+        Object o = new Object();
+        String expected = "java.lang.Object\n";
+        //When
+        String actual = GetClassHierarchy.getClassHierarchy(o);
+        //Then
+        Assert.assertEquals(expected, actual);
+    }
+
+}
diff --git a/src/test/java/zygmundfelt/dan/typeinformation/Part1/InstantiateClassHierarchyTest.java b/src/test/java/zygmundfelt/dan/typeinformation/Part1/InstantiateClassHierarchyTest.java
new file mode 100644
index 0000000..23397bf
--- /dev/null
+++ b/src/test/java/zygmundfelt/dan/typeinformation/Part1/InstantiateClassHierarchyTest.java
@@ -0,0 +1,74 @@
+package zygmundfelt.dan.typeinformation.Part1;
+import org.junit.*;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.TreeMap;
+
+/* Need to work out these tests. Instantiating objects and adding them to an
+   ArrayList won't lead to the .contains() method returning true, because, duh,
+   they're different instances of the same class.
+
+   This may not be too much trouble but I want to move on to something else.
+ */
+
+
+
+public class InstantiateClassHierarchyTest {
+
+    @Test
+    public void instantiateClassHierarchyTrueTest() {
+        //Given
+        TreeMap map = new TreeMap();
+        Object object = new Object();
+        ArrayList<Object> expected = new ArrayList<Object>();
+        expected.add(map);
+        expected.add(object);
+        //When
+        ArrayList<Object> actual = InstantiateClassHierarchy.instantiateClassHierarchy(map);
+        //Then
+        boolean result = true;
+
+        for(Object o : expected) {
+            if(!actual.contains(o)) {
+                result = false;
+            }
+        }
+
+        for(Object o : actual) {
+            if(!expected.contains(o)) {
+                result = false;
+            }
+        }
+
+        Assert.assertTrue(result);
+    }
+
+
+    @Test
+    public void instantiateClassHierarchyFalseTest() {
+        //Given
+        LinkedList list = new LinkedList();
+        ArrayList<Object> expected = new ArrayList<Object>();
+        expected.add(list);
+        //When
+        ArrayList<Object> actual = InstantiateClassHierarchy.instantiateClassHierarchy(list);
+        //Then
+        boolean result = true;
+
+        for(Object o : expected) {
+            if(!actual.contains(o)) {
+                result = false;
+            }
+        }
+
+        for(Object o : actual) {
+            if(!expected.contains(o)) {
+                result = false;
+            }
+        }
+
+        Assert.assertFalse(result);
+
+    }
+}
diff --git a/src/test/java/zygmundfelt/dan/typeinformation/Part1/ListAllMembersTest.java b/src/test/java/zygmundfelt/dan/typeinformation/Part1/ListAllMembersTest.java
new file mode 100644
index 0000000..86d171a
--- /dev/null
+++ b/src/test/java/zygmundfelt/dan/typeinformation/Part1/ListAllMembersTest.java
@@ -0,0 +1,18 @@
+package zygmundfelt.dan.typeinformation.Part1;
+import org.junit.*;
+
+import java.util.LinkedList;
+
+public class ListAllMembersTest {
+
+    @Test
+    public void listAllMembersSimpleTest() {
+        //Given
+        LinkedList list = new LinkedList();
+        String expected = "class java.util.LinkedList\ntransient java.util.LinkedList$Node java.util.LinkedList.first\ntransient java.util.LinkedList$Node java.util.LinkedList.last\nprivate static final long java.util.LinkedList.serialVersionUID\ntransient int java.util.LinkedList.size\npublic java.util.LinkedList()\npublic java.util.LinkedList(java.util.Collection)\npublic boolean java.util.LinkedList.add(java.lang.Object)\npublic void java.util.LinkedList.add(int,java.lang.Object)\npublic boolean java.util.LinkedList.addAll(int,java.util.Collection)\npublic boolean java.util.LinkedList.addAll(java.util.Collection)\npublic void java.util.LinkedList.addFirst(java.lang.Object)\npublic void java.util.LinkedList.addLast(java.lang.Object)\nprivate void java.util.LinkedList.checkElementIndex(int)\nprivate void java.util.LinkedList.checkPositionIndex(int)\npublic void java.util.LinkedList.clear()\npublic java.lang.Object java.util.LinkedList.clone()\npublic boolean java.util.LinkedList.contains(java.lang.Object)\npublic java.util.Iterator java.util.LinkedList.descendingIterator()\npublic java.lang.Object java.util.LinkedList.element()\npublic java.lang.Object java.util.LinkedList.get(int)\npublic java.lang.Object java.util.LinkedList.getFirst()\npublic java.lang.Object java.util.LinkedList.getLast()\npublic int java.util.LinkedList.indexOf(java.lang.Object)\nprivate boolean java.util.LinkedList.isElementIndex(int)\nprivate boolean java.util.LinkedList.isPositionIndex(int)\npublic int java.util.LinkedList.lastIndexOf(java.lang.Object)\nvoid java.util.LinkedList.linkBefore(java.lang.Object,java.util.LinkedList$Node)\nprivate void java.util.LinkedList.linkFirst(java.lang.Object)\nvoid java.util.LinkedList.linkLast(java.lang.Object)\npublic java.util.ListIterator java.util.LinkedList.listIterator(int)\njava.util.LinkedList$Node java.util.LinkedList.node(int)\npublic boolean java.util.LinkedList.offer(java.lang.Object)\npublic boolean java.util.LinkedList.offerFirst(java.lang.Object)\npublic boolean java.util.LinkedList.offerLast(java.lang.Object)\nprivate java.lang.String java.util.LinkedList.outOfBoundsMsg(int)\npublic java.lang.Object java.util.LinkedList.peek()\npublic java.lang.Object java.util.LinkedList.peekFirst()\npublic java.lang.Object java.util.LinkedList.peekLast()\npublic java.lang.Object java.util.LinkedList.poll()\npublic java.lang.Object java.util.LinkedList.pollFirst()\npublic java.lang.Object java.util.LinkedList.pollLast()\npublic java.lang.Object java.util.LinkedList.pop()\npublic void java.util.LinkedList.push(java.lang.Object)\nprivate void java.util.LinkedList.readObject(java.io.ObjectInputStream) throws java.io.IOException,java.lang.ClassNotFoundException\npublic boolean java.util.LinkedList.remove(java.lang.Object)\npublic java.lang.Object java.util.LinkedList.remove()\npublic java.lang.Object java.util.LinkedList.remove(int)\npublic java.lang.Object java.util.LinkedList.removeFirst()\npublic boolean java.util.LinkedList.removeFirstOccurrence(java.lang.Object)\npublic java.lang.Object java.util.LinkedList.removeLast()\npublic boolean java.util.LinkedList.removeLastOccurrence(java.lang.Object)\npublic java.lang.Object java.util.LinkedList.set(int,java.lang.Object)\npublic int java.util.LinkedList.size()\npublic java.util.Spliterator java.util.LinkedList.spliterator()\nprivate java.util.LinkedList java.util.LinkedList.superClone()\npublic java.lang.Object[] java.util.LinkedList.toArray(java.lang.Object[])\npublic java.lang.Object[] java.util.LinkedList.toArray()\njava.lang.Object java.util.LinkedList.unlink(java.util.LinkedList$Node)\nprivate java.lang.Object java.util.LinkedList.unlinkFirst(java.util.LinkedList$Node)\nprivate java.lang.Object java.util.LinkedList.unlinkLast(java.util.LinkedList$Node)\nprivate void java.util.LinkedList.writeObject(java.io.ObjectOutputStream) throws java.io.IOException\n\nclass java.util.AbstractSequentialList\npublic void java.util.AbstractSequentialList.add(int,java.lang.Object)\npublic boolean java.util.AbstractSequentialList.addAll(int,java.util.Collection)\npublic java.lang.Object java.util.AbstractSequentialList.get(int)\npublic java.util.Iterator java.util.AbstractSequentialList.iterator()\npublic abstract java.util.ListIterator java.util.AbstractSequentialList.listIterator(int)\npublic java.lang.Object java.util.AbstractSequentialList.remove(int)\npublic java.lang.Object java.util.AbstractSequentialList.set(int,java.lang.Object)\n\nclass java.util.AbstractList\nprotected transient int java.util.AbstractList.modCount\npublic void java.util.AbstractList.add(int,java.lang.Object)\npublic boolean java.util.AbstractList.add(java.lang.Object)\npublic boolean java.util.AbstractList.addAll(int,java.util.Collection)\npublic void java.util.AbstractList.clear()\npublic boolean java.util.AbstractList.equals(java.lang.Object)\npublic abstract java.lang.Object java.util.AbstractList.get(int)\npublic int java.util.AbstractList.hashCode()\npublic int java.util.AbstractList.indexOf(java.lang.Object)\npublic java.util.Iterator java.util.AbstractList.iterator()\npublic int java.util.AbstractList.lastIndexOf(java.lang.Object)\npublic java.util.ListIterator java.util.AbstractList.listIterator(int)\npublic java.util.ListIterator java.util.AbstractList.listIterator()\nprivate java.lang.String java.util.AbstractList.outOfBoundsMsg(int)\nprivate void java.util.AbstractList.rangeCheckForAdd(int)\npublic java.lang.Object java.util.AbstractList.remove(int)\nprotected void java.util.AbstractList.removeRange(int,int)\npublic java.lang.Object java.util.AbstractList.set(int,java.lang.Object)\npublic java.util.List java.util.AbstractList.subList(int,int)\n\nclass java.util.AbstractCollection\nprivate static final int java.util.AbstractCollection.MAX_ARRAY_SIZE\npublic boolean java.util.AbstractCollection.add(java.lang.Object)\npublic boolean java.util.AbstractCollection.addAll(java.util.Collection)\npublic void java.util.AbstractCollection.clear()\npublic boolean java.util.AbstractCollection.contains(java.lang.Object)\npublic boolean java.util.AbstractCollection.containsAll(java.util.Collection)\nprivate static java.lang.Object[] java.util.AbstractCollection.finishToArray(java.lang.Object[],java.util.Iterator)\nprivate static int java.util.AbstractCollection.hugeCapacity(int)\npublic boolean java.util.AbstractCollection.isEmpty()\npublic abstract java.util.Iterator java.util.AbstractCollection.iterator()\npublic boolean java.util.AbstractCollection.remove(java.lang.Object)\npublic boolean java.util.AbstractCollection.removeAll(java.util.Collection)\npublic boolean java.util.AbstractCollection.retainAll(java.util.Collection)\npublic abstract int java.util.AbstractCollection.size()\npublic java.lang.Object[] java.util.AbstractCollection.toArray(java.lang.Object[])\npublic java.lang.Object[] java.util.AbstractCollection.toArray()\npublic java.lang.String java.util.AbstractCollection.toString()\n\nclass java.lang.Object\npublic java.lang.Object()\nprotected native java.lang.Object java.lang.Object.clone() throws java.lang.CloneNotSupportedException\npublic boolean java.lang.Object.equals(java.lang.Object)\nprotected void java.lang.Object.finalize() throws java.lang.Throwable\npublic final native java.lang.Class java.lang.Object.getClass()\npublic native int java.lang.Object.hashCode()\npublic final native void java.lang.Object.notify()\npublic final native void java.lang.Object.notifyAll()\nprivate static native void java.lang.Object.registerNatives()\npublic java.lang.String java.lang.Object.toString()\npublic final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException\npublic final native void java.lang.Object.wait(long) throws java.lang.InterruptedException\npublic final void java.lang.Object.wait() throws java.lang.InterruptedException\n\n";
+        //When
+        String actual = ListAllMembers.listAllMembers(list);
+        //Then
+        Assert.assertEquals(expected, actual);
+    }
+}
diff --git a/src/test/java/zygmundfelt/dan/typeinformation/unitCorn/DummyTest.java b/src/test/java/zygmundfelt/dan/typeinformation/unitCorn/DummyTest.java
new file mode 100644
index 0000000..dd809d5
--- /dev/null
+++ b/src/test/java/zygmundfelt/dan/typeinformation/unitCorn/DummyTest.java
@@ -0,0 +1,40 @@
+package zygmundfelt.dan.typeinformation.unitCorn;
+
+import org.junit.*;
+
+
+public class DummyTest {
+
+    @Test
+    public void setANumberTest() {
+        double expected = 81.18;
+        double actual = 81.18;
+
+        Assert.assertEquals("The samesies", expected, actual, 0);
+    }
+
+    @Test
+    public void setANumberTestFail() {
+        double expected = -81.18;
+        double actual = 81.18;
+
+        Assert.assertEquals("The samesies", expected, actual, 0);
+    }
+
+    public void throwsIndexOutOfBoundsException() {
+        int[] arr = new int[10000];
+        int thisShouldBeAnException = arr[arr.length + 3];
+        return;
+    }
+
+    @Test
+    public void anotherTestFail() {
+        Assert.assertTrue(8 == 9);
+    }
+
+    @Test
+    public void anotherTestPass() {
+        Assert.assertTrue(7.5 == 7.5);
+    }
+
+}
diff --git a/src/test/java/zygmundfelt/dan/typeinformation/unitCorn/UnitCornTestRunnerTest.java b/src/test/java/zygmundfelt/dan/typeinformation/unitCorn/UnitCornTestRunnerTest.java
new file mode 100644
index 0000000..0a5f6a5
--- /dev/null
+++ b/src/test/java/zygmundfelt/dan/typeinformation/unitCorn/UnitCornTestRunnerTest.java
@@ -0,0 +1,148 @@
+package zygmundfelt.dan.typeinformation.unitCorn;
+import org.junit.*;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+
+public class UnitCornTestRunnerTest {
+
+    UnitCornTestRunner unitCorn;
+    DummyTest dummyTest;
+
+
+    @Before
+    public void initialize() {
+        unitCorn = new UnitCornTestRunner();
+        dummyTest = new DummyTest();
+    }
+
+    @Test
+    public void runTestTest() {
+        try {
+            Class clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.DummyTest");
+            String methodName = "setANumberTest";
+            Result result = UnitCornTestRunner.runTest(clazz, methodName);
+
+            Assert.assertEquals(result.getResult(), "success");
+        } catch (Exception e){
+            Assert.fail("Couldn't create instance of DummyTest." + e.getMessage());
+        }
+    }
+
+    @Test
+    public void runTestTestFail() {
+        try {
+            Class clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.DummyTest");
+            String methodName = "setANumberTestFail";
+            Result result = UnitCornTestRunner.runTest(clazz, methodName);
+
+            Assert.assertNotEquals(result.getResult(), null);
+        } catch (Exception e){
+            Assert.fail("Couldn't create instance of DummyTest." + e.getMessage());
+        }
+    }
+
+    @Test
+    public void testIndexOutOfBoundsExceptionInTestMethod() {
+        try {
+            Class clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.DummyTest");
+            String methodName = "throwsIndexOutOfBoundsException";
+            Result result = UnitCornTestRunner.runTest(clazz, methodName);
+
+            Assert.assertNotEquals(result.getResult(), null);
+        } catch (Exception e){
+            Assert.fail("Couldn't create instance of DummyTest." + e.getMessage());
+        }
+    }
+
+    /*
+    This test is designed to fail. Be happy!
+     */
+    @Test
+    public void runTestTestWhichShouldFail() {
+        try {
+            Class clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.DummyTest");
+            String methodName = "setANumberTest";
+            Result result = UnitCornTestRunner.runTest(clazz, methodName);
+
+            Assert.assertEquals(result.getResult(), null);
+        } catch (Exception e){
+            Assert.fail("Couldn't create instance of DummyTest." + e.getMessage());
+        }
+    }
+
+    @Test
+    public void getJUnitAnnotatedMethodsTest() {
+        Class clazz = null;
+        try {
+            clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.DummyTest");
+        } catch (Exception e){
+            Assert.assertTrue("Couldn't create instance of DummyTest.", false);
+        }
+
+        ArrayList<String> expected = UnitCornTestRunner.getJUnitAnnotatedMethods(clazz);
+
+        ArrayList<String> actual = new ArrayList<String>();
+        actual.add("setANumberTest");
+        actual.add("setANumberTestFail");
+        actual.add("anotherTestPass");
+        actual.add("anotherTestFail");
+
+        boolean result = true;
+
+        if(actual.size() != expected.size()) {
+            result = false;
+        } else {
+            for(String s : actual) {
+                if(!expected.contains(s)) {
+                    result = false;
+                }
+            }
+        }
+
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void runTestsTestDummy() {
+        Class clazz = null;
+        try {
+            clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.DummyTest");
+        } catch (Exception e){
+            Assert.assertTrue("Couldn't create instance of DummyTest.", false);
+        }
+
+        String expected = "The result of testing setANumberTest was success.\n" +
+                "The result of testing setANumberTestFail was java.lang.reflect.InvocationTargetException.\n" +
+                "The result of testing anotherTestPass was success.\n" +
+                "The result of testing anotherTestFail was java.lang.reflect.InvocationTargetException.\n";
+
+        String actual = UnitCornTestRunner.runTests(clazz);
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    /*
+    This test method sometimes reverses the order of the expected String, but that's OK for now.
+     */
+    @Test
+    public void runTestsTestUnitCornTestRunner() {
+        Class clazz = null;
+        try {
+            clazz = Class.forName("zygmundfelt.dan.typeinformation.unitCorn.UnitCornTestRunner");
+        } catch (Exception e) {
+            Assert.assertTrue("Couldn't create instance of UnitCornTestRunner", false);
+        }
+
+        String expected =
+                "The result of testing getJUnitAnnotatedMethods was java.lang.IllegalArgumentException: wrong number of arguments.\n"+
+                        "The result of testing runTests was java.lang.IllegalArgumentException: wrong number of arguments.\n";
+
+        String actual = UnitCornTestRunner.runTests(clazz);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+}