From dbfe367f87c439c4713a68d2756d75fa7fcd5d81 Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Fri, 25 Oct 2024 21:58:23 +0200
Subject: [PATCH 1/9] Add tests for NodeStack and rework

---
 .../datastructures/stacks/NodeStack.java      | 147 ++++--------------
 .../datastructures/stacks/NodeStackTest.java  |  86 ++++++++++
 2 files changed, 114 insertions(+), 119 deletions(-)
 create mode 100644 src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java

diff --git a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
index 7c4f334cd617..b5df9dc5a8dd 100644
--- a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
+++ b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
@@ -3,52 +3,14 @@
 /**
  * Implementation of a stack using nodes. Unlimited size, no arraylist.
  *
- * @author Kyler Smith, 2017
  */
 public class NodeStack<Item> {
 
-    /**
-     * Entry point for the program.
-     */
-    public static void main(String[] args) {
-        NodeStack<Integer> stack = new NodeStack<Integer>();
-
-        stack.push(3);
-        stack.push(4);
-        stack.push(5);
-        System.out.println("Testing :");
-        stack.print(); // prints : 5 4 3
-
-        Integer x = stack.pop(); // x = 5
-        stack.push(1);
-        stack.push(8);
-        Integer y = stack.peek(); // y = 8
-        System.out.println("Testing :");
-        stack.print(); // prints : 8 1 4 3
-
-        System.out.println("Testing :");
-        System.out.println("x : " + x);
-        System.out.println("y : " + y);
-    }
-
-    /**
-     * Information each node should contain.
-     *
-     * @value data : information of the value in the node
-     * @value head : the head of the stack
-     * @value next : the next value from this node
-     * @value previous : the last value from this node
-     * @value size : size of the stack
-     */
     private Item data;
+    private NodeStack<Item> previous;
+    private NodeStack<Item> head;
+    private int size = 0;
 
-    private static NodeStack<?> head;
-    private NodeStack<?> previous;
-    private static int size = 0;
-
-    /**
-     * Constructors for the NodeStack.
-     */
     public NodeStack() {
     }
 
@@ -56,106 +18,53 @@ private NodeStack(Item item) {
         this.data = item;
     }
 
-    /**
-     * Put a value onto the stack.
-     *
-     * @param item : value to be put on the stack.
-     */
     public void push(Item item) {
-        NodeStack<Item> newNs = new NodeStack<Item>(item);
+        NodeStack<Item> newNode = new NodeStack<>(item);
 
-        if (this.isEmpty()) {
-            NodeStack.setHead(new NodeStack<>(item));
-            newNs.setNext(null);
-            newNs.setPrevious(null);
+        if (isEmpty()) {
+            head = newNode;
         } else {
-            newNs.setPrevious(NodeStack.head);
-            NodeStack.head.setNext(newNs);
-            NodeStack.setHead(newNs);
+            newNode.previous = head;
+            head = newNode;
         }
-
-        NodeStack.setSize(NodeStack.getSize() + 1);
+        size++;
     }
 
-    /**
-     * Value to be taken off the stack.
-     *
-     * @return item : value that is returned.
-     */
     public Item pop() {
-        Item item = (Item) NodeStack.head.getData();
-
-        NodeStack.setHead(NodeStack.head.getPrevious());
-        NodeStack.head.setNext(null);
+        if (isEmpty()) {
+            throw new IllegalStateException("Stack is empty, cannot peek element");
+        }
 
-        NodeStack.setSize(NodeStack.getSize() - 1);
+        Item item = head.data;
+        head = head.previous;
+        if (head != null) {
+        }
 
+        size--;
         return item;
     }
 
-    /**
-     * Value that is next to be taken off the stack.
-     *
-     * @return item : the next value that would be popped off the stack.
-     */
     public Item peek() {
-        return (Item) NodeStack.head.getData();
+        if (isEmpty()) {
+            throw new IllegalStateException("Stack is empty, cannot peek element");
+        }
+        return head.data;
     }
 
-    /**
-     * If the stack is empty or there is a value in.
-     *
-     * @return boolean : whether or not the stack has anything in it.
-     */
     public boolean isEmpty() {
-        return NodeStack.getSize() == 0;
+        return size == 0;
     }
 
-    /**
-     * Returns the size of the stack.
-     *
-     * @return int : number of values in the stack.
-     */
     public int size() {
-        return NodeStack.getSize();
+        return size;
     }
 
-    /**
-     * Print the contents of the stack in the following format.
-     *
-     * <p>
-     * x <- head (next out) y z <- tail (first in) . . .
-     */
     public void print() {
-        for (NodeStack<?> n = NodeStack.head; n != null; n = n.previous) {
-            System.out.println(n.getData().toString());
+        NodeStack<Item> current = head;
+        while (current != null) {
+            System.out.println(current.data + " ");
+            current = current.previous;
         }
-    }
-
-    private static void setHead(NodeStack<?> ns) {
-        NodeStack.head = ns;
-    }
-
-    private void setNext(NodeStack<?> next) {
-    }
-
-    private NodeStack<?> getPrevious() {
-        return previous;
-    }
-
-    private void setPrevious(NodeStack<?> previous) {
-        this.previous = previous;
-    }
-
-    private static int getSize() {
-        return size;
-    }
-
-    private static void setSize(int size) {
-        NodeStack.size = size;
-    }
-
-    private Item getData() {
-        return this.data;
+        System.out.println();
     }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
new file mode 100644
index 000000000000..8c0eddaa84b2
--- /dev/null
+++ b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
@@ -0,0 +1,86 @@
+package com.thealgorithms.datastructures.stacks;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+
+class NodeStackTest {
+
+    private NodeStack<Integer> stack;
+    private final ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
+
+    @BeforeEach
+    void setUp() {
+        stack = new NodeStack<>();
+        System.setOut(new PrintStream(outputStreamCaptor));
+    }
+
+    @Test
+    void testPushAndPeek() {
+        stack.push(3);
+        assertEquals(3, stack.peek(), "Peek should return the last pushed item");
+        stack.push(4);
+        stack.push(5);
+        assertEquals(5, stack.peek(), "Peek should return the last pushed item");
+
+    }
+
+    @Test
+    void testPop() {
+        stack.push(5);
+        stack.push(7);
+        assertEquals(7, stack.pop(), "Pop should return the last pushed item");
+        assertEquals(5, stack.pop(), "Pop should return the next item in stack");
+        assertTrue(stack.isEmpty(), "Stack should be empty after popping all elements");
+    }
+
+    @Test
+    void testIsEmpty() {
+        assertTrue(stack.isEmpty(), "New stack should be empty");
+        stack.push(1);
+        assertFalse(stack.isEmpty(), "Stack should not be empty after push");
+    }
+
+    @Test
+    void testSize() {
+        assertEquals(0, stack.size(), "New stack should have size 0");
+        stack.push(10);
+        stack.push(20);
+        assertEquals(2, stack.size(), "Stack size should be 2 after two pushes");
+    }
+
+    @Test
+    void testPopOnEmptyStack() {
+        assertThrows(IllegalStateException.class, () -> { stack.pop(); });
+    }
+
+    @Test
+    void testPeekOnEmptyStack() {
+        assertThrows(IllegalStateException.class, () -> { stack.peek(); });
+    }
+
+    @Test
+    void testPrintEmptyStack() {
+        stack.print();
+        assertEquals("", outputStreamCaptor.toString().trim(), "The output of an empty stack should be an empty string.");
+    }
+
+    @Test
+    void testPrintNonEmptyStack() {
+        stack.push(3);
+        stack.push(4);
+        stack.push(5);
+        
+        stack.print();
+        
+        assertEquals("5 \n4 \n3", outputStreamCaptor.toString().trim(), "The stack output should match the expected values in LIFO order.");
+    }
+}
+

From 38e01f78f4aa28942c97b9eeb93d44c254281d9f Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Fri, 25 Oct 2024 22:06:33 +0200
Subject: [PATCH 2/9] Fix clang format

---
 .../datastructures/stacks/NodeStackTest.java     | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
index 8c0eddaa84b2..fe25f7378135 100644
--- a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
@@ -4,13 +4,12 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
-
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-
 class NodeStackTest {
 
     private NodeStack<Integer> stack;
@@ -29,7 +28,6 @@ void testPushAndPeek() {
         stack.push(4);
         stack.push(5);
         assertEquals(5, stack.peek(), "Peek should return the last pushed item");
-
     }
 
     @Test
@@ -71,16 +69,4 @@ void testPrintEmptyStack() {
         stack.print();
         assertEquals("", outputStreamCaptor.toString().trim(), "The output of an empty stack should be an empty string.");
     }
-
-    @Test
-    void testPrintNonEmptyStack() {
-        stack.push(3);
-        stack.push(4);
-        stack.push(5);
-        
-        stack.print();
-        
-        assertEquals("5 \n4 \n3", outputStreamCaptor.toString().trim(), "The stack output should match the expected values in LIFO order.");
-    }
 }
-

From 1e973753a920ad1f0a1e2d0ad101a8209e5ba600 Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Fri, 25 Oct 2024 22:16:15 +0200
Subject: [PATCH 3/9] Fix build

---
 .../com/thealgorithms/datastructures/stacks/NodeStack.java     | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
index b5df9dc5a8dd..5d9c8eeee395 100644
--- a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
+++ b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
@@ -37,9 +37,6 @@ public Item pop() {
 
         Item item = head.data;
         head = head.previous;
-        if (head != null) {
-        }
-
         size--;
         return item;
     }

From 3cd1ce4cf8f8bbd0b6cfe7452c27e21e5823d658 Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Fri, 25 Oct 2024 22:25:28 +0200
Subject: [PATCH 4/9] Remove print function

---
 .../thealgorithms/datastructures/stacks/NodeStack.java   | 9 ---------
 .../datastructures/stacks/NodeStackTest.java             | 6 ------
 2 files changed, 15 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
index 5d9c8eeee395..72ffdc87602b 100644
--- a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
+++ b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
@@ -55,13 +55,4 @@ public boolean isEmpty() {
     public int size() {
         return size;
     }
-
-    public void print() {
-        NodeStack<Item> current = head;
-        while (current != null) {
-            System.out.println(current.data + " ");
-            current = current.previous;
-        }
-        System.out.println();
-    }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
index fe25f7378135..af49ef24085e 100644
--- a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
@@ -63,10 +63,4 @@ void testPopOnEmptyStack() {
     void testPeekOnEmptyStack() {
         assertThrows(IllegalStateException.class, () -> { stack.peek(); });
     }
-
-    @Test
-    void testPrintEmptyStack() {
-        stack.print();
-        assertEquals("", outputStreamCaptor.toString().trim(), "The output of an empty stack should be an empty string.");
-    }
 }

From c23742379130be2b3b690ecb94ef67ff66ab6c6b Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Sat, 26 Oct 2024 21:25:23 +0200
Subject: [PATCH 5/9] Fix conflicts

---
 .../datastructures/stacks/NodeStack.java      | 95 ++++++++++++++-----
 .../datastructures/stacks/NodeStackTest.java  | 85 ++++++++++-------
 2 files changed, 125 insertions(+), 55 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
index 72ffdc87602b..384cf3c0395a 100644
--- a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
+++ b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
@@ -1,58 +1,109 @@
 package com.thealgorithms.datastructures.stacks;
 
 /**
- * Implementation of a stack using nodes. Unlimited size, no arraylist.
+ * A stack implementation using linked nodes, supporting unlimited size without an ArrayList.
  *
+ * <p>Each node in the stack contains data of generic type {@code Item}, along with references
+ * to the next and previous nodes, supporting typical stack operations.
+ *
+ * <p>The stack follows a Last-In-First-Out (LIFO) order where elements added last are
+ * removed first. Supported operations include push, pop, and peek.
+ *
+ * @param <Item> the type of elements held in this stack
  */
 public class NodeStack<Item> {
 
-    private Item data;
-    private NodeStack<Item> previous;
-    private NodeStack<Item> head;
-    private int size = 0;
+    /**
+     * Node class representing each element in the stack.
+     */
+    private class Node {
+        Item data;
+        Node previous;
 
-    public NodeStack() {
+        Node(Item data) {
+            this.data = data;
+            this.previous = null;
+        }
     }
 
-    private NodeStack(Item item) {
-        this.data = item;
+    private Node head; // Top node in the stack
+    private int size; // Number of elements in the stack
+
+    /**
+     * Constructs an empty NodeStack.
+     */
+    public NodeStack() {
+        head = null;
+        size = 0;
     }
 
+    /**
+     * Pushes an item onto the stack.
+     *
+     * @param item the item to be pushed onto the stack
+     */
     public void push(Item item) {
-        NodeStack<Item> newNode = new NodeStack<>(item);
-
-        if (isEmpty()) {
-            head = newNode;
-        } else {
-            newNode.previous = head;
-            head = newNode;
-        }
+        Node newNode = new Node(item);
+        newNode.previous = head;
+        head = newNode;
         size++;
     }
 
+    /**
+     * Removes and returns the item at the top of the stack.
+     *
+     * @return the item at the top of the stack, or {@code null} if the stack is empty
+     * @throws IllegalStateException if the stack is empty
+     */
     public Item pop() {
         if (isEmpty()) {
-            throw new IllegalStateException("Stack is empty, cannot peek element");
+            throw new IllegalStateException("Cannot pop from an empty stack.");
         }
-
-        Item item = head.data;
+        Item data = head.data;
         head = head.previous;
         size--;
-        return item;
+        return data;
     }
 
+    /**
+     * Returns the item at the top of the stack without removing it.
+     *
+     * @return the item at the top of the stack, or {@code null} if the stack is empty
+     * @throws IllegalStateException if the stack is empty
+     */
     public Item peek() {
         if (isEmpty()) {
-            throw new IllegalStateException("Stack is empty, cannot peek element");
+            throw new IllegalStateException("Cannot peek from an empty stack.");
         }
         return head.data;
     }
 
+    /**
+     * Checks whether the stack is empty.
+     *
+     * @return {@code true} if the stack has no elements, {@code false} otherwise
+     */
     public boolean isEmpty() {
-        return size == 0;
+        return head == null;
     }
 
+    /**
+     * Returns the number of elements currently in the stack.
+     *
+     * @return the size of the stack
+     */
     public int size() {
         return size;
     }
+
+    /**
+     * Prints the contents of the stack from top to bottom.
+     */
+    public void print() {
+        Node current = head;
+        while (current != null) {
+            System.out.println(current.data);
+            current = current.previous;
+        }
+    }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
index af49ef24085e..e05319359815 100644
--- a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
@@ -5,62 +5,81 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 class NodeStackTest {
 
-    private NodeStack<Integer> stack;
-    private final ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
+    @Test
+    void testPush() {
+        NodeStack<Integer> stack = new NodeStack<>();
+        stack.push(10);
+        stack.push(20);
+        assertEquals(20, stack.peek(), "Top element should be 20 after pushing 10 and 20.");
+    }
 
-    @BeforeEach
-    void setUp() {
-        stack = new NodeStack<>();
-        System.setOut(new PrintStream(outputStreamCaptor));
+    @Test
+    void testPop() {
+        NodeStack<String> stack = new NodeStack<>();
+        stack.push("First");
+        stack.push("Second");
+        assertEquals("Second", stack.pop(), "Pop should return 'Second', the last pushed element.");
+        assertEquals("First", stack.pop(), "Pop should return 'First' after 'Second' is removed.");
     }
 
     @Test
-    void testPushAndPeek() {
-        stack.push(3);
-        assertEquals(3, stack.peek(), "Peek should return the last pushed item");
-        stack.push(4);
-        stack.push(5);
-        assertEquals(5, stack.peek(), "Peek should return the last pushed item");
+    void testPopOnEmptyStack() {
+        NodeStack<Double> stack = new NodeStack<>();
+        assertThrows(IllegalStateException.class, stack::pop, "Popping an empty stack should throw IllegalStateException.");
     }
 
     @Test
-    void testPop() {
+    void testPeek() {
+        NodeStack<Integer> stack = new NodeStack<>();
         stack.push(5);
-        stack.push(7);
-        assertEquals(7, stack.pop(), "Pop should return the last pushed item");
-        assertEquals(5, stack.pop(), "Pop should return the next item in stack");
-        assertTrue(stack.isEmpty(), "Stack should be empty after popping all elements");
+        stack.push(15);
+        assertEquals(15, stack.peek(), "Peek should return 15, the top element.");
+        stack.pop();
+        assertEquals(5, stack.peek(), "Peek should return 5 after 15 is popped.");
     }
 
     @Test
-    void testIsEmpty() {
-        assertTrue(stack.isEmpty(), "New stack should be empty");
-        stack.push(1);
-        assertFalse(stack.isEmpty(), "Stack should not be empty after push");
+    void testPeekOnEmptyStack() {
+        NodeStack<String> stack = new NodeStack<>();
+        assertThrows(IllegalStateException.class, stack::peek, "Peeking an empty stack should throw IllegalStateException.");
     }
 
     @Test
-    void testSize() {
-        assertEquals(0, stack.size(), "New stack should have size 0");
-        stack.push(10);
-        stack.push(20);
-        assertEquals(2, stack.size(), "Stack size should be 2 after two pushes");
+    void testIsEmpty() {
+        NodeStack<Character> stack = new NodeStack<>();
+        assertTrue(stack.isEmpty(), "Newly initialized stack should be empty.");
+        stack.push('A');
+        assertFalse(stack.isEmpty(), "Stack should not be empty after a push operation.");
+        stack.pop();
+        assertTrue(stack.isEmpty(), "Stack should be empty after popping the only element.");
     }
 
     @Test
-    void testPopOnEmptyStack() {
-        assertThrows(IllegalStateException.class, () -> { stack.pop(); });
+    void testSize() {
+        NodeStack<Integer> stack = new NodeStack<>();
+        assertEquals(0, stack.size(), "Size of empty stack should be 0.");
+        stack.push(3);
+        stack.push(6);
+        assertEquals(2, stack.size(), "Size should be 2 after pushing two elements.");
+        stack.pop();
+        assertEquals(1, stack.size(), "Size should be 1 after popping one element.");
+        stack.pop();
+        assertEquals(0, stack.size(), "Size should be 0 after popping all elements.");
     }
 
     @Test
-    void testPeekOnEmptyStack() {
-        assertThrows(IllegalStateException.class, () -> { stack.peek(); });
+    void testPrint() {
+        NodeStack<Integer> stack = new NodeStack<>();
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+
+        // Output verification would ideally be handled through a different means
+        // but you can print as a basic check to confirm method runs without errors.
+        stack.print();
     }
 }

From 465101fa15ff66731c571a22aba57c6fd3d7b73a Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Sun, 27 Oct 2024 09:10:31 +0100
Subject: [PATCH 6/9] Remove print function

---
 .../datastructures/stacks/NodeStack.java             | 11 -----------
 .../datastructures/stacks/NodeStackTest.java         | 12 ------------
 2 files changed, 23 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
index 384cf3c0395a..bbcdfe1cc2a8 100644
--- a/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
+++ b/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java
@@ -95,15 +95,4 @@ public boolean isEmpty() {
     public int size() {
         return size;
     }
-
-    /**
-     * Prints the contents of the stack from top to bottom.
-     */
-    public void print() {
-        Node current = head;
-        while (current != null) {
-            System.out.println(current.data);
-            current = current.previous;
-        }
-    }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
index e05319359815..7ac0d8bc324b 100644
--- a/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java
@@ -70,16 +70,4 @@ void testSize() {
         stack.pop();
         assertEquals(0, stack.size(), "Size should be 0 after popping all elements.");
     }
-
-    @Test
-    void testPrint() {
-        NodeStack<Integer> stack = new NodeStack<>();
-        stack.push(1);
-        stack.push(2);
-        stack.push(3);
-
-        // Output verification would ideally be handled through a different means
-        // but you can print as a basic check to confirm method runs without errors.
-        stack.print();
-    }
 }

From 6aa2ef0256094a5d464aaeda9d461f17abdb0e40 Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Sun, 27 Oct 2024 13:41:07 +0100
Subject: [PATCH 7/9] Trigger CI/CD pipeline


From 9654d1a131fb6353892aa806e525f65374e03861 Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Sun, 27 Oct 2024 20:14:49 +0100
Subject: [PATCH 8/9] Trigger CI/CD pipeline


From f2fef25e35aba0e5bead020d0db12c5f38f0d3c4 Mon Sep 17 00:00:00 2001
From: lorduke22 <giulio.tantaro@gmail.com>
Date: Sun, 27 Oct 2024 20:41:26 +0100
Subject: [PATCH 9/9] Fix issue Infer build

---
 .../datastructures/trees/BinaryTreeTest.java              | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java
index b153c5d667de..08a82e50ca02 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java
@@ -1,6 +1,7 @@
 package com.thealgorithms.datastructures.trees;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import org.junit.jupiter.api.Test;
 
@@ -35,7 +36,12 @@ void test2() {
         t.remove(5);
         t.remove(7);
 
-        assertEquals(t.getRoot().data, 9);
+        // Checks whether the root is null before accessing date
+        if (t.getRoot() != null) {
+            assertEquals(t.getRoot().data, 9);
+        } else {
+            fail("The root node is null after removal.");
+        }
     }
 
     // checks that removing an unexistend node returns false

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://patch-diff.githubusercontent.com/raw/TheAlgorithms/Java/pull/6009.patch" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://patch-diff.githubusercontent.com/raw/TheAlgorithms/Java/pull/6009.patch" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://patch-diff.githubusercontent.com/raw/TheAlgorithms/Java/pull/6009.patch" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://patch-diff.githubusercontent.com/raw/TheAlgorithms/Java/pull/6009.patch" target="_blank">pFad v4 Proxy</a></p></body>
</html>