updated

Author: Krishnan M

src/test/java/com/thealgorithms/tree/BinarySearchTree.java

@@ -28,17 +28,27 @@ void setUp() {
         bst.populate(values);
     }
 
+    /**
+     * Verifies that the BST is not empty after insertion.
+     */
     @Test
     void testBSTIsNotEmpty() {
         assertFalse(bst.isEmpty(), "BST should not be empty after insertion");
     }
 
+    /**
+     * Tests the height calculation of the root node.
+     */
     @Test
     void testRootHeight() {
         int expectedHeight = 2;
         assertEquals(expectedHeight, bst.height(bst.getRoot()), "Height of root node should be 2");
     }
 
+    /**
+     * Tests the populateSorted method to ensure the BST is balanced
+     * when populated with a sorted array.
+     */
     @Test
     void testPopulateSortedAndBalanced() {
         BinarySearchTree sortedBST = new BinarySearchTree();
@@ -47,52 +57,78 @@ void testPopulateSortedAndBalanced() {
         assertTrue(sortedBST.balanced(), "BST should be balanced after populateSorted");
     }
 
+    /**
+     * Unit test for verifying the height calculation of nodes in the BinarySearchTree.
+     * This test inserts three nodes and checks the height of the left child of the root.
+     */
     @Test
     void testHeightCalculation() {
         BinarySearchTree localBST = new BinarySearchTree();
         localBST.insert(10); // Root
         localBST.insert(5);  // Left child
         localBST.insert(15); // Right child
-
         assertEquals(0, localBST.height(localBST.getRoot().getLeft()), "Left child height should be 0");
     }
-
+    
+    /**
+     * Tests if the BST is balanced.
+     */
     @Test
     void testBalancedTree() {
         assertTrue(bst.balanced(), "BST should be balanced with given values");
     }
 
+    /**
+     * Tests inorder traversal output.
+     */
     @Test
     void testInOrderTraversal() {
         bst.inOrder(); // Output can be redirected and verified if needed
         assertTrue(true, "Inorder traversal executed successfully");
     }
 
+    /**
+     * Tests preorder traversal output.
+     */
     @Test
     void testPreOrderTraversal() {
         bst.preOrder();
         assertTrue(true, "Preorder traversal executed successfully");
     }
 
+    /**
+     * Tests the height of the root node after inserting multiple values into the BST.
+     * Ensures the height is calculated correctly for a balanced tree.
+     */
     @Test
     void testRootHeightAfterInsertions() {
         bst.populate(new int[] {30, 20, 40, 10, 25, 35, 50});
         int expectedHeight = 2;
         assertEquals(expectedHeight, bst.height(bst.getRoot()), "Height of root node should be 2");
     }
 
+    /**
+     * Tests postorder traversal output.
+     */
     @Test
     void testPostOrderTraversal() {
         bst.postOrder();
         assertTrue(true, "Postorder traversal executed successfully");
     }
 
+    /**
+     * Tests pretty display of the BST.
+     */
     @Test
     void testPrettyDisplay() {
         bst.prettyDisplay();
         assertTrue(true, "Pretty display executed successfully");
     }
 
+    /**
+     * Tests insertion of negative values into the BST.
+     * Verifies that the tree is not empty and remains balanced.
+     */
     @Test
     void testInsertNegativeValues() {
         BinarySearchTree negativeBST = new BinarySearchTree();
@@ -102,6 +138,11 @@ void testInsertNegativeValues() {
         assertTrue(negativeBST.balanced(), "BST with negative values should be balanced");
     }
 
+    /**
+     * Tests insertion of duplicate values into the BST.
+     * Verifies that the tree handles duplicates (either inserts or ignores them).
+     * Note: Current BST implementation inserts duplicates to the right.
+     */
     @Test
     void testInsertDuplicateValues() {
         BinarySearchTree duplicateBST = new BinarySearchTree();
@@ -112,12 +153,15 @@ void testInsertDuplicateValues() {
         duplicateBST.inOrder(); // Visual check if needed
         assertTrue(true, "BST handled duplicate values (check logic if duplicates are allowed)");
     }
-
+    
+    /**
+     * Tests balanced population using sorted array.
+     */
     @Test
     void testPopulateSorted() {
         int[] sortedValues = {10, 20, 30, 40, 50};
         BinarySearchTree sortedBST = new BinarySearchTree();
         sortedBST.populateSorted(sortedValues);
         assertTrue(sortedBST.balanced(), "BST populated with sorted array should be balanced");
     }
-}
+}