Jul 18, 2025
diff --git a/src/test/java/com/thealgorithms/datastructures/lists/CountSinglyLinkedListRecursionTest.java b/src/test/java/com/thealgorithms/datastructures/lists/CountSinglyLinkedListRecursionTest.java
 package com.thealgorithms.datastructures.lists;

 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;

 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;

 public class CountSinglyLinkedListRecursionTest {
    }

    @Test
    @DisplayName("Count of an empty list should be 0")
    public void testCountEmptyList() {
        // An empty list should have a count of 0
        assertEquals(0, list.count(), "Count of an empty list should be 0.");
        assertEquals(0, list.count());
    }

    @Test
    @DisplayName("Count after inserting a single element should be 1")
    public void testCountSingleElementList() {
        // Insert a single element and check the count
        list.insert(1);
        assertEquals(1, list.count(), "Count of a single-element list should be 1.");
        assertEquals(1, list.count());
    }

    @Test
    @DisplayName("Count after inserting multiple distinct elements")
    public void testCountMultipleElements() {
        // Insert multiple elements and check the count
        for (int i = 1; i <= 5; i++) {
            list.insert(i);
        }
        assertEquals(5, list.count(), "Count of a list with 5 elements should be 5.");
        assertEquals(5, list.count());
    }

    @Test
    @DisplayName("Count should reflect total number of nodes with duplicate values")
    public void testCountWithDuplicateElements() {
        // Insert duplicate elements and verify the count is correct
        list.insert(1);
        list.insert(2);
        list.insert(2);
        list.insert(3);
        list.insert(3);
        assertEquals(5, list.count(), "Count of a list with duplicate elements should match total node count.");
        list.insert(1);
        assertEquals(5, list.count());
    }

    @Test
    @DisplayName("Count should return 0 after clearing the list")
    public void testCountAfterClearingList() {
        for (int i = 1; i <= 4; i++) {
            list.insert(i);
        }
        list.clear(); //assuming you have a clear method; if not, skip this
        assertEquals(0, list.count(), "Count after clearing the list should be 0.");
        list.clear(); //assumed to exist
        assertEquals(0, list.count());
    }

    @Test
    @DisplayName("Count on a very large list should be accurate")
    public void testCountOnVeryLargeList() {
        int n = 1000;
        for (int i = 0; i < n; i++) {
            list.insert(i);
        }
        assertEquals(n, list.count(), "Count should correctly return for large list sizes.");
        assertEquals(n, list.count());
    }

    @Test
    @DisplayName("Count should work correctly with negative values")
    public void testCountOnListWithNegativeNumbers() {
        list.insert(-1);
        list.insert(-5);
        list.insert(-10);
        assertEquals(3, list.count(), "Count should correctly handle negative values.");
        list.insert(-2);
        list.insert(-3);
        assertEquals(3, list.count());
    }

    @Test
    @DisplayName("Calling count multiple times should return the same value if list is unchanged")
    public void testCountIsConsistentWithoutModification() {
        list.insert(1);
        list.insert(2);
        int firstCount = list.count();
        int secondCount = list.count();
        assertEquals(firstCount, secondCount, "Repeated count calls should return consistent values.");
        int count1 = list.count();
        int count2 = list.count();
        assertEquals(count1, count2);
    }

    @Test
    @DisplayName("Count should reflect total even if all values are the same")
    public void testCountAllSameValues() {
        for (int i = 0; i < 5; i++) {
            list.insert(42);
        }
        assertEquals(5, list.count());
    }

    @Test
    @DisplayName("Count should remain correct after multiple interleaved insert and count operations")
    public void testCountAfterEachInsert() {
        assertEquals(0, list.count());
        list.insert(1);
        assertEquals(1, list.count());
        list.insert(2);
        assertEquals(2, list.count());
        list.insert(3);
        assertEquals(3, list.count());
    }

    @Test
    @DisplayName("List should not throw on edge count (0 nodes)")
    public void testEdgeCaseNoElements() {
        assertDoesNotThrow(() -> list.count());
    }

    @Test
    @DisplayName("Should count accurately after inserting then removing all elements")
    public void testCountAfterInsertAndClear() {
        for (int i = 0; i < 10; i++) {
            list.insert(i);
        }
        assertEquals(10, list.count());
        list.clear();
        assertEquals(0, list.count());
    }
 }
Original file line number	Diff line number	Diff line change
		@@ -1,8 +1,10 @@
		package com.thealgorithms.datastructures.lists;

		import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
		import static org.junit.jupiter.api.Assertions.assertEquals;

		import org.junit.jupiter.api.BeforeEach;
		import org.junit.jupiter.api.DisplayName;
		import org.junit.jupiter.api.Test;

		public class CountSinglyLinkedListRecursionTest {
Expand All		@@ -15,70 +17,112 @@ public void setUp() {
		}

		@Test
		@DisplayName("Count of an empty list should be 0")
		public void testCountEmptyList() {
		// An empty list should have a count of 0
		assertEquals(0, list.count(), "Count of an empty list should be 0.");
		assertEquals(0, list.count());
		}

		@Test
		@DisplayName("Count after inserting a single element should be 1")
		public void testCountSingleElementList() {
		// Insert a single element and check the count
		list.insert(1);
		assertEquals(1, list.count(), "Count of a single-element list should be 1.");
		assertEquals(1, list.count());
		}

		@Test
		@DisplayName("Count after inserting multiple distinct elements")
		public void testCountMultipleElements() {
		// Insert multiple elements and check the count
		for (int i = 1; i <= 5; i++) {
		list.insert(i);
		}
		assertEquals(5, list.count(), "Count of a list with 5 elements should be 5.");
		assertEquals(5, list.count());
		}

		@Test
		@DisplayName("Count should reflect total number of nodes with duplicate values")
		public void testCountWithDuplicateElements() {
		// Insert duplicate elements and verify the count is correct
		list.insert(1);
		list.insert(2);
		list.insert(2);
		list.insert(3);
		list.insert(3);
		assertEquals(5, list.count(), "Count of a list with duplicate elements should match total node count.");
		list.insert(1);
		assertEquals(5, list.count());
		}

		@Test
		@DisplayName("Count should return 0 after clearing the list")
		public void testCountAfterClearingList() {
		for (int i = 1; i <= 4; i++) {
		list.insert(i);
		}
		list.clear(); //assuming you have a clear method; if not, skip this
		assertEquals(0, list.count(), "Count after clearing the list should be 0.");
		list.clear(); //assumed to exist
		assertEquals(0, list.count());
		}

		@Test
		@DisplayName("Count on a very large list should be accurate")
		public void testCountOnVeryLargeList() {
		int n = 1000;
		for (int i = 0; i < n; i++) {
		list.insert(i);
		}
		assertEquals(n, list.count(), "Count should correctly return for large list sizes.");
		assertEquals(n, list.count());
		}

		@Test
		@DisplayName("Count should work correctly with negative values")
		public void testCountOnListWithNegativeNumbers() {
		list.insert(-1);
		list.insert(-5);
		list.insert(-10);
		assertEquals(3, list.count(), "Count should correctly handle negative values.");
		list.insert(-2);
		list.insert(-3);
		assertEquals(3, list.count());
		}

		@Test
		@DisplayName("Calling count multiple times should return the same value if list is unchanged")
		public void testCountIsConsistentWithoutModification() {
		list.insert(1);
		list.insert(2);
		int firstCount = list.count();
		int secondCount = list.count();
		assertEquals(firstCount, secondCount, "Repeated count calls should return consistent values.");
		int count1 = list.count();
		int count2 = list.count();
		assertEquals(count1, count2);
		}

		@Test
		@DisplayName("Count should reflect total even if all values are the same")
		public void testCountAllSameValues() {
		for (int i = 0; i < 5; i++) {
		list.insert(42);
		}
		assertEquals(5, list.count());
		}

		@Test
		@DisplayName("Count should remain correct after multiple interleaved insert and count operations")
		public void testCountAfterEachInsert() {
		assertEquals(0, list.count());
		list.insert(1);
		assertEquals(1, list.count());
		list.insert(2);
		assertEquals(2, list.count());
		list.insert(3);
		assertEquals(3, list.count());
		}

		@Test
		@DisplayName("List should not throw on edge count (0 nodes)")
		public void testEdgeCaseNoElements() {
		assertDoesNotThrow(() -> list.count());
		}

		@Test
		@DisplayName("Should count accurately after inserting then removing all elements")
		public void testCountAfterInsertAndClear() {
		for (int i = 0; i < 10; i++) {
		list.insert(i);
		}
		assertEquals(10, list.count());
		list.clear();
		assertEquals(0, list.count());
		}
		}