Made style changes

According to Clang again...

Author: J-manLans

src/test/java/com/thealgorithms/datastructures/trees/AVLSimpleTest.java

@@ -1,5 +1,7 @@
 package com.thealgorithms.datastructures.trees;
 
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import com.thealgorithms.devutils.ConsoleInterceptor;
@@ -20,11 +22,13 @@ public class AVLSimpleTest {
         Setup/TearDown
     ======================== */
 
+    /** Starts capturing System.in. */
     @BeforeEach
     void setup() {
         interceptor.captureOutput();
     }
 
+    /** Cleans up after each test by closing the interceptor. */
     @AfterEach
     void tearDown() {
         interceptor.close();
@@ -34,10 +38,29 @@ void tearDown() {
         Helper methods
     ======================== */
 
+    /**
+     * Returns a string representation of the expected tree after inserting
+     * the values 10, 20, and 30 in any order.
+     * <p>
+     * The returned string follows the same format as the tree's display method,
+     * where each node is represented in the form "left=>value<=right" and "END"
+     * denotes an empty (null) child.
+     * @return a string representing the expected tree structure
+     */
     String getExpectedTree() {
         return "10=>20<=30END=>10<=ENDEND=>30<=END2";
     }
 
+    /**
+     * Returns the actual string representation of the tree as printed
+     * by the display method.
+     *
+     * <p>This method captures the console output via the interceptor and
+     * removes all newline characters, returning a single-line string
+     * suitable for comparison with the expected tree string.
+     *
+     * @return the actual tree structure as a single-line string
+     */
     String getActualTree() {
         return interceptor.getAndClearConsoleOutput().replaceAll("[\\r\\n]", "");
     }
@@ -47,7 +70,7 @@ String getActualTree() {
     ======================== */
 
     @Test
-    @DisplayName("A longer generic AVL tree creation that should pass")
+    @DisplayName("Creates a longer simple AVL tree that matches the expected layout")
     void testTreeCreation() {
         tree.insert(25);
         tree.insert(30);
@@ -77,52 +100,51 @@ void testEmptyTree() {
     }
 
     @ParameterizedTest
-    @MethodSource("getTreeNodesInput")
+    @MethodSource("getTreeNodesValues")
     @DisplayName("Test to ensure all rotation paths are covered")
-    void testAllRotations(int node1, int node2, int node3) {
-        tree.insert(node1);
-        tree.insert(node2);
-        tree.insert(node3);
+    void testAllRotations(int node1, int node2, int node3, String errorMessage) {
+        assertAll(() -> assertDoesNotThrow(() -> tree.insert(node1), "inserting: " + node1), () -> assertDoesNotThrow(() -> tree.insert(node2), "inserting: " + node2), () -> assertDoesNotThrow(() -> tree.insert(node3), "inserting: " + node3));
 
         tree.display();
 
-        assertEquals(getExpectedTree(), getActualTree());
+        assertEquals(getExpectedTree(), getActualTree(), errorMessage);
     }
 
-    public static Stream<Arguments> getTreeNodesInput() {
-        return Stream.of(Arguments.of(30, 20, 10), Arguments.of(30, 10, 20), Arguments.of(10, 20, 30), Arguments.of(10, 30, 20));
+    public static Stream<Arguments> getTreeNodesValues() {
+        return Stream.of(Arguments.of(30, 20, 10, "LL rotation failed"), Arguments.of(30, 10, 20, "LR rotation failed"), Arguments.of(10, 20, 30, "RR rotation failed"), Arguments.of(10, 30, 20, "RL rotation failed"));
     }
 
     @ParameterizedTest
     @MethodSource("getTreeNodesInputForBFEqualsOneRotations")
-    @DisplayName("Rotation not triggered when balance factor equals threshold")
-    void testRotatesNotTriggeredWhenBFEqualsOne(int node, String expectedTree) {
-        tree.insert(30);
+    @DisplayName("Checks rotation isn't triggered when balance factor equals threshold")
+    void testRotationsNotTriggeredWhenBFEqualsOne(int boundaryNode, String expectedTree, String errorMessage) {
         tree.insert(20);
+        tree.insert(30);
         tree.insert(10);
-        tree.insert(node);
+        tree.insert(boundaryNode);
 
         tree.display();
 
-        assertEquals(expectedTree, getActualTree());
+        assertEquals(expectedTree, getActualTree(), errorMessage);
     }
 
     public static Stream<Arguments> getTreeNodesInputForBFEqualsOneRotations() {
-        return Stream.of(Arguments.of(5, "10=>20<=305=>10<=ENDEND=>5<=ENDEND=>30<=END3"), Arguments.of(35, "10=>20<=30END=>10<=ENDEND=>30<=35END=>35<=END3"));
+        return Stream.of(Arguments.of(5, "10=>20<=305=>10<=ENDEND=>5<=ENDEND=>30<=END3", "Insertion of 5 should not trigger rotation"), Arguments.of(15, "10=>20<=30END=>10<=15END=>15<=ENDEND=>30<=END3", "Insertion of 15 should not trigger rotation"),
+            Arguments.of(25, "10=>20<=30END=>10<=END25=>30<=ENDEND=>25<=END3", "Insertion of 25 should not trigger rotation"), Arguments.of(35, "10=>20<=30END=>10<=ENDEND=>30<=35END=>35<=END3", "Insertion of 35 should not trigger rotation"));
     }
 
     @Test
-    @DisplayName("Should return true for a tree that don't account for duplicates")
-    void testDuplicatesInTreeCreationDoNotStick() {
+    @DisplayName("Ignores duplicate insertions and create a tree with depth one")
+    void testDuplicateInsertionsIgnored() {
         int duplicate = 20;
-        tree.insert(30);
         tree.insert(duplicate);
-        tree.insert(20);
         tree.insert(duplicate);
-        tree.insert(10);
+        tree.insert(duplicate);
 
         tree.display();
 
-        assertEquals(getExpectedTree(), getActualTree());
+        String actualTree = getActualTree();
+
+        assertEquals('1', actualTree.charAt(actualTree.length() - 1));
     }
 }

src/test/java/com/thealgorithms/datastructures/trees/GenericTreeTest.java

@@ -5,6 +5,7 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
@@ -17,17 +18,25 @@ public class GenericTreeTest {
         Setup/TearDown
     ======================== */
 
+    /**
+     * Sets up the test environment before each test:
+     * <ol>
+     *   <li>Makes the interceptor provide a predefined sequence of values for the tree.</li>
+     *   <li>Initializes a new GenericTree instance.</li>
+     *   <li>Starts capturing console output via the interceptor.</li>
+     * </ol>
+     */
     @BeforeEach
     void setup() {
         String treeValues = "40\n5\n34\n0\n1\n0\n32\n1\n123\n0\n342\n2\n98\n0\n35\n0\n12\n0";
         interceptor.mockInput(treeValues);
-        interceptor.captureOutput();
 
         tree = new GenericTree();
 
-        interceptor.clearConsoleOutput();
+        interceptor.captureOutput();
     }
 
+    /** Cleans up after each test by closing the interceptor. */
     @AfterEach
     void tearDown() {
         interceptor.close();
@@ -38,7 +47,8 @@ void tearDown() {
     ======================== */
 
     /**
-     * Creates a generic tree that looks something like this:
+     * Returns the string representation of the generic tree that's created in the {@link #setup()} method.
+     * It looks something like this:
      *
      * <pre>
      *                    40
@@ -54,6 +64,15 @@ String getExpectedTree() {
         return "40=>34 1 32 342 12 .34=>.1=>.32=>123 .123=>.342=>98 35 .98=>.35=>.12=>.";
     }
 
+    /**
+     * Returns the actual string representation of the tree as printed
+     * by the display method.
+     * <p>
+     * This method captures the console output via the interceptor and
+     * removes all newline characters, returning a single-line string
+     * suitable for comparison with the expected tree string.
+     * @return the actual tree structure as a single-line string
+     */
     String getConsoleOutput() {
         return interceptor.getAndClearConsoleOutput().replaceAll("[\\r\\n]", "");
     }
@@ -63,20 +82,15 @@ String getConsoleOutput() {
     ======================== */
 
     @Test
-    void testCreateValidTree() {
+    @DisplayName("Asserts the created tree have the expected structure")
+    void testValidTree() {
         tree.display();
 
         Assertions.assertEquals(getExpectedTree(), getConsoleOutput());
     }
 
     @Test
-    void testCreateValidTreeIsNotEmpty() {
-        tree.display();
-
-        Assertions.assertDoesNotThrow(interceptor::getAndClearConsoleOutput);
-    }
-
-    @Test
+    @DisplayName("Creating GenericTree with invalid input throws InputMismatchException")
     void testCreateInValidTree() {
         String invalidTreeValues = "a\nb\nc\n";
         interceptor.mockInput(invalidTreeValues);
@@ -85,33 +99,39 @@ void testCreateInValidTree() {
     }
 
     @Test
+    @DisplayName("Gets the correct number of nodes in the tree")
     void testGettingCorrectSizeOfTree() {
-        Assertions.assertEquals(9, tree.size2call());
+        Assertions.assertEquals(3, tree.size2call());
     }
 
     @Test
+    @DisplayName("Gets the highest value among the trees nodes")
     void testGettingTheMaximalValueOfTreesNodes() {
         Assertions.assertEquals(342, tree.maxcall());
     }
 
     @Test
+    @DisplayName("Returns the correct height of the tree")
     void testGettingTheHeightOfTree() {
         Assertions.assertEquals(2, tree.heightcall());
     }
 
     @ParameterizedTest
     @ValueSource(ints = {40, 34, 1, 32, 342, 123, 98, 35})
+    @DisplayName("Returns true when searching for values that is in the tree")
     void testFindingAllPresentValuesInTree(int value) {
-        Assertions.assertTrue(tree.findcall(value));
+        Assertions.assertTrue(tree.findcall(value), "The expected value " + value + " wasn't in the tree");
     }
 
     @ParameterizedTest
     @ValueSource(ints = {41, 31, 2, 52, 542, 223, 92, 38})
+    @DisplayName("Returns false when searching for values that isn't in the tree")
     void testFindingAbsentValuesInTree(int value) {
-        Assertions.assertFalse(tree.findcall(value));
+        Assertions.assertFalse(tree.findcall(value), "The value " + value + " was unexpectedly in the tree");
     }
 
     @Test
+    @DisplayName("Outputs all nodes at each tree level from left to right")
     void testFindingAllNodesOfCertainDepthInTree() {
         int height = tree.heightcall();
 
@@ -123,24 +143,28 @@ void testFindingAllNodesOfCertainDepthInTree() {
     }
 
     @Test
+    @DisplayName("Prints all node values in pre order")
     void testPreOrderPrintsAsExpected() {
         tree.preordercall();
         Assertions.assertEquals("40 34 1 32 123 342 98 35 12 .", getConsoleOutput());
     }
 
     @Test
+    @DisplayName("Prints all node values in post order")
     void testPostOrderPrintsAsExpected() {
         tree.postordercall();
         Assertions.assertEquals("34 1 123 32 98 35 342 12 40 .", getConsoleOutput());
     }
 
     @Test
+    @DisplayName("Prints all node values in level order")
     void testLevelOrderPrintsAsExpected() {
         tree.levelorder();
         Assertions.assertEquals("40 34 1 32 342 12 123 98 35 .", getConsoleOutput());
     }
 
     @Test
+    @DisplayName("Removes all leaves from the tree")
     void testLeavesAreRemoved() {
         tree.removeleavescall();
         tree.display();

src/test/java/com/thealgorithms/datastructures/trees/LCATest.java

@@ -31,7 +31,7 @@ public class LCATest {
     ======================== */
 
     @ParameterizedTest
-    @MethodSource("getInput")
+    @MethodSource("getSimulatedInputAndExpectedParent")
     @DisplayName("Should return correct common ancestor for any two nodes in the tree")
     void shouldReturnCorrectLCAThroughMain(String simulatedInput, String expectedParent) {
         try (ConsoleInterceptor interceptor = new ConsoleInterceptor()) {
@@ -42,11 +42,11 @@ void shouldReturnCorrectLCAThroughMain(String simulatedInput, String expectedPar
 
             String actualParent = interceptor.getAndClearConsoleOutput().replaceAll("[\\r\\n]", "");
 
-            assertEquals(expectedParent, actualParent);
+            assertEquals(expectedParent, actualParent, "The two nodes Lowest Common Ancestor wasn't the expected one.");
         }
     }
 
-    public static Stream<Arguments> getInput() {
+    public static Stream<Arguments> getSimulatedInputAndExpectedParent() {
         return Stream.of(Arguments.of(TREE + "9\n4\n", "2"), Arguments.of(TREE + "5\n6\n", "5"), Arguments.of(TREE + "5\n4\n", "0"), Arguments.of(TREE + "3\n8\n", "3"), Arguments.of(TREE + "6\n3\n", "0"), Arguments.of(TREE + "3\n3\n", "3"));
     }
 }

src/test/java/com/thealgorithms/devutils/ConsoleInterceptor.java

@@ -51,7 +51,7 @@ public void mockInput(String mockedInput) {
 
     /**
      * Start capturing System.out by replacing stdout with a custom PrintStream.
-     * All printed data will be stored in outContent for later retrieval.
+     * All printed data will be stored in outContent - available via {@link #getAndClearConsoleOutput}, for later retrieval.
      */
     public void captureOutput() {
         if (!isCapturing) {