refurbish unit tests with method source, better names and assertj

Author: Abductcows

pom.xml

@@ -24,23 +24,30 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.1.0</version>
+            <version>5.8.2</version>
             <scope>test</scope>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-params</artifactId>
-            <version>5.1.0</version>
+            <version>5.8.2</version>
             <scope>test</scope>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.jetbrains</groupId>
             <artifactId>annotations</artifactId>
-            <version>22.0.0</version>
+            <version>23.0.0</version>
             <scope>compile</scope>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.assertj/assertj-core -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.21.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

src/test/java/gr/geompokon/bitarray/BitArrayTest.java

@@ -16,106 +16,143 @@
 
 package gr.geompokon.bitarray;
 
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.*;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 import java.util.UnknownFormatConversionException;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+@DisplayName("BitArray Unit Tests")
 class BitArrayTest {
 
     static BitArray bitArray;
-    static ArrayList<Boolean> boolArray;
-    static Random random;
 
-    /**
-     * Start each test with a fresh array
-     */
+    static final int SEED = 101;
+    static final Random consistentRandom = new Random(SEED);
+
     @BeforeEach
     void setUp() {
         bitArray = new BitArray();
-        boolArray = new ArrayList<>();
-        random = new Random();
     }
 
-    /**
-     * Clears both arrays and adds the same {@code noOfElements} random booleans to both. That is, a call to
-     * boolArray.equals(bitArray) is always successful afterwards
-     *
-     * @param noOfElements number of random booleans to be added
-     */
-    void initArrays(int noOfElements) {
-        bitArray.clear();
-        boolArray.clear();
-        for (int i = 0; i < noOfElements; i++) {
-            boolean element = random.nextBoolean();
-            bitArray.add(element);
-            boolArray.add(element);
+
+    @Nested
+    @DisplayName("Copy tests")
+    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+    class CopyTests {
+
+        @ParameterizedTest(name = "{0} elements")
+        @DisplayName("Result of copy constructor should have the same elements")
+        @MethodSource("gr.geompokon.bitarray.BitArrayTest#testCaseBooleans")
+        void copy_constructor_returns_identical_list(List<Boolean> elementsToAdd) {
+            // given
+            bitArray.addAll(elementsToAdd);
+
+            // when
+            BitArray copy = new BitArray(bitArray);
+
+            // then
+            assertThat(copy).isEqualTo(bitArray);
         }
-    }
 
-    /**
-     * Asserts that the two lists have the same exact contents
-     */
-    void myAssertSameArrays() {
-        for (int i = 0; i < boolArray.size(); i++) {
-            assertEquals(boolArray.get(i), bitArray.get(i));
+        @ParameterizedTest(name = "{0} elements")
+        @DisplayName("Result of copy constructor should be a separate object")
+        @MethodSource("gr.geompokon.bitarray.BitArrayTest#testCaseBooleans")
+        void copy_constructor_returns_new_Object(List<Boolean> elementsToAdd) {
+            // given
+            bitArray.addAll(elementsToAdd);
+
+            // when
+            BitArray copy = new BitArray(bitArray);
+
+            // then
+            assertThat(copy == bitArray).isFalse();
         }
-    }
 
-    /**
-     * Make the bit array from the boolean array
-     */
-    @ParameterizedTest
-    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
-    @DisplayName("Copy constructor result should have same size and elements")
-    void testCopyConstructor(int elementsToAdd) {
-        initArrays(elementsToAdd);
-        bitArray = new BitArray(boolArray);
-
-        myAssertSameArrays();
-    }
 
-    @ParameterizedTest
-    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
-    @DisplayName("Result of clone() should have the same elements")
-    void testClone(int elementsToAdd) {
-        initArrays(elementsToAdd);
-        BitArray clone = bitArray.clone();
+        @ParameterizedTest(name = "{0} elements")
+        @DisplayName("Result of clone() should have the same elements")
+        @MethodSource("gr.geompokon.bitarray.BitArrayTest#testCaseBooleans")
+        void clone_returns_identical_list(List<Boolean> elementsToAdd) {
+            // given
+            bitArray.addAll(elementsToAdd);
+
+            // when
+            BitArray copy = bitArray.clone();
 
-        assertEquals(bitArray, clone);
+            // then
+            assertThat(copy).isEqualTo(bitArray);
+        }
+
+
+        @ParameterizedTest(name = "{0} elements")
+        @DisplayName("Result of clone should be a separate object")
+        @MethodSource("gr.geompokon.bitarray.BitArrayTest#testCaseBooleans")
+        void clone_returns_new_Object(List<Boolean> elementsToAdd) {
+            // given
+            bitArray.addAll(elementsToAdd);
+
+            // when
+            BitArray copy = bitArray.clone();
+
+            // then
+            assertThat(copy == bitArray).isFalse();
+        }
     }
 
 
-    @ParameterizedTest
-    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
-    @DisplayName("Serialized and immediately deserialized array should be the same as original")
-    void testToFromString(int elementsToAdd) {
-        // test array with elements
-        initArrays(elementsToAdd);
-        BitArray copy = BitArray.fromString(bitArray.toString());
+    @Nested
+    @DisplayName("Serialization Tests")
+    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+    class SerializationTests {
+
+        @ParameterizedTest(name = "{0} elements")
+        @DisplayName("Serialized and immediately deserialized array should be the same as original")
+        @MethodSource("gr.geompokon.bitarray.BitArrayTest#testCaseBooleans")
+        void toString_and_fromString_do_not_alter_content(List<Boolean> elementsToAdd) {
+            // given
+            bitArray.addAll(elementsToAdd);
 
-        assertEquals(bitArray, copy);
+            // when
+            String serialized = bitArray.toString();
+            BitArray deserialized = BitArray.fromString(serialized);
+
+            // then
+            assertThat(deserialized).isEqualTo(bitArray);
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"[0 1]", "Size = 2, [true true]", "Size =z, [0 1]", "Size = 3, [0 1]"})
+        @DisplayName("Bad strings should throw specific exceptions")
+        void fromString_throws_on_bad_string(String faultyString) {
+            // when/then
+            assertThatThrownBy(() -> {
+                BitArray impossibleList = BitArray.fromString(faultyString);
+                System.out.println(impossibleList);
+                impossibleList.add(Boolean.FALSE);
+            }).isInstanceOf(UnknownFormatConversionException.class);
+        }
     }
 
-    @ParameterizedTest
-    @ValueSource(strings = {"[0 1]", "Size = 2, [true true]", "Size =z, [0 1]", "Size = 3, [0 1]"})
-    @DisplayName("Bad strings should throw specific exceptions")
-    void testBadFromString(String faultyString) {
-        try {
-            BitArray.fromString(faultyString);
-        } catch (Exception e) {
-            if (!(e instanceof UnknownFormatConversionException
-                    || e instanceof IndexOutOfBoundsException
-                    || e instanceof NumberFormatException)) {
-                fail(e);
-            }
+
+    static Stream<Named<List<Boolean>>> testCaseBooleans() {
+        synchronized (consistentRandom) {
+            consistentRandom.setSeed(SEED);
+            return Stream.of(
+                    Named.of("0", List.of()),
+                    Named.of("1", List.of(Boolean.FALSE)),
+                    Named.of("2", List.of(Boolean.TRUE, Boolean.FALSE)),
+                    Named.of("5", List.of(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE)),
+                    Named.of("100", Stream.generate(consistentRandom::nextBoolean).limit(100).collect(Collectors.toList()))
+            );
         }
     }
 }