onto part3

src/main/java/StackArray/GenericStack.java

@@ -11,5 +11,31 @@ public class GenericStack<E> {
     private E[] elements;
 
     public GenericStack() {
+        this.elements = (E[]) new Object[0];
+    }
+
+    public E push(E value){
+        //needs to remove an element from E[] and resize
+        //now I just need to push the value onto the end of the array
+        E[] newArray = Arrays.copyOf(this.elements, this.elements.length + 1);
+        newArray[newArray.length-1] = value;
+        this.elements = newArray;
+        return value;
+
+    }
+
+    public E pop(){
+        //according to the api, pop should return a value
+        //didn't need to assign the value
+        E value = this.elements[elements.length-1];
+        E[] newArray = Arrays.copyOf(elements, elements.length - 1);
+        //newArray[newArray.length-1] = value;
+        this.elements = newArray;
+        return value;
+    }
+
+    public boolean isEmpty(){
+        return (elements.length==0);
+
     }
 }

src/main/java/StackArray/ObjectStack.java

@@ -1,20 +1,35 @@
-//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() {
-//        this.elements = new Object[];
-//    }
-//    //the way stacks work, its just like generics accept you are using Objects
-//    public Object push(Object value){
-//
-//    }
-//}
+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() {
+        this.elements = new Object[0];
+    }
+    //the way stacks work, its just like generics accept you are using Objects
+    public Object push(Object value){
+        Object[] newArray = Arrays.copyOf(this.elements, this.elements.length + 1);
+        newArray[newArray.length-1] = value;
+        this.elements = newArray;
+        return value;
+    }
+
+    public Object pop(){
+        Object value = this.elements[elements.length-1];
+        Object[] newArray = Arrays.copyOf(elements, elements.length - 1);
+        //newArray[newArray.length-1] = value;
+        this.elements = newArray;
+        return value;
+    }
+
+    public boolean isEmpty(){
+        return(elements.length==0);
+    }
+}

src/main/java/StackArrayList/Stack.java

@@ -30,7 +30,5 @@ public class Stack<E> {
         return (elements.size()==0);
     }
 
-    public E pop() {
-        return (E) this.elements;
-    }
+
 }

src/test/java/StackArray/GenericStackTest.java

@@ -1,41 +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
-//    }
-//
-//}
+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

@@ -1,39 +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
-//    }
-//}
+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
+    }
+}