migrate tests to AssertJ

build.gradle.kts

@@ -27,31 +27,40 @@ repositories {
 }
 
 sourceSets {
+    create("common") {
+        compileClasspath += sourceSets.main.get().output
+    }
     create("example") {
         compileClasspath += sourceSets.main.get().output
         runtimeClasspath += sourceSets.main.get().output
     }
     create("intTest") {
-        compileClasspath += sourceSets.main.get().output
-        runtimeClasspath += sourceSets.main.get().output
+        compileClasspath += sourceSets["common"].output
+        runtimeClasspath += sourceSets["common"].output
+    }
+    test {
+        compileClasspath += sourceSets["common"].output
+        runtimeClasspath += sourceSets["common"].output
     }
 }
 
-val intTestImplementation by configurations.getting {
+val commonImplementation by configurations.getting {
     extendsFrom(configurations.implementation.get())
 }
-val intTestRuntimeOnly by configurations.getting
 
-configurations["intTestRuntimeOnly"].extendsFrom(configurations.runtimeOnly.get())
+val intTest by sourceSets.getting
+configurations[intTest.implementationConfigurationName].extendsFrom(configurations.testImplementation.get())
+configurations[intTest.runtimeOnlyConfigurationName].extendsFrom(configurations.testRuntimeOnly.get())
 
 dependencies {
+    commonImplementation("org.assertj:assertj-core:3.24.2")
+
     testImplementation(platform("org.junit:junit-bom:5.9.3"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testImplementation("org.assertj:assertj-core:3.24.2")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 
-    intTestImplementation(platform("org.junit:junit-bom:5.9.3"))
-    intTestImplementation("org.junit.jupiter:junit-jupiter")
-    intTestRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    "intTestImplementation"(project)
 
     signature("com.toasttab.android:gummy-bears-api-33:0.5.1@signature")
 }
@@ -67,6 +76,21 @@ tasks.test {
     finalizedBy(tasks.jacocoTestReport)
 }
 
+val intTestTask = tasks.register<Test>("intTest") {
+    group = "verification"
+    useJUnitPlatform()
+
+    testClassesDirs = intTest.output.classesDirs
+    classpath = sourceSets["intTest"].runtimeClasspath
+
+    finalizedBy(tasks.jacocoTestReport)
+    shouldRunAfter(tasks.test)
+}
+
+tasks.check {
+    dependsOn(intTestTask)
+}
+
 pitest {
     junit5PluginVersion = "1.1.2"
     targetClasses = setOf("blackbox.*", "de.siegmar.*")
@@ -80,12 +104,15 @@ pmd {
 }
 
 tasks.jacocoTestReport {
+    executionData = files(fileTree(buildDir).include("/jacoco/*.exec"))
     reports {
         xml.required.set(true)
     }
+    dependsOn(intTestTask)
 }
 
 tasks.jacocoTestCoverageVerification {
+    executionData = files(fileTree(buildDir).include("/jacoco/*.exec"))
     violationRules {
         rule {
             limit {
@@ -95,6 +122,7 @@ tasks.jacocoTestCoverageVerification {
             }
         }
     }
+    dependsOn(intTestTask)
 }
 
 tasks.jmh {

config/checkstyle/suppressions.xml

@@ -3,6 +3,7 @@
 <suppressions>
 
     <suppress files=".*Test.java" checks="(MagicNumber|MissingJavadocType|MissingJavadocMethod)"/>
+    <suppress files="testutil/.*" checks="(MissingJavadocType|MissingJavadocMethod|JavadocVariable)"/>
     <suppress files=".*Benchmark.java" checks="(MissingJavadocType|MissingJavadocMethod)"/>
     <suppress files=".*Example.java" checks="(MissingJavadocType|MissingJavadocMethod|UncommentedMain|HideUtilityClassConstructor|RegexpMultiline)"/>
 

src/common/java/module-info.java

@@ -0,0 +1,8 @@
+module common {
+
+    requires de.siegmar.fastcsv;
+    requires org.assertj.core;
+
+    exports testutil;
+
+}

src/common/java/testutil/CsvRowAssert.java

@@ -0,0 +1,55 @@
+package testutil;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.InstanceOfAssertFactory;
+import org.assertj.core.api.ListAssert;
+
+import de.siegmar.fastcsv.reader.CsvRow;
+
+public class CsvRowAssert extends AbstractAssert<CsvRowAssert, CsvRow> {
+
+    public static final InstanceOfAssertFactory<CsvRow, CsvRowAssert> CSV_ROW =
+        new InstanceOfAssertFactory<>(CsvRow.class, CsvRowAssert::assertThat);
+
+    protected CsvRowAssert(final CsvRow actual) {
+        super(actual, CsvRowAssert.class);
+    }
+
+    public static CsvRowAssert assertThat(final CsvRow actual) {
+        return new CsvRowAssert(actual);
+    }
+
+    public CsvRowAssert isOriginalLineNumber(final long originalLineNumber) {
+        isNotNull();
+        if (actual.getOriginalLineNumber() != originalLineNumber) {
+            failWithMessage("Expected original line number to be <%d> but was <%d>",
+                originalLineNumber, actual.getOriginalLineNumber());
+        }
+
+        return this;
+    }
+
+    public CsvRowAssert isComment(final boolean comment) {
+        isNotNull();
+        if (actual.isComment() != comment) {
+            failWithMessage("Expected comment to be <%b> but was <%b>",
+                comment, actual.isComment());
+        }
+
+        return this;
+    }
+
+    public CsvRowAssert isComment() {
+        return isComment(true);
+    }
+
+    public CsvRowAssert isNotComment() {
+        return isComment(false);
+    }
+
+    public ListAssert<String> fields() {
+        isNotNull();
+        return new ListAssert<>(actual.getFields());
+    }
+
+}

src/common/java/testutil/NamedCsvRowAssert.java

@@ -0,0 +1,43 @@
+package testutil;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.InstanceOfAssertFactory;
+import org.assertj.core.api.MapAssert;
+import org.assertj.core.api.StringAssert;
+
+import de.siegmar.fastcsv.reader.NamedCsvRow;
+
+public class NamedCsvRowAssert extends AbstractAssert<NamedCsvRowAssert, NamedCsvRow> {
+
+    public static final InstanceOfAssertFactory<NamedCsvRow, NamedCsvRowAssert> NAMED_CSV_ROW =
+        new InstanceOfAssertFactory<>(NamedCsvRow.class, NamedCsvRowAssert::assertThat);
+
+    protected NamedCsvRowAssert(final NamedCsvRow actual) {
+        super(actual, NamedCsvRowAssert.class);
+    }
+
+    public static NamedCsvRowAssert assertThat(final NamedCsvRow actual) {
+        return new NamedCsvRowAssert(actual);
+    }
+
+    public NamedCsvRowAssert isOriginalLineNumber(final long originalLineNumber) {
+        isNotNull();
+        if (actual.getOriginalLineNumber() != originalLineNumber) {
+            failWithMessage("Expected original line number to be <%d> but was <%d>",
+                originalLineNumber, actual.getOriginalLineNumber());
+        }
+
+        return this;
+    }
+
+    public MapAssert<String, String> fields() {
+        isNotNull();
+        return new MapAssert<>(actual.getFields());
+    }
+
+    public StringAssert field(final String name) {
+        isNotNull();
+        return new StringAssert(actual.getField(name));
+    }
+
+}

src/intTest/java/blackbox/reader/CsvReaderBuilderTest.java

@@ -1,28 +1,25 @@
 package blackbox.reader;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static testutil.CsvRowAssert.CSV_ROW;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.NullSource;
 
 import de.siegmar.fastcsv.reader.CommentStrategy;
 import de.siegmar.fastcsv.reader.CsvReader;
 import de.siegmar.fastcsv.reader.CsvRow;
+import testutil.CsvRowAssert;
 
 @SuppressWarnings("PMD.CloseResource")
 class CsvReaderBuilderTest {
@@ -32,67 +29,79 @@ class CsvReaderBuilderTest {
 
     private final CsvReader.CsvReaderBuilder crb = CsvReader.builder();
 
-    @ParameterizedTest
-    @NullSource
-    void nullInput(final String text) {
-        assertThrows(NullPointerException.class, () -> crb.build(text));
+    @Test
+    void nullInput() {
+        assertThatThrownBy(() -> crb.build((String) null))
+            .isInstanceOf(NullPointerException.class);
     }
 
     @Test
     void fieldSeparator() {
         final Iterator<CsvRow> it = crb.fieldSeparator(';')
             .build("foo,bar;baz").iterator();
-        assertEquals(Arrays.asList("foo,bar", "baz"), it.next().getFields());
+        assertThat(it).toIterable()
+            .singleElement(CSV_ROW)
+            .isOriginalLineNumber(1)
+            .isNotComment()
+            .fields().containsExactly("foo,bar", "baz");
     }
 
     @Test
     void quoteCharacter() {
         final Iterator<CsvRow> it = crb.quoteCharacter('_')
             .build("_foo \", __ bar_,foo \" bar").iterator();
-        assertEquals(Arrays.asList("foo \", _ bar", "foo \" bar"), it.next().getFields());
+        assertThat(it).toIterable()
+            .singleElement(CSV_ROW)
+            .isOriginalLineNumber(1)
+            .isNotComment()
+            .fields().containsExactly("foo \", _ bar", "foo \" bar");
     }
 
     @Test
     void commentSkip() {
         final Iterator<CsvRow> it = crb.commentCharacter(';').commentStrategy(CommentStrategy.SKIP)
             .build("#foo\n;bar\nbaz").iterator();
-        assertEquals(Collections.singletonList("#foo"), it.next().getFields());
-        assertEquals(Collections.singletonList("baz"), it.next().getFields());
+        assertThat(it).toIterable()
+            .satisfiesExactly(
+                item1 -> CsvRowAssert.assertThat(item1)
+                    .isOriginalLineNumber(1)
+                    .isNotComment()
+                    .fields().containsExactly("#foo"),
+                item2 -> CsvRowAssert.assertThat(item2)
+                    .isOriginalLineNumber(3)
+                    .isNotComment()
+                    .fields().containsExactly("baz"));
     }
 
     @Test
     void builderToString() {
-        assertEquals("CsvReaderBuilder[fieldSeparator=,, quoteCharacter=\", "
-            + "commentStrategy=NONE, commentCharacter=#, skipEmptyRows=true, "
-            + "errorOnDifferentFieldCount=false]", crb.toString());
-    }
-
-    @Test
-    void reader() {
-        final List<CsvRow> list = crb
-            .build(DATA).stream()
-            .collect(Collectors.toList());
-        assertEquals(EXPECTED, list.get(0).getFields());
+        assertThat(crb).asString()
+            .isEqualTo("CsvReaderBuilder[fieldSeparator=,, quoteCharacter=\", "
+                + "commentStrategy=NONE, commentCharacter=#, skipEmptyRows=true, "
+                + "errorOnDifferentFieldCount=false]");
     }
 
     @Test
     void string() {
-        final List<CsvRow> list = crb.build(DATA).stream()
-            .collect(Collectors.toList());
-        assertEquals(EXPECTED, list.get(0).getFields());
+        assertThat(crb.build(DATA).stream())
+            .singleElement(CSV_ROW)
+            .isOriginalLineNumber(1)
+            .isNotComment()
+            .fields().isEqualTo(EXPECTED);
     }
 
     @Test
     void path(@TempDir final Path tempDir) throws IOException {
         final Path file = tempDir.resolve("fastcsv.csv");
         Files.write(file, DATA.getBytes(UTF_8));
 
-        final List<CsvRow> list;
         try (Stream<CsvRow> stream = crb.build(file).stream()) {
-            list = stream.collect(Collectors.toList());
+            assertThat(stream)
+                .singleElement(CSV_ROW)
+                .isOriginalLineNumber(1)
+                .isNotComment()
+                .fields().isEqualTo(EXPECTED);
         }
-
-        assertEquals(EXPECTED, list.get(0).getFields());
     }
 
     @Test
@@ -106,7 +115,7 @@ void chained() {
             .errorOnDifferentFieldCount(false)
             .build("foo");
 
-        assertNotNull(reader);
+        assertThat(reader).isNotNull();
     }
 
 }