17-12-2025 [added other test cases for classes]

Author: krishanthan4

src/test/java/com/dsa/algorithms/Traversal/InOrderTraversalTest.java

@@ -0,0 +1,63 @@
+package com.dsa.algorithms.Traversal;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.*;
+
+class InOrderTraversalTest {
+    
+    private In_Order_Traversal traversal;
+    
+    @BeforeEach
+    void setUp() {
+        traversal = new In_Order_Traversal();
+    }
+    
+    private In_Order_Traversal.TreeNode createSampleTree() {
+        /*
+                1
+               / \
+              2   3
+             / \
+            4   5
+        */
+        In_Order_Traversal.TreeNode root = new In_Order_Traversal.TreeNode(1);
+        root.left = new In_Order_Traversal.TreeNode(2);
+        root.right = new In_Order_Traversal.TreeNode(3);
+        root.left.left = new In_Order_Traversal.TreeNode(4);
+        root.left.right = new In_Order_Traversal.TreeNode(5);
+        return root;
+    }
+    
+    @Test
+    void testInorderRecursive() {
+        In_Order_Traversal.TreeNode root = createSampleTree();
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.inorderRecursive(root);
+        // assertEquals(Arrays.asList(4, 2, 5, 1, 3), result);
+    }
+    
+    @Test
+    void testInorderIterative() {
+        In_Order_Traversal.TreeNode root = createSampleTree();
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.inorderIterative(root);
+        // assertEquals(Arrays.asList(4, 2, 5, 1, 3), result);
+    }
+    
+    @Test
+    void testInorderEmptyTree() {
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.inorderRecursive(null);
+        // assertTrue(result.isEmpty());
+    }
+    
+    @Test
+    void testInorderSingleNode() {
+        In_Order_Traversal.TreeNode root = new In_Order_Traversal.TreeNode(1);
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.inorderRecursive(root);
+        // assertEquals(Arrays.asList(1), result);
+    }
+}

src/test/java/com/dsa/algorithms/Traversal/PostOrderTraversalTest.java

@@ -0,0 +1,63 @@
+package com.dsa.algorithms.Traversal;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.*;
+
+class PostOrderTraversalTest {
+    
+    private Post_Order_Traversal traversal;
+    
+    @BeforeEach
+    void setUp() {
+        traversal = new Post_Order_Traversal();
+    }
+    
+    private Post_Order_Traversal.TreeNode createSampleTree() {
+        /*
+                1
+               / \
+              2   3
+             / \
+            4   5
+        */
+        Post_Order_Traversal.TreeNode root = new Post_Order_Traversal.TreeNode(1);
+        root.left = new Post_Order_Traversal.TreeNode(2);
+        root.right = new Post_Order_Traversal.TreeNode(3);
+        root.left.left = new Post_Order_Traversal.TreeNode(4);
+        root.left.right = new Post_Order_Traversal.TreeNode(5);
+        return root;
+    }
+    
+    @Test
+    void testPostorderRecursive() {
+        Post_Order_Traversal.TreeNode root = createSampleTree();
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.postorderRecursive(root);
+        // assertEquals(Arrays.asList(4, 5, 2, 3, 1), result);
+    }
+    
+    @Test
+    void testPostorderIterative() {
+        Post_Order_Traversal.TreeNode root = createSampleTree();
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.postorderIterative(root);
+        // assertEquals(Arrays.asList(4, 5, 2, 3, 1), result);
+    }
+    
+    @Test
+    void testPostorderEmptyTree() {
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.postorderRecursive(null);
+        // assertTrue(result.isEmpty());
+    }
+    
+    @Test
+    void testPostorderSingleNode() {
+        Post_Order_Traversal.TreeNode root = new Post_Order_Traversal.TreeNode(1);
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.postorderRecursive(root);
+        // assertEquals(Arrays.asList(1), result);
+    }
+}

src/test/java/com/dsa/algorithms/Traversal/PreOrderTraversalTest.java

@@ -0,0 +1,63 @@
+package com.dsa.algorithms.Traversal;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.*;
+
+class PreOrderTraversalTest {
+    
+    private Pre_Order_Traversal traversal;
+    
+    @BeforeEach
+    void setUp() {
+        traversal = new Pre_Order_Traversal();
+    }
+    
+    private Pre_Order_Traversal.TreeNode createSampleTree() {
+        /*
+                1
+               / \
+              2   3
+             / \
+            4   5
+        */
+        Pre_Order_Traversal.TreeNode root = new Pre_Order_Traversal.TreeNode(1);
+        root.left = new Pre_Order_Traversal.TreeNode(2);
+        root.right = new Pre_Order_Traversal.TreeNode(3);
+        root.left.left = new Pre_Order_Traversal.TreeNode(4);
+        root.left.right = new Pre_Order_Traversal.TreeNode(5);
+        return root;
+    }
+    
+    @Test
+    void testPreorderRecursive() {
+        Pre_Order_Traversal.TreeNode root = createSampleTree();
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.preorderRecursive(root);
+        // assertEquals(Arrays.asList(1, 2, 4, 5, 3), result);
+    }
+    
+    @Test
+    void testPreorderIterative() {
+        Pre_Order_Traversal.TreeNode root = createSampleTree();
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.preorderIterative(root);
+        // assertEquals(Arrays.asList(1, 2, 4, 5, 3), result);
+    }
+    
+    @Test
+    void testPreorderEmptyTree() {
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.preorderRecursive(null);
+        // assertTrue(result.isEmpty());
+    }
+    
+    @Test
+    void testPreorderSingleNode() {
+        Pre_Order_Traversal.TreeNode root = new Pre_Order_Traversal.TreeNode(1);
+        // TODO: Uncomment when implementation is complete
+        // List<Integer> result = traversal.preorderRecursive(root);
+        // assertEquals(Arrays.asList(1), result);
+    }
+}

src/test/java/com/dsa/algorithms/dynamic_programming/FibonacciTest.java

@@ -0,0 +1,55 @@
+package com.dsa.algorithms.dynamic_programming;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+
+class FibonacciTest {
+    
+    private Fibonacci fibonacci;
+    
+    @BeforeEach
+    void setUp() {
+        fibonacci = new Fibonacci();
+    }
+    
+    @Test
+    void testFibonacciMemoization() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(0, fibonacci.fibonacciMemoization(0));
+        // assertEquals(1, fibonacci.fibonacciMemoization(1));
+        // assertEquals(1, fibonacci.fibonacciMemoization(2));
+        // assertEquals(2, fibonacci.fibonacciMemoization(3));
+        // assertEquals(5, fibonacci.fibonacciMemoization(5));
+        // assertEquals(55, fibonacci.fibonacciMemoization(10));
+    }
+    
+    @Test
+    void testFibonacciTabulation() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(0, fibonacci.fibonacciTabulation(0));
+        // assertEquals(1, fibonacci.fibonacciTabulation(1));
+        // assertEquals(1, fibonacci.fibonacciTabulation(2));
+        // assertEquals(2, fibonacci.fibonacciTabulation(3));
+        // assertEquals(5, fibonacci.fibonacciTabulation(5));
+        // assertEquals(55, fibonacci.fibonacciTabulation(10));
+    }
+    
+    @Test
+    void testFibonacciOptimized() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(0, fibonacci.fibonacciOptimized(0));
+        // assertEquals(1, fibonacci.fibonacciOptimized(1));
+        // assertEquals(1, fibonacci.fibonacciOptimized(2));
+        // assertEquals(2, fibonacci.fibonacciOptimized(3));
+        // assertEquals(5, fibonacci.fibonacciOptimized(5));
+        // assertEquals(55, fibonacci.fibonacciOptimized(10));
+    }
+    
+    @Test
+    void testLargeFibonacci() {
+        // TODO: Uncomment when implementation is complete
+        // Test that optimized version can handle larger inputs efficiently
+        // assertDoesNotThrow(() -> fibonacci.fibonacciOptimized(50));
+    }
+}

src/test/java/com/dsa/algorithms/dynamic_programming/KnapsackTest.java

@@ -0,0 +1,53 @@
+package com.dsa.algorithms.dynamic_programming;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+
+class KnapsackTest {
+    
+    private Knapsack knapsack;
+    
+    @BeforeEach
+    void setUp() {
+        knapsack = new Knapsack();
+    }
+    
+    @Test
+    void testBasicKnapsack() {
+        // TODO: Uncomment when implementation is complete
+        // int[] weights = {2, 3, 4, 5};
+        // int[] values = {3, 4, 5, 6};
+        // int capacity = 5;
+        // assertEquals(7, knapsack.knapsack(weights, values, capacity));
+    }
+    
+    @Test
+    void testKnapsackAllItems() {
+        // TODO: Uncomment when implementation is complete
+        // int[] weights = {1, 2, 3};
+        // int[] values = {10, 15, 40};
+        // int capacity = 6;
+        // assertEquals(65, knapsack.knapsack(weights, values, capacity));
+    }
+    
+    @Test
+    void testKnapsackZeroCapacity() {
+        // TODO: Uncomment when implementation is complete
+        // int[] weights = {1, 2, 3};
+        // int[] values = {10, 15, 40};
+        // int capacity = 0;
+        // assertEquals(0, knapsack.knapsack(weights, values, capacity));
+    }
+    
+    @Test
+    void testKnapsackWithItems() {
+        // TODO: Uncomment when implementation is complete
+        // int[] weights = {2, 3, 4, 5};
+        // int[] values = {3, 4, 5, 6};
+        // int capacity = 5;
+        // int[] items = knapsack.knapsackWithItems(weights, values, capacity);
+        // assertNotNull(items);
+        // // Verify selected items give maximum value
+    }
+}

src/test/java/com/dsa/algorithms/dynamic_programming/LongestCommonSubsequenceTest.java

@@ -0,0 +1,54 @@
+package com.dsa.algorithms.dynamic_programming;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+
+class LongestCommonSubsequenceTest {
+    
+    private LongestCommonSubsequence lcs;
+    
+    @BeforeEach
+    void setUp() {
+        lcs = new LongestCommonSubsequence();
+    }
+    
+    @Test
+    void testLCSBasic() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(3, lcs.lcs("ABCDGH", "AEDFHR"));
+    }
+    
+    @Test
+    void testLCSIdenticalStrings() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(3, lcs.lcs("ABC", "ABC"));
+    }
+    
+    @Test
+    void testLCSNoCommon() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(0, lcs.lcs("ABC", "DEF"));
+    }
+    
+    @Test
+    void testLCSEmptyString() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals(0, lcs.lcs("", "ABC"));
+        // assertEquals(0, lcs.lcs("ABC", ""));
+    }
+    
+    @Test
+    void testLCSString() {
+        // TODO: Uncomment when implementation is complete
+        // String result = lcs.lcsString("ABCDGH", "AEDFHR");
+        // assertEquals(3, result.length());
+        // // Verify result is a valid subsequence
+    }
+    
+    @Test
+    void testLCSStringIdentical() {
+        // TODO: Uncomment when implementation is complete
+        // assertEquals("ABC", lcs.lcsString("ABC", "ABC"));
+    }
+}