First commit with the first few assignments added.

README.md

@@ -0,0 +1,8 @@
+# Generics MicroLabs
+The microlabs for the Generics chapter are all grouped together.  So, you need to work through them package by package.
+The following list is the package name followed by a quick description of the assignment.
+1. StackArrayList -- Implement `Stack<E>` to use an ArrayList as a stack.  You need to make the `push`, `pop`, and
+`isEmpty` functions.
+2. StackArray -- Implement `Stack<E>` to use an array as a stack.  You'll need to potentially grow the array in the 
+`push` method.  Do this first with an `E[]` array, and then again with an `Object[]` array.  Both should compile
+without warnings and pass the tests.

src/main/java/StackArray/GenericStack.java

@@ -0,0 +1,15 @@
+package StackArray;
+
+import java.util.Arrays;
+
+/**
+ * Expand the ArrayList implementation of stack here to use an E[] array.  Still implement push, pop, and isEmpty.
+ * Remember, you might need to resize the stack in the push method.
+ * @param <E>
+ */
+public class GenericStack<E> {
+    private E[] elements;
+
+    public GenericStack() {
+    }
+}

src/main/java/StackArray/ObjectStack.java

@@ -0,0 +1,16 @@
+package StackArray;
+
+import java.util.Arrays;
+
+/**
+ * Expand the ArrayList implementation of stack here to use an Object[] array.  Still implement push, pop, and isEmpty.
+ * Remember, you might need to resize the stack in the push method.
+ * @param <E>
+ */
+public class ObjectStack<E> {
+    private Object[] elements;
+
+    public ObjectStack() {
+
+    }
+}

src/main/java/StackArrayList/Stack.java

@@ -0,0 +1,16 @@
+package StackArrayList;
+
+import java.util.ArrayList;
+
+/**
+ * Implement Stack<E> by adding the push, pop, and isEmpty functions.  It must pass the prewritten unit tests.
+ * If you pop on an empty stack, throw an IndexOutOfBoundsException.
+ */
+public class Stack<E> {
+    private ArrayList elements;
+
+
+    public Stack(){
+
+    }
+}

src/test/java/StackArray/GenericStackTest.java

@@ -0,0 +1,41 @@
+//package StackArray;
+//
+//import org.junit.Assert;
+//import org.junit.Test;
+//
+//public class GenericStackTest {
+//    @Test
+//    public void testPushingGrowsTheStack() throws Exception {
+//        // Given an empty stack
+//        GenericStack<String> stack = new GenericStack<>();
+//
+//        // Assert that it is empty.
+//        Assert.assertEquals(true, stack.isEmpty());
+//        // When we push something onto the stack
+//        stack.push("foobar");
+//        // Then it shouldn't be empty
+//        Assert.assertEquals(false, stack.isEmpty());
+//    }
+//
+//    @Test
+//    public void testPushingAndPoppingOrder() throws Exception {
+//        // Given an empty stack
+//        GenericStack<String> stack = new GenericStack<>();
+//        // When we push two elements on it
+//        stack.push("foo");
+//        stack.push("bar");
+//        // Then we should see them returned in the correct order
+//        Assert.assertEquals("bar", stack.pop());
+//        Assert.assertEquals("foo", stack.pop());
+//    }
+//
+//    @Test(expected = IndexOutOfBoundsException.class)
+//    public void testPopFirst() throws Exception {
+//        // Given an empty stack
+//        GenericStack<String> stack = new GenericStack<>();
+//        // When it's popped
+//        stack.pop();
+//        // Then we should get an exception
+//    }
+//
+//}

src/test/java/StackArray/ObjectStackTest.java

@@ -0,0 +1,39 @@
+//package StackArray;
+//
+//import org.junit.Assert;
+//import org.junit.Test;
+//
+//public class ObjectStackTest {
+//    @Test
+//    public void testPushingGrowsTheStack() throws Exception {
+//        // Given an empty stack
+//        ObjectStack<String> stack = new ObjectStack<>();
+//        // Assert that it is empty.
+//        Assert.assertEquals(true, stack.isEmpty());
+//        // When we push something onto the stack
+//        stack.push("foobar");
+//        // Then it shouldn't be empty
+//        Assert.assertEquals(false, stack.isEmpty());
+//    }
+//
+//    @Test
+//    public void testPushingAndPoppingOrder() throws Exception {
+//        // Given an empty stack
+//        ObjectStack<String> stack = new ObjectStack<>();
+//        // When we push two elements on it
+//        stack.push("foo");
+//        stack.push("bar");
+//        // Then we should see them returned in the correct order
+//        Assert.assertEquals("bar", stack.pop());
+//        Assert.assertEquals("foo", stack.pop());
+//    }
+//
+//    @Test(expected = IndexOutOfBoundsException.class)
+//    public void testPopFirst() throws Exception {
+//        // Given an empty stack
+//        ObjectStack<String> stack = new ObjectStack<>();
+//        // When it's popped
+//        stack.pop();
+//        // Then we should get an exception
+//    }
+//}

src/test/java/StackArrayList/StackTest.java

@@ -0,0 +1,45 @@
+//package StackArrayList;
+//
+//import org.junit.Test;
+//
+//import org.junit.Assert;
+//
+//public class StackTest {
+//    @Test
+//    public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception {
+//        // Given an empty stack
+//        Stack<String> stack = new Stack<>();
+//        // Assert that it starts empty
+//        Assert.assertEquals(true, stack.isEmpty());
+//        // When an element gets pushed
+//        stack.push("foobar");
+//        // Then the stack should not be empty.
+//        Assert.assertEquals(false, stack.isEmpty());
+//    }
+//
+//    @Test
+//    public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception {
+//        // Given an empty stack
+//        Stack<String> stack = new Stack<>();
+//
+//        //When two items are pushed
+//        stack.push("foo");
+//        stack.push("bar");
+//
+//        // Then they should come off in reverse order.
+//        Assert.assertEquals("bar", stack.pop());
+//        Assert.assertEquals("foo", stack.pop());
+//
+//        // And then the stack should be empty
+//        Assert.assertEquals(true, stack.isEmpty());
+//    }
+//
+//    @Test(expected = IndexOutOfBoundsException.class)
+//    public void testPopFirst() throws Exception {
+//        // Given an empty stack
+//        Stack<String> stack = new Stack<>();
+//        // Then it is popped
+//        stack.pop();
+//        // We should get an exception
+//    }
+//}