Implemented first version of JoinAssertThatStatements inspection that will try to merge assertThat() statements with the same actual object together, preserving comments.

src/test/java/de/platon42/intellij/playground/Playground.java

@@ -4,10 +4,7 @@ import org.assertj.core.api.ListAssert;
 import org.assertj.core.data.Offset;
 import org.assertj.core.extractor.Extractors;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;
@@ -38,6 +35,39 @@ public class Playground {
         assertThat(new Long[1]).as("etc").hasSameSizeAs(new Long[2]);
     }
 
+    private void joinStatements() {
+        List<String> list = new ArrayList<>();
+        assertThat(list).as("foo").hasSize(2);
+        assertThat(list).as("bar").contains("barbar"); // comment to keep
+        assertThat(list).as("etc").contains("etcetc");
+
+        // moar!
+        assertThat(list).doesNotContain("foobar");
+
+        assertThat("narf").isNotEqualTo("puit");
+        assertThat(list).as("bar").contains("barbar");
+        assertThat(list).as("foo").hasSize(2);
+        assertThat(list).as("evil").extracting(String::length).contains(2);
+
+        assertThat(list).as("bar").contains("barbar");
+        assertThat("narf").isNotEqualTo("puit");
+        assertThat(list).as("foo").hasSize(2);
+        if (true) {
+            assertThat(list).doesNotContain("narf");
+            assertThat(list).as("bar").contains("barbar");
+        }
+        assertThat(list.get(0)).isNotEmpty();
+        assertThat(list.get(0)).hasSize(3);
+        assertThat(list.get(0)).isEqualTo("bar");
+
+        assertThat(list.get(0) + "foo").isEqualTo("bar");
+        assertThat(list.get(0) + "foo").doesNotStartWith("foo");
+
+        Iterator<String> iterator = list.iterator();
+        assertThat(iterator.next()).isEqualTo("foo");
+        assertThat(iterator.next()).isEqualTo("bar");
+    }
+
     private void sizeOfArray() {
         assertThat(new String[1].length).isLessThanOrEqualTo(1);
         assertThat(new String[1]).hasSameSizeAs(new Object());

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt

@@ -0,0 +1,21 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.junit.jupiter.api.Test
+
+internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/JoinStatements")
+    internal fun assertThat_size_of_array_or_collection_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        runTest {
+            myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
+            myFixture.configureByFile("JoinStatementsBefore.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 6)
+            myFixture.checkResultByFile("JoinStatementsAfter.java")
+        }
+    }
+}

src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java

@@ -0,0 +1,40 @@
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JoinStatements {
+
+    private void joinStatements() {
+        List<String> list = new ArrayList<>();
+        // the future is always born in pain
+        /* tricky */
+        assertThat(list).as("foo").hasSize(2)
+                /* do another */
+                /* do one */.as("bar").contains("barbar")
+                // comment to keep
+                .doesNotContain("barbara") // another comment to keep
+                .doesNotContain("wrzlbrmpft")
+                /* and a multi line comment
+                    after the statement */
+                // across two lines
+                .as("etc")/* what a nasty comment */.contains("etcetc")
+                // moar!
+                .doesNotContain("foobar");
+
+        assertThat("narf").isNotEqualTo("puit").as("bar").contains("barbar").as("foo").hasSize(2);
+        assertThat(list).as("evil").extracting(String::length).contains(2);
+
+        assertThat(list).as("bar").contains("barbar");
+        assertThat("narf").isNotEqualTo("puit").as("foo").hasSize(2);
+        if (true) {
+            assertThat(list).doesNotContain("narf").as("bar").contains("barbar");
+        }
+        assertThat(list.get(0)).isNotEmpty().hasSize(3).isEqualTo("bar");
+
+        assertThat(list.get(0) + "foo").isEqualTo("bar").doesNotStartWith("foo");
+
+        Iterator<String> iterator = list.iterator();
+        assertThat(iterator.next()).isEqualTo("foo");
+        assertThat(iterator.next()).isEqualTo("bar");
+    }
+}

src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java

@@ -0,0 +1,44 @@
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JoinStatements {
+
+    private void joinStatements() {
+        List<String> list = new ArrayList<>();
+        // the future is always born in pain
+        /* tricky */assertThat(list).as("foo").hasSize(2); /* do one */ /* do another */
+        assertThat(list).as("bar").contains("barbar"); // comment to keep
+        assertThat(list).doesNotContain("barbara") // another comment to keep
+                .doesNotContain("wrzlbrmpft") // across two lines
+        ; /* and a multi line comment
+        after the statement */
+        assertThat(list).as("etc")/* what a nasty comment */.contains("etcetc");
+
+        // moar!
+        assertThat(list).doesNotContain("foobar");
+
+        assertThat("narf").isNotEqualTo("puit");
+        assertThat(list).as("bar").contains("barbar");
+        assertThat(list).as("foo").hasSize(2);
+        assertThat(list).as("evil").extracting(String::length).contains(2);
+
+        assertThat(list).as("bar").contains("barbar");
+        assertThat("narf").isNotEqualTo("puit");
+        assertThat(list).as("foo").hasSize(2);
+        if (true) {
+            assertThat(list).doesNotContain("narf");
+            assertThat(list).as("bar").contains("barbar");
+        }
+        assertThat(list.get(0)).isNotEmpty();
+        assertThat(list.get(0)).hasSize(3);
+        assertThat(list.get(0)).isEqualTo("bar");
+
+        assertThat(list.get(0) + "foo").isEqualTo("bar");
+        assertThat(list.get(0) + "foo").doesNotStartWith("foo");
+
+        Iterator<String> iterator = list.iterator();
+        assertThat(iterator.next()).isEqualTo("foo");
+        assertThat(iterator.next()).isEqualTo("bar");
+    }
+}