Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 chrisly42
|
a0909d8c39 | ||
|
chrisly42
|
5113cc15ab | ||
|
chrisly42
|
ae2076a425 | ||
|
chrisly42
|
42429c0f72 | ||
|
chrisly42
|
8133f3850f | ||
|
chrisly42
|
8d03b3734c | ||
|
chrisly42
|
2f0d855d1e | ||
|
chrisly42
|
6dab8ad552 | ||
|
chrisly42
|
1983750077 | ||
|
chrisly42
|
a0ed4eab76 | ||
|
chrisly42
|
acc81863f5 | ||
|
chrisly42
|
2b97494c17 |
@@ -189,12 +189,39 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
from: assertThat(stringActual.endsWith(stringExpected)).isTrue();
|
||||
to: assertThat(stringActual).endsWith(stringExpected);
|
||||
|
||||
from: assertThat(stringActual.matches(stringExpected)).isTrue();
|
||||
to: assertThat(stringActual).matches(stringExpected);
|
||||
```
|
||||
Analogously with ```isFalse()```.
|
||||
|
||||
More funny stuff (excerpt):
|
||||
|
||||
```
|
||||
from: assertThat(stringActual.compareToIgnoreCase(stringExpected)).isEqualTo(0);
|
||||
to: assertThat(stringActual).isEqualToIgnoringCase(stringExpected);
|
||||
|
||||
from: assertThat(stringActual.indexOf(stringExpected)).isEqualTo(0);
|
||||
from: assertThat(stringActual.indexOf(stringExpected)).isZero();
|
||||
to: assertThat(stringActual).startsWith(stringExpected);
|
||||
|
||||
from: assertThat(stringActual.indexOf(stringExpected)).isNotZero();
|
||||
to: assertThat(stringActual).doesNotStartWith(stringExpected);
|
||||
|
||||
from: assertThat(stringActual.indexOf(stringExpected)).isEqualTo(-1);
|
||||
from: assertThat(stringActual.indexOf(stringExpected)).isNegative();
|
||||
to: assertThat(stringActual).doesNotContain(stringExpected);
|
||||
|
||||
from: assertThat(stringActual.indexOf(stringExpected)).isGreaterThanOrEqualTo(0);
|
||||
to: assertThat(stringActual).contains(stringExpected);
|
||||
|
||||
from: assertThat(stringActual.trim()).isNotEmpty();
|
||||
to: assertThat(stringActual).isNotBlank();
|
||||
```
|
||||
|
||||
- AssertThatObjectExpression
|
||||
|
||||
Handles equals(), toString() and hashCode() inside an expected expression.
|
||||
Handles ```equals()```, ```toString()``` and ```hashCode()``` inside an expected expression.
|
||||
|
||||
```
|
||||
from: assertThat(objActual.equals(objExpected)).isTrue();
|
||||
@@ -207,9 +234,38 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
to: assertThat(objActual).hasSameHashCodeAs(objExpected);
|
||||
```
|
||||
|
||||
- AssertThatComparableExpression
|
||||
|
||||
Handles ```compareTo()``` inside an expected expression.
|
||||
|
||||
```
|
||||
from: assertThat(obj1.compareTo(obj2)).isEqualTo(0);
|
||||
to: assertThat(obj1).isEqualByComparingTo(obj2);
|
||||
|
||||
from: assertThat(obj1.compareTo(obj2)).isNotZero();
|
||||
to: assertThat(obj1).isNotEqualByComparingTo(obj2);
|
||||
|
||||
from: assertThat(obj1.compareTo(obj2)).isNotEqualTo(-1);
|
||||
from: assertThat(obj1.compareTo(obj2)).isGreaterThanOrEqualTo(0);
|
||||
from: assertThat(obj1.compareTo(obj2)).isGreaterThan(-1);
|
||||
from: assertThat(obj1.compareTo(obj2)).isNotNegative();
|
||||
to: assertThat(obj1).isGreaterThanOrEqualTo(obj2);
|
||||
|
||||
from: assertThat(obj1.compareTo(obj2)).isOne();
|
||||
to: assertThat(obj1).isGreaterThan(obj2);
|
||||
|
||||
from: assertThat(obj1.compareTo(obj2)).isNotPositive();
|
||||
to: assertThat(obj1).isLessThanOrEqualTo(obj2);
|
||||
|
||||
from: assertThat(obj1.compareTo(obj2)).isLessThan(0);
|
||||
to: assertThat(obj1).isLessThan(obj2);
|
||||
```
|
||||
|
||||
Several more combinations omitted...
|
||||
|
||||
- AssertThatCollectionOrMapExpression
|
||||
|
||||
Moves collection and map operations inside ```assertThat()``` out.
|
||||
Moves ```Collection``` and ```Map``` operations inside ```assertThat()``` out.
|
||||
|
||||
```
|
||||
from: assertThat(collection.isEmpty()).isTrue();
|
||||
@@ -232,7 +288,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
```
|
||||
Analogously with ```isFalse()``` (except for ```containsAll()```).
|
||||
|
||||
Additional transformations for maps:
|
||||
Additional transformations for ```Map``` instances:
|
||||
|
||||
```
|
||||
from: assertThat(map.get(key)).isEqualTo(value);
|
||||
@@ -258,6 +314,95 @@ 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();
|
||||
```
|
||||
|
||||
and additionally with AssertJ 3.14.0 or later
|
||||
|
||||
```
|
||||
from: assertThat(file.length()).isEqualTo(0);
|
||||
from: assertThat(file.length()).isZero();
|
||||
to: assertThat(file).isEmpty();
|
||||
|
||||
from: assertThat(file.length()).isNotEqualTo(0);
|
||||
from: assertThat(file.length()).isNotZero();
|
||||
to: assertThat(file).isNotEmpty();
|
||||
|
||||
from: assertThat(file.length()).isEqualTo(len);
|
||||
to: assertThat(file).hasSize(len);
|
||||
```
|
||||
|
||||
- AssertThatPathExpression
|
||||
|
||||
Moves ```Path``` method calls inside ```assertThat()``` out.
|
||||
Note: Uses hasParentRaw() instead of hasParent() for quickfixes, because it is semantically
|
||||
equivalent. For most cases though, hasParent() will show identical behavior.
|
||||
|
||||
```
|
||||
from: assertThat(path.isAbsolute()).isTrue();
|
||||
to: assertThat(path).isAbsolute();
|
||||
|
||||
from: assertThat(path.isAbsolute()).isFalse();
|
||||
to: assertThat(path).isRelative();
|
||||
|
||||
from: assertThat(path.getParent()).isEqualTo(pathname);
|
||||
to: assertThat(path).hasParentRaw(pathname);
|
||||
|
||||
from: assertThat(path.getParent()).isNull();
|
||||
to: assertThat(path).hasNoParentRaw();
|
||||
|
||||
from: assertThat(path.startsWith(otherPath)).isTrue();
|
||||
to: assertThat(path).startsWithRaw(otherPath);
|
||||
|
||||
from: assertThat(path.endsWith(otherPath)).isTrue();
|
||||
to: assertThat(path).endsWithRaw(otherPath);
|
||||
```
|
||||
|
||||
- AssertThatEnumerableIsEmpty
|
||||
|
||||
Uses ```isEmpty()``` for ```hasSize(0)``` iterable assertions instead.
|
||||
@@ -269,8 +414,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
- AssertThatSize
|
||||
|
||||
Makes assertions on sizes of arrays, collections, maps, strings,
|
||||
or ```CharSequence```s more concise.
|
||||
Makes assertions on sizes on ```Array```, ```Collection```,
|
||||
```Map```, ```String```, or ```CharSequence``` instances more concise.
|
||||
|
||||
```
|
||||
from: assertThat(array.length).isEqualTo(0);
|
||||
@@ -306,7 +451,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
from: assertThat(array.length).isGreaterThanOrEqualTo(expression);
|
||||
to: assertThat(array).hasSizeGreaterThanOrEqualTo(expression);
|
||||
```
|
||||
and analogously for collections, maps, strings and CharSequences, e.g:
|
||||
and analogously for ```Collection```, ```Map```, ```String``` and
|
||||
```CharSequence``` objects, e.g:
|
||||
|
||||
```
|
||||
from: assertThat("string".length()).isLessThan(1);
|
||||
@@ -433,7 +579,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
to: assertThat(opt).isPresent();
|
||||
```
|
||||
|
||||
AssertJ for Guava needs to be available in the classpath.
|
||||
AssertJ for Guava needs to be available in the classpath for this inspection to work.
|
||||
|
||||
- AssumeThatInsteadOfReturn
|
||||
|
||||
@@ -526,6 +672,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
### Implemented referencing
|
||||
|
||||
You can ctrl-click on references inside .extracting() method parameters to go the
|
||||
referencing method definition.
|
||||
```
|
||||
.extracting("field")
|
||||
.extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
|
||||
@@ -539,7 +687,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
.flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
|
||||
.flatExtracting(Extractors.resultOf("bareMethod")
|
||||
```
|
||||
Works on both POJOs and ```Iterable```s/```Array```s.
|
||||
This works on both POJOs and ```Iterable```s/```Array```s.
|
||||
Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
|
||||
If there's demand, I could add it.
|
||||
|
||||
@@ -552,10 +700,9 @@ 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.
|
||||
- Converting ```foo.compareTo(bar) == 0``` to ```isEqualTo()``` (yes, I've *really* seen code like that)
|
||||
- Extraction with property names to lambda with Java 8
|
||||
- More Optional fixes such as ```opt1.get() == opt2.get()``` etc.
|
||||
- More moving out of methods for LocalDate/Time etc.
|
||||
- Extraction with property names to lambda/method reference with Java 8
|
||||
|
||||
```
|
||||
from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
|
||||
@@ -564,6 +711,23 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
|
||||
## Changelog
|
||||
|
||||
#### V1.7 (19-Nov-19)
|
||||
- Fixed a lapsuus in AssertThatFileExpression also transforming ```.listFiles()``` with a filter argument.
|
||||
- Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
|
||||
but requires detection and transformation of static ```Files```-methods).
|
||||
- Added AssertThatComparableExpression for funny ```compareTo()``` uses.
|
||||
- Added ```hasSize(), isEmpty()``` and ```isNotEmpty()``` for AssertThatFileExpression when using AssertJ >= 3.14.0.
|
||||
|
||||
#### V1.6 (30-Sep-19)
|
||||
- Really fixed AssertThatGuavaOptional inspections to avoid conversions from ```.get()``` to ```.contains()```
|
||||
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).
|
||||
- Added several transformations to AssertThatStringExpression inspection.
|
||||
Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
|
||||
|
||||
#### V1.5 (24-Sep-19)
|
||||
- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception.
|
||||
- AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
|
||||
|
||||
+13
-16
@@ -1,13 +1,13 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'org.jetbrains.intellij' version '0.4.10'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.3.50'
|
||||
id 'org.jetbrains.intellij' version '0.4.13'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.3.60'
|
||||
id 'jacoco'
|
||||
id 'com.github.kt3k.coveralls' version '2.8.4'
|
||||
}
|
||||
|
||||
group 'de.platon42'
|
||||
version '1.5'
|
||||
version '1.7'
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
@@ -20,8 +20,8 @@ repositories {
|
||||
|
||||
dependencies {
|
||||
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
testCompile "org.assertj:assertj-core:3.13.2"
|
||||
testCompile "org.assertj:assertj-guava:3.2.1"
|
||||
testCompile "org.assertj:assertj-core:3.14.0"
|
||||
testCompile "org.assertj:assertj-guava:3.3.0"
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-test"
|
||||
@@ -35,7 +35,7 @@ compileTestKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
intellij {
|
||||
version '2019.2.3'
|
||||
version '2019.2.4'
|
||||
// pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
|
||||
updateSinceUntilBuild false
|
||||
plugins = ['java']
|
||||
@@ -43,16 +43,13 @@ intellij {
|
||||
|
||||
patchPluginXml {
|
||||
changeNotes """
|
||||
<h4>V1.5 (24-Sep-19)</h4>
|
||||
<h4>V1.7 (19-Nov-19)</h4>
|
||||
<ul>
|
||||
<li>Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception.
|
||||
<li>AssertThatGuavaOptional inspections will now avoid conversions from .get() to .contains()
|
||||
for array types (currently not correctly supported by AssertJ-Guava).
|
||||
<li>Added an settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with null values.
|
||||
It is now possible to change the behavior for map.get(key) == null, so it can offer either .doesNotContainKey() (default)
|
||||
or .containsEntry(key, null), or even both.
|
||||
<li>Fixes to AssertThatSize inspection after extending it for Maps in previous release as not all
|
||||
combinations for .hasSameSizeAs() are supported.
|
||||
<li>Fixed a lapsuus in AssertThatFileExpression also transforming listFiles() with a filter argument.
|
||||
<li>Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
|
||||
but requires detection and transformation of static Files-methods).
|
||||
<li>Added AssertThatComparableExpression for funny compareTo() uses.
|
||||
<li>Added hasSize(), isEmpty() and isNotEmpty() for AssertThatFileExpression when using AssertJ >= 3.14.0.
|
||||
</ul>
|
||||
<p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
|
||||
"""
|
||||
@@ -66,7 +63,7 @@ test {
|
||||
}
|
||||
|
||||
jacoco {
|
||||
toolVersion = '0.8.4'
|
||||
toolVersion = '0.8.5'
|
||||
}
|
||||
|
||||
jacocoTestReport {
|
||||
|
||||
@@ -44,8 +44,12 @@ 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_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"
|
||||
|
||||
+19
-3
@@ -25,7 +25,7 @@ import de.platon42.intellij.plugins.cajon.MethodNames
|
||||
import de.platon42.intellij.plugins.cajon.qualifierExpression
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
|
||||
|
||||
open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
|
||||
abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
|
||||
|
||||
companion object {
|
||||
const val SIMPLIFY_MESSAGE_TEMPLATE = "%s() can be simplified to %s()"
|
||||
@@ -120,6 +120,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
|
||||
val IS_NOT_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_NULL)
|
||||
.parameterCount(0)!!
|
||||
|
||||
val IS_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_EMPTY)
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_NOT_EMPTY)
|
||||
.parameterCount(0)!!
|
||||
val HAS_SIZE = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE)
|
||||
@@ -135,9 +137,23 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
|
||||
val IS_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN_OR_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
|
||||
val IS_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
|
||||
val IS_ZERO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
|
||||
val IS_NOT_ZERO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
|
||||
.parameterCount(0)!!
|
||||
val IS_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
|
||||
.parameterCount(0)!!
|
||||
val IS_ONE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
|
||||
.parameterCount(0)!!
|
||||
val IS_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
|
||||
.parameterCount(0)!!
|
||||
val IS_NOT_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
|
||||
.parameterCount(0)!!
|
||||
val IS_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
|
||||
.parameterCount(0)!!
|
||||
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)
|
||||
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.codeInspection.ProblemsHolder
|
||||
import com.intellij.psi.PsiExpressionStatement
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
|
||||
|
||||
abstract class AbstractMoveOutInspection : AbstractAssertJInspection() {
|
||||
|
||||
protected fun createInspectionsForMappings(
|
||||
statement: PsiExpressionStatement,
|
||||
holder: ProblemsHolder,
|
||||
mappings: List<MoveOutMapping>
|
||||
) {
|
||||
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
|
||||
if (mapping.additionalCondition?.invoke(statement, expectedCallExpression) == false) 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
|
||||
if (mapping.additionalCondition?.invoke(statement, expectedCallExpression) == false) 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) {
|
||||
if (mapping.additionalCondition?.invoke(statement, expectedCallExpression) == false) continue
|
||||
registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, mapping.replacementForTrue) { desc, method ->
|
||||
MoveOutMethodCallExpressionQuickFix(
|
||||
desc, method,
|
||||
replaceOnlyThisMethod = mapping.expectedMatcher,
|
||||
replaceFromOriginalMethod = mapping.replaceFromOriginalMethod,
|
||||
noExpectedExpression = mapping.noExpectedExpression
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class MoveOutMapping(
|
||||
val callMatcher: CallMatcher,
|
||||
val replacementForTrue: String,
|
||||
val replacementForFalse: String? = null,
|
||||
val expectBoolean: Boolean = false,
|
||||
val expectNullNonNull: Boolean? = null,
|
||||
val expectedMatcher: CallMatcher? = null,
|
||||
val replaceFromOriginalMethod: Boolean = false,
|
||||
val noExpectedExpression: Boolean = false,
|
||||
val additionalCondition: ((PsiExpressionStatement, PsiMethodCallExpression) -> Boolean)? = null
|
||||
)
|
||||
}
|
||||
+7
-1
@@ -38,7 +38,13 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
|
||||
|
||||
if (isLeftNull && isRightNull) return
|
||||
if (isLeftNull || isRightNull) {
|
||||
val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
|
||||
val expectedResultOnOp =
|
||||
when (binaryExpression.operationTokenType) {
|
||||
JavaTokenType.EQEQ -> expectedResult
|
||||
JavaTokenType.NE -> !expectedResult
|
||||
else -> return
|
||||
}
|
||||
val replacementMethod = expectedResultOnOp.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
|
||||
registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
|
||||
SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
|
||||
}
|
||||
|
||||
+14
-28
@@ -12,7 +12,7 @@ import javax.swing.JComponent
|
||||
import javax.swing.JPanel
|
||||
|
||||
|
||||
class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection() {
|
||||
class AssertThatCollectionOrMapExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a collection or map specific expression"
|
||||
@@ -39,28 +39,28 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
|
||||
)
|
||||
|
||||
private val MAPPINGS = listOf(
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.anyOf(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.IS_EMPTY).parameterCount(0),
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.IS_EMPTY).parameterCount(0)
|
||||
),
|
||||
MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
|
||||
MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS).parameterCount(1),
|
||||
MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
|
||||
MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS_ALL).parameterCount(1),
|
||||
MethodNames.CONTAINS_ALL, null
|
||||
MethodNames.CONTAINS_ALL, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_KEY).parameterCount(1),
|
||||
MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY
|
||||
MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_VALUE).parameterCount(1),
|
||||
MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE
|
||||
MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE, expectBoolean = true
|
||||
)
|
||||
)
|
||||
}
|
||||
@@ -78,8 +78,8 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
|
||||
val staticMethodCall = statement.findStaticMethodCall() ?: return
|
||||
|
||||
val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
|
||||
val expectedCallExpression = statement.findOutmostMethodCall() ?: return
|
||||
if (MAP_GET_MATCHER.test(assertThatArgument)) {
|
||||
val expectedCallExpression = statement.findOutmostMethodCall() ?: return
|
||||
val nullOrNotNull = expectedCallExpression.getAllTheSameNullNotNullConstants()
|
||||
if (nullOrNotNull == true) {
|
||||
registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_KEY) { desc, method ->
|
||||
@@ -108,7 +108,7 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
|
||||
expectedCallExpression,
|
||||
assertThatArgument,
|
||||
MethodNames.DOES_NOT_CONTAIN_KEY + "/" + MethodNames.CONTAINS_ENTRY
|
||||
) { desc ->
|
||||
) { _ ->
|
||||
listOf(
|
||||
MoveOutMethodCallExpressionQuickFix(
|
||||
"Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)",
|
||||
@@ -136,15 +136,7 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
|
||||
val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
|
||||
|
||||
val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
|
||||
|
||||
val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse ?: return
|
||||
registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
|
||||
MoveOutMethodCallExpressionQuickFix(desc, method)
|
||||
}
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -163,10 +155,4 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
|
||||
)
|
||||
return panel
|
||||
}
|
||||
|
||||
private class Mapping(
|
||||
val callMatcher: CallMatcher,
|
||||
val replacementForTrue: String,
|
||||
val replacementForFalse: String?
|
||||
)
|
||||
}
|
||||
+115
@@ -0,0 +1,115 @@
|
||||
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.MethodNames
|
||||
import de.platon42.intellij.plugins.cajon.calculateConstantValue
|
||||
import de.platon42.intellij.plugins.cajon.firstArg
|
||||
|
||||
class AssertThatComparableInspection : AbstractMoveOutInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a compareTo() expression"
|
||||
|
||||
private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
|
||||
private val ARG_IS_PLUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 1 }
|
||||
private val ARG_IS_MINUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == -1 }
|
||||
|
||||
private val COMPARABLE_COMPARE_TO =
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_COMPARABLE, "compareTo").parameterCount(1)
|
||||
|
||||
private val MAPPINGS = listOf(
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
"isEqualByComparingTo", expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
"isEqualByComparingTo", expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
"isNotEqualByComparingTo", expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
"isNotEqualByComparingTo", expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_GREATER_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = CallMatcher.anyOf(IS_NOT_EQUAL_TO_INT, IS_GREATER_THAN_INT), replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_MINUS_ONE_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_INT, IS_GREATER_THAN_OR_EQUAL_TO_INT), replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_PLUS_ONE_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = IS_GREATER_THAN_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE, IS_ONE), replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_LESS_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = CallMatcher.anyOf(IS_NOT_EQUAL_TO_INT, IS_LESS_THAN_INT), replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_PLUS_ONE_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_INT, IS_LESS_THAN_OR_EQUAL_TO_INT), replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_MINUS_ONE_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = IS_LESS_THAN_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
COMPARABLE_COMPARE_TO,
|
||||
MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
|
||||
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
|
||||
return object : JavaElementVisitor() {
|
||||
override fun visitExpressionStatement(statement: PsiExpressionStatement) {
|
||||
super.visitExpressionStatement(statement)
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+119
@@ -0,0 +1,119 @@
|
||||
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.*
|
||||
|
||||
|
||||
class AssertThatFileExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a file specific expression"
|
||||
|
||||
private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
|
||||
private val ARG_IS_NOT_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call ->
|
||||
val constant =
|
||||
call.firstArg.calculateConstantValue()
|
||||
(constant != null) && (constant != 0)
|
||||
}
|
||||
|
||||
private val MAPPINGS = listOf(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "canRead").parameterCount(0),
|
||||
"canRead", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "canWrite").parameterCount(0),
|
||||
"canWrite", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "exists").parameterCount(0),
|
||||
"exists", "doesNotExist", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isAbsolute").parameterCount(0),
|
||||
"isAbsolute", "isRelative", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isDirectory").parameterCount(0),
|
||||
"isDirectory", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isFile").parameterCount(0),
|
||||
"isFile", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getName").parameterCount(0),
|
||||
"hasName",
|
||||
expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParent", "getParentFile").parameterCount(0),
|
||||
"hasNoParent", expectNullNonNull = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParent").parameterCount(0),
|
||||
"hasParent",
|
||||
expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParentFile").parameterCount(0),
|
||||
"hasParent",
|
||||
expectedMatcher = IS_EQUAL_TO_OBJECT
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "list", "listFiles").parameterCount(0),
|
||||
"isEmptyDirectory",
|
||||
expectedMatcher = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, MethodNames.IS_EMPTY)
|
||||
.parameterCount(0)
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "list", "listFiles").parameterCount(0),
|
||||
"isNotEmptyDirectory",
|
||||
expectedMatcher = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, MethodNames.IS_NOT_EMPTY)
|
||||
.parameterCount(0)
|
||||
)
|
||||
)
|
||||
|
||||
private val MAPPINGS_SINCE_ASSERTJ_3_14_0 = listOf(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
|
||||
"isEmpty", expectedMatcher = IS_ZERO_LONG, noExpectedExpression = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
|
||||
"isEmpty", expectedMatcher = IS_EQUAL_TO_LONG, noExpectedExpression = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
|
||||
"isNotEmpty", expectedMatcher = IS_NOT_ZERO_LONG, noExpectedExpression = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
|
||||
"isNotEmpty", expectedMatcher = IS_NOT_EQUAL_TO_LONG, noExpectedExpression = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
|
||||
"hasSize", expectedMatcher = IS_EQUAL_TO_LONG,
|
||||
additionalCondition = ARG_IS_NOT_ZERO_CONST
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
|
||||
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
|
||||
return object : JavaElementVisitor() {
|
||||
override fun visitExpressionStatement(statement: PsiExpressionStatement) {
|
||||
super.visitExpressionStatement(statement)
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS)
|
||||
if (hasAssertJMethod(statement, AssertJClassNames.ABSTRACT_FILE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)) {
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS_SINCE_ASSERTJ_3_14_0)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -29,7 +29,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
|
||||
val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
|
||||
val outmostMethodCall = statement.findOutmostMethodCall() ?: return
|
||||
if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
|
||||
if (actualExpression.resolveMethod()?.returnType is PsiArrayType) return
|
||||
if (actualExpression.type is PsiArrayType) return
|
||||
val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
|
||||
if (CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expectedCallExpression)) {
|
||||
registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
|
||||
|
||||
+21
-25
@@ -5,10 +5,8 @@ import com.intellij.psi.*
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.HasHashCodeQuickFix
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
|
||||
|
||||
class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
|
||||
class AssertThatObjectExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting equals(), toString(), or hashCode()"
|
||||
@@ -16,6 +14,17 @@ class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
|
||||
|
||||
private val OBJECT_TO_STRING = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "toString").parameterCount(0)
|
||||
private val OBJECT_HASHCODE = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "hashCode").parameterCount(0)
|
||||
|
||||
private val MAPPINGS = listOf(
|
||||
MoveOutMapping(
|
||||
OBJECT_EQUALS,
|
||||
MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
OBJECT_TO_STRING,
|
||||
MethodNames.HAS_TO_STRING, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
@@ -25,31 +34,18 @@ class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
|
||||
override fun visitExpressionStatement(statement: PsiExpressionStatement) {
|
||||
super.visitExpressionStatement(statement)
|
||||
if (!statement.hasAssertThat()) return
|
||||
|
||||
val staticMethodCall = statement.findStaticMethodCall() ?: return
|
||||
|
||||
val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
|
||||
val expectedCallExpression = statement.findOutmostMethodCall() ?: return
|
||||
when {
|
||||
OBJECT_EQUALS.test(assertThatArgument) -> {
|
||||
val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
|
||||
val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
|
||||
registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
|
||||
MoveOutMethodCallExpressionQuickFix(desc, method)
|
||||
}
|
||||
}
|
||||
OBJECT_TO_STRING.test(assertThatArgument) -> {
|
||||
staticMethodCall.findFluentCallTo(IS_EQUAL_TO_OBJECT) ?: staticMethodCall.findFluentCallTo(IS_EQUAL_TO_STRING) ?: return
|
||||
registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.HAS_TO_STRING) { desc, method ->
|
||||
RemoveActualOutmostMethodCallQuickFix(desc, method)
|
||||
}
|
||||
}
|
||||
OBJECT_HASHCODE.test(assertThatArgument) -> {
|
||||
val isEqualTo = staticMethodCall.findFluentCallTo(IS_EQUAL_TO_INT) ?: return
|
||||
val expectedExpression = isEqualTo.firstArg as? PsiMethodCallExpression ?: return
|
||||
if (OBJECT_HASHCODE.test(expectedExpression)) {
|
||||
holder.registerProblem(expectedCallExpression, HASHCODE_MESSAGE_TEMPLATE, HasHashCodeQuickFix())
|
||||
}
|
||||
if (OBJECT_HASHCODE.test(assertThatArgument)) {
|
||||
val expectedCallExpression = statement.findOutmostMethodCall() ?: return
|
||||
val isEqualTo = staticMethodCall.findFluentCallTo(IS_EQUAL_TO_INT) ?: return
|
||||
val expectedExpression = isEqualTo.firstArg as? PsiMethodCallExpression ?: return
|
||||
if (OBJECT_HASHCODE.test(expectedExpression)) {
|
||||
holder.registerProblem(expectedCallExpression, HASHCODE_MESSAGE_TEMPLATE, HasHashCodeQuickFix())
|
||||
}
|
||||
} else {
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
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.PsiExpressionStatement
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
|
||||
|
||||
class AssertThatPathExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a path specific expression"
|
||||
private const val JAVA_NIO_PATH = "java.nio.file.Path"
|
||||
|
||||
private val MAPPINGS = listOf(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(JAVA_NIO_PATH, "isAbsolute").parameterCount(0),
|
||||
"isAbsolute", "isRelative", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(JAVA_NIO_PATH, "startsWith").parameterTypes(JAVA_NIO_PATH),
|
||||
"startsWithRaw", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(JAVA_NIO_PATH, "endsWith").parameterTypes(JAVA_NIO_PATH),
|
||||
"endsWithRaw", expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(JAVA_NIO_PATH, "getParent").parameterCount(0),
|
||||
"hasParentRaw",
|
||||
expectedMatcher = IS_EQUAL_TO_OBJECT
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(JAVA_NIO_PATH, "getParent").parameterCount(0),
|
||||
"hasNoParentRaw", expectNullNonNull = true
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
|
||||
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
|
||||
return object : JavaElementVisitor() {
|
||||
override fun visitExpressionStatement(statement: PsiExpressionStatement) {
|
||||
super.visitExpressionStatement(statement)
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -57,10 +57,10 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
|
||||
} else {
|
||||
val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 0))
|
||||
|| (IS_LESS_THAN_INT.test(expression) && (constValue == 1))
|
||||
|| IS_ZERO.test(expression))
|
||||
|| IS_ZERO_INT.test(expression))
|
||||
val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expression) && (constValue == 0))
|
||||
|| (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 1))
|
||||
|| IS_NOT_ZERO.test(expression))
|
||||
|| IS_NOT_ZERO_INT.test(expression))
|
||||
if ((isTestForEmpty && isLastExpression) || isTestForNotEmpty) {
|
||||
val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
|
||||
return Match(expression, replacementMethod, noExpectedExpression = true)
|
||||
|
||||
+113
-35
@@ -3,41 +3,138 @@ 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
|
||||
import de.platon42.intellij.plugins.cajon.MethodNames
|
||||
import de.platon42.intellij.plugins.cajon.calculateConstantValue
|
||||
import de.platon42.intellij.plugins.cajon.firstArg
|
||||
|
||||
class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
|
||||
class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting a string specific expression"
|
||||
|
||||
private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
|
||||
private val ARG_IS_MINUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == -1 }
|
||||
|
||||
private val STRING_COMPARE_TO_IGNORE_CASE =
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "compareToIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING)
|
||||
private val STRING_INDEX_OF = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "indexOf").parameterTypes(CommonClassNames.JAVA_LANG_STRING)
|
||||
private val STRING_TRIM = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "trim").parameterCount(0)
|
||||
|
||||
private val MAPPINGS = listOf(
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0),
|
||||
MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
|
||||
MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.anyOf(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equals").parameterCount(1),
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contentEquals").parameterCount(1)
|
||||
),
|
||||
MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO
|
||||
MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equalsIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
|
||||
MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC
|
||||
MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contains").parameterCount(1),
|
||||
MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
|
||||
MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "startsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
|
||||
MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH
|
||||
MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH, expectBoolean = true
|
||||
),
|
||||
Mapping(
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "endsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
|
||||
MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH
|
||||
MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH, expectBoolean = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "matches").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
|
||||
"matches", "doesNotMatch", expectBoolean = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_COMPARE_TO_IGNORE_CASE,
|
||||
MethodNames.IS_EQUAL_TO_IC, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_COMPARE_TO_IGNORE_CASE,
|
||||
MethodNames.IS_EQUAL_TO_IC, expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_COMPARE_TO_IGNORE_CASE,
|
||||
MethodNames.IS_NOT_EQUAL_TO_IC, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_COMPARE_TO_IGNORE_CASE,
|
||||
MethodNames.IS_NOT_EQUAL_TO_IC, expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.STARTS_WITH, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.STARTS_WITH, expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_START_WITH, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_START_WITH, expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_MINUS_ONE_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_GREATER_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.CONTAINS, expectedMatcher = IS_GREATER_THAN_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_MINUS_ONE_CONST
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_MINUS_ONE_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_LESS_THAN_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_ZERO_CONST
|
||||
),
|
||||
MoveOutMapping(
|
||||
STRING_INDEX_OF,
|
||||
MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_LESS_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
|
||||
additionalCondition = ARG_IS_MINUS_ONE_CONST
|
||||
),
|
||||
|
||||
MoveOutMapping(
|
||||
STRING_TRIM,
|
||||
"isNotBlank", expectedMatcher = IS_NOT_EMPTY
|
||||
)
|
||||
)
|
||||
}
|
||||
@@ -48,27 +145,8 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
|
||||
return object : JavaElementVisitor() {
|
||||
override fun visitExpressionStatement(statement: PsiExpressionStatement) {
|
||||
super.visitExpressionStatement(statement)
|
||||
if (!statement.hasAssertThat()) return
|
||||
val staticMethodCall = statement.findStaticMethodCall() ?: return
|
||||
if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
|
||||
|
||||
val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
|
||||
val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
|
||||
|
||||
val expectedCallExpression = statement.findOutmostMethodCall() ?: return
|
||||
val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
|
||||
|
||||
val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse
|
||||
registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
|
||||
MoveOutMethodCallExpressionQuickFix(desc, method)
|
||||
}
|
||||
createInspectionsForMappings(statement, holder, MAPPINGS)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class Mapping(
|
||||
val callMatcher: CallMatcher,
|
||||
val replacementForTrue: String,
|
||||
val replacementForFalse: String
|
||||
)
|
||||
}
|
||||
+46
-21
@@ -3,7 +3,9 @@ package de.platon42.intellij.plugins.cajon.quickfixes
|
||||
import com.intellij.codeInspection.ProblemDescriptor
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.psi.JavaPsiFacade
|
||||
import com.intellij.psi.PsiExpression
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
|
||||
class MoveOutMethodCallExpressionQuickFix(
|
||||
@@ -11,7 +13,9 @@ 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,
|
||||
private val replaceFromOriginalMethod: Boolean = false
|
||||
) :
|
||||
AbstractCommonQuickFix(description) {
|
||||
|
||||
@@ -27,31 +31,52 @@ class MoveOutMethodCallExpressionQuickFix(
|
||||
val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
|
||||
val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
|
||||
val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
|
||||
val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy()
|
||||
val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy() as PsiExpression?
|
||||
|
||||
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,
|
||||
*if (replaceFromOriginalMethod || noExpectedExpression) listOfNotNull(assertExpressionArg).toTypedArray() else 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -41,10 +41,16 @@
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatObjectExpression" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectExpressionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatComparable" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatComparableInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatStringExpression" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringExpressionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatCollectionOrMapExpression" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatCollectionOrMapExpressionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatFileExpression" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatFileExpressionInspection"/>
|
||||
<localInspection groupPath="Java" shortName="AssertThatPathExpression" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatPathExpressionInspection"/>
|
||||
|
||||
<localInspection groupPath="Java" shortName="JoinAssertThatStatements" enabledByDefault="true" level="WARNING"
|
||||
implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinAssertThatStatementsInspection"/>
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
<html>
|
||||
<body>
|
||||
Turns assertThat(obj1.compareTo(obj2)) into assertThat(obj1).someMethod(obj2).
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,8 @@
|
||||
<html>
|
||||
<body>
|
||||
Operates on assertions on objects of type File. Turns assertThat(file.someMethod(arg)).someAssertion() into assertThat(file).someMethod(arg).
|
||||
<!-- tooltip end -->
|
||||
<br>someMethod() can be canRead(), canWrite(), exists(), isAbsolute(), isDirectory(), isFile(),
|
||||
getName(), getParent(), getParentFile(), list() and listFiles().
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,7 @@
|
||||
<html>
|
||||
<body>
|
||||
Operates on assertions on objects of type Path. Turns assertThat(file.someMethod(arg)).someAssertion() into assertThat(path).someMethod(arg).
|
||||
<!-- tooltip end -->
|
||||
<br>someMethod() can be isAbsolute(), getParent(), startsWith() and endsWith().
|
||||
</body>
|
||||
</html>
|
||||
@@ -2,6 +2,7 @@
|
||||
<body>
|
||||
Turns assertThat(string.someMethod(arg)).isTrue/isFalse() into assertThat(string).someMethod(arg).
|
||||
<!-- tooltip end -->
|
||||
<br>someMethod() can be isEmpty(), equals(), equalsIgnoreCase(), contentEquals(), contains(), startsWith(), and endsWith().
|
||||
<br>someMethod() can be isEmpty(), equals(), equalsIgnoreCase(), contentEquals(), contains(), startsWith(), endsWith(),
|
||||
matches(), compareToIgnoreCase(), indexOf(), and trim().
|
||||
</body>
|
||||
</html>
|
||||
+1
-1
@@ -13,7 +13,7 @@ internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
|
||||
internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
|
||||
myFixture.configureByFile("BinaryExpressionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 149)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
|
||||
myFixture.checkResultByFile("BinaryExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
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 AssertThatComparableInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/Comparable")
|
||||
internal fun assertThat_with_compareTo_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatComparableInspection::class.java)
|
||||
myFixture.configureByFile("ComparableBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
|
||||
myFixture.checkResultByFile("ComparableAfter.java")
|
||||
}
|
||||
}
|
||||
+38
@@ -0,0 +1,38 @@
|
||||
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)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
|
||||
myFixture.checkResultByFile("FileExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
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 AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/PathExpression")
|
||||
internal fun assertThat_with_certain_Path_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatPathExpressionInspection::class.java)
|
||||
myFixture.configureByFile("PathExpressionBefore.java")
|
||||
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 startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
|
||||
myFixture.checkResultByFile("PathExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
+9
@@ -20,6 +20,8 @@ internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
|
||||
@@ -27,6 +29,13 @@ internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
|
||||
myFixture.checkResultByFile("StringExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
@@ -189,6 +189,20 @@ public class BinaryExpression {
|
||||
assertThat(stringAct).isNotNull();
|
||||
assertThat(stringAct).isNotNull();
|
||||
|
||||
assertThat(stringAct).as("doh!").isNotNull();
|
||||
assertThat(stringAct).isNotNull();
|
||||
assertThat(stringAct).isNotNull();
|
||||
assertThat(stringAct).isNull();
|
||||
assertThat(stringAct).isNull();
|
||||
assertThat(stringAct).isNull();
|
||||
|
||||
assertThat(stringAct).as("doh!").isNotNull();
|
||||
assertThat(stringAct).isNotNull();
|
||||
assertThat(stringAct).isNotNull();
|
||||
assertThat(stringAct).isNull();
|
||||
assertThat(stringAct).isNull();
|
||||
assertThat(stringAct).isNull();
|
||||
|
||||
assertThat(null == null).isTrue();
|
||||
assertThat(!false).isTrue();
|
||||
|
||||
|
||||
@@ -189,6 +189,20 @@ public class BinaryExpression {
|
||||
assertThat(null == stringAct).isEqualTo(false);
|
||||
assertThat(null == stringAct).isNotEqualTo(true);
|
||||
|
||||
assertThat(stringAct != null).as("doh!").isTrue();
|
||||
assertThat(stringAct != null).isEqualTo(true);
|
||||
assertThat(stringAct != null).isNotEqualTo(false);
|
||||
assertThat(stringAct != null).isFalse();
|
||||
assertThat(stringAct != null).isEqualTo(false);
|
||||
assertThat(stringAct != null).isNotEqualTo(true);
|
||||
|
||||
assertThat(null != stringAct).as("doh!").isTrue();
|
||||
assertThat(null != stringAct).isEqualTo(true);
|
||||
assertThat(null != stringAct).isNotEqualTo(false);
|
||||
assertThat(null != stringAct).isFalse();
|
||||
assertThat(null != stringAct).isEqualTo(false);
|
||||
assertThat(null != stringAct).isNotEqualTo(true);
|
||||
|
||||
assertThat(null == null).isTrue();
|
||||
assertThat(!false).isTrue();
|
||||
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class CompareTo {
|
||||
|
||||
private void comparable() {
|
||||
String string = "string";
|
||||
assertThat(string).isEqualByComparingTo("foo");
|
||||
assertThat(string).isEqualByComparingTo("foo");
|
||||
|
||||
assertThat(string).isNotEqualByComparingTo("foo");
|
||||
assertThat(string).isNotEqualByComparingTo("foo");
|
||||
|
||||
assertThat(string).isGreaterThanOrEqualTo("foo");
|
||||
assertThat(string).isGreaterThanOrEqualTo("foo");
|
||||
assertThat(string).isGreaterThanOrEqualTo("foo");
|
||||
assertThat(string).isGreaterThanOrEqualTo("foo");
|
||||
|
||||
assertThat(string).isGreaterThan("foo");
|
||||
assertThat(string).isGreaterThan("foo");
|
||||
assertThat(string).isGreaterThan("foo");
|
||||
assertThat(string).isGreaterThan("foo");
|
||||
assertThat(string).isGreaterThan("foo");
|
||||
|
||||
assertThat(string).isLessThanOrEqualTo("foo");
|
||||
assertThat(string).isLessThanOrEqualTo("foo");
|
||||
assertThat(string).isLessThanOrEqualTo("foo");
|
||||
assertThat(string).isLessThanOrEqualTo("foo");
|
||||
|
||||
assertThat(string).isLessThan("foo");
|
||||
assertThat(string).isLessThan("foo");
|
||||
assertThat(string).isLessThan("foo");
|
||||
assertThat(string).isLessThan("foo");
|
||||
|
||||
assertThat(string.compareTo("foo")).isNotEqualTo(2);
|
||||
assertThat(string.compareTo("foo")).isEqualTo(2);
|
||||
|
||||
org.junit.Assert.assertThat(string, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class CompareTo {
|
||||
|
||||
private void comparable() {
|
||||
String string = "string";
|
||||
assertThat(string.compareTo("foo")).isEqualTo(0);
|
||||
assertThat(string.compareTo("foo")).isZero();
|
||||
|
||||
assertThat(string.compareTo("foo")).isNotEqualTo(0);
|
||||
assertThat(string.compareTo("foo")).isNotZero();
|
||||
|
||||
assertThat(string.compareTo("foo")).isNotEqualTo(-1);
|
||||
assertThat(string.compareTo("foo")).isGreaterThanOrEqualTo(0);
|
||||
assertThat(string.compareTo("foo")).isGreaterThan(-1);
|
||||
assertThat(string.compareTo("foo")).isNotNegative();
|
||||
|
||||
assertThat(string.compareTo("foo")).isEqualTo(1);
|
||||
assertThat(string.compareTo("foo")).isOne();
|
||||
assertThat(string.compareTo("foo")).isGreaterThan(0);
|
||||
assertThat(string.compareTo("foo")).isPositive();
|
||||
assertThat(string.compareTo("foo")).isGreaterThanOrEqualTo(1);
|
||||
|
||||
assertThat(string.compareTo("foo")).isNotEqualTo(1);
|
||||
assertThat(string.compareTo("foo")).isLessThanOrEqualTo(0);
|
||||
assertThat(string.compareTo("foo")).isLessThan(1);
|
||||
assertThat(string.compareTo("foo")).isNotPositive();
|
||||
|
||||
assertThat(string.compareTo("foo")).isEqualTo(-1);
|
||||
assertThat(string.compareTo("foo")).isLessThan(0);
|
||||
assertThat(string.compareTo("foo")).isNegative();
|
||||
assertThat(string.compareTo("foo")).isLessThanOrEqualTo(-1);
|
||||
|
||||
assertThat(string.compareTo("foo")).isNotEqualTo(2);
|
||||
assertThat(string.compareTo("foo")).isEqualTo(2);
|
||||
|
||||
org.junit.Assert.assertThat(string, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
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).isEmpty();
|
||||
assertThat(file).isEmpty();
|
||||
assertThat(file).isNotEmpty();
|
||||
assertThat(file).isNotEmpty();
|
||||
assertThat(file).hasSize(2);
|
||||
|
||||
assertThat(file.listFiles()).isNull();
|
||||
assertThat(file.listFiles()).isNullOrEmpty();
|
||||
assertThat(file).isEmptyDirectory();
|
||||
assertThat(file).isNotEmptyDirectory();
|
||||
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isNull();
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isNullOrEmpty();
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isEmpty();
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isNotEmpty();
|
||||
|
||||
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!");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
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.length()).isEqualTo(0);
|
||||
assertThat(file.length()).isZero();
|
||||
assertThat(file.length()).isNotEqualTo(0);
|
||||
assertThat(file.length()).isNotZero();
|
||||
assertThat(file.length()).isEqualTo(2);
|
||||
|
||||
assertThat(file.listFiles()).isNull();
|
||||
assertThat(file.listFiles()).isNullOrEmpty();
|
||||
assertThat(file.listFiles()).isEmpty();
|
||||
assertThat(file.listFiles()).isNotEmpty();
|
||||
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isNull();
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isNullOrEmpty();
|
||||
assertThat(file.listFiles(f -> f.canExecute())).isEmpty();
|
||||
assertThat(file.listFiles(f -> f.canExecute())).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!");
|
||||
}
|
||||
}
|
||||
@@ -73,6 +73,8 @@ public class GuavaOptional {
|
||||
|
||||
assertThat(opt.orNull()).as("foo").isEqualTo(null).isNotNull();
|
||||
|
||||
assertThat(Optional.of(new byte[] { 2, 3 }).get()).isEqualTo(new byte[] { 2, 3 }); // not working with assertj-guava 3.2.1
|
||||
|
||||
org.junit.Assert.assertThat(opt, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
@@ -73,6 +73,8 @@ public class GuavaOptional {
|
||||
|
||||
assertThat(opt.orNull()).as("foo").isEqualTo(null).isNotNull();
|
||||
|
||||
assertThat(Optional.of(new byte[] { 2, 3 }).get()).isEqualTo(new byte[] { 2, 3 }); // not working with assertj-guava 3.2.1
|
||||
|
||||
org.junit.Assert.assertThat(opt, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class PathExpression {
|
||||
|
||||
private void pathExpression() {
|
||||
Path path = Paths.get("foo");
|
||||
Path otherPath = Paths.get("bar");
|
||||
|
||||
assertThat(path).as("foo").isAbsolute();
|
||||
assertThat(path).isAbsolute();
|
||||
assertThat(path).isAbsolute();
|
||||
assertThat(path).as("foo").isRelative();
|
||||
assertThat(path).isRelative();
|
||||
assertThat(path).isRelative();
|
||||
|
||||
assertThat(path).hasParentRaw(otherPath);
|
||||
assertThat(path.getParent()).isNotEqualTo(otherPath);
|
||||
assertThat(path).hasNoParentRaw();
|
||||
assertThat(path).hasNoParentRaw();
|
||||
assertThat(path.getParent()).isNotEqualTo(null);
|
||||
assertThat(path.getParent()).isNotNull();
|
||||
|
||||
assertThat(path).as("foo").startsWithRaw(otherPath);
|
||||
assertThat(path).startsWithRaw(otherPath);
|
||||
assertThat(path).startsWithRaw(otherPath);
|
||||
assertThat(path.startsWith(otherPath)).as("foo").isEqualTo(false);
|
||||
assertThat(path.startsWith(otherPath)).isNotEqualTo(true);
|
||||
assertThat(path.startsWith(otherPath)).isFalse();
|
||||
|
||||
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(true);
|
||||
assertThat(path.startsWith("otherPath")).isNotEqualTo(false);
|
||||
assertThat(path.startsWith("otherPath")).isTrue();
|
||||
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(false);
|
||||
assertThat(path.startsWith("otherPath")).isNotEqualTo(true);
|
||||
assertThat(path.startsWith("otherPath")).isFalse();
|
||||
|
||||
assertThat(path).as("foo").endsWithRaw(otherPath);
|
||||
assertThat(path).endsWithRaw(otherPath);
|
||||
assertThat(path).endsWithRaw(otherPath);
|
||||
assertThat(path.endsWith(otherPath)).as("foo").isEqualTo(false);
|
||||
assertThat(path.endsWith(otherPath)).isNotEqualTo(true);
|
||||
assertThat(path.endsWith(otherPath)).isFalse();
|
||||
|
||||
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(true);
|
||||
assertThat(path.endsWith("otherPath")).isNotEqualTo(false);
|
||||
assertThat(path.endsWith("otherPath")).isTrue();
|
||||
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(false);
|
||||
assertThat(path.endsWith("otherPath")).isNotEqualTo(true);
|
||||
assertThat(path.endsWith("otherPath")).isFalse();
|
||||
|
||||
assertThat(Files.isReadable(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isReadable(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isReadable(path)).isTrue();
|
||||
assertThat(Files.isReadable(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isReadable(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isReadable(path)).isFalse();
|
||||
|
||||
assertThat(Files.isWritable(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isWritable(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isWritable(path)).isTrue();
|
||||
assertThat(Files.isWritable(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isWritable(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isWritable(path)).isFalse();
|
||||
|
||||
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isExecutable(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isExecutable(path)).isTrue();
|
||||
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isExecutable(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isExecutable(path)).isFalse();
|
||||
|
||||
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isDirectory(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isDirectory(path)).isTrue();
|
||||
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isDirectory(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isDirectory(path)).isFalse();
|
||||
|
||||
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isRegularFile(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isRegularFile(path)).isTrue();
|
||||
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isRegularFile(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isRegularFile(path)).isFalse();
|
||||
|
||||
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isSymbolicLink(path)).isTrue();
|
||||
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isSymbolicLink(path)).isFalse();
|
||||
|
||||
assertThat(Files.exists(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.exists(path)).isNotEqualTo(false);
|
||||
assertThat(Files.exists(path)).isTrue();
|
||||
assertThat(Files.exists(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.exists(path)).isNotEqualTo(true);
|
||||
assertThat(Files.exists(path)).isFalse();
|
||||
|
||||
assertThat(Files.notExists(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.notExists(path)).isNotEqualTo(false);
|
||||
assertThat(Files.notExists(path)).isTrue();
|
||||
assertThat(Files.notExists(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.notExists(path)).isNotEqualTo(true);
|
||||
assertThat(Files.notExists(path)).isFalse();
|
||||
|
||||
assertThat(Files.list(path)).isEmpty();
|
||||
assertThat(Files.list(path)).isNotEmpty();
|
||||
|
||||
assertThat(Files.readAllBytes(path)).isEqualTo(new byte[1]);
|
||||
assertThat(Files.readAllLines(path)).containsExactly("foo");
|
||||
assertThat(Files.lines(path)).containsExactly("foo");
|
||||
|
||||
assertThat(path.getName()).endsWith(".foo"); // could be turned into .hasExtension("foo"), but not always.
|
||||
|
||||
assertThat(path.getName()).as("foo").isEqualTo("foo").as("bar").isEqualTo("bar");
|
||||
|
||||
org.junit.Assert.assertThat(path, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class PathExpression {
|
||||
|
||||
private void pathExpression() {
|
||||
Path path = Paths.get("foo");
|
||||
Path otherPath = Paths.get("bar");
|
||||
|
||||
assertThat(path.isAbsolute()).as("foo").isEqualTo(true);
|
||||
assertThat(path.isAbsolute()).isNotEqualTo(false);
|
||||
assertThat(path.isAbsolute()).isTrue();
|
||||
assertThat(path.isAbsolute()).as("foo").isEqualTo(false);
|
||||
assertThat(path.isAbsolute()).isNotEqualTo(true);
|
||||
assertThat(path.isAbsolute()).isFalse();
|
||||
|
||||
assertThat(path.getParent()).isEqualTo(otherPath);
|
||||
assertThat(path.getParent()).isNotEqualTo(otherPath);
|
||||
assertThat(path.getParent()).isEqualTo(null);
|
||||
assertThat(path.getParent()).isNull();
|
||||
assertThat(path.getParent()).isNotEqualTo(null);
|
||||
assertThat(path.getParent()).isNotNull();
|
||||
|
||||
assertThat(path.startsWith(otherPath)).as("foo").isEqualTo(true);
|
||||
assertThat(path.startsWith(otherPath)).isNotEqualTo(false);
|
||||
assertThat(path.startsWith(otherPath)).isTrue();
|
||||
assertThat(path.startsWith(otherPath)).as("foo").isEqualTo(false);
|
||||
assertThat(path.startsWith(otherPath)).isNotEqualTo(true);
|
||||
assertThat(path.startsWith(otherPath)).isFalse();
|
||||
|
||||
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(true);
|
||||
assertThat(path.startsWith("otherPath")).isNotEqualTo(false);
|
||||
assertThat(path.startsWith("otherPath")).isTrue();
|
||||
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(false);
|
||||
assertThat(path.startsWith("otherPath")).isNotEqualTo(true);
|
||||
assertThat(path.startsWith("otherPath")).isFalse();
|
||||
|
||||
assertThat(path.endsWith(otherPath)).as("foo").isEqualTo(true);
|
||||
assertThat(path.endsWith(otherPath)).isNotEqualTo(false);
|
||||
assertThat(path.endsWith(otherPath)).isTrue();
|
||||
assertThat(path.endsWith(otherPath)).as("foo").isEqualTo(false);
|
||||
assertThat(path.endsWith(otherPath)).isNotEqualTo(true);
|
||||
assertThat(path.endsWith(otherPath)).isFalse();
|
||||
|
||||
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(true);
|
||||
assertThat(path.endsWith("otherPath")).isNotEqualTo(false);
|
||||
assertThat(path.endsWith("otherPath")).isTrue();
|
||||
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(false);
|
||||
assertThat(path.endsWith("otherPath")).isNotEqualTo(true);
|
||||
assertThat(path.endsWith("otherPath")).isFalse();
|
||||
|
||||
assertThat(Files.isReadable(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isReadable(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isReadable(path)).isTrue();
|
||||
assertThat(Files.isReadable(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isReadable(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isReadable(path)).isFalse();
|
||||
|
||||
assertThat(Files.isWritable(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isWritable(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isWritable(path)).isTrue();
|
||||
assertThat(Files.isWritable(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isWritable(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isWritable(path)).isFalse();
|
||||
|
||||
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isExecutable(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isExecutable(path)).isTrue();
|
||||
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isExecutable(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isExecutable(path)).isFalse();
|
||||
|
||||
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isDirectory(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isDirectory(path)).isTrue();
|
||||
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isDirectory(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isDirectory(path)).isFalse();
|
||||
|
||||
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isRegularFile(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isRegularFile(path)).isTrue();
|
||||
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isRegularFile(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isRegularFile(path)).isFalse();
|
||||
|
||||
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(false);
|
||||
assertThat(Files.isSymbolicLink(path)).isTrue();
|
||||
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(true);
|
||||
assertThat(Files.isSymbolicLink(path)).isFalse();
|
||||
|
||||
assertThat(Files.exists(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.exists(path)).isNotEqualTo(false);
|
||||
assertThat(Files.exists(path)).isTrue();
|
||||
assertThat(Files.exists(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.exists(path)).isNotEqualTo(true);
|
||||
assertThat(Files.exists(path)).isFalse();
|
||||
|
||||
assertThat(Files.notExists(path)).as("foo").isEqualTo(true);
|
||||
assertThat(Files.notExists(path)).isNotEqualTo(false);
|
||||
assertThat(Files.notExists(path)).isTrue();
|
||||
assertThat(Files.notExists(path)).as("foo").isEqualTo(false);
|
||||
assertThat(Files.notExists(path)).isNotEqualTo(true);
|
||||
assertThat(Files.notExists(path)).isFalse();
|
||||
|
||||
assertThat(Files.list(path)).isEmpty();
|
||||
assertThat(Files.list(path)).isNotEmpty();
|
||||
|
||||
assertThat(Files.readAllBytes(path)).isEqualTo(new byte[1]);
|
||||
assertThat(Files.readAllLines(path)).containsExactly("foo");
|
||||
assertThat(Files.lines(path)).containsExactly("foo");
|
||||
|
||||
assertThat(path.getName()).endsWith(".foo"); // could be turned into .hasExtension("foo"), but not always.
|
||||
|
||||
assertThat(path.getName()).as("foo").isEqualTo("foo").as("bar").isEqualTo("bar");
|
||||
|
||||
org.junit.Assert.assertThat(path, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,8 @@ public class StringExpression {
|
||||
assertThat(string).startsWith("foo");
|
||||
assertThat(string).endsWith("foo");
|
||||
assertThat(string).endsWith("foo");
|
||||
assertThat(string).matches("foo");
|
||||
assertThat(string).matches("foo");
|
||||
|
||||
assertThat(string).as("foo").isNotEmpty();
|
||||
assertThat(string).isNotEmpty();
|
||||
@@ -46,11 +48,43 @@ public class StringExpression {
|
||||
assertThat(string).doesNotStartWith("foo");
|
||||
assertThat(string).doesNotEndWith("foo");
|
||||
assertThat(string).doesNotEndWith("foo");
|
||||
assertThat(string).doesNotMatch("foo");
|
||||
assertThat(string).doesNotMatch("foo");
|
||||
|
||||
assertThat(string).as("foo").doesNotEndWith("foo").as("bar").doesNotEndWith("foo");
|
||||
assertThat(string.endsWith("foo")).as("foo").isEqualTo(false).as("bar").isTrue();
|
||||
assertThat(string.endsWith("foo")).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
|
||||
|
||||
assertThat(string).isEqualToIgnoringCase("foo");
|
||||
assertThat(string).isEqualToIgnoringCase("foo");
|
||||
assertThat(string.compareToIgnoreCase("foo")).isEqualTo(1);
|
||||
assertThat(string.compareToIgnoreCase("foo")).isLessThan(0);
|
||||
|
||||
assertThat(string).isNotEqualToIgnoringCase("foo");
|
||||
assertThat(string).isNotEqualToIgnoringCase("foo");
|
||||
assertThat(string.compareToIgnoreCase("foo")).isNotEqualTo(1);
|
||||
assertThat(string.compareToIgnoreCase("foo")).isGreaterThan(0);
|
||||
|
||||
assertThat(string).startsWith("foo");
|
||||
assertThat(string).doesNotStartWith("foo");
|
||||
assertThat(string).startsWith("foo");
|
||||
assertThat(string.indexOf("foo")).isEqualTo(1);
|
||||
assertThat(string).doesNotContain("foo");
|
||||
assertThat(string).doesNotStartWith("foo");
|
||||
assertThat(string.indexOf("foo")).isNotEqualTo(1);
|
||||
assertThat(string).contains("foo");
|
||||
assertThat(string).doesNotContain("foo");
|
||||
assertThat(string).doesNotContain("foo");
|
||||
assertThat(string).contains("foo");
|
||||
assertThat(string).contains("foo");
|
||||
assertThat(string).doesNotContain("foo");
|
||||
assertThat(string.indexOf("foo")).isPositive();
|
||||
assertThat(string).contains("foo");
|
||||
assertThat(string.indexOf("foo")).isNotPositive();
|
||||
|
||||
assertThat(string.trim()).isEmpty(); // would turn into isJavaBlank(), which is deprecated. Should be isNotNull().isBlank() then...
|
||||
assertThat(string).isNotBlank();
|
||||
|
||||
org.junit.Assert.assertThat(string, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
@@ -26,6 +26,8 @@ public class StringExpression {
|
||||
assertThat(string.startsWith("foo")).isTrue();
|
||||
assertThat(string.endsWith("foo")).isEqualTo(true);
|
||||
assertThat(string.endsWith("foo")).isTrue();
|
||||
assertThat(string.matches("foo")).isEqualTo(true);
|
||||
assertThat(string.matches("foo")).isTrue();
|
||||
|
||||
assertThat(string.isEmpty()).as("foo").isEqualTo(false);
|
||||
assertThat(string.isEmpty()).isNotEqualTo(true);
|
||||
@@ -46,11 +48,43 @@ public class StringExpression {
|
||||
assertThat(string.startsWith("foo")).isFalse();
|
||||
assertThat(string.endsWith("foo")).isEqualTo(false);
|
||||
assertThat(string.endsWith("foo")).isFalse();
|
||||
assertThat(string.matches("foo")).isEqualTo(false);
|
||||
assertThat(string.matches("foo")).isFalse();
|
||||
|
||||
assertThat(string.endsWith("foo")).as("foo").isEqualTo(false).as("bar").isFalse();
|
||||
assertThat(string.endsWith("foo")).as("foo").isEqualTo(false).as("bar").isTrue();
|
||||
assertThat(string.endsWith("foo")).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
|
||||
|
||||
assertThat(string.compareToIgnoreCase("foo")).isEqualTo(0);
|
||||
assertThat(string.compareToIgnoreCase("foo")).isZero();
|
||||
assertThat(string.compareToIgnoreCase("foo")).isEqualTo(1);
|
||||
assertThat(string.compareToIgnoreCase("foo")).isLessThan(0);
|
||||
|
||||
assertThat(string.compareToIgnoreCase("foo")).isNotEqualTo(0);
|
||||
assertThat(string.compareToIgnoreCase("foo")).isNotZero();
|
||||
assertThat(string.compareToIgnoreCase("foo")).isNotEqualTo(1);
|
||||
assertThat(string.compareToIgnoreCase("foo")).isGreaterThan(0);
|
||||
|
||||
assertThat(string.indexOf("foo")).isZero();
|
||||
assertThat(string.indexOf("foo")).isNotZero();
|
||||
assertThat(string.indexOf("foo")).isEqualTo(0);
|
||||
assertThat(string.indexOf("foo")).isEqualTo(1);
|
||||
assertThat(string.indexOf("foo")).isEqualTo(-1);
|
||||
assertThat(string.indexOf("foo")).isNotEqualTo(0);
|
||||
assertThat(string.indexOf("foo")).isNotEqualTo(1);
|
||||
assertThat(string.indexOf("foo")).isNotEqualTo(-1);
|
||||
assertThat(string.indexOf("foo")).isLessThan(0);
|
||||
assertThat(string.indexOf("foo")).isLessThanOrEqualTo(-1);
|
||||
assertThat(string.indexOf("foo")).isGreaterThan(-1);
|
||||
assertThat(string.indexOf("foo")).isGreaterThanOrEqualTo(0);
|
||||
assertThat(string.indexOf("foo")).isNegative();
|
||||
assertThat(string.indexOf("foo")).isPositive();
|
||||
assertThat(string.indexOf("foo")).isNotNegative();
|
||||
assertThat(string.indexOf("foo")).isNotPositive();
|
||||
|
||||
assertThat(string.trim()).isEmpty(); // would turn into isJavaBlank(), which is deprecated. Should be isNotNull().isBlank() then...
|
||||
assertThat(string.trim()).isNotEmpty();
|
||||
|
||||
org.junit.Assert.assertThat(string, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user