Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Niels Ulrik Andersen
|
49a3b1aada | ||
|
Niels Ulrik Andersen
|
f8b86ac78f |
+1
-1
@@ -1,4 +1,4 @@
|
||||
Copyright 2019-2022 Chris Hodges <chrisly@platon42.de>
|
||||
Copyright 2019 Chris Hodges <chrisly@platon42.de>
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
|
||||
@@ -32,7 +32,7 @@ Then AssertJ would tell you the _actual contents_ of the collection on failure.
|
||||
|
||||
## Conversion of JUnit assertions to AssertJ
|
||||
|
||||
The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
|
||||
The plugin also supports the conversion of the most common JUnit 4 and JUnit 5 assertions to AssertJ.
|
||||
|
||||
## Wrong use of AssertJ
|
||||
|
||||
@@ -171,23 +171,6 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
to: assertThat(object).isNotInstanceOf(classname.class);
|
||||
```
|
||||
|
||||
- AssertThatIsZeroOne
|
||||
|
||||
Uses ```isZero()```, ```isNotZero()``` and ```isOne()``` instead.
|
||||
Works with shorts, integers, longs, floats and doubles, and tries to evaluate
|
||||
constant expressions, too.
|
||||
|
||||
```
|
||||
from: assertThat(numeric).isEqualTo(0);
|
||||
to: assertThat(numeric).isZero();
|
||||
|
||||
from: assertThat(numeric).isNotEqualTo(0);
|
||||
to: assertThat(numeric).isNotZero();
|
||||
|
||||
from: assertThat(numeric).isEqualTo(1);
|
||||
to: assertThat(numeric).isOne();
|
||||
```
|
||||
|
||||
- AssertThatStringIsEmpty
|
||||
|
||||
Uses ```isEmpty()``` for empty string assertions.
|
||||
@@ -711,7 +694,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
However, this suggests that the test has actually been run and passed instead of showing the test
|
||||
as being skipped.
|
||||
|
||||
Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or
|
||||
Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or JUnit 5 or
|
||||
Jupiter ```@Test``` annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
|
||||
Method calls within the same class will be examined for ```assertThat()``` statements, too.
|
||||
However, at most 50 statements and down to five recursions will be tolerated before giving up.
|
||||
@@ -748,7 +731,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
- JUnitAssertToAssertJ
|
||||
|
||||
Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
|
||||
Tries to convert most of the JUnit 4 and JUnit 5 assertions and assumptions to AssertJ format.
|
||||
Sometimes the expected and actual expressions are specified in wrong order --
|
||||
Cajon tries to swap these when it detects the supposed actual expression to be a
|
||||
constant while the expected one is not.
|
||||
@@ -815,7 +798,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
## Development notice
|
||||
|
||||
Cajon is written in Kotlin 1.7.
|
||||
Cajon is written in Kotlin 1.4.
|
||||
|
||||
Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one I'm aware of ;) ).
|
||||
The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to make it work with JUnit 5.
|
||||
@@ -831,17 +814,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
|
||||
to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
|
||||
```
|
||||
- Support primitives in assertThat(map.containsKey(1)).isTrue();
|
||||
|
||||
## Changelog
|
||||
|
||||
### V1.13 (15-Aug-22)
|
||||
#### V1.13 (unreleased)
|
||||
|
||||
- Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
|
||||
- Tried to fix unreproducible issue #9.
|
||||
- Added workaround for upcoming API change in IntelliJ breaking older releases.
|
||||
- Added AssertThatIsZeroOne inspection demanded by issue #5.
|
||||
- Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
|
||||
- Added support for converting JUnit 5 tests to AssertJ
|
||||
|
||||
### V1.12 (06-May-21)
|
||||
|
||||
|
||||
+12
-25
@@ -1,13 +1,13 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'org.jetbrains.intellij' version '1.8.0'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.7.10'
|
||||
id 'org.jetbrains.intellij' version '1.1.3'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.5.21'
|
||||
id 'jacoco'
|
||||
id 'com.github.kt3k.coveralls' version '2.12.0'
|
||||
id 'com.github.kt3k.coveralls' version '2.11.0'
|
||||
}
|
||||
|
||||
group 'de.platon42'
|
||||
version '1.13'
|
||||
version '1.12.1'
|
||||
sourceCompatibility = "1.8"
|
||||
targetCompatibility = "1.8"
|
||||
|
||||
@@ -22,10 +22,10 @@ repositories {
|
||||
|
||||
dependencies {
|
||||
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
testImplementation "org.assertj:assertj-core:3.23.1"
|
||||
testImplementation "org.assertj:assertj-guava:3.5.0"
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
|
||||
testImplementation "org.assertj:assertj-core:3.20.2"
|
||||
testImplementation "org.assertj:assertj-guava:3.4.0"
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-test"
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-reflect"
|
||||
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
|
||||
@@ -40,26 +40,17 @@ compileTestKotlin {
|
||||
}
|
||||
|
||||
intellij {
|
||||
setVersion("2022.2") // LATEST-EAP-SNAPSHOT
|
||||
setVersion("2021.1.3") // LATEST-EAP-SNAPSHOT
|
||||
//pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
|
||||
setUpdateSinceUntilBuild(false)
|
||||
setPlugins(["com.intellij.java"])
|
||||
}
|
||||
|
||||
runPluginVerifier {
|
||||
ideVersions = ["IC-193.5662.53", "IC-222.3345.118"] // 2020.3 - 2022.2
|
||||
downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
|
||||
}
|
||||
|
||||
patchPluginXml {
|
||||
setChangeNotes("""
|
||||
<h4>V1.13 (15-Aug-22)</h4>
|
||||
<h4>V1.13 (unreleased)</h4>
|
||||
<ul>
|
||||
<li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
|
||||
<li>Tried to fix unreproducible issue #9.
|
||||
<li>Added workaround for upcoming API change in IntelliJ breaking older releases.
|
||||
<li>Added AssertThatIsZeroOne inspection demanded by issue #5.
|
||||
<li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
|
||||
<li>Added support for converting JUnit 5 tests to AssertJ
|
||||
</ul>
|
||||
<p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
|
||||
""")
|
||||
@@ -72,12 +63,8 @@ test {
|
||||
}
|
||||
}
|
||||
|
||||
tasks.test {
|
||||
systemProperty("idea.force.use.core.classloader", "true")
|
||||
}
|
||||
|
||||
jacoco {
|
||||
toolVersion = '0.8.8'
|
||||
toolVersion = '0.8.7'
|
||||
}
|
||||
|
||||
jacocoTestReport {
|
||||
|
||||
+1
-1
@@ -1,5 +1,5 @@
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
@@ -12,100 +12,68 @@ class AssertJClassNames {
|
||||
|
||||
@NonNls
|
||||
const val DESCRIPTABLE_INTERFACE = "org.assertj.core.api.Descriptable"
|
||||
|
||||
@NonNls
|
||||
const val EXTENSION_POINTS_INTERFACE = "org.assertj.core.api.ExtensionPoints"
|
||||
|
||||
@NonNls
|
||||
const val ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.EnumerableAssert"
|
||||
|
||||
@NonNls
|
||||
const val OBJECT_ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.ObjectEnumerableAssert"
|
||||
|
||||
@NonNls
|
||||
const val ASSERT_INTERFACE = "org.assertj.core.api.Assert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_OBJECT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_SHORT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_INTEGER_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntegerAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_LONG_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_FLOAT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_DOUBLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_COMPARABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractComparableAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_MAP_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractMapAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_BOOLEAN_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_BYTE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractByteArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_SHORT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_INT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_LONG_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_FLOAT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_DOUBLE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleArrayAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_CHAR_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharArrayAssert"
|
||||
|
||||
@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_FILE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFileAssert"
|
||||
|
||||
@NonNls
|
||||
const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"
|
||||
|
||||
@NonNls
|
||||
const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"
|
||||
|
||||
@NonNls
|
||||
const val GUAVA_OPTIONAL_CLASSNAME = "com.google.common.base.Optional"
|
||||
|
||||
@NonNls
|
||||
const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
|
||||
|
||||
@NonNls
|
||||
const val GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
|
||||
}
|
||||
|
||||
@@ -50,21 +50,9 @@ val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
|
||||
"singleElement", "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
|
||||
)!!
|
||||
|
||||
val FILTERED_ON = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "filteredOn", "filteredOnNull", "filteredOnAssertions")!!
|
||||
|
||||
val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
|
||||
EXTRACTING_CALL_MATCHERS,
|
||||
DESCRIBED_AS,
|
||||
WITH_REPRESENTATION_AND_SUCH,
|
||||
FILTERED_ON,
|
||||
USING_COMPARATOR,
|
||||
IN_HEXADECIMAL_OR_BINARY
|
||||
)!!
|
||||
|
||||
val COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE = CallMatcher.anyOf(
|
||||
EXTRACTING_CALL_MATCHERS,
|
||||
WITH_REPRESENTATION_AND_SUCH,
|
||||
FILTERED_ON,
|
||||
USING_COMPARATOR,
|
||||
IN_HEXADECIMAL_OR_BINARY
|
||||
)!!
|
||||
|
||||
@@ -115,7 +115,8 @@ fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
|
||||
}
|
||||
|
||||
fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
|
||||
return getArgOrNull(argIndex)?.calculateConstantValue()
|
||||
if (argIndex >= argumentList.expressions.size) return null
|
||||
return getArg(argIndex).calculateConstantValue()
|
||||
}
|
||||
|
||||
fun PsiExpression.calculateConstantValue(): Any? {
|
||||
|
||||
@@ -17,25 +17,19 @@ class MethodNames {
|
||||
|
||||
@NonNls
|
||||
const val AS = "as"
|
||||
|
||||
@NonNls
|
||||
const val DESCRIBED_AS = "describedAs"
|
||||
|
||||
@NonNls
|
||||
const val IN_HEXADECIMAL = "inHexadecimal"
|
||||
|
||||
@NonNls
|
||||
const val IN_BINARY = "inBinary"
|
||||
|
||||
@NonNls
|
||||
const val IS_EQUAL_TO = "isEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_EQUAL_TO = "isNotEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_SAME_AS = "isSameAs"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_SAME_AS = "isNotSameAs"
|
||||
|
||||
@@ -44,133 +38,89 @@ class MethodNames {
|
||||
|
||||
@NonNls
|
||||
const val IS_GREATER_THAN = "isGreaterThan"
|
||||
|
||||
@NonNls
|
||||
const val IS_GREATER_THAN_OR_EQUAL_TO = "isGreaterThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_LESS_THAN = "isLessThan"
|
||||
|
||||
@NonNls
|
||||
const val IS_LESS_THAN_OR_EQUAL_TO = "isLessThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_ZERO = "isZero"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_ZERO = "isNotZero"
|
||||
|
||||
@NonNls
|
||||
const val IS_ONE = "isOne"
|
||||
|
||||
@NonNls
|
||||
const val IS_TRUE = "isTrue"
|
||||
|
||||
@NonNls
|
||||
const val IS_FALSE = "isFalse"
|
||||
|
||||
@NonNls
|
||||
const val IS_NULL = "isNull" // terminal, returns void
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_NULL = "isNotNull"
|
||||
|
||||
@NonNls
|
||||
const val IS_CLOSE_TO = "isCloseTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_CLOSE_TO = "isNotCloseTo"
|
||||
|
||||
@NonNls
|
||||
const val IS_INSTANCE_OF = "isInstanceOf"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"
|
||||
|
||||
@NonNls
|
||||
const val IS_NULL_OR_EMPTY = "isNullOrEmpty" // terminal, returns void
|
||||
|
||||
@NonNls
|
||||
const val IS_EMPTY = "isEmpty" // terminal, returns void
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_EMPTY = "isNotEmpty"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE = "hasSize"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_LESS_THAN = "hasSizeLessThan"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_LESS_THAN_OR_EQUAL_TO = "hasSizeLessThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_GREATER_THAN = "hasSizeGreaterThan"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO = "hasSizeGreaterThanOrEqualTo"
|
||||
|
||||
@NonNls
|
||||
const val HAS_SAME_SIZE_AS = "hasSameSizeAs"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS = "contains"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_ONLY_ONCE = "containsOnlyOnce"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN = "doesNotContain"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_EXACTLY = "containsExactly"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_ALL = "containsAll"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_KEY = "containsKey"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN_KEY = "doesNotContainKey"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_VALUE = "containsValue"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN_VALUE = "doesNotContainValue"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_ENTRY = "containsEntry"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_CONTAIN_ENTRY = "doesNotContainEntry"
|
||||
|
||||
@NonNls
|
||||
const val IS_EQUAL_TO_IC = "isEqualToIgnoringCase"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_EQUAL_TO_IC = "isNotEqualToIgnoringCase"
|
||||
|
||||
@NonNls
|
||||
const val STARTS_WITH = "startsWith"
|
||||
|
||||
@NonNls
|
||||
const val ENDS_WITH = "endsWith"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_START_WITH = "doesNotStartWith"
|
||||
|
||||
@NonNls
|
||||
const val DOES_NOT_END_WITH = "doesNotEndWith"
|
||||
|
||||
@NonNls
|
||||
const val CONTAINS_SAME = "containsSame"
|
||||
|
||||
@NonNls
|
||||
const val IS_PRESENT = "isPresent"
|
||||
|
||||
@NonNls
|
||||
const val IS_NOT_PRESENT = "isNotPresent"
|
||||
|
||||
|
||||
+5
-10
@@ -15,7 +15,6 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_D
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_FLOAT_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_LONG_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_SHORT_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_STRING_ASSERT_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
|
||||
@@ -89,8 +88,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
|
||||
val IS_EQUAL_TO_STRING = CallMatcher.instanceCall(ABSTRACT_STRING_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
|
||||
val IS_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
.parameterTypes("short")!!
|
||||
val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
val IS_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
|
||||
@@ -106,8 +103,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
|
||||
val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
.parameterTypes("boolean")!!
|
||||
val IS_NOT_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
.parameterTypes("short")!!
|
||||
val IS_NOT_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
val IS_NOT_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
|
||||
@@ -160,15 +155,15 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
|
||||
.parameterCount(0)!!
|
||||
val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
|
||||
val IS_ONE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
|
||||
.parameterCount(0)!!
|
||||
val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
|
||||
val IS_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
|
||||
val IS_NOT_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
|
||||
.parameterCount(0)!!
|
||||
val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
|
||||
val IS_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
|
||||
val IS_NOT_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
|
||||
.parameterCount(0)!!
|
||||
|
||||
val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)
|
||||
|
||||
+8
-2
@@ -8,10 +8,16 @@ abstract class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTo
|
||||
|
||||
companion object {
|
||||
@NonNls
|
||||
const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
|
||||
const val JUNIT4_ASSERT_CLASSNAME = "org.junit.Assert"
|
||||
|
||||
@NonNls
|
||||
const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
|
||||
const val JUNIT5_ASSERT_CLASSNAME = "org.junit.jupiter.api.Assertions"
|
||||
|
||||
@NonNls
|
||||
const val JUNIT4_ASSUME_CLASSNAME = "org.junit.Assume"
|
||||
|
||||
@NonNls
|
||||
const val JUNIT5_ASSUME_CLASSNAME = "org.junit.jupiter.api.Assumptions"
|
||||
|
||||
@NonNls
|
||||
const val ASSERT_TRUE_METHOD = "assertTrue"
|
||||
|
||||
+4
-4
@@ -52,7 +52,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
@@ -67,7 +67,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE_INT, IS_ONE_INT), replaceFromOriginalMethod = true
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE, IS_ONE), replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
@@ -82,7 +82,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
@@ -97,7 +97,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
-81
@@ -1,81 +0,0 @@
|
||||
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 com.intellij.psi.util.TypeConversionUtil
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
|
||||
class AssertThatIsZeroOneInspection : AbstractAssertJInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a zero or one value"
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
|
||||
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
|
||||
return object : JavaElementVisitor() {
|
||||
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
|
||||
super.visitMethodCallExpression(expression)
|
||||
if (!expression.hasAssertThat()) return
|
||||
val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_SHORT, IS_EQUAL_TO_INT, IS_EQUAL_TO_LONG, IS_EQUAL_TO_FLOAT, IS_EQUAL_TO_DOUBLE).test(expression)
|
||||
val isNotEqualTo =
|
||||
CallMatcher.anyOf(IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_SHORT, IS_NOT_EQUAL_TO_INT, IS_NOT_EQUAL_TO_LONG, IS_NOT_EQUAL_TO_FLOAT, IS_NOT_EQUAL_TO_DOUBLE)
|
||||
.test(expression)
|
||||
|
||||
if (!(isEqualTo || isNotEqualTo)) return
|
||||
|
||||
val expectedExpression = expression.firstArg
|
||||
if (!TypeConversionUtil.isNumericType(expectedExpression.type)) return
|
||||
|
||||
val expectedResult = expression.calculateConstantParameterValue(0) ?: return
|
||||
var isZero = false
|
||||
var isOne = false
|
||||
when (expectedResult) {
|
||||
is Short -> {
|
||||
isZero = (expectedResult == 0.toShort())
|
||||
isOne = (expectedResult == 1.toShort())
|
||||
}
|
||||
|
||||
is Int -> {
|
||||
isZero = (expectedResult == 0)
|
||||
isOne = (expectedResult == 1)
|
||||
}
|
||||
|
||||
is Long -> {
|
||||
isZero = (expectedResult == 0L)
|
||||
isOne = (expectedResult == 1L)
|
||||
}
|
||||
|
||||
is Float -> {
|
||||
isZero = (expectedResult == 0.0f)
|
||||
isOne = (expectedResult == 1.0f)
|
||||
}
|
||||
|
||||
is Double -> {
|
||||
isZero = (expectedResult == 0.0)
|
||||
isOne = (expectedResult == 1.0)
|
||||
}
|
||||
}
|
||||
if (isZero || isOne) {
|
||||
val numericBaseClass = listOf(
|
||||
AssertJClassNames.ABSTRACT_SHORT_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_INTEGER_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_LONG_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_FLOAT_ASSERT_CLASSNAME,
|
||||
AssertJClassNames.ABSTRACT_DOUBLE_ASSERT_CLASSNAME
|
||||
).any { checkAssertedType(expression, it) }
|
||||
if (!numericBaseClass) return
|
||||
}
|
||||
if (isZero) {
|
||||
registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_ZERO, MethodNames.IS_NOT_ZERO))
|
||||
} else if (isOne && isEqualTo) {
|
||||
registerSimplifyMethod(holder, expression, MethodNames.IS_ONE)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -94,7 +94,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
@@ -119,7 +119,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
|
||||
+98
-46
@@ -3,6 +3,8 @@ package de.platon42.intellij.plugins.cajon.inspections
|
||||
import com.intellij.codeInspection.LocalQuickFix
|
||||
import com.intellij.codeInspection.ProblemsHolder
|
||||
import com.intellij.psi.*
|
||||
import com.intellij.psi.CommonClassNames.*
|
||||
import com.intellij.psi.PsiKeyword.*
|
||||
import com.intellij.psi.search.GlobalSearchScope
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import com.siyeh.ig.callMatcher.CallMatcher.anyOf
|
||||
@@ -20,94 +22,127 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
|
||||
private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
|
||||
private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"
|
||||
|
||||
private const val DOUBLE_ARR = "$DOUBLE[]"
|
||||
private const val FLOAT_ARR = "$FLOAT[]"
|
||||
|
||||
private val ASSERT_MAPPINGS = listOf(
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_TRUE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_FALSE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
),
|
||||
MethodNames.IS_NULL, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
|
||||
),
|
||||
MethodNames.IS_NOT_NULL, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
),
|
||||
MethodNames.IS_CLOSE_TO, hasDelta = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_EQUAL_TO
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
|
||||
),
|
||||
MethodNames.IS_NOT_CLOSE_TO, hasDelta = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_NOT_EQUAL_TO
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_SAME_AS
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
|
||||
),
|
||||
MethodNames.IS_NOT_SAME_AS
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double[]", "double[]", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("double[]", "double[]", "double"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float[]", "float[]", "float"),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT_ARR, FLOAT_ARR, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
|
||||
),
|
||||
MethodNames.CONTAINS_EXACTLY, hasDelta = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
|
||||
staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
|
||||
staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
|
||||
),
|
||||
MethodNames.CONTAINS_EXACTLY
|
||||
)
|
||||
@@ -116,26 +151,35 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
|
||||
private val ASSUME_MAPPINGS = listOf(
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_TRUE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes("boolean")
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
|
||||
),
|
||||
MethodNames.IS_FALSE, hasExpected = false
|
||||
),
|
||||
Mapping(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
|
||||
anyOf(
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
|
||||
),
|
||||
MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
|
||||
),
|
||||
Mapping(
|
||||
anyOf(
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_THROWABLE),
|
||||
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_THROWABLE)
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_THROWABLE),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE, JAVA_LANG_STRING),
|
||||
staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
|
||||
staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
|
||||
),
|
||||
"doesNotThrowAnyException", hasExpected = false
|
||||
)
|
||||
@@ -149,29 +193,37 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
|
||||
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
|
||||
super.visitMethodCallExpression(expression)
|
||||
when (expression.resolveMethod()?.containingClass?.qualifiedName) {
|
||||
JUNIT_ASSERT_CLASSNAME -> {
|
||||
JUNIT4_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, false)
|
||||
JUNIT5_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, true)
|
||||
JUNIT4_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, false)
|
||||
JUNIT5_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, true)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun visitMethodCallExpressionAssert(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
|
||||
JavaPsiFacade.getInstance(expression.project)
|
||||
.findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
|
||||
val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
|
||||
if (mapping.hasDelta) {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
|
||||
ReplaceJUnitDeltaAssertMethodCallQuickFix(desc, method, junit5)
|
||||
}
|
||||
} else {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
|
||||
ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
|
||||
ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected, junit5)
|
||||
}
|
||||
}
|
||||
}
|
||||
JUNIT_ASSUME_CLASSNAME -> {
|
||||
|
||||
private fun visitMethodCallExpressionAssume(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
|
||||
JavaPsiFacade.getInstance(expression.project)
|
||||
.findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
|
||||
val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
|
||||
if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
|
||||
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
|
||||
ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ReplaceJUnitAssumeMethodCallQuickFix(desc, method, junit5)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+1
-2
@@ -72,7 +72,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
|
||||
if (!statement.hasAssertThat()) return null
|
||||
|
||||
val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
|
||||
return assertThatCall?.takeIf { it.findFluentCallTo(COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE) == null }
|
||||
return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
|
||||
}
|
||||
return null
|
||||
}
|
||||
@@ -83,7 +83,6 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
|
||||
val matched = when (element) {
|
||||
is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
|
||||
|| (element.operationTokenType == JavaTokenType.MINUSMINUS)
|
||||
|
||||
is PsiMethodCallExpression -> KNOWN_METHODS_WITH_SIDE_EFFECTS.test(element)
|
||||
else -> false
|
||||
}
|
||||
|
||||
+2
-7
@@ -56,14 +56,9 @@ class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommo
|
||||
}
|
||||
|
||||
private fun addLineBreak(project: Project, lastElementBeforeConcat: PsiElement) {
|
||||
val newLineNode = try {
|
||||
PsiParserFacade.getInstance(project).createWhiteSpaceFromText("\n\t")
|
||||
} catch (ex: NoSuchMethodError) {
|
||||
// scheduled for removal, but alternate version not even available in 2020.3.
|
||||
// So keep it here until we run into a problem.
|
||||
// Changing the min version from 2017.3 to 2021.x is a major thing.
|
||||
val newLineNode =
|
||||
PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
|
||||
}
|
||||
|
||||
lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
|
||||
}
|
||||
|
||||
|
||||
+14
-8
@@ -7,7 +7,7 @@ import com.intellij.psi.PsiMethodCallExpression
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
|
||||
|
||||
class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean) :
|
||||
class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean, private val junit5: Boolean) :
|
||||
AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
@@ -23,14 +23,20 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
|
||||
val methodCallExpression = element as? PsiMethodCallExpression ?: return
|
||||
val args = methodCallExpression.argumentList
|
||||
val count = args.expressions.size
|
||||
val actualExpression = args.expressions[count - 1] ?: return
|
||||
val (expectedExpressions, messageExpression) = if (noExpectedExpression) {
|
||||
val message = args.expressions.getOrNull(count - 2)
|
||||
emptyArray<PsiExpression>() to message
|
||||
val hasMessage = if (noExpectedExpression) count == 1 else count == 2;
|
||||
|
||||
val actualExpression: PsiExpression
|
||||
val expectedExpressions: Array<PsiExpression>
|
||||
val messageExpression: PsiExpression?
|
||||
|
||||
if (junit5) {
|
||||
actualExpression = args.expressions[if (noExpectedExpression) 0 else 1] ?: return
|
||||
messageExpression = if (hasMessage) null else args.expressions[count - 1]
|
||||
expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[0])
|
||||
} else {
|
||||
val expected = args.expressions[count - 2] ?: return
|
||||
val message = args.expressions.getOrNull(count - 3)
|
||||
arrayOf(expected) to message
|
||||
actualExpression = args.expressions[count - 1] ?: return
|
||||
messageExpression = if (hasMessage) null else args.expressions[0]
|
||||
expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[count - 2])
|
||||
}
|
||||
|
||||
val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)
|
||||
|
||||
+3
-3
@@ -5,7 +5,7 @@ import com.intellij.openapi.project.Project
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
|
||||
class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
|
||||
class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) :
|
||||
AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
@@ -21,8 +21,8 @@ class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val repl
|
||||
val methodCallExpression = element as? PsiMethodCallExpression ?: return
|
||||
val args = methodCallExpression.argumentList
|
||||
val count = args.expressions.size
|
||||
val actualExpression = args.expressions[count - 1] ?: return
|
||||
val messageExpression = args.expressions.getOrNull(count - 2)
|
||||
val actualExpression = args.expressions[if (junit5) 0 else count - 1] ?: return
|
||||
val messageExpression = args.expressions.getOrNull(if (junit5) 1 else count - 2)
|
||||
|
||||
val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
|
||||
val newMethodCall = createAssumeThat(element, actualExpression)
|
||||
|
||||
+5
-5
@@ -6,7 +6,7 @@ import com.intellij.psi.PsiMethodCallExpression
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
|
||||
|
||||
class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
|
||||
class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) : AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
private const val CONVERT_DESCRIPTION = "Convert JUnit assertions with delta to assertJ"
|
||||
@@ -21,10 +21,10 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
|
||||
val methodCallExpression = element as? PsiMethodCallExpression ?: return
|
||||
val args = methodCallExpression.argumentList
|
||||
val count = args.expressions.size
|
||||
val messageExpression = args.expressions.getOrNull(count - 4)
|
||||
val expectedExpression = args.expressions[count - 3] ?: return
|
||||
val actualExpression = args.expressions[count - 2] ?: return
|
||||
val deltaExpression = args.expressions[count - 1] ?: return
|
||||
val messageExpression = args.expressions.getOrNull(if (junit5) 3 else count - 4)
|
||||
val expectedExpression = args.expressions[if (junit5) 0 else count - 3] ?: return
|
||||
val actualExpression = args.expressions[if (junit5) 1 else count - 2] ?: return
|
||||
val deltaExpression = args.expressions[if (junit5) 2 else count - 1] ?: return
|
||||
|
||||
val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
|
||||
|
||||
|
||||
@@ -28,8 +28,6 @@
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanConditionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatInvertedBooleanCondition" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInvertedBooleanConditionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatIsZeroOne" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatIsZeroOneInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatInstanceOf" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInstanceOfInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
<html>
|
||||
<body>
|
||||
Turns assertThat(numeric).isEqualTo(0/1) into assertThat(numeric).isZero()/isOne()
|
||||
or assertThat(numeric).isNotEqualTo(0) into assertThat(numeric).isNotZero().
|
||||
<!-- tooltip end -->
|
||||
<br>Also works with constant expressions.
|
||||
</body>
|
||||
</html>
|
||||
@@ -8,7 +8,6 @@ import de.platon42.intellij.jupiter.LightCodeInsightExtension
|
||||
import de.platon42.intellij.jupiter.TestDataPath
|
||||
import de.platon42.intellij.jupiter.TestJdk
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.assertj.core.api.Condition
|
||||
import org.junit.jupiter.api.DisplayNameGeneration
|
||||
import org.junit.jupiter.api.DisplayNameGenerator
|
||||
import org.junit.jupiter.api.extension.ExtendWith
|
||||
@@ -40,8 +39,11 @@ abstract class AbstractCajonTest {
|
||||
}
|
||||
|
||||
protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
|
||||
assertThat(myFixture.doHighlighting())
|
||||
.areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
|
||||
val highlights = myFixture.doHighlighting()
|
||||
.asSequence()
|
||||
.filter { it.description?.contains(snippet) ?: false }
|
||||
.toList()
|
||||
assertThat(highlights).hasSize(count)
|
||||
}
|
||||
|
||||
class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {
|
||||
|
||||
-21
@@ -1,21 +0,0 @@
|
||||
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 AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/IsZeroOne")
|
||||
internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
|
||||
myFixture.configureByFile("IsZeroOneBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
|
||||
myFixture.checkResultByFile("IsZeroOneAfter.java")
|
||||
}
|
||||
}
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddLocalJarToModule(org.junit.jupiter.api.Assertions::class, Assertions::class)
|
||||
internal class JUnit5AssertToAssertJInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/JUnit5AssertToAssertJ")
|
||||
internal fun junit5_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
|
||||
myFixture.configureByFile("JUnit5AssertToAssertJInspectionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 4)
|
||||
myFixture.checkResultByFile("JUnit5AssertToAssertJInspectionAfter.java")
|
||||
}
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class IsZeroOne {
|
||||
|
||||
private void isZeroOne() {
|
||||
short shortValue = 0;
|
||||
int intValue = 0;
|
||||
long longValue = 0L;
|
||||
float floatValue = 0.0f;
|
||||
double doubleValue = 0.0;
|
||||
|
||||
assertThat(shortValue).as("foo").isZero();
|
||||
assertThat(shortValue).isZero();
|
||||
assertThat(shortValue).as("foo").isOne();
|
||||
assertThat(shortValue).isOne();
|
||||
|
||||
assertThat(shortValue).as("foo").isNotZero();
|
||||
assertThat(shortValue).isNotZero();
|
||||
assertThat(shortValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(shortValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(intValue).as("foo").isZero();
|
||||
assertThat(intValue).isZero();
|
||||
assertThat(intValue).as("foo").isOne();
|
||||
assertThat(intValue).isOne();
|
||||
|
||||
assertThat(intValue).as("foo").isNotZero();
|
||||
assertThat(intValue).isNotZero();
|
||||
assertThat(intValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(intValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(longValue).as("foo").isZero();
|
||||
assertThat(longValue).isZero();
|
||||
assertThat(longValue).as("foo").isOne();
|
||||
assertThat(longValue).isOne();
|
||||
|
||||
assertThat(longValue).as("foo").isNotZero();
|
||||
assertThat(longValue).isNotZero();
|
||||
assertThat(longValue).as("foo").isNotEqualTo(1L);
|
||||
assertThat(longValue).isNotEqualTo(0L + 1L);
|
||||
|
||||
assertThat(floatValue).as("foo").isZero();
|
||||
assertThat(floatValue).isZero();
|
||||
assertThat(floatValue).as("foo").isOne();
|
||||
assertThat(floatValue).isOne();
|
||||
|
||||
assertThat(floatValue).as("foo").isNotZero();
|
||||
assertThat(floatValue).isNotZero();
|
||||
assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
|
||||
assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
|
||||
|
||||
assertThat(doubleValue).as("foo").isZero();
|
||||
assertThat(doubleValue).isZero();
|
||||
assertThat(doubleValue).as("foo").isOne();
|
||||
assertThat(doubleValue).isOne();
|
||||
|
||||
assertThat(doubleValue).as("foo").isNotZero();
|
||||
assertThat(doubleValue).isNotZero();
|
||||
assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
|
||||
assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
|
||||
|
||||
assertThat(intValue).as("foo").isEqualTo(2);
|
||||
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class IsZeroOne {
|
||||
|
||||
private void isZeroOne() {
|
||||
short shortValue = 0;
|
||||
int intValue = 0;
|
||||
long longValue = 0L;
|
||||
float floatValue = 0.0f;
|
||||
double doubleValue = 0.0;
|
||||
|
||||
assertThat(shortValue).as("foo").isEqualTo(0);
|
||||
assertThat(shortValue).isEqualTo(1 - 1);
|
||||
assertThat(shortValue).as("foo").isEqualTo(1);
|
||||
assertThat(shortValue).isEqualTo(0 + 1);
|
||||
|
||||
assertThat(shortValue).as("foo").isNotEqualTo(0);
|
||||
assertThat(shortValue).isNotEqualTo(1 - 1);
|
||||
assertThat(shortValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(shortValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(intValue).as("foo").isEqualTo(0);
|
||||
assertThat(intValue).isEqualTo(1 - 1);
|
||||
assertThat(intValue).as("foo").isEqualTo(1);
|
||||
assertThat(intValue).isEqualTo(0 + 1);
|
||||
|
||||
assertThat(intValue).as("foo").isNotEqualTo(0);
|
||||
assertThat(intValue).isNotEqualTo(1 - 1);
|
||||
assertThat(intValue).as("foo").isNotEqualTo(1);
|
||||
assertThat(intValue).isNotEqualTo(0 + 1);
|
||||
|
||||
assertThat(longValue).as("foo").isEqualTo(0L);
|
||||
assertThat(longValue).isEqualTo(1L - 1L);
|
||||
assertThat(longValue).as("foo").isEqualTo(1L);
|
||||
assertThat(longValue).isEqualTo(0L + 1L);
|
||||
|
||||
assertThat(longValue).as("foo").isNotEqualTo(0L);
|
||||
assertThat(longValue).isNotEqualTo(1L - 1L);
|
||||
assertThat(longValue).as("foo").isNotEqualTo(1L);
|
||||
assertThat(longValue).isNotEqualTo(0L + 1L);
|
||||
|
||||
assertThat(floatValue).as("foo").isEqualTo(0.0f);
|
||||
assertThat(floatValue).isEqualTo(1.0f - 1.0f);
|
||||
assertThat(floatValue).as("foo").isEqualTo(1.0f);
|
||||
assertThat(floatValue).isEqualTo(0.0f + 1.0f);
|
||||
|
||||
assertThat(floatValue).as("foo").isNotEqualTo(0.0f);
|
||||
assertThat(floatValue).isNotEqualTo(1.0f - 1.0f);
|
||||
assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
|
||||
assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
|
||||
|
||||
assertThat(doubleValue).as("foo").isEqualTo(0.0);
|
||||
assertThat(doubleValue).isEqualTo(1.0 - 1.0);
|
||||
assertThat(doubleValue).as("foo").isEqualTo(1.0);
|
||||
assertThat(doubleValue).isEqualTo(0.0 + 1.0);
|
||||
|
||||
assertThat(doubleValue).as("foo").isNotEqualTo(0.0);
|
||||
assertThat(doubleValue).isNotEqualTo(1.0 - 1.0);
|
||||
assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
|
||||
assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
|
||||
|
||||
assertThat(intValue).as("foo").isEqualTo(2);
|
||||
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assumptions.assumeThat;
|
||||
import static org.assertj.core.data.Offset.offset;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.junit.jupiter.api.Assumptions.*;
|
||||
|
||||
public class JUnit5AssertToAssertJ {
|
||||
|
||||
private void jUnit5AssertToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
int someInt = 1;
|
||||
double someDouble = 1.0;
|
||||
float someFloat = 1.0f;
|
||||
|
||||
assertThat(foo == "foo").isTrue();
|
||||
assertThat(foo == "foo").as("oh no!").isTrue();
|
||||
assertThat(foo == "bar").isFalse();
|
||||
assertThat(foo == "bar").as("boom!").isFalse();
|
||||
|
||||
assertThat(foo).isNull();
|
||||
assertThat(foo).as("oh no!").isNull();
|
||||
assertThat(foo).isNotNull();
|
||||
assertThat(foo).as("oh no!").isNotNull();
|
||||
|
||||
assertThat(foo).isEqualTo(bar);
|
||||
assertThat(foo).as("equals").isEqualTo(bar);
|
||||
assertThat(foo).isNotEqualTo(bar);
|
||||
assertThat(foo).as("equals").isNotEqualTo(bar);
|
||||
|
||||
assertThat(foo).isSameAs(bar);
|
||||
assertThat(foo).as("same").isSameAs(bar);
|
||||
assertThat(foo).isNotSameAs(bar);
|
||||
assertThat(foo).as("same").isNotSameAs(bar);
|
||||
|
||||
assertThat(2.0).isEqualTo(1.0);
|
||||
assertThat(2.0).isCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0).as("equals").isEqualTo(1.0);
|
||||
assertThat(2.0).as("equals").isCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0f).isEqualTo(1.0f);
|
||||
assertThat(2.0f).isCloseTo(1.0f, offset(0.1f));
|
||||
assertThat(2.0f).as("equals").isEqualTo(1.0f);
|
||||
assertThat(2.0f).as("equals").isCloseTo(1.0f, offset(0.1f));
|
||||
|
||||
assertThat(2.0).isNotEqualTo(1.0);
|
||||
assertThat(2.0).isNotCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0).as("equals").isNotEqualTo(1.0);
|
||||
assertThat(2.0).as("equals").isNotCloseTo(1.0, offset(0.1));
|
||||
assertThat(2.0f).isNotEqualTo(1.0f);
|
||||
assertThat(2.0f).isNotCloseTo(1.0f, offset(0.1f));
|
||||
assertThat(2.0f).as("equals").isNotEqualTo(1.0f);
|
||||
assertThat(2.0f).as("equals").isNotCloseTo(1.0f, offset(0.1f));
|
||||
|
||||
assertThat(new int[1]).containsExactly(new int[2]);
|
||||
assertThat(new int[1]).as("array equals").containsExactly(new int[2]);
|
||||
|
||||
assertThat(new double[1]).containsExactly(new double[2], offset(1.0));
|
||||
assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
|
||||
assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
|
||||
assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
|
||||
|
||||
assertThat(foo).isEqualTo("bar");
|
||||
assertThat(bar).as("equals").isEqualTo("foo");
|
||||
assertThat(bar).isNotEqualTo("foo");
|
||||
assertThat(foo).as("equals").isNotEqualTo("bar");
|
||||
|
||||
assertThat(someInt).isEqualTo(2);
|
||||
assertThat(someDouble).isCloseTo(2.0, offset(0.1));
|
||||
assertThat(someDouble).as("equals").isEqualTo(1.0);
|
||||
assertThat(someDouble).as("equals").isCloseTo(1.0, offset(0.1));
|
||||
assertThat(someFloat).isEqualTo(1.0f);
|
||||
assertThat(someFloat).isCloseTo(2.0f, offset(0.1f));
|
||||
|
||||
fail();
|
||||
fail("oh no!")
|
||||
}
|
||||
|
||||
private void jUnit5AssumeToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
assumeThat(foo == "foo").isTrue();
|
||||
assumeThat(foo == "foo").as("oh no!").isTrue();
|
||||
assumeThat(foo == "bar").isFalse();
|
||||
assumeThat(foo == "bar").as("boom!").isFalse();
|
||||
}
|
||||
}
|
||||
+83
@@ -0,0 +1,83 @@
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.junit.jupiter.api.Assumptions.*;
|
||||
|
||||
public class JUnit5AssertToAssertJ {
|
||||
|
||||
private void jUnit5AssertToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
int someInt = 1;
|
||||
double someDouble = 1.0;
|
||||
float someFloat = 1.0f;
|
||||
|
||||
assertTrue(foo == "foo");
|
||||
assertTrue(foo == "foo", "oh no!");
|
||||
assertFalse(foo == "bar");
|
||||
assertFalse(foo == "bar", "boom!");
|
||||
|
||||
assertNull(foo);
|
||||
assertNull(foo, "oh no!");
|
||||
assertNotNull(foo);
|
||||
assertNotNull(foo, "oh no!");
|
||||
|
||||
assertEquals(bar, foo);
|
||||
assertEquals(bar, foo, "equals");
|
||||
assertNotEquals(bar, foo);
|
||||
assertNotEquals(bar, foo, "equals");
|
||||
|
||||
assertSame(bar, foo);
|
||||
assertSame(bar, foo, "same");
|
||||
assertNotSame(bar, foo);
|
||||
assertNotSame(bar, foo, "same");
|
||||
|
||||
assertEquals(1.0, 2.0);
|
||||
assertEquals(1.0, 2.0, 0.1);
|
||||
assertEquals(1.0, 2.0, "equals");
|
||||
assertEquals(1.0, 2.0, 0.1, "equals");
|
||||
assertEquals(1.0f, 2.0f);
|
||||
assertEquals(1.0f, 2.0f, 0.1f);
|
||||
assertEquals(1.0f, 2.0f, "equals");
|
||||
assertEquals(1.0f, 2.0f, 0.1f, "equals");
|
||||
|
||||
assertNotEquals(1.0, 2.0);
|
||||
assertNotEquals(1.0, 2.0, 0.1);
|
||||
assertNotEquals(1.0, 2.0, "equals");
|
||||
assertNotEquals(1.0, 2.0, 0.1, "equals");
|
||||
assertNotEquals(1.0f, 2.0f);
|
||||
assertNotEquals(1.0f, 2.0f, 0.1f);
|
||||
assertNotEquals(1.0f, 2.0f, "equals");
|
||||
assertNotEquals(1.0f, 2.0f, 0.1f, "equals");
|
||||
|
||||
assertArrayEquals(new int[2], new int[1]);
|
||||
assertArrayEquals(new int[2], new int[1], "array equals");
|
||||
|
||||
assertArrayEquals(new double[2], new double[1], 1.0);
|
||||
assertArrayEquals(new double[2], new double[1], 1.0, "array equals");
|
||||
assertArrayEquals(new float[2], new float[1], 1.0f);
|
||||
assertArrayEquals(new float[2], new float[1], 1.0f, "array equals");
|
||||
|
||||
assertEquals("bar", foo);
|
||||
assertEquals(bar, "foo", "equals");
|
||||
assertNotEquals(bar, "foo");
|
||||
assertNotEquals("bar", foo, "equals");
|
||||
|
||||
assertEquals(someInt, 2);
|
||||
assertEquals(someDouble, 2.0, 0.1);
|
||||
assertEquals(1.0, someDouble, "equals");
|
||||
assertEquals(1.0, someDouble, 0.1, "equals");
|
||||
assertEquals(1.0f, someFloat);
|
||||
assertEquals(someFloat, 2.0f, 0.1f);
|
||||
|
||||
fail();
|
||||
fail("oh no!")
|
||||
}
|
||||
|
||||
private void jUnit5AssumeToAssertJ() {
|
||||
String foo = "foo";
|
||||
String bar = "bar";
|
||||
assumeTrue(foo == "foo");
|
||||
assumeTrue(foo == "foo", "oh no!");
|
||||
assumeFalse(foo == "bar");
|
||||
assumeFalse(foo == "bar", "boom!");
|
||||
}
|
||||
}
|
||||
@@ -66,9 +66,6 @@ public class JoinStatements {
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
|
||||
assertThat(list).filteredOn("foo", "foo").contains("narf");
|
||||
assertThat(list).filteredOn("bar", "bar").contains("puit");
|
||||
|
||||
org.junit.Assert.assertThat(list, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
@@ -63,9 +63,6 @@ public class JoinStatements {
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
assertThat(list.get(--i)).isEqualTo("foo");
|
||||
|
||||
assertThat(list).filteredOn("foo", "foo").contains("narf");
|
||||
assertThat(list).filteredOn("bar", "bar").contains("puit");
|
||||
|
||||
org.junit.Assert.assertThat(list, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user