From a0ed4eab76347ba4e41ec108c1c048e134f961d6 Mon Sep 17 00:00:00 2001 From: chrisly42 Date: Sun, 29 Sep 2019 21:56:36 +0200 Subject: [PATCH] Added new AssertThatFileExpression to move out many common methods from inside the assertThat() expression (exists(), getName(), getParent(), and many more). --- README.md | 56 ++++++++- build.gradle | 2 + .../plugins/cajon/AssertJClassNames.kt | 2 + .../AssertThatFileExpressionInspection.kt | 117 ++++++++++++++++++ .../MoveOutMethodCallExpressionQuickFix.kt | 59 ++++++--- src/main/resources/META-INF/plugin.xml | 2 + .../AssertThatFileExpression.html | 8 ++ .../AssertThatFileExpressionInspectionTest.kt | 35 ++++++ .../FileExpression/FileExpressionAfter.java | 95 ++++++++++++++ .../FileExpression/FileExpressionBefore.java | 95 ++++++++++++++ 10 files changed, 448 insertions(+), 23 deletions(-) create mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspection.kt create mode 100644 src/main/resources/inspectionDescriptions/AssertThatFileExpression.html create mode 100644 src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt create mode 100644 src/test/resources/inspections/FileExpression/FileExpressionAfter.java create mode 100644 src/test/resources/inspections/FileExpression/FileExpressionBefore.java diff --git a/README.md b/README.md index b2df9f3..b951aed 100644 --- a/README.md +++ b/README.md @@ -258,6 +258,54 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the choosing between both fixes (does not work well for batch processing), or ignore this edge case altogether (just to be sure to not break any code). +- AssertThatFileExpression + + Moves File method calls inside ```assertThat()``` out. + + ``` + from: assertThat(file.canRead()).isTrue(); + to: assertThat(file).canRead(); + + from: assertThat(file.canWrite()).isTrue(); + to: assertThat(file).canWrite(); + + from: assertThat(file.exists()).isTrue(); + to: assertThat(file).exists(); + + from: assertThat(file.exists()).isFalse(); + to: assertThat(file).doesNotExist(); + + from: assertThat(file.isAbsolute()).isTrue(); + to: assertThat(file).isAbsolute(); + + from: assertThat(file.isAbsolute()).isFalse(); + to: assertThat(file).isRelative(); + + from: assertThat(file.isDirectory()).isTrue(); + to: assertThat(file).isDirectory(); + + from: assertThat(file.isFile()).isTrue(); + to: assertThat(file).isFile(); + + from: assertThat(file.getName()).isEqualTo(filename); + to: assertThat(file).hasName(filename); + + from: assertThat(file.getParent()).isEqualTo(pathname); + to: assertThat(file).hasParent(pathname); + + from: assertThat(file.getParent()).isNull(); + from: assertThat(file.getParentFile()).isNull(); + to: assertThat(file).hasNoParent(); + + from: assertThat(file.list()).isEmpty(); + from: assertThat(file.listFiles()).isEmpty(); + to: assertThat(file).isEmptyDirectory(); + + from: assertThat(file.list()).isNotEmpty(); + from: assertThat(file.listFiles()).isNotEmpty(); + to: assertThat(file).isNotEmptyDirectory(); + ``` + - AssertThatEnumerableIsEmpty Uses ```isEmpty()``` for ```hasSize(0)``` iterable assertions instead. @@ -552,10 +600,10 @@ The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing and Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution). ## Planned features -- More Optional fixes such as opt1.get() == opt2.get() etc. -- More moving out of methods for File, Path, LocalDate/Time etc. +- More Optional fixes such as ```opt1.get() == opt2.get()``` etc. +- More moving out of methods for Path, LocalDate/Time etc. - Converting ```foo.compareTo(bar) == 0``` to ```isEqualTo()``` (yes, I've *really* seen code like that) -- Extraction with property names to lambda with Java 8 +- Extraction with property names to lambda/method reference with Java 8 ``` from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")... @@ -569,6 +617,8 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo for array types. Sigh. Shouldn't be working >12h a day and then do some more stuff at home. - Fixed a bug in AssertThatBinaryExpression inspection for ```assertThat(null != expression)``` and related that would not correctly invert the condition on transformation. +- Added new AssertThatFileExpression to move out many common methods from inside the + ```assertThat()``` expression (```exists(), getName(), getParent()```, and many more). #### V1.5 (24-Sep-19) - Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception. diff --git a/build.gradle b/build.gradle index 9a0f55b..647c3ab 100644 --- a/build.gradle +++ b/build.gradle @@ -49,6 +49,8 @@ patchPluginXml { for array types. Sigh. Shouldn't be working >12h a day and then do some more stuff at home.
  • Fixed a bug in AssertThatBinaryExpression inspection for assertThat(null != expression) and related that would not correctly invert the condition on transformation. +
  • Added new AssertThatFileExpression to move out many common methods from inside the + assertThat() expression (exists(), getName(), getParent() and many more).

    Full changelog available at Github project site.

    """ diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt b/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt index 1d306d0..3b93318 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt +++ b/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt @@ -44,6 +44,8 @@ class AssertJClassNames { @NonNls const val ABSTRACT_MAP_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractMapAssert" @NonNls + const val ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectArrayAssert" + @NonNls const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert" @NonNls const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert" diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspection.kt new file mode 100644 index 0000000..0e2bc95 --- /dev/null +++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspection.kt @@ -0,0 +1,117 @@ +package de.platon42.intellij.plugins.cajon.inspections + +import com.intellij.codeInspection.ProblemsHolder +import com.intellij.psi.* +import com.siyeh.ig.callMatcher.CallMatcher +import de.platon42.intellij.plugins.cajon.* +import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix + + +class AssertThatFileExpressionInspection : AbstractAssertJInspection() { + + companion object { + private const val DISPLAY_NAME = "Asserting a file specific expression" + + private val MAPPINGS = listOf( + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "canRead"), + "canRead", expectBoolean = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "canWrite"), + "canWrite", expectBoolean = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "exists"), + "exists", "doesNotExist", expectBoolean = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isAbsolute"), + "isAbsolute", "isRelative", expectBoolean = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isDirectory"), + "isDirectory", expectBoolean = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isFile"), + "isFile", expectBoolean = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getName"), + "hasName", + expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING) + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParent", "getParentFile"), + "hasNoParent", expectNullNonNull = true + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParent"), + "hasParent", + expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING) + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParentFile"), + "hasParent", + expectedMatcher = IS_EQUAL_TO_OBJECT + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "list", "listFiles"), + "isEmptyDirectory", + expectedMatcher = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, MethodNames.IS_EMPTY) + .parameterCount(0)!! + ), + Mapping( + CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "list", "listFiles"), + "isNotEmptyDirectory", + expectedMatcher = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, MethodNames.IS_NOT_EMPTY) + .parameterCount(0)!! + ) + ) + } + + override fun getDisplayName() = DISPLAY_NAME + + override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor { + return object : JavaElementVisitor() { + override fun visitExpressionStatement(statement: PsiExpressionStatement) { + super.visitExpressionStatement(statement) + if (!statement.hasAssertThat()) return + val staticMethodCall = statement.findStaticMethodCall() ?: return + + val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return + val expectedCallExpression = statement.findOutmostMethodCall() ?: return + + for (mapping in MAPPINGS.filter { it.callMatcher.test(assertThatArgument) }) { + if (mapping.expectBoolean && ASSERT_THAT_BOOLEAN.test(staticMethodCall)) { + val expectedBooleanResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: continue + val replacementMethod = if (expectedBooleanResult) mapping.replacementForTrue else mapping.replacementForFalse ?: return + registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method -> + MoveOutMethodCallExpressionQuickFix(desc, method) + } + } else if (mapping.expectNullNonNull != null) { + val expectedNullNonNullResult = expectedCallExpression.getExpectedNullNonNullResult() ?: continue + val replacementMethod = if (expectedNullNonNullResult xor mapping.expectNullNonNull) mapping.replacementForTrue else mapping.replacementForFalse ?: continue + registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method -> + MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true) + } + } else if (mapping.expectedMatcher?.test(expectedCallExpression) == true) { + registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, mapping.replacementForTrue) { desc, method -> + MoveOutMethodCallExpressionQuickFix(desc, method, replaceOnlyThisMethod = mapping.expectedMatcher) + } + } + } + } + } + } + + private class Mapping( + val callMatcher: CallMatcher, + val replacementForTrue: String, + val replacementForFalse: String? = null, + val expectBoolean: Boolean = false, + val expectNullNonNull: Boolean? = null, + val expectedMatcher: CallMatcher? = null + ) +} \ No newline at end of file diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt index c8d3fe5..52b1cf4 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt +++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt @@ -4,6 +4,7 @@ import com.intellij.codeInspection.ProblemDescriptor import com.intellij.openapi.project.Project import com.intellij.psi.JavaPsiFacade import com.intellij.psi.PsiMethodCallExpression +import com.siyeh.ig.callMatcher.CallMatcher import de.platon42.intellij.plugins.cajon.* class MoveOutMethodCallExpressionQuickFix( @@ -11,7 +12,8 @@ class MoveOutMethodCallExpressionQuickFix( private val replacementMethod: String, private val useNullNonNull: Boolean = false, private val noExpectedExpression: Boolean = false, - private val keepExpectedAsSecondArgument: Boolean = false + private val keepExpectedAsSecondArgument: Boolean = false, + private val replaceOnlyThisMethod: CallMatcher? = null ) : AbstractCommonQuickFix(description) { @@ -29,29 +31,46 @@ class MoveOutMethodCallExpressionQuickFix( val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy() - if (keepExpectedAsSecondArgument) { - assertExpressionArg ?: return - val secondArg = - if (useNullNonNull) JavaPsiFacade.getElementFactory(project).createExpressionFromText("null", null) else outmostCallExpression.getArgOrNull(0)?.copy() ?: return + when { + replaceOnlyThisMethod != null -> { + val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement() + .filter(replaceOnlyThisMethod::test) + .toList() - assertExpression.replace(assertExpression.qualifierExpression) + assertExpression.replace(assertExpression.qualifierExpression) - val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, assertExpressionArg, secondArg) - expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression) - outmostCallExpression.replace(expectedExpression) - } else { - val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement() - .filter { (if (useNullNonNull) it.getExpectedNullNonNullResult() else it.getExpectedBooleanResult()) != null } - .toList() + methodsToFix + .forEach { + val expectedExpression = createExpectedMethodCall(it, replacementMethod, *it.argumentList.expressions) + expectedExpression.replaceQualifierFromMethodCall(it) + it.replace(expectedExpression) + } + } + keepExpectedAsSecondArgument -> { + assertExpressionArg ?: return + val secondArg = + if (useNullNonNull) JavaPsiFacade.getElementFactory(project).createExpressionFromText("null", null) else outmostCallExpression.getArgOrNull(0)?.copy() ?: return - assertExpression.replace(assertExpression.qualifierExpression) + assertExpression.replace(assertExpression.qualifierExpression) - methodsToFix - .forEach { - val expectedExpression = createExpectedMethodCall(it, replacementMethod, *listOfNotNull(assertExpressionArg).toTypedArray()) - expectedExpression.replaceQualifierFromMethodCall(it) - it.replace(expectedExpression) - } + val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, assertExpressionArg, secondArg) + expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression) + outmostCallExpression.replace(expectedExpression) + } + else -> { + val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement() + .filter { (if (useNullNonNull) it.getExpectedNullNonNullResult() else it.getExpectedBooleanResult()) != null } + .toList() + + assertExpression.replace(assertExpression.qualifierExpression) + + methodsToFix + .forEach { + val expectedExpression = createExpectedMethodCall(it, replacementMethod, *listOfNotNull(assertExpressionArg).toTypedArray()) + expectedExpression.replaceQualifierFromMethodCall(it) + it.replace(expectedExpression) + } + } } } } \ No newline at end of file diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml index d29b894..f53d42a 100644 --- a/src/main/resources/META-INF/plugin.xml +++ b/src/main/resources/META-INF/plugin.xml @@ -45,6 +45,8 @@ implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringExpressionInspection"/> + diff --git a/src/main/resources/inspectionDescriptions/AssertThatFileExpression.html b/src/main/resources/inspectionDescriptions/AssertThatFileExpression.html new file mode 100644 index 0000000..ffdf8bb --- /dev/null +++ b/src/main/resources/inspectionDescriptions/AssertThatFileExpression.html @@ -0,0 +1,8 @@ + + +Operates on assertions on objects of type File. Turns assertThat(file.someMethod(arg)).someAssertion() into assertThat(file).someMethod(arg). + +
    someMethod() can be canRead(), canWrite(), exists(), isAbsolute(), isDirectory(), isFile(), +getName(), getParent(), getParentFile(), list() and listFiles(). + + \ No newline at end of file diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt new file mode 100644 index 0000000..698974a --- /dev/null +++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt @@ -0,0 +1,35 @@ +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 AssertThatFileExpressionInspectionTest : AbstractCajonTest() { + + @Test + @TestDataSubPath("inspections/FileExpression") + internal fun assertThat_with_certain_File_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) { + myFixture.enableInspections(AssertThatFileExpressionInspection::class.java) + myFixture.configureByFile("FileExpressionBefore.java") + executeQuickFixes(myFixture, Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1) + executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1) + myFixture.checkResultByFile("FileExpressionAfter.java") + } +} \ No newline at end of file diff --git a/src/test/resources/inspections/FileExpression/FileExpressionAfter.java b/src/test/resources/inspections/FileExpression/FileExpressionAfter.java new file mode 100644 index 0000000..7df21fc --- /dev/null +++ b/src/test/resources/inspections/FileExpression/FileExpressionAfter.java @@ -0,0 +1,95 @@ +import java.io.File; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.fail; + +public class FileExpression { + + private void fileExpression() { + File file = new File("foo"); + + assertThat(file).as("foo").canRead(); + assertThat(file).canRead(); + assertThat(file).canRead(); + assertThat(file.canRead()).as("foo").isEqualTo(false); + assertThat(file.canRead()).isNotEqualTo(true); + assertThat(file.canRead()).isFalse(); + + assertThat(file).as("foo").canWrite(); + assertThat(file).canWrite(); + assertThat(file).canWrite(); + assertThat(file.canWrite()).as("foo").isEqualTo(false); + assertThat(file.canWrite()).isNotEqualTo(true); + assertThat(file.canWrite()).isFalse(); + + assertThat(file).as("foo").exists(); + assertThat(file).exists(); + assertThat(file).exists(); + assertThat(file).as("foo").doesNotExist(); + assertThat(file).doesNotExist(); + assertThat(file).doesNotExist(); + + assertThat(file).as("foo").isAbsolute(); + assertThat(file).isAbsolute(); + assertThat(file).isAbsolute(); + assertThat(file).as("foo").isRelative(); + assertThat(file).isRelative(); + assertThat(file).isRelative(); + + assertThat(file).as("foo").isDirectory(); + assertThat(file).isDirectory(); + assertThat(file).isDirectory(); + assertThat(file.isDirectory()).as("foo").isEqualTo(false); + assertThat(file.isDirectory()).isNotEqualTo(true); + assertThat(file.isDirectory()).isFalse(); + + assertThat(file).as("foo").isFile(); + assertThat(file).isFile(); + assertThat(file).isFile(); + assertThat(file.isFile()).as("foo").isEqualTo(false); + assertThat(file.isFile()).isNotEqualTo(true); + assertThat(file.isFile()).isFalse(); + + assertThat(file).hasName("foo"); + assertThat(file.getName()).isNotEqualTo("foo"); + assertThat(file).hasName(null); + assertThat(file.getName()).isNull(); + assertThat(file.getName()).isNotEqualTo(null); + assertThat(file.getName()).isNotNull(); + assertThat(file.getName()).isEmpty(); + assertThat(file.getName()).isNotEmpty(); + + assertThat(file).hasParent("foo"); + assertThat(file.getParent()).isNotEqualTo("foo"); + assertThat(file).hasNoParent(); + assertThat(file).hasNoParent(); + assertThat(file.getParent()).isNotEqualTo(null); + assertThat(file.getParent()).isNotNull(); + assertThat(file.getParent()).isEmpty(); + assertThat(file.getParent()).isNotEmpty(); + + assertThat(file).hasParent(new File("foo")); + assertThat(file.getParentFile()).isNotEqualTo(new File("foo")); + assertThat(file).hasNoParent(); + assertThat(file).hasNoParent(); + assertThat(file.getParentFile()).isNotEqualTo(null); + assertThat(file.getParentFile()).isNotNull(); + + assertThat(file.listFiles()).isNull(); + assertThat(file.listFiles()).isNullOrEmpty(); + assertThat(file).isEmptyDirectory(); + assertThat(file).isNotEmptyDirectory(); + + assertThat(file.list()).isNull(); + assertThat(file.list()).isNullOrEmpty(); + assertThat(file).isEmptyDirectory(); + assertThat(file).isNotEmptyDirectory(); + + assertThat(file.getName()).endsWith(".foo"); // could be turned into .hasExtension("foo"), but not always. + + assertThat(file).as("foo").hasName("foo").as("bar").hasName("bar"); + + org.junit.Assert.assertThat(file, null); + fail("oh no!"); + } +} diff --git a/src/test/resources/inspections/FileExpression/FileExpressionBefore.java b/src/test/resources/inspections/FileExpression/FileExpressionBefore.java new file mode 100644 index 0000000..1af703f --- /dev/null +++ b/src/test/resources/inspections/FileExpression/FileExpressionBefore.java @@ -0,0 +1,95 @@ +import java.io.File; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.fail; + +public class FileExpression { + + private void fileExpression() { + File file = new File("foo"); + + assertThat(file.canRead()).as("foo").isEqualTo(true); + assertThat(file.canRead()).isNotEqualTo(false); + assertThat(file.canRead()).isTrue(); + assertThat(file.canRead()).as("foo").isEqualTo(false); + assertThat(file.canRead()).isNotEqualTo(true); + assertThat(file.canRead()).isFalse(); + + assertThat(file.canWrite()).as("foo").isEqualTo(true); + assertThat(file.canWrite()).isNotEqualTo(false); + assertThat(file.canWrite()).isTrue(); + assertThat(file.canWrite()).as("foo").isEqualTo(false); + assertThat(file.canWrite()).isNotEqualTo(true); + assertThat(file.canWrite()).isFalse(); + + assertThat(file.exists()).as("foo").isEqualTo(true); + assertThat(file.exists()).isNotEqualTo(false); + assertThat(file.exists()).isTrue(); + assertThat(file.exists()).as("foo").isEqualTo(false); + assertThat(file.exists()).isNotEqualTo(true); + assertThat(file.exists()).isFalse(); + + assertThat(file.isAbsolute()).as("foo").isEqualTo(true); + assertThat(file.isAbsolute()).isNotEqualTo(false); + assertThat(file.isAbsolute()).isTrue(); + assertThat(file.isAbsolute()).as("foo").isEqualTo(false); + assertThat(file.isAbsolute()).isNotEqualTo(true); + assertThat(file.isAbsolute()).isFalse(); + + assertThat(file.isDirectory()).as("foo").isEqualTo(true); + assertThat(file.isDirectory()).isNotEqualTo(false); + assertThat(file.isDirectory()).isTrue(); + assertThat(file.isDirectory()).as("foo").isEqualTo(false); + assertThat(file.isDirectory()).isNotEqualTo(true); + assertThat(file.isDirectory()).isFalse(); + + assertThat(file.isFile()).as("foo").isEqualTo(true); + assertThat(file.isFile()).isNotEqualTo(false); + assertThat(file.isFile()).isTrue(); + assertThat(file.isFile()).as("foo").isEqualTo(false); + assertThat(file.isFile()).isNotEqualTo(true); + assertThat(file.isFile()).isFalse(); + + assertThat(file.getName()).isEqualTo("foo"); + assertThat(file.getName()).isNotEqualTo("foo"); + assertThat(file.getName()).isEqualTo(null); + assertThat(file.getName()).isNull(); + assertThat(file.getName()).isNotEqualTo(null); + assertThat(file.getName()).isNotNull(); + assertThat(file.getName()).isEmpty(); + assertThat(file.getName()).isNotEmpty(); + + assertThat(file.getParent()).isEqualTo("foo"); + assertThat(file.getParent()).isNotEqualTo("foo"); + assertThat(file.getParent()).isEqualTo(null); + assertThat(file.getParent()).isNull(); + assertThat(file.getParent()).isNotEqualTo(null); + assertThat(file.getParent()).isNotNull(); + assertThat(file.getParent()).isEmpty(); + assertThat(file.getParent()).isNotEmpty(); + + assertThat(file.getParentFile()).isEqualTo(new File("foo")); + assertThat(file.getParentFile()).isNotEqualTo(new File("foo")); + assertThat(file.getParentFile()).isEqualTo(null); + assertThat(file.getParentFile()).isNull(); + assertThat(file.getParentFile()).isNotEqualTo(null); + assertThat(file.getParentFile()).isNotNull(); + + assertThat(file.listFiles()).isNull(); + assertThat(file.listFiles()).isNullOrEmpty(); + assertThat(file.listFiles()).isEmpty(); + assertThat(file.listFiles()).isNotEmpty(); + + assertThat(file.list()).isNull(); + assertThat(file.list()).isNullOrEmpty(); + assertThat(file.list()).isEmpty(); + assertThat(file.list()).isNotEmpty(); + + assertThat(file.getName()).endsWith(".foo"); // could be turned into .hasExtension("foo"), but not always. + + assertThat(file.getName()).as("foo").isEqualTo("foo").as("bar").isEqualTo("bar"); + + org.junit.Assert.assertThat(file, null); + fail("oh no!"); + } +}