Solution with nodes.

Author: Kay Hudson

src/main/java/com/galvanize/Node.java

@@ -0,0 +1,18 @@
+package com.galvanize;
+
+public class Node {
+    public Object value;
+    private Node next;
+
+    public Node(Object value) {
+        this.value = value;
+    }
+
+    public Node getNext() {
+        return next;
+    }
+
+    public void setNext(Node next) {
+        this.next = next;
+    }
+}

src/main/java/com/galvanize/Stack.java

@@ -1,34 +1,39 @@
 package com.galvanize;
 
-import java.util.ArrayList;
-
 public class Stack {
     public boolean empty;
-    private ArrayList items;
+    public Node top;
+    private int size;
 
     public Stack() {
         this.empty = true;
-        this.items = new ArrayList();
+        this.size = 0;
     }
 
     public int count() {
-        return this.items.size();
+        return size;
     }
 
-    public void push(Object item) {
-        this.items.add(item);
-        this.empty = false;
+    public void push(Node item) {
+        if (top == null) {
+            top = item;
+            this.empty = false;
+        } else {
+            item.setNext(top);
+            top = item;
+        }
+        this.size++;
     }
 
-    public Object pop() {
-        int lastIndex = this.count() -1;
-        Object lastItem = this.items.get(lastIndex);
-        this.items.remove(lastIndex);
-        return lastItem;
+    public Node pop() {
+        Node current = top;
+        top = current.getNext();
+        current.setNext(new Node(null));
+        this.size--;
+        return current;
     }
 
-    public Object peek() {
-        int lastIndex = this.count() -1;
-        return this.items.get(lastIndex);
+    public Node peek() {
+        return top;
     }
 }

src/test/java/StackTestCase.java

@@ -1,41 +1,49 @@
-import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 
 import com.galvanize.Stack;
+import com.galvanize.Node;
 
 class StackTestCase {
+    Stack stack;
 
-    @Test()
-    @DisplayName("Stack.push() adds a new object")
-    void testStackPush() {
-        Stack newStack = new Stack();
-        assertEquals(0, newStack.count(),"Stack should be empty on initialization");
-        newStack.push(100);
-        assertEquals(1, newStack.count(), "Stack should contain only 1 object.");
-        assertFalse(newStack.empty, "Stack should not be empty.");
+    @BeforeEach
+    void setUp() {
+        stack = new Stack();
     }
 
     @Test
-    @DisplayName("Stack.pop() removes and returns last item added.")
-    void testStackPopRemovesAndReturnsLastItemIn() {
-        Stack newStack = new Stack();
-        newStack.push(1);
-        newStack.push(2);
-        newStack.push(3);
-        assertEquals(3, newStack.count(), "Stack should contain 3 objects.");
-        Object item = newStack.pop();
-        assertEquals(2, newStack.count(), "Stack should contain only 2 items after .pop()");
-        assertEquals(3, item, "The removed object should have a value of 3");
+    void testStackPushNode () {
+        stack.push(new Node(100));
+        assertEquals(1, stack.count());
     }
 
     @Test
-    @DisplayName("Stack.peek() returns the last item added without removing it.")
-    void testStackPeek() {
-        Stack newStack = new Stack();
-        newStack.push("sock");
-        newStack.push("shoe");
-        assertEquals("shoe", newStack.peek(), "The last object should be 'shoe'.");
-        assertEquals(2, newStack.count(), "The stack size should be unchanged after peek().");
+    void testStackPopRemovesNode_LIFO() {
+        stack.push(new Node(200));
+        stack.push(new Node(300));
+        Node lastIn = new Node(400);
+        stack.push(lastIn);
+        assertEquals(3, stack.count());
+
+        Node firstOut = stack.pop();
+        assertEquals(2, stack.count());
+        assertEquals(lastIn, firstOut);
+    }
+
+    @Test
+    void testStackPeekReturnsTopNode() {
+        Node item = new Node(200);
+        Node topItem = new Node(300);
+        stack.push(item);
+        stack.push(topItem);
+        Node peekItem = stack.peek();
+        assertEquals(topItem, peekItem);
+    }
+
+    @Test
+    void testStackEmptyTrue() {
+        assertTrue(stack.empty);
     }
 }