Merge branch 'master' into my_algorithm

DenizAltunkapan · web-flow · commit 8c1beaa69346 · 2025-07-21T18:04:37.000+02:00
diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java
@@ -1,110 +1,115 @@
 package com.thealgorithms.datastructures.lists;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
 import java.util.stream.IntStream;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 class SkipListTest {
 
+    private SkipList<String> skipList;
+
+    @BeforeEach
+    void setUp() {
+        skipList = new SkipList<>();
+    }
+
     @Test
-    void add() {
-        SkipList<String> skipList = new SkipList<>();
+    @DisplayName("Add element and verify size and retrieval")
+    void testAdd() {
         assertEquals(0, skipList.size());
 
         skipList.add("value");
 
-        print(skipList);
         assertEquals(1, skipList.size());
+        assertEquals("value", skipList.get(0));
     }
 
     @Test
-    void get() {
-        SkipList<String> skipList = new SkipList<>();
+    @DisplayName("Get retrieves correct element by index")
+    void testGet() {
         skipList.add("value");
-
-        String actualValue = skipList.get(0);
-
-        print(skipList);
-        assertEquals("value", actualValue);
+        assertEquals("value", skipList.get(0));
     }
 
     @Test
-    void contains() {
-        SkipList<String> skipList = createSkipList();
-        print(skipList);
-
-        boolean contains = skipList.contains("b");
-
-        assertTrue(contains);
+    @DisplayName("Contains returns true if element exists")
+    void testContains() {
+        skipList = createSkipList();
+        assertTrue(skipList.contains("b"));
+        assertTrue(skipList.contains("a"));
+        assertFalse(skipList.contains("z")); // negative test
     }
 
     @Test
-    void removeFromHead() {
-        SkipList<String> skipList = createSkipList();
-        String mostLeftElement = skipList.get(0);
+    @DisplayName("Remove element from head and check size and order")
+    void testRemoveFromHead() {
+        skipList = createSkipList();
+        String first = skipList.get(0);
         int initialSize = skipList.size();
-        print(skipList);
 
-        skipList.remove(mostLeftElement);
+        skipList.remove(first);
 
-        print(skipList);
         assertEquals(initialSize - 1, skipList.size());
+        assertFalse(skipList.contains(first));
     }
 
     @Test
-    void removeFromTail() {
-        SkipList<String> skipList = createSkipList();
-        String mostRightValue = skipList.get(skipList.size() - 1);
+    @DisplayName("Remove element from tail and check size and order")
+    void testRemoveFromTail() {
+        skipList = createSkipList();
+        String last = skipList.get(skipList.size() - 1);
         int initialSize = skipList.size();
-        print(skipList);
 
-        skipList.remove(mostRightValue);
+        skipList.remove(last);
 
-        print(skipList);
         assertEquals(initialSize - 1, skipList.size());
+        assertFalse(skipList.contains(last));
     }
 
     @Test
-    void checkSortedOnLowestLayer() {
-        SkipList<String> skipList = new SkipList<>();
+    @DisplayName("Elements should be sorted at base level")
+    void testSortedOrderOnBaseLevel() {
         String[] values = {"d", "b", "a", "c"};
         Arrays.stream(values).forEach(skipList::add);
-        print(skipList);
 
         String[] actualOrder = IntStream.range(0, values.length).mapToObj(skipList::get).toArray(String[] ::new);
 
-        assertArrayEquals(new String[] {"a", "b", "c", "d"}, actualOrder);
+        org.junit.jupiter.api.Assertions.assertArrayEquals(new String[] {"a", "b", "c", "d"}, actualOrder);
     }
 
-    private SkipList<String> createSkipList() {
-        SkipList<String> skipList = new SkipList<>();
-        String[] values = {
-            "a",
-            "b",
-            "c",
-            "d",
-            "e",
-            "f",
-            "g",
-            "h",
-            "i",
-            "j",
-            "k",
-        };
+    @Test
+    @DisplayName("Duplicate elements can be added and count correctly")
+    void testAddDuplicates() {
+        skipList.add("x");
+        skipList.add("x");
+        assertEquals(2, skipList.size());
+        assertEquals("x", skipList.get(0));
+        assertEquals("x", skipList.get(1));
+    }
+
+    @Test
+    @DisplayName("Add multiple and remove all")
+    void testClearViaRemovals() {
+        String[] values = {"a", "b", "c"};
         Arrays.stream(values).forEach(skipList::add);
-        return skipList;
+
+        for (String v : values) {
+            skipList.remove(v);
+        }
+
+        assertEquals(0, skipList.size());
     }
 
-    /**
-     * Print Skip List representation to console.
-     * Optional method not involved in testing process. Used only for visualisation purposes.
-     * @param skipList to print
-     */
-    private void print(SkipList<?> skipList) {
-        System.out.println(skipList);
+    private SkipList<String> createSkipList() {
+        SkipList<String> s = new SkipList<>();
+        String[] values = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"};
+        Arrays.stream(values).forEach(s::add);
+        return s;
     }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/queues/DequeTest.java b/src/test/java/com/thealgorithms/datastructures/queues/DequeTest.java
@@ -87,4 +87,38 @@ void testToString() {
         deque.addFirst(5);
         assertEquals("Head -> 5 <-> 10 <-> 20 <- Tail", deque.toString());
     }
+
+    @Test
+    void testAlternatingAddRemove() {
+        Deque<Integer> deque = new Deque<>();
+        deque.addFirst(1);
+        deque.addLast(2);
+        deque.addFirst(0);
+        assertEquals(0, deque.pollFirst());
+        assertEquals(2, deque.pollLast());
+        assertEquals(1, deque.pollFirst());
+        org.junit.jupiter.api.Assertions.assertTrue(deque.isEmpty());
+    }
+
+    @Test
+    void testSizeAfterOperations() {
+        Deque<Integer> deque = new Deque<>();
+        assertEquals(0, deque.size());
+        deque.addFirst(1);
+        deque.addLast(2);
+        deque.addFirst(3);
+        assertEquals(3, deque.size());
+        deque.pollFirst();
+        deque.pollLast();
+        assertEquals(1, deque.size());
+    }
+
+    @Test
+    void testNullValues() {
+        Deque<String> deque = new Deque<>();
+        deque.addFirst(null);
+        assertNull(deque.peekFirst());
+        assertNull(deque.pollFirst());
+        org.junit.jupiter.api.Assertions.assertTrue(deque.isEmpty());
+    }
 }
diff --git a/src/test/java/com/thealgorithms/stacks/PostfixEvaluatorTest.java b/src/test/java/com/thealgorithms/stacks/PostfixEvaluatorTest.java
@@ -4,24 +4,41 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.EmptyStackException;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 
 public class PostfixEvaluatorTest {
 
-    @Test
-    public void testValidExpressions() {
-        assertEquals(22, PostfixEvaluator.evaluatePostfix("5 6 + 2 *"));
-        assertEquals(27, PostfixEvaluator.evaluatePostfix("7 2 + 3 *"));
-        assertEquals(3, PostfixEvaluator.evaluatePostfix("10 5 / 1 +"));
+    @ParameterizedTest(name = "Expression: \"{0}\" → Result: {1}")
+    @CsvSource({"'5 6 + 2 *', 22", "'7 2 + 3 *', 27", "'10 5 / 1 +', 3", "'8', 8", "'3 4 +', 7"})
+    @DisplayName("Valid postfix expressions")
+    void testValidExpressions(String expression, int expected) {
+        assertEquals(expected, PostfixEvaluator.evaluatePostfix(expression));
     }
 
     @Test
-    public void testInvalidExpression() {
+    @DisplayName("Should throw EmptyStackException for incomplete expression")
+    void testInvalidExpression() {
         assertThrows(EmptyStackException.class, () -> PostfixEvaluator.evaluatePostfix("5 +"));
     }
 
     @Test
-    public void testMoreThanOneStackSizeAfterEvaluation() {
+    @DisplayName("Should throw IllegalArgumentException for extra operands")
+    void testExtraOperands() {
         assertThrows(IllegalArgumentException.class, () -> PostfixEvaluator.evaluatePostfix("5 6 + 2 * 3"));
     }
+
+    @Test
+    @DisplayName("Should throw ArithmeticException for division by zero")
+    void testDivisionByZero() {
+        assertThrows(ArithmeticException.class, () -> PostfixEvaluator.evaluatePostfix("1 0 /"));
+    }
+
+    @Test
+    @DisplayName("Should throw IllegalArgumentException for invalid characters")
+    void testInvalidToken() {
+        assertThrows(IllegalArgumentException.class, () -> PostfixEvaluator.evaluatePostfix("1 a +"));
+    }
 }
