Changes to tests and benchmarks

- Added parameters to tests and cleaned them up a little
- Removed Benchmark test (replaced with benchmark repo @ https://github.com/Abductcows/bit-array-benchmarks)

Author: George Bouroutzoglou

pom.xml

@@ -7,7 +7,7 @@
 
     <groupId>gr.geompokon</groupId>
     <artifactId>bit-array</artifactId>
-    <version>1.0.1</version>
+    <version>1.0.2</version>
 
     <name>BitArray</name>
     <description>Java List of Booleans class with reduced memory usage and higher performance</description>
@@ -25,6 +25,14 @@
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
             <version>5.1.0</version>
+            <scope>test</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>5.1.0</version>
+            <scope>test</scope>
             <optional>true</optional>
         </dependency>
     </dependencies>

src/main/java/gr/geompokon/bitarray/BitArray.java

@@ -50,7 +50,7 @@
  * not follow the one bit per entry principle.
  * </p>
  *
- * @version 1.0.1
+ * @version 1.0.2
  * @see java.util.List
  * @see java.util.AbstractList
  * @see java.util.ArrayList

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

@@ -17,7 +17,9 @@
 package gr.geompokon.bitarray;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -27,8 +29,6 @@
 
 class BitArrayInterfaceTest {
 
-    final static int MAX_TEST_SIZE = 200;
-
     static List<Boolean> bitArray;
     static List<Boolean> boolArray;
     static Random random;
@@ -71,9 +71,11 @@ void myAssertSameArrays() {
     /**
      * Random insertions at random indices
      */
-    @Test
-    void addAtIndex() {
-        for (int i = 0; i < MAX_TEST_SIZE; i++) {
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
+    @DisplayName("Lists should be the same when doing the same insertions")
+    void addAtIndex(int elementsToAdd) {
+        for (int i = 0; i < elementsToAdd; i++) {
             int index = random.nextInt(bitArray.size() + 1); // bound is exclusive
             boolean element = random.nextBoolean();
             bitArray.add(index, element);
@@ -85,15 +87,17 @@ void addAtIndex() {
     /**
      * Modification of elements at random indices
      */
-    @Test
-    void set() {
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
+    @DisplayName("Lists should be the same when doing the same set operations")
+    void set(int elementsToAdd) {
         // test empty array behaviour
         assertThrows(IndexOutOfBoundsException.class, () -> bitArray.set(0, true));
 
         // test with elements
-        initArrays(MAX_TEST_SIZE);
+        initArrays(elementsToAdd);
 
-        for (int i = 0; i < MAX_TEST_SIZE; i++) {
+        for (int i = 0; i < elementsToAdd; i++) {
             int index = random.nextInt(bitArray.size());
             Boolean negatedElement = !bitArray.get(index); // to ensure contents change
             bitArray.set(index, negatedElement);
@@ -106,49 +110,35 @@ void set() {
     /**
      * Remove of elements at random indices
      */
-    @Test
-    void remove() {
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
+    @DisplayName("Lists should be the same at any point while doing the same removes")
+    void remove(int elementsToAdd) {
         // test empty array behaviour
         assertThrows(IndexOutOfBoundsException.class, () -> bitArray.remove(0));
 
         // test with elements
-        initArrays(MAX_TEST_SIZE);
-        for (int i = 0; i < MAX_TEST_SIZE; i++) {
+        initArrays(elementsToAdd);
+        for (int i = 0; i < elementsToAdd; i++) {
             int index = random.nextInt(boolArray.size());
             assertEquals(boolArray.remove(index), bitArray.remove(index));
         }
     }
 
-    @Test
-    void clear() {
-        initArrays(10);
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
+    @DisplayName("Cleared array should be empty")
+    void clear(int elementsToAdd) {
+        initArrays(elementsToAdd);
         bitArray.clear();
         assertTrue(bitArray.isEmpty());
     }
 
-    @Test
-    void size() {
-        // test newly created array size
-        assertEquals(0, bitArray.size());
-
-        // add some elements
-        initArrays(MAX_TEST_SIZE);
-        int expectedSize = MAX_TEST_SIZE;
-        assertEquals(expectedSize, bitArray.size());
-
-        // remove some
-        int noToRemove = MAX_TEST_SIZE / 2;
-        bitArray.subList(0, noToRemove).clear();
-
-        expectedSize -= noToRemove;
-        assertEquals(expectedSize, bitArray.size());
-
-        // add back some
-        int noToAdd = MAX_TEST_SIZE / 2;
-        for (int i = 0; i < noToAdd; i++) {
-            bitArray.add(random.nextBoolean());
-        }
-        expectedSize += noToAdd;
-        assertEquals(expectedSize, bitArray.size());
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 5, 10, 50, 100})
+    @DisplayName("Number of elements should be the same as the number of insertions on new arrays")
+    void size(int elementsToAdd) {
+        initArrays(elementsToAdd);
+        assertEquals(elementsToAdd, bitArray.size());
     }
 }

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

@@ -17,17 +17,19 @@
 package gr.geompokon.bitarray;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.ArrayList;
 import java.util.Random;
+import java.util.UnknownFormatConversionException;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
 
 class BitArrayTest {
 
-    final static int MAX_TEST_SIZE = 200;
-
     static BitArray bitArray;
     static ArrayList<Boolean> boolArray;
     static Random random;
@@ -70,37 +72,50 @@ void myAssertSameArrays() {
     /**
      * Make the bit array from the boolean array
      */
-    @Test
-    void testCopyConstructor() {
-        initArrays(MAX_TEST_SIZE);
-        bitArray.clear();
-
+    @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();
     }
 
-    @Test
-    void testClone() {
-        initArrays(MAX_TEST_SIZE);
+    @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();
 
         assertEquals(bitArray, clone);
     }
 
-    @Test
-    void testToFromString() {
+
+    @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(MAX_TEST_SIZE);
-        String bitArrayStr = bitArray.toString();
-        BitArray copy = BitArray.fromString(bitArrayStr);
+        initArrays(elementsToAdd);
+        BitArray copy = BitArray.fromString(bitArray.toString());
 
         assertEquals(bitArray, copy);
+    }
 
-
-        // test empty array
-        bitArrayStr = new BitArray().toString();
-        copy = BitArray.fromString(bitArrayStr);
-
-        assertEquals(new BitArray(), copy);
+    @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);
+            }
+        }
     }
 }