Add tests mergesortedarray and add check list null

src/main/java/com/thealgorithms/datastructures/heaps/GenericHeap.java

@@ -9,6 +9,10 @@ public class GenericHeap<T extends Comparable<T>> {
     HashMap<T, Integer> map = new HashMap<>();
 
     public void add(T item) {
+        if (item == null) {
+            throw new IllegalArgumentException("Cannot insert null into the heap.");
+        }
+
         this.data.add(item);
         map.put(item, this.data.size() - 1); //
         upHeapify(this.data.size() - 1);

src/main/java/com/thealgorithms/datastructures/lists/MergeSortedArrayList.java

@@ -39,6 +39,10 @@ public static void main(String[] args) {
      * @param listC the result list after merging
      */
     public static void merge(List<Integer> listA, List<Integer> listB, List<Integer> listC) {
+        if (listA == null || listB == null || listC == null) {
+            throw new NullPointerException("Lists cannot be null.");
+        }
+
         int pa = 0;
         /* the index of listA */
         int pb = 0;

src/test/java/com/thealgorithms/datastructures/heaps/GenericHeapTest.java

@@ -0,0 +1,126 @@
+package com.thealgorithms.datastructures.heaps;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class GenericHeapTest {
+
+    private GenericHeap<Integer> heap;
+
+    @BeforeEach
+    public void setUp() {
+        heap = new GenericHeap<>();
+    }
+
+    @Test
+    public void testGenericHeapAddAndGet() {
+        heap.add(19);
+        heap.add(36);
+        heap.add(100);
+        heap.add(-17);
+        heap.add(3);
+
+        // Check that the largest element (100) is at the top of the heap
+        assertEquals(100, heap.get());
+    }
+
+    @Test
+    public void testGenericHeapRemove() {
+        heap.add(19);
+        heap.add(36);
+        heap.add(100);
+        heap.add(-17);
+        heap.add(3);
+
+        // Verify that the largest element is removed correctly
+        assertEquals(100, heap.remove());
+
+        // The new element at the top should be 36
+        assertEquals(36, heap.get());
+
+        // Check that the size is correct after removal
+        assertEquals(4, heap.size());
+    }
+
+    @Test
+    public void testGenericHeapSize() {
+        assertTrue(heap.isEmpty());
+
+        heap.add(10);
+        heap.add(20);
+
+        // Check that the size is correct
+        assertEquals(2, heap.size());
+
+        heap.remove();
+
+        // After removal, the size should be 1
+        assertEquals(1, heap.size());
+    }
+
+    @Test
+    public void testGenericHeapIsEmpty() {
+        // Verify that the heap is initially empty
+        assertTrue(heap.isEmpty());
+
+        heap.add(15);
+
+        // Now the heap should not be empty
+        assertFalse(heap.isEmpty());
+
+        heap.remove();
+
+        // After removing the one element, it should be empty again
+        assertTrue(heap.isEmpty());
+    }
+
+    @Test
+    public void testGenericHeapUpdatePriority() {
+        heap.add(19);
+        heap.add(36);
+        heap.add(100);
+        heap.add(-17);
+        heap.add(3);
+
+        // Verify that the largest element initially is 100
+        assertEquals(100, heap.get());
+
+        heap.remove();
+
+        // Simulates a change in priority by increasing the value of 100 to 44
+        heap.add(44);
+
+        // Now, the new high should be 25
+        assertEquals(44, heap.get());
+    }
+
+    @Test
+    public void testGenericHeapRemoveUntilEmpty() {
+        heap.add(5);
+        heap.add(3);
+        heap.add(4);
+        heap.add(1);
+        heap.add(2);
+
+        // Remove all items and check that they are removed in descending order
+        assertEquals(5, heap.remove());
+        assertEquals(4, heap.remove());
+        assertEquals(3, heap.remove());
+        assertEquals(2, heap.remove());
+        assertEquals(1, heap.remove());
+
+        // Empty heap
+        assertTrue(heap.isEmpty());
+    }
+
+    @Test
+    public void testGenericHeapAddNullItem() {
+        // Check null item
+        assertThrows(IllegalArgumentException.class, () -> { heap.add(null); });
+    }
+}

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

@@ -0,0 +1,128 @@
+package com.thealgorithms.datastructures.lists;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+public class MergeSortedArrayListTest {
+
+    @Test
+    public void testMergeSortedWithSameSizeLists() {
+        List<Integer> listA = Arrays.asList(1, 3, 5, 7, 9);
+        List<Integer> listB = Arrays.asList(2, 4, 6, 8, 10);
+        List<Integer> listC = new ArrayList<>();
+
+        MergeSortedArrayList.merge(listA, listB, listC);
+
+        // Expected merged result
+        List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+        // Assert the merged list is as expected
+        assertEquals(expected, listC);
+    }
+
+    @Test
+    public void testMergeSortedWithEmptyListA() {
+        List<Integer> listA = new ArrayList<>(); // Empty list
+        List<Integer> listB = Arrays.asList(2, 4, 6, 8, 10);
+        List<Integer> listC = new ArrayList<>();
+
+        MergeSortedArrayList.merge(listA, listB, listC);
+
+        // Expected result is listB since listA is empty
+        List<Integer> expected = Arrays.asList(2, 4, 6, 8, 10);
+        assertEquals(expected, listC);
+    }
+
+    @Test
+    public void testMergeSortedWithEmptyListB() {
+        List<Integer> listA = Arrays.asList(1, 3, 5, 7, 9);
+        List<Integer> listB = new ArrayList<>(); // Empty list
+        List<Integer> listC = new ArrayList<>();
+
+        MergeSortedArrayList.merge(listA, listB, listC);
+
+        // Expected result is listA since listB is empty
+        List<Integer> expected = Arrays.asList(1, 3, 5, 7, 9);
+        assertEquals(expected, listC);
+    }
+
+    @Test
+    public void testMergeSortedWithBothEmptyLists() {
+        List<Integer> listA = new ArrayList<>(); // Empty list
+        List<Integer> listB = new ArrayList<>(); // Empty list
+        List<Integer> listC = new ArrayList<>();
+
+        MergeSortedArrayList.merge(listA, listB, listC);
+
+        // Expected result is an empty list since both inputs are empty
+        List<Integer> expected = new ArrayList<>();
+        assertEquals(expected, listC);
+    }
+
+    @Test
+    public void testMergeSortedWithDifferentSizeLists() {
+        List<Integer> listA = Arrays.asList(1, 3);
+        List<Integer> listB = Arrays.asList(2, 4, 6, 8, 10);
+        List<Integer> listC = new ArrayList<>();
+
+        MergeSortedArrayList.merge(listA, listB, listC);
+
+        // Expected merged result
+        List<Integer> expected = Arrays.asList(1, 2, 3, 4, 6, 8, 10);
+        assertEquals(expected, listC);
+    }
+
+    @Test
+    public void testMergeSortedWithDuplicateElements() {
+        List<Integer> listA = Arrays.asList(1, 3, 5);
+        List<Integer> listB = Arrays.asList(1, 3, 5);
+        List<Integer> listC = new ArrayList<>();
+
+        MergeSortedArrayList.merge(listA, listB, listC);
+
+        // Expected merged result with duplicates
+        List<Integer> expected = Arrays.asList(1, 1, 3, 3, 5, 5);
+        assertEquals(expected, listC);
+    }
+
+    @Test
+    public void testMergeSortedWithNullListA() {
+        List<Integer> listA = null; // Null list
+        List<Integer> listB = Arrays.asList(2, 4, 6, 8, 10);
+        List<Integer> listC = new ArrayList<>();
+
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(listA, listB, listC));
+    }
+
+    @Test
+    public void testMergeSortedWithNullListB() {
+        List<Integer> listA = Arrays.asList(1, 3, 5, 7, 9);
+        List<Integer> listB = null; // Null list
+        List<Integer> listC = new ArrayList<>();
+
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(listA, listB, listC));
+    }
+
+    @Test
+    public void testMergeSortedWithBothNullLists() {
+        List<Integer> listA = null; // Null list
+        List<Integer> listB = null; // Null list
+        List<Integer> listC = new ArrayList<>();
+
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(listA, listB, listC));
+    }
+
+    @Test
+    public void testMergeSortedNullLists() {
+        List<Integer> listA = null; // Null list
+        List<Integer> listB = null; // Null list
+        List<Integer> listC = null; // Null list
+
+        assertThrows(NullPointerException.class, () -> MergeSortedArrayList.merge(listA, listB, listC));
+    }
+}