custom-set: use generics and tidy up tests

exercises/custom-set/src/test/java/CustomSetTest.java

+import org.junit.Ignore;
+import org.junit.Test;
 
 import java.util.Arrays;
 import java.util.Collections;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import org.junit.Test;
-import org.junit.Ignore;
+
+import static org.junit.Assert.*;
 
 public class CustomSetTest {
 
     @Test
     public void setsWithNoElementsAreEmpty() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .isEmpty();
-        assertTrue(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Collections.emptyList());
+        assertTrue(customSet.isEmpty());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setsWithElementsAreNotEmpty() {
-        final boolean actual
-                = new CustomSet<>(Collections.singletonList(1))
-                        .isEmpty();
-
-        assertFalse(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Collections.singletonList(1));
+        assertFalse(customSet.isEmpty());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nothingIsContainedInAnEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .contains(1);
-
-        assertFalse(actual);
+        CustomSet<Character> customSet = new CustomSet<>(Collections.emptyList());
+        assertFalse(customSet.contains('1'));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void whenTheElementIsInTheSet() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3))
-                        .contains(1);
-
-        assertTrue(actual);
+        CustomSet<String> customSet = new CustomSet<>(Arrays.asList("1", "2", "3"));
+        assertTrue(customSet.contains("1"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void whenTheElementIsNotInTheSet() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3))
-                        .contains(4);
-
-        assertFalse(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Arrays.asList(1, 2, 3));
+        assertFalse(customSet.contains(4));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void emptySetIsASubsetOfAnotherEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .isSubset(
-                                new CustomSet<>(Collections.emptyList())
-                        );
-
-        assertTrue(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Collections.emptyList());
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Collections.emptyList());
+        assertTrue(customSet.isSubset(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void emptySetIsASubsetOfNonEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.singletonList(1))
-                        .isSubset(
-                                new CustomSet<>(Collections.emptyList())
-                        );
-
-        assertTrue(actual);
+        CustomSet<Character> customSet = new CustomSet<>(Collections.singletonList('1'));
+        CustomSet<Character> secondCustomSet = new CustomSet<>(Collections.emptyList());
+        assertTrue(customSet.isSubset(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nonEmptySetIsNotASubsetOfEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .isSubset(
-                                new CustomSet<>(Collections.singletonList(1))
-                        );
-
-        assertFalse(actual);
+        CustomSet<Character> customSet = new CustomSet<>(Collections.emptyList());
+        CustomSet<Character> secondCustomSet = new CustomSet<>(Collections.singletonList('1'));
+        assertFalse(customSet.isSubset(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setIsASubsetOfSetWithExactSameElements() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3))
-                        .isSubset(
-                                new CustomSet<>(Arrays.asList(1, 2, 3))
-                        );
-
-        assertTrue(actual);
+        CustomSet<String> customSet = new CustomSet<>(Arrays.asList("1", "2", "3"));
+        CustomSet<String> secondCustomSet = new CustomSet<>(Arrays.asList("1", "2", "3"));
+        assertTrue(customSet.isSubset(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setIsASubsetOfLargerSetWithSameElements() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(4, 1, 2, 3))
-                        .isSubset(
-                                new CustomSet<>(Arrays.asList(1, 2, 3))
-                        );
-
-        assertTrue(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Arrays.asList(4, 1, 2, 3));
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Arrays.asList(1, 2, 3));
+        assertTrue(customSet.isSubset(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setIsNotASubsetOfSetThatDoesNotContainItsElements() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(4, 1, 3))
-                        .isSubset(
-                                new CustomSet<>(Arrays.asList(1, 2, 3))
-                        );
-
-        assertFalse(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Arrays.asList(4, 1, 3));
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Arrays.asList(1, 2, 3));
+        assertFalse(customSet.isSubset(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void theEmptySetIsDisjointWithItself() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .isDisjoint(
-                                new CustomSet<>(Collections.emptyList())
-                        );
-
-        assertTrue(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Collections.emptyList());
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Collections.emptyList());
+        assertTrue(customSet.isDisjoint(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void emptySetIsDisjointWithNonEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .isDisjoint(
-                                new CustomSet<>(Collections.singletonList(1))
-                        );
-
-        assertTrue(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Collections.emptyList());
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Collections.singletonList(1));
+        assertTrue(customSet.isDisjoint(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nonEmptySetIsDisjointWithEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.singletonList(1))
-                        .isDisjoint(
-                                new CustomSet<>(Collections.emptyList())
-                        );
-
-        assertTrue(actual);
+        CustomSet<Character> customSet = new CustomSet<>(Collections.singletonList('1'));
+        CustomSet<Character> secondCustomSet = new CustomSet<>(Collections.emptyList());
+        assertTrue(customSet.isDisjoint(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setsAreNotDisjointIfTheyShareAnElement() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2))
-                        .isDisjoint(
-                                new CustomSet<>(Arrays.asList(2, 3))
-                        );
-
-        assertFalse(actual);
+        CustomSet<Character> customSet = new CustomSet<>(Arrays.asList('1', '2'));
+        CustomSet<Character> secondCustomSet = new CustomSet<>(Arrays.asList('2', '3'));
+        assertFalse(customSet.isDisjoint(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setsAreDisjointIfTheyShareNoElements() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2))
-                        .isDisjoint(
-                                new CustomSet<>(Arrays.asList(3, 4))
-                        );
-
-        assertTrue(actual);
+        CustomSet<String> customSet = new CustomSet<>(Arrays.asList("1", "2"));
+        CustomSet<String> secondCustomSet = new CustomSet<>(Arrays.asList("3", "4"));
+        assertTrue(customSet.isDisjoint(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void emptySetsAreEqual() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .equals(
-                                new CustomSet<>(Collections.emptyList())
-                        );
-
-        assertTrue(actual);
+        CustomSet<String> customSet = new CustomSet<>(Collections.emptyList());
+        CustomSet<String> secondCustomSet = new CustomSet<>(Collections.emptyList());
+        assertTrue(customSet.equals(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void emptySetIsNotEqualToNonEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Collections.emptyList())
-                        .equals(
-                                new CustomSet<>(Arrays.asList(1, 2, 3))
-                        );
-
-        assertFalse(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Collections.emptyList());
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Arrays.asList(1, 2, 3));
+        assertFalse(customSet.equals(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nonEmptySetIsNotEqualToEmptySet() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3))
-                        .equals(
-                                new CustomSet<>(Collections.emptyList())
-                        );
-
-        assertFalse(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Arrays.asList(1, 2, 3));
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Collections.emptyList());
+        assertFalse(customSet.equals(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setsWithTheSameElementsAreEqual() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2))
-                        .equals(
-                                new CustomSet<>(Arrays.asList(2, 1))
-                        );
-
-        assertTrue(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Arrays.asList(1, 2));
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Arrays.asList(2, 1));
+        assertTrue(customSet.equals(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void setsWithDifferentElementsAreNotEqual() {
-        final boolean actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3))
-                        .equals(
-                                new CustomSet<>(Arrays.asList(1, 2, 4))
-                        );
-
-        assertFalse(actual);
+        CustomSet<Integer> customSet = new CustomSet<>(Arrays.asList(1, 2, 3));
+        CustomSet<Integer> secondCustomSet = new CustomSet<>(Arrays.asList(2, 1, 4));
+        assertFalse(customSet.equals(secondCustomSet));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void addToEmptySet() {
-        final int element = 3;
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Collections.singletonList(element))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Collections.emptyList());
+        char element = '3';
+        CustomSet<Character> expected = new CustomSet<>(Collections.unmodifiableList(Collections.singletonList(element)));
+        CustomSet<Character> actual = new CustomSet<>(Collections.emptyList());
 
         actual.add(element);
 
     @Ignore("Remove to run test")
     @Test
     public void addToNonEmptySet() {
-        final int element = 3;
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(1, 2, 3, 4))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 2, 4));
+        int element = 3;
+        CustomSet<Integer> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList(1, 2, 3, 4)));
+        CustomSet<Integer> actual = new CustomSet<>(Arrays.asList(1, 2, 4));
 
         actual.add(element);
 
     @Ignore("Remove to run test")
     @Test
     public void addingAnExistingElementDoesNotChangeTheSet() {
-        final int element = 3;
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(1, 2, 3))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3));
+        String element = "3";
+        CustomSet<String> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList("1", "2", "3")));
+        CustomSet<String> actual = new CustomSet<>(Arrays.asList("1", "2", "3"));
 
         actual.add(element);
 
     @Ignore("Remove to run test")
     @Test
     public void intersectionOfTwoEmptySetsIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<Integer>(Collections.emptyList())
-                        .getIntersection(
-                                new CustomSet<>(Collections.emptyList())
-                        );
+        CustomSet<Integer> actual = new CustomSet<Integer>(Collections.emptyList())
+                .getIntersection(new CustomSet<>(Collections.emptyList()));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void intersectionOfAnEmptySetAndNonEmptySetIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<Integer>(Collections.emptyList())
-                        .getIntersection(
-                                new CustomSet<>(Arrays.asList(3, 2, 5))
-                        );
+        CustomSet<Integer> actual = new CustomSet<Integer>(Collections.emptyList())
+                .getIntersection(new CustomSet<>(Arrays.asList(3, 2, 5)));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void intersectionOfANonEmptySetAndAnEmptySetIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3, 4))
-                        .getIntersection(
-                                new CustomSet<>(Collections.emptyList())
-                        );
+        CustomSet<Character> actual = new CustomSet<>(Arrays.asList('1', '2', '3', '4'))
+                .getIntersection(new CustomSet<>(Collections.emptyList()));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void intersectionOfTwoSetsWithNoSharedElementsIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3))
-                        .getIntersection(
-                                new CustomSet<>(Arrays.asList(4, 5, 6))
-                        );
+        CustomSet<Integer> actual = new CustomSet<>(Arrays.asList(1, 2, 3))
+                .getIntersection(new CustomSet<>(Arrays.asList(4, 5, 6)));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void intersectionOfTwoSetsWithSharedElementsIsASetOfTheSharedElements() {
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(2, 3))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3, 4))
-                        .getIntersection(
-                                new CustomSet<>(Arrays.asList(3, 2, 5))
-                        );
+        CustomSet<Integer> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList(2, 3)));
+        CustomSet<Integer> actual = new CustomSet<>(Arrays.asList(1, 2, 3, 4))
+                .getIntersection(new CustomSet<>(Arrays.asList(3, 2, 5)));
 
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void differenceOfTwoEmptySetsIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<Integer>(Collections.emptyList())
-                        .getDifference(
-                                new CustomSet<>(Collections.emptyList())
-                        );
+        CustomSet<Integer> actual = new CustomSet<Integer>(Collections.emptyList())
+                .getDifference(new CustomSet<>(Collections.emptyList()));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void differenceOfAnEmptySetAndNonEmptySetIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<Integer>(Collections.emptyList())
-                        .getDifference(
-                                new CustomSet<>(Arrays.asList(3, 2, 5))
-                        );
+        CustomSet<String> actual = new CustomSet<String>(Collections.emptyList())
+                .getDifference(new CustomSet<>(Arrays.asList("3", "2", "5")));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void differenceOfANonEmptySetAndAnEmptySetIsTheNonEmptySet() {
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(1, 2, 3, 4))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 2, 3, 4))
-                        .getDifference(
-                                new CustomSet<>(Collections.emptyList())
-                        );
+        CustomSet<Integer> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList(1, 2, 3, 4)));
+        CustomSet<Integer> actual = new CustomSet<>(Arrays.asList(1, 2, 3, 4))
+                .getDifference(new CustomSet<>(Collections.emptyList()));
 
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void differenceOfTwoNonEmptySetsIsASetOfElementsThatAreOnlyInTheFirstSet() {
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(1, 3))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(3, 2, 1))
-                        .getDifference(
-                                new CustomSet<>(Arrays.asList(2, 4))
-                        );
+        CustomSet<Integer> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList(1, 3)));
+        CustomSet<Integer> actual = new CustomSet<>(Arrays.asList(3, 2, 1))
+                .getDifference(new CustomSet<>(Arrays.asList(2, 4)));
 
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void unionOfTwoEmptySetsIsAnEmptySet() {
-        final CustomSet<Integer> actual
-                = new CustomSet<Integer>(Collections.emptyList())
-                        .getUnion(
-                                new CustomSet<>(Collections.emptyList())
-                        );
+        CustomSet<Integer> actual = new CustomSet<Integer>(Collections.emptyList())
+                .getUnion(new CustomSet<>(Collections.emptyList()));
 
         assertNotNull(actual);
         assertTrue(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void unionOfAnEmptySetAndNonEmptySetIsTheNonEmptySet() {
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Collections.singletonList(2))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<Integer>(Collections.emptyList())
-                        .getUnion(
-                                new CustomSet<>(Collections.singletonList(2))
-                        );
+        CustomSet<Integer> expected = new CustomSet<>(Collections.unmodifiableList(Collections.singletonList(2)));
+        CustomSet<Integer> actual = new CustomSet<Integer>(Collections.emptyList())
+                .getUnion(new CustomSet<>(Collections.singletonList(2)));
 
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void unionOfANonEmptySetAndAnEmptySetIsTheNonEmptySet() {
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(1, 3))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 3))
-                        .getUnion(
-                                new CustomSet<>(Collections.emptyList())
-                        );
+        CustomSet<Integer> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList(1, 3)));
+        CustomSet<Integer> actual = new CustomSet<>(Arrays.asList(1, 3))
+                .getUnion(new CustomSet<>(Collections.emptyList()));
 
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
     @Ignore("Remove to run test")
     @Test
     public void unionOfTwoNonEmptySetsContainsAllUniqueElements() {
-        final CustomSet<Integer> expected
-                = new CustomSet<>(
-                        Collections.unmodifiableList(Arrays.asList(3, 2, 1))
-                );
-        final CustomSet<Integer> actual
-                = new CustomSet<>(Arrays.asList(1, 3))
-                        .getUnion(
-                                new CustomSet<>(Arrays.asList(2, 3))
-                        );
+        CustomSet<Character> expected = new CustomSet<>(Collections.unmodifiableList(Arrays.asList('3', '2', '1')));
+        CustomSet<Character> actual = new CustomSet<>(Arrays.asList('1', '3'))
+                .getUnion(new CustomSet<>(Arrays.asList('2', '3')));
 
         assertNotNull(actual);
         assertFalse(actual.isEmpty());