diff --git a/README.md b/README.md index 29f37f5..9b05a29 100644 --- a/README.md +++ b/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 diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt index 26fbc6b..b6875f9 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt +++ b/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 IS_NOT_EQUAL_TO = "isNotEqualTo" - const val HAS_SIZE = "hasSize" + const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert" - 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) - .parameterTypes("boolean")!! - val CHAR_SEQUENCE_HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, HAS_SIZE) + val IS_NOT_EQUAL_TO_BOOLEAN = + CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO_METHOD) + .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) + } } \ No newline at end of file diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanIsTrueOrFalseInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanIsTrueOrFalseInspection.kt index 92935ad..da9b19b 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanIsTrueOrFalseInspection.kt +++ b/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 result = constantEvaluationHelper.computeConstantExpression(equalToExpression) - if (result == null) { + var value = calculateConstantParameterValue(expression, 0) + if (value == 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 == "FALSE" -> result = false + field.name == "TRUE" -> value = true + 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) diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt new file mode 100644 index 0000000..c1fe957 --- /dev/null +++ b/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()") + } + } + } + } +} \ No newline at end of file diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt index f6af10c..bb7bf8f 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt +++ b/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 psiExpression = expression.argumentList.expressions[0] as? PsiLiteralExpression ?: return - - 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()") - } + val value = calculateConstantParameterValue(expression, 0) ?: return + if ((isEqual && (value == "")) || (hasSize && (value == 0))) { + registerSimplifyMethod(holder, expression, "isEmpty()") } } } diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml index 7c8bb09..385e11e 100644 --- a/src/main/resources/META-INF/plugin.xml +++ b/src/main/resources/META-INF/plugin.xml @@ -27,6 +27,9 @@ implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanIsTrueOrFalseInspection"/> + diff --git a/src/main/resources/inspectionDescriptions/AssertThatBooleanIsTrueOrFalse.html b/src/main/resources/inspectionDescriptions/AssertThatBooleanIsTrueOrFalse.html index d87d6de..e020310 100644 --- a/src/main/resources/inspectionDescriptions/AssertThatBooleanIsTrueOrFalse.html +++ b/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(). +
Also works with Boolean.TRUE/FALSE. \ No newline at end of file diff --git a/src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html b/src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html new file mode 100644 index 0000000..ed79f54 --- /dev/null +++ b/src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html @@ -0,0 +1,7 @@ + + +Turns assertThat(enumerable).hasSize(0) into assertThat(enumerable).isEmpty(). + +
Works with anything that is enumerable such as arrays, iterables, collections, etc. + + \ No newline at end of file diff --git a/src/main/resources/inspectionDescriptions/AssertThatStringIsEmpty.html b/src/main/resources/inspectionDescriptions/AssertThatStringIsEmpty.html index c3df8c2..d692164 100644 --- a/src/main/resources/inspectionDescriptions/AssertThatStringIsEmpty.html +++ b/src/main/resources/inspectionDescriptions/AssertThatStringIsEmpty.html @@ -2,6 +2,6 @@ Turns assertThat(string).isEqualTo("") or assertThat(string).hasSize(0) into assertThat(string).isEmpty(). -Also works with CharSequences. +
Also works with CharSequences. \ No newline at end of file diff --git a/src/test/java/de/platon42/intellij/playground/Playground.java b/src/test/java/de/platon42/intellij/playground/Playground.java index 8e64fa7..5b549e0 100644 --- a/src/test/java/de/platon42/intellij/playground/Playground.java +++ b/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 etc = assertThat(new ArrayList()).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()).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); + } + } diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt new file mode 100644 index 0000000..793f19c --- /dev/null +++ b/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") + } + } +} \ No newline at end of file diff --git a/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java b/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java new file mode 100644 index 0000000..607af6b --- /dev/null +++ b/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()).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()).as("etc").hasSize(1); + assertThat(new Long[1]).as("etc").hasSize(1); + } +} diff --git a/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java b/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java new file mode 100644 index 0000000..3c91aca --- /dev/null +++ b/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()).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()).as("etc").hasSize(1); + assertThat(new Long[1]).as("etc").hasSize(1); + } +} diff --git a/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java b/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java index 34226c2..2fc9489 100644 --- a/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java +++ b/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("");