Implemented AssertThatEnumerableIsEmptyInspection. Improved literal values by constant value calculation, more refactoring.

README.md

@@ -39,6 +39,9 @@ Then AssertJ would tell you the contents of the collection on failure.
   > from: assertThat(charSequence/string).isEqualTo("");
   > from: assertThat(charSequence/string).hasSize(0);
   >   to: assertThat(charSequence/string).isEmpty();
+- AssertThatEnumerableIsEmpty
+  > from: assertThat(enumerable).hasSize(0);
+  >   to: assertThat(charSequence/string).isEmpty();
 
 ## TODO
 - AssertThatArrayHasLiteralSize

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt

@@ -27,19 +27,22 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
         const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
         const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
-        const val IS_EQUAL_TO = "isEqualTo"
+        const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
-        const val IS_NOT_EQUAL_TO = "isNotEqualTo"
-        const val HAS_SIZE = "hasSize"
 
-        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO)
+        const val IS_EQUAL_TO_METHOD = "isEqualTo"
+        const val IS_NOT_EQUAL_TO_METHOD = "isNotEqualTo"
+        const val HAS_SIZE_METHOD = "hasSize"
+
+        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO)
+        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO_METHOD)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_EQUAL_TO)
+        val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
             .parameterTypes("boolean")!!
-        val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO)
+        val IS_NOT_EQUAL_TO_BOOLEAN =
-            .parameterTypes("boolean")!!
+            CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO_METHOD)
-        val CHAR_SEQUENCE_HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, HAS_SIZE)
+                .parameterTypes("boolean")!!
+        val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, HAS_SIZE_METHOD)
             .parameterTypes("int")!!
     }
 
@@ -77,4 +80,10 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
             ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
         )
     }
+
+    protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
+        val valueExpression = expression.argumentList.expressions[argIndex] ?: return null
+        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+        return constantEvaluationHelper.computeConstantExpression(valueExpression)
+    }
 }

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanIsTrueOrFalseInspection.kt

@@ -31,22 +31,21 @@ class AssertThatBooleanIsTrueOrFalseInspection : AbstractAssertJInspection() {
                     return
                 }
 
-                val equalToExpression = expression.argumentList.expressions[0]!!
+                val equalToExpression = expression.argumentList.expressions[0] ?: return
                 if (!TypeConversionUtil.isBooleanType(equalToExpression.type)) {
                     return
                 }
-                val constantEvaluationHelper = JavaPsiFacade.getInstance(holder.project).constantEvaluationHelper
+                var value = calculateConstantParameterValue(expression, 0)
-                var result = constantEvaluationHelper.computeConstantExpression(equalToExpression)
+                if (value == null) {
-                if (result == null) {
                     val field = (equalToExpression as? PsiReferenceExpression)?.resolve() as? PsiField
                     if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
                         when {
-                            field.name == "TRUE" -> result = true
+                            field.name == "TRUE" -> value = true
-                            field.name == "FALSE" -> result = false
+                            field.name == "FALSE" -> value = false
                         }
                     }
                 }
-                val expectedResult = result as? Boolean ?: return
+                val expectedResult = value as? Boolean ?: return
 
                 val replacementMethod = if (expectedResult xor flippedBooleanTest) "isTrue()" else "isFalse()"
                 registerSimplifyMethod(holder, expression, replacementMethod)

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt

@@ -0,0 +1,34 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
+import org.jetbrains.annotations.NonNls
+
+class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
+
+    companion object {
+        @NonNls
+        private val DISPLAY_NAME = "Asserting an enumerable is empty"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                val hasSize = HAS_SIZE.test(expression)
+                if (!hasSize) {
+                    return
+                }
+
+                val value = calculateConstantParameterValue(expression, 0) ?: return
+                if (value == 0) {
+                    registerSimplifyMethod(holder, expression, "isEmpty()")
+                }
+            }
+        }
+    }
+}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt

@@ -3,7 +3,6 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiLiteralExpression
 import com.intellij.psi.PsiMethodCallExpression
 import org.jetbrains.annotations.NonNls
 
@@ -21,7 +20,7 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
                 val isEqual = IS_EQUAL_TO_OBJECT.test(expression)
-                val hasSize = CHAR_SEQUENCE_HAS_SIZE.test(expression)
+                val hasSize = HAS_SIZE.test(expression)
                 if (!(isEqual || hasSize)) {
                     return
                 }
@@ -30,17 +29,9 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
                     return
                 }
 
-                if (isEqual) {
+                val value = calculateConstantParameterValue(expression, 0) ?: return
-                    val psiExpression = expression.argumentList.expressions[0] as? PsiLiteralExpression ?: return
+                if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
-
+                    registerSimplifyMethod(holder, expression, "isEmpty()")
-                    if (psiExpression.value == "") {
-                        registerSimplifyMethod(holder, expression, "isEmpty()")
-                    }
-                } else {
-                    val psiExpression = expression.argumentList.expressions[0] as? PsiLiteralExpression ?: return
-                    if (psiExpression.value == 0) {
-                        registerSimplifyMethod(holder, expression, "isEmpty()")
-                    }
                 }
             }
         }

src/main/resources/META-INF/plugin.xml

@@ -27,6 +27,9 @@
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanIsTrueOrFalseInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringIsEmptyInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true"
+                         level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatEnumerableIsEmptyInspection"/>
     </extensions>
 
     <actions>

src/main/resources/inspectionDescriptions/AssertThatBooleanIsTrueOrFalse.html

@@ -3,5 +3,6 @@
 Turns assertThat(booleanExpression).isEqualTo(true/false) or assertThat(booleanExpression).isNotEqualTo(true/false)
 into assertThat(booleanExpression).isTrue() or assertThat(booleanExpression).isFalse().
 <!-- tooltip end -->
+<br>Also works with Boolean.TRUE/FALSE.
 </body>
 </html>

src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html

@@ -0,0 +1,7 @@
+<html>
+<body>
+Turns assertThat(enumerable).hasSize(0) into assertThat(enumerable).isEmpty().
+<!-- tooltip end -->
+<br>Works with anything that is enumerable such as arrays, iterables, collections, etc.
+</body>
+</html>

src/main/resources/inspectionDescriptions/AssertThatStringIsEmpty.html

@@ -2,6 +2,6 @@
 <body>
 Turns assertThat(string).isEqualTo("") or assertThat(string).hasSize(0) into assertThat(string).isEmpty().
 <!-- tooltip end -->
-Also works with CharSequences.
+<br>Also works with CharSequences.
 </body>
 </html>

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

@@ -1,12 +1,26 @@
 package de.platon42.intellij.playground;
 
+import org.assertj.core.api.ListAssert;
+
 import java.util.ArrayList;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
 
 public class Playground {
 
     private void sizeOfList() {
+        assertThat("string").as("foo").hasSize(0);
+        assertThat(new StringBuilder()).as("bar").hasSize(0);
+        ListAssert<String> etc = assertThat(new ArrayList<String>()).as("etc");
+        etc.hasSize(0);
+        assertThat(new Long[1]).as("etc").hasSize(0);
+
+        assertThat("string").as("foo").isEmpty();
+        assertThat(new StringBuilder()).as("bar").isEmpty();
+        assertThat(new ArrayList<Long>()).as("etc").isEmpty();
+        assertThat(new Long[1]).as("etc").isEmpty();
+
         assertThat(new ArrayList<>().size()).isEqualTo(1);
     }
 
@@ -54,4 +68,15 @@ public class Playground {
         assertThat(foo).hasSize(0);
     }
 
+    private void junitAssertions() {
+        assertTrue(true);
+        assertTrue("message", true);
+        assertFalse(true);
+        assertFalse("message", true);
+        assertEquals(1L, 2L);
+        assertEquals("message", 1L, 2L);
+        assertNotEquals(1L, 2L);
+        assertNotEquals("message", 1L, 2L);
+    }
+
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.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 AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/EnumerableIsEmpty")
+    internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        runTest {
+            myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
+            myFixture.configureByFile("EnumerableIsEmptyBefore.java")
+            executeQuickFixes(myFixture, Regex("Replace hasSize.*"), 4)
+            myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
+        }
+    }
+}

src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java

@@ -0,0 +1,18 @@
+import java.util.ArrayList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EnumerableIsEmpty {
+
+    private void enumerableIsEmpty() {
+        assertThat("string").as("foo").isEmpty();
+        assertThat(new StringBuilder()).as("bar").isEmpty();
+        assertThat(new ArrayList<Long>()).as("etc").isEmpty();
+        assertThat(new Long[1]).as("etc").isEmpty();
+
+        assertThat("string").as("foo").hasSize(1);
+        assertThat(new StringBuilder()).as("bar").hasSize(1);
+        assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
+        assertThat(new Long[1]).as("etc").hasSize(1);
+    }
+}

src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java

@@ -0,0 +1,18 @@
+import java.util.ArrayList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EnumerableIsEmpty {
+
+    private void enumerableIsEmpty() {
+        assertThat("string").as("foo").hasSize(0);
+        assertThat(new StringBuilder()).as("bar").hasSize(0 + 0);
+        assertThat(new ArrayList<Long>()).as("etc").hasSize(10 / 100);
+        assertThat(new Long[1]).as("etc").hasSize(1 - 1);
+
+        assertThat("string").as("foo").hasSize(1);
+        assertThat(new StringBuilder()).as("bar").hasSize(1);
+        assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
+        assertThat(new Long[1]).as("etc").hasSize(1);
+    }
+}

src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java

@@ -11,7 +11,7 @@ public class StringIsEmpty {
         assertThat(string).as("bar").hasSize(0);
 
         assertThat(stringBuilder).isEqualTo("foo");
-        assertThat(stringBuilder).as("foo").isEqualTo("");
+        assertThat(stringBuilder).as("foo").isEqualTo("" + "");
         assertThat(stringBuilder).as("bar").hasSize(0);
 
         assertThat(new Object()).isEqualTo("");