test: upgrade MergeSortedArrayListTest to use JUnit 5 parameterized tests

Author: parassawale

src/test/java/com/thealgorithms/datastructures/lists/MergeSortedArrayListTest.java

@@ -2,98 +2,85 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class MergeSortedArrayListTest {
 
-    @Test
-    void testMergeTwoSortedLists() {
-        List<Integer> listA = Arrays.asList(1, 3, 5, 7, 9);
-        List<Integer> listB = Arrays.asList(2, 4, 6, 8, 10);
+    @ParameterizedTest(name = "{3}")
+    @MethodSource("provideMergeTestData")
+    void testMergeParameterizedScenarios(List<Integer> listA, List<Integer> listB, List<Integer> expected, String scenarioName) {
         List<Integer> result = new ArrayList<>();
-
         MergeSortedArrayList.merge(listA, listB, result);
-
-        List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-        assertEquals(expected, result, "Merged list should be sorted and contain all elements from both input lists.");
+        assertEquals(expected, result, () -> "Failed scenario: " + scenarioName);
     }
 
-    @Test
-    void testMergeWithEmptyList() {
-        List<Integer> listA = Arrays.asList(1, 2, 3);
-        List<Integer> listB = new ArrayList<>(); // Empty list
-        List<Integer> result = new ArrayList<>();
-
-        MergeSortedArrayList.merge(listA, listB, result);
-
-        List<Integer> expected = Arrays.asList(1, 2, 3);
-        assertEquals(expected, result, "Merged list should match listA when listB is empty.");
-    }
-
-    @Test
-    void testMergeWithBothEmptyLists() {
-        List<Integer> listA = new ArrayList<>(); // Empty list
-        List<Integer> listB = new ArrayList<>(); // Empty list
-        List<Integer> result = new ArrayList<>();
-
-        MergeSortedArrayList.merge(listA, listB, result);
-
-        assertTrue(result.isEmpty(), "Merged list should be empty when both input lists are empty.");
+    private static Stream<Arguments> provideMergeTestData() {
+        return Stream.of(
+            Arguments.of(
+                Arrays.asList(1, 3, 5, 7, 9), 
+                Arrays.asList(2, 4, 6, 8, 10), 
+                Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
+                "Standard alternating sorted lists"
+            ),
+            Arguments.of(
+                Arrays.asList(1, 2, 3), 
+                new ArrayList<>(), 
+                Arrays.asList(1, 2, 3),
+                "Merge with empty second list"
+            ),
+            Arguments.of(
+                new ArrayList<>(), 
+                Arrays.asList(4, 5, 6), 
+                Arrays.asList(4, 5, 6),
+                "Merge with empty first list"
+            ),
+            Arguments.of(
+                new ArrayList<>(), 
+                new ArrayList<>(), 
+                new ArrayList<>(),
+                "Merge with both lists empty"
+            ),
+            Arguments.of(
+                Arrays.asList(1, 2, 2, 3), 
+                Arrays.asList(2, 3, 4), 
+                Arrays.asList(1, 2, 2, 2, 3, 3, 4),
+                "Handling duplicate elements gracefully"
+            ),
+            Arguments.of(
+                Arrays.asList(-3, -1, 2), 
+                Arrays.asList(-2, 0, 3), 
+                Arrays.asList(-3, -2, -1, 0, 2, 3),
+                "Handling negative numbers mixed with positive numbers"
+            )
+        );
     }
 
     @Test
-    void testMergeWithDuplicateElements() {
-        List<Integer> listA = Arrays.asList(1, 2, 2, 3);
-        List<Integer> listB = Arrays.asList(2, 3, 4);
+    void testMergeThrowsExceptionWhenListAIsNull() {
+        List<Integer> listB = Arrays.asList(1, 2, 3);
         List<Integer> result = new ArrayList<>();
-
-        MergeSortedArrayList.merge(listA, listB, result);
-
-        List<Integer> expected = Arrays.asList(1, 2, 2, 2, 3, 3, 4);
-        assertEquals(expected, result, "Merged list should correctly handle and include duplicate elements.");
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(null, listB, result));
     }
 
     @Test
-    void testMergeWithNegativeAndPositiveNumbers() {
-        List<Integer> listA = Arrays.asList(-3, -1, 2);
-        List<Integer> listB = Arrays.asList(-2, 0, 3);
+    void testMergeThrowsExceptionWhenListBIsNull() {
+        List<Integer> listA = Arrays.asList(1, 2, 3);
         List<Integer> result = new ArrayList<>();
-
-        MergeSortedArrayList.merge(listA, listB, result);
-
-        List<Integer> expected = Arrays.asList(-3, -2, -1, 0, 2, 3);
-        assertEquals(expected, result, "Merged list should correctly handle negative and positive numbers.");
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(listA, null, result));
     }
 
     @Test
-    void testMergeThrowsExceptionOnNullInput() {
-        List<Integer> listA = null;
-        List<Integer> listB = Arrays.asList(1, 2, 3);
-        List<Integer> result = new ArrayList<>();
-
-        List<Integer> finalListB = listB;
-        List<Integer> finalListA = listA;
-        List<Integer> finalResult = result;
-        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(finalListA, finalListB, finalResult), "Should throw NullPointerException if any input list is null.");
-
-        listA = Arrays.asList(1, 2, 3);
-        listB = null;
-        List<Integer> finalListA1 = listA;
-        List<Integer> finalListB1 = listB;
-        List<Integer> finalResult1 = result;
-        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(finalListA1, finalListB1, finalResult1), "Should throw NullPointerException if any input list is null.");
-
-        listA = Arrays.asList(1, 2, 3);
-        listB = Arrays.asList(4, 5, 6);
-        result = null;
-        List<Integer> finalListA2 = listA;
-        List<Integer> finalListB2 = listB;
-        List<Integer> finalResult2 = result;
-        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(finalListA2, finalListB2, finalResult2), "Should throw NullPointerException if the result collection is null.");
+    void testMergeThrowsExceptionWhenResultCollectionIsNull() {
+        List<Integer> listA = Arrays.asList(1, 2, 3);
+        List<Integer> listB = Arrays.asList(4, 5, 6);
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(listA, listB, null));
     }
-}
+}