Increase test coverage for ListUtils

 - isEqualList: same size, but different elements in the lists
 - isEqualList: same size, same elements, but different order
 - hashCodeForList: with null element
 - partition.get: edge cases (Exception)
 - union: multiple cases
 - sum: happy path

src/test/java/org/apache/commons/collections4/ListUtilsTest.java

@@ -81,16 +81,25 @@ public void testEmptyIfNull() {
     public void testEquals() {
         final Collection<String> data = Arrays.asList("a", "b", "c");
 
-        final List<String> a = new ArrayList<>( data );
-        final List<String> b = new ArrayList<>( data );
-
-        assertEquals(a, b);
-        assertTrue(ListUtils.isEqualList(a, b));
-        a.clear();
-        assertFalse(ListUtils.isEqualList(a, b));
-        assertFalse(ListUtils.isEqualList(a, null));
-        assertFalse(ListUtils.isEqualList(null, b));
+        final List<String> list1 = new ArrayList<>( data );
+        final List<String> list2 = new ArrayList<>( data );
+
+        assertEquals(list1, list2);
+        assertTrue(ListUtils.isEqualList(list1, list2));
+        list1.clear();
+        assertFalse(ListUtils.isEqualList(list1, list2));
+        assertFalse(ListUtils.isEqualList(list1, null));
+        assertFalse(ListUtils.isEqualList(null, list2));
         assertTrue(ListUtils.isEqualList(null, null));
+
+        list2.clear();
+        list1.add("a");
+        list2.add("b");
+        assertFalse(ListUtils.isEqualList(list1, list2));
+
+        list1.add("b");
+        list2.add("a");
+        assertFalse(ListUtils.isEqualList(list1, list2));
     }
 
     @Test
@@ -111,16 +120,19 @@ public void testGetLast() {
     public void testHashCode() {
         final Collection<String> data = Arrays.asList("a", "b", "c");
 
-        final List<String> a = new ArrayList<>(data);
-        final List<String> b = new ArrayList<>(data);
+        final List<String> list1 = new ArrayList<>(data);
+        final List<String> list2 = new ArrayList<>(data);
 
-        assertEquals(a.hashCode(), b.hashCode());
-        assertEquals(a.hashCode(), ListUtils.hashCodeForList(a));
-        assertEquals(b.hashCode(), ListUtils.hashCodeForList(b));
-        assertEquals(ListUtils.hashCodeForList(a), ListUtils.hashCodeForList(b));
-        a.clear();
-        assertNotEquals(ListUtils.hashCodeForList(a), ListUtils.hashCodeForList(b));
+        assertEquals(list1.hashCode(), list2.hashCode());
+        assertEquals(list1.hashCode(), ListUtils.hashCodeForList(list1));
+        assertEquals(list2.hashCode(), ListUtils.hashCodeForList(list2));
+        assertEquals(ListUtils.hashCodeForList(list1), ListUtils.hashCodeForList(list2));
+        list1.clear();
+        assertNotEquals(ListUtils.hashCodeForList(list1), ListUtils.hashCodeForList(list2));
         assertEquals(0, ListUtils.hashCodeForList(null));
+
+        list1.add(null);
+        assertEquals(31, ListUtils.hashCodeForList(list1));
     }
 
     /**
@@ -328,6 +340,12 @@ public void testPartition() {
         assertNotNull(partition);
         assertEquals(3, partition.size());
         assertEquals(1, partition.get(2).size());
+        assertAll(
+                () -> assertThrows(IndexOutOfBoundsException.class, () -> partition.get(-1),
+                        "Index -1 must not be negative"),
+                () -> assertThrows(IndexOutOfBoundsException.class, () -> partition.get(3),
+                        "Index " + 3 + " must be less than size " + partition.size())
+        );
         assertAll(
                 () -> assertThrows(NullPointerException.class, () -> ListUtils.partition(null, 3),
                         "failed to check for null argument"),
@@ -481,4 +499,59 @@ public void testSubtractNullElement() {
         assertEquals(expected, result);
     }
 
+    @Test
+    public void testUnion() {
+        final List<String> list1 = new ArrayList<>();
+        list1.add(a);
+        final List<String> list2 = new ArrayList<>();
+        list2.add(b);
+        final List<String> result1 = ListUtils.union(list1, list2);
+        final List<String> expected1 = new ArrayList<>();
+        expected1.add(a);
+        expected1.add(b);
+        assertEquals(2, result1.size());
+        assertEquals(expected1, result1);
+
+        final List<String> list3 = new ArrayList<>();
+        list3.add(a);
+        final List<String> result2 = ListUtils.union(list1, list3);
+        final List<String> expected2 = new ArrayList<>();
+        expected2.add(a);
+        expected2.add(a);
+        assertEquals(2, result1.size());
+        assertEquals(expected2, result2);
+
+        list1.add(null);
+        final List<String> result3 = ListUtils.union(list1, list2);
+        final List<String> expected3 = new ArrayList<>();
+        expected3.add(a);
+        expected3.add(null);
+        expected3.add(b);
+        assertEquals(3, result3.size());
+        assertEquals(expected3, result3);
+
+        list2.add(null);
+        final List<String> result4 = ListUtils.union(list1, list2);
+        final List<String> expected4 = new ArrayList<>();
+        expected4.add(a);
+        expected4.add(null);
+        expected4.add(b);
+        expected4.add(null);
+        assertEquals(4, result4.size());
+        assertEquals(expected4, result4);
+    }
+
+    @Test
+    public void testSum() {
+        final List<String> list1 = new ArrayList<>();
+        list1.add(a);
+        final List<String> list2 = new ArrayList<>();
+        list2.add(b);
+        final List<String> expected1 = new ArrayList<>();
+        expected1.add(a);
+        expected1.add(b);
+        final List<String> result1 = ListUtils.sum(list1, list2);
+        assertEquals(2, result1.size());
+        assertEquals(expected1, result1);
+    }
 }