Last update 1.14. Reworked so much without success it was just painful.
This commit is contained in:
parent
855dc41a7f
commit
a71253142b
@ -1,4 +1,4 @@
|
||||
Copyright 2019-2022 Chris Hodges <chrisly@platon42.de>
|
||||
Copyright 2019-2024 Chris Hodges <chrisly@platon42.de>
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
|
||||
65
README.md
65
README.md
@ -1,4 +1,5 @@
|
||||
# Cajon - Concise AssertJ Optimizing Nitpicker [](https://app.travis-ci.com/chrisly42/cajon-plugin) [](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
|
||||
# Cajon - Concise AssertJ Optimizing Nitpicker
|
||||
|
||||
Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
|
||||
|
||||
## Purpose
|
||||
@ -39,7 +40,8 @@ Cajon also warns about bogus or incorrect uses of AssertJ.
|
||||
|
||||
## Lookup and refactoring of string-based extracting()
|
||||
|
||||
AssertJ allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
|
||||
AssertJ
|
||||
allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
|
||||
|
||||
Using strings is not safe for refactoring (and before Java 8 Lambdas were available,
|
||||
creating extractor functions just for testing purpose was a bit too tedious).
|
||||
@ -65,6 +67,7 @@ Applying a quick fix might result in further optimization possibilities, so
|
||||
you might need to perform a couple of fixes before you get to the final result.
|
||||
|
||||
Check out this example where every line represents the result after a Cajon quickfix:
|
||||
|
||||
```
|
||||
assertFalse(!(array.length == collection.size()));
|
||||
|
||||
@ -793,8 +796,9 @@ 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.
|
||||
You can ctrl-click on references inside .extracting() method parameters to go the
|
||||
referencing method definition.
|
||||
|
||||
```
|
||||
.extracting("field")
|
||||
.extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
|
||||
@ -808,9 +812,10 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
.flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
|
||||
.flatExtracting(Extractors.resultOf("bareMethod")
|
||||
```
|
||||
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.
|
||||
|
||||
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.
|
||||
|
||||
## Development notice
|
||||
|
||||
@ -821,6 +826,7 @@ The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, an
|
||||
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 LocalDate/Time etc.
|
||||
- assertThat(foo.toLowerCase()/toUpperCase()).isEqualTo("foo") -> assertThat(foo).isEqualToIgnoringCase()
|
||||
@ -834,9 +840,18 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
|
||||
## Changelog
|
||||
|
||||
### V1.14 (19-Feb-24)
|
||||
|
||||
- Now requires minimum version 2022.2.
|
||||
- Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
|
||||
- Reworked JUnit 5 test framework to work again. However, all the tests are broken.
|
||||
I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
|
||||
Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
|
||||
- This is very likely the last version.
|
||||
|
||||
### V1.13 (18-Aug-22)
|
||||
|
||||
- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibilty after four attempts.
|
||||
- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
|
||||
- Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
|
||||
- Tried to fix unreproducible issue #9.
|
||||
- Added AssertThatIsZeroOne inspection demanded by issue #5.
|
||||
@ -859,10 +874,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
inspection.
|
||||
|
||||
#### V1.10 (31-Jul-20) Friday the 31st Edition
|
||||
|
||||
- Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
|
||||
- Fixed two possible index out-of-bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
|
||||
|
||||
#### V1.9 (25-Feb-20) Mardi Gras Edition
|
||||
|
||||
- TwistedAssertion inspection will no longer warn for ```.matches()``` and ```doesNotMatch()``` for regular expressions.
|
||||
Apparently, ```assertThat("somestring").matches(regex)``` is a valid test if the regex is what needs to be tested.
|
||||
If the actual expression is of ```Class``` type, this will no longer be reported.
|
||||
@ -873,12 +890,14 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
the warning will be reduced to information level as the assertion may be testing ```equals()``` or ```hashCode()``` for validity.
|
||||
|
||||
#### V1.8 (14-Feb-20) Valentine Edition
|
||||
|
||||
- Maintenance. Removed experimental API use. Updated dependencies. Fixed testing problems introduced with IntelliJ IDEA 2019.3
|
||||
- Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating
|
||||
swapped use of actual and expected expressions.
|
||||
- Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
|
||||
|
||||
#### 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).
|
||||
@ -886,6 +905,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- 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
|
||||
@ -896,6 +916,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
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()```
|
||||
for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
|
||||
@ -906,11 +927,13 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
combinations for ```.hasSameSizeAs()``` are supported.
|
||||
|
||||
#### V1.4 (25-Aug-19)
|
||||
|
||||
- Minor fix for highlighting of JoinVarArgsContains inspection.
|
||||
- Extended AssertThatSize inspection to Maps, too.
|
||||
- Extended AssertThatCollectionOrMap inspection for several ```assertThat(map.get())``` cases as suggested by Georgij G.
|
||||
|
||||
#### V1.3 (03-Aug-19)
|
||||
|
||||
- New JoinVarArgsContains inspection that will detect multiple ```.contains()```, ```.doesNotContain()```,
|
||||
and ```.containsOnlyOnce()``` calls within the same statement that could be joined together using variadic arguments.
|
||||
- AssertJ 3.13.0 broke some inspections due to new ```AbstractStringAssert::isEqualTo()``` method.
|
||||
@ -919,10 +942,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
when ```expression``` is not a non-null constant expression.
|
||||
|
||||
#### V1.2 (23-Jun-19)
|
||||
|
||||
- Due to popular demand the JoinAssertThatStatements inspection will now add line breaks on joining statements.
|
||||
The amount of statements joined without causing line breaks can be configured but defaults to 1 (always).
|
||||
|
||||
#### V1.1 (09-Jun-19)
|
||||
|
||||
- Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
|
||||
- Added Guava Optional ```opt.orNull() == null``` case. You know, I'm not making this stuff up, people actually write this kind of code.
|
||||
- Added Java 8 Optional ```opt.orElse(null) == null``` case, too.
|
||||
@ -933,14 +958,18 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- Added new AssertThatObjectExpression inspection for ```toString()``` and ```hashCode()``` and moved ```equals()``` from AssertThatBinaryExpression there.
|
||||
|
||||
#### V1.0 (06-May-19)
|
||||
|
||||
- First release to be considered stable enough for production use.
|
||||
- Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
|
||||
- Fixed missing description for AssumeThatInsteadOfReturn inspection.
|
||||
- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()``` expression.
|
||||
- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()```
|
||||
expression.
|
||||
|
||||
#### V0.8 (05-May-19)
|
||||
|
||||
- Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
|
||||
- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()``` and ```isNull()``` return void.
|
||||
- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()```
|
||||
and ```isNull()``` return void.
|
||||
- Heavily reworked inspections for edge cases, such as multiple ```isEqualTo()``` calls inside a single statement.
|
||||
- Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
|
||||
- Corrected highlighting for many inspections.
|
||||
@ -949,6 +978,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- Added a first version of a new inspection that tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
|
||||
|
||||
#### V0.7 (28-Apr-19)
|
||||
|
||||
- Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
|
||||
(really, Jetbrains, this sucks for no reason).
|
||||
- Extended AssertThatSize inspection to transform ```hasSize()``` into ```hasSameSizeAs()```, if possible.
|
||||
@ -956,6 +986,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
actual object together, preserving comments.
|
||||
|
||||
#### V0.6 (22-Apr-19)
|
||||
|
||||
- New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
|
||||
```startsWith()```, and ```endsWith()``` out of actual expression.
|
||||
- Extended AssertThatSize inspection to take ```String```s and ```CharSequences``` into account, too.
|
||||
@ -964,6 +995,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
- New AssertThatInstanceOf inspection that moves instanceof expressions out of ```assertThat()```.
|
||||
|
||||
#### V0.5 (18-Apr-19)
|
||||
|
||||
- Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
|
||||
- Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
|
||||
- Added support for referencing and refactoring inside ```.extracting()``` methods with fields, properties and methods (though
|
||||
@ -972,20 +1004,27 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
|
||||
|
||||
#### V0.4 (11-Apr-19)
|
||||
|
||||
- Reduced minimal supported IDEA version from 2018.2 to 2017.2.
|
||||
- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```, and ```isNotPresent()``` instead.
|
||||
- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```,
|
||||
and ```isNotPresent()``` instead.
|
||||
- New inspection AssertThatGuavaOptional that operates on Guava ```Optional``` objects and tries to use ```contains()```, ```isPresent()```, and ```isAbsent()``` instead.
|
||||
- Added support in AssertThatBinaryExpressionIsTrueOrFalse for ```is(Not)EqualTo(Boolean.TRUE/FALSE)```.
|
||||
|
||||
#### V0.3 (07-Apr-19)
|
||||
- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations) inside ```assertThat()```.
|
||||
|
||||
- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations)
|
||||
inside ```assertThat()```.
|
||||
- Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
|
||||
- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with AssertJ >=3.12.0).
|
||||
- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with
|
||||
AssertJ >=3.12.0).
|
||||
- Really fixed highlighting for JUnit conversion. Sorry.
|
||||
|
||||
#### V0.2 (01-Apr-19)
|
||||
|
||||
- Fixed descriptions and quick fix texts.
|
||||
- Fixed highlighting of found problems and 'Run inspection by Name' returning nothing, too.
|
||||
|
||||
#### V0.1 (31-Mar-19)
|
||||
|
||||
- Initial release.
|
||||
93
build.gradle
93
build.gradle
@ -1,93 +0,0 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'org.jetbrains.intellij' version '1.8.0'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.7.10'
|
||||
id 'jacoco'
|
||||
id 'com.github.kt3k.coveralls' version '2.12.0'
|
||||
}
|
||||
|
||||
group 'de.platon42'
|
||||
version '1.13'
|
||||
sourceCompatibility = "1.8"
|
||||
targetCompatibility = "1.8"
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
/*
|
||||
To run tests in IntelliJ use these VM Options for run configuration
|
||||
-ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
|
||||
*/
|
||||
|
||||
dependencies {
|
||||
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
testImplementation "org.assertj:assertj-core:3.23.1"
|
||||
testImplementation "org.assertj:assertj-guava:3.5.0"
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-test"
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-reflect"
|
||||
testImplementation 'org.junit.platform:junit-platform-launcher:1.9.0'
|
||||
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
|
||||
}
|
||||
|
||||
compileKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
|
||||
compileTestKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
|
||||
intellij {
|
||||
setVersion("2022.2") // LATEST-EAP-SNAPSHOT
|
||||
//pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
|
||||
setUpdateSinceUntilBuild(false)
|
||||
setPlugins(["com.intellij.java"])
|
||||
}
|
||||
|
||||
runPluginVerifier {
|
||||
ideVersions = ["IC-193.5662.53", "IC-222.3345.118"] // 2019.3.1 - 2022.2
|
||||
downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
|
||||
}
|
||||
|
||||
patchPluginXml {
|
||||
setChangeNotes("""
|
||||
<h4>V1.13 (18-Aug-22)</h4>
|
||||
<ul>
|
||||
<li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibilty after four attempts.
|
||||
<li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
|
||||
<li>Tried to fix unreproducible issue #9.
|
||||
<li>Added AssertThatIsZeroOne inspection demanded by issue #5.
|
||||
<li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
|
||||
</ul>
|
||||
<p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
|
||||
""")
|
||||
}
|
||||
|
||||
test {
|
||||
useJUnitPlatform()
|
||||
testLogging {
|
||||
events "passed", "skipped", "failed"
|
||||
}
|
||||
}
|
||||
|
||||
tasks.coveralls {
|
||||
dependsOn jacocoTestReport
|
||||
}
|
||||
|
||||
jacoco {
|
||||
toolVersion = '0.8.8'
|
||||
}
|
||||
|
||||
jacocoTestReport {
|
||||
reports {
|
||||
xml.required.set(true)
|
||||
csv.required.set(false)
|
||||
}
|
||||
}
|
||||
|
||||
publishPlugin {
|
||||
setToken(intellijPublishToken)
|
||||
}
|
||||
131
build.gradle.kts
Normal file
131
build.gradle.kts
Normal file
@ -0,0 +1,131 @@
|
||||
plugins {
|
||||
id("java")
|
||||
id("org.jetbrains.intellij") version "1.17.1"
|
||||
id("org.jetbrains.kotlin.jvm") version "1.9.22"
|
||||
id("jacoco")
|
||||
id("com.github.kt3k.coveralls") version "2.12.2"
|
||||
}
|
||||
|
||||
group = "de.platon42"
|
||||
version = "1.14"
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
/*
|
||||
To run tests in IntelliJ use these VM Options for run configuration
|
||||
-ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
|
||||
*/
|
||||
|
||||
dependencies {
|
||||
//implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
testImplementation("org.assertj:assertj-core:3.25.3")
|
||||
testImplementation("org.assertj:assertj-guava:3.25.3")
|
||||
testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
|
||||
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
|
||||
testImplementation("org.jetbrains.kotlin:kotlin-test")
|
||||
testImplementation("org.jetbrains.kotlin:kotlin-reflect")
|
||||
testImplementation("org.junit.platform:junit-platform-launcher:1.10.2")
|
||||
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
|
||||
}
|
||||
|
||||
intellij {
|
||||
version.set("2022.2") // LATEST-EAP-SNAPSHOT
|
||||
//pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
|
||||
updateSinceUntilBuild.set(false)
|
||||
plugins.set(listOf("com.intellij.java"))
|
||||
}
|
||||
|
||||
tasks {
|
||||
withType<JavaCompile> {
|
||||
sourceCompatibility = "11"
|
||||
targetCompatibility = "11"
|
||||
}
|
||||
withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
|
||||
kotlinOptions.jvmTarget = "11"
|
||||
}
|
||||
|
||||
test {
|
||||
useJUnitPlatform()
|
||||
testLogging {
|
||||
events("passed", "skipped", "failed")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
prepareSandbox {
|
||||
enabled = true
|
||||
}
|
||||
|
||||
verifyPlugin {
|
||||
enabled = true
|
||||
}
|
||||
|
||||
verifyPluginConfiguration {
|
||||
enabled = true
|
||||
}
|
||||
|
||||
patchPluginXml {
|
||||
enabled = true
|
||||
sinceBuild.set("222")
|
||||
changeNotes.set(
|
||||
"""
|
||||
<h4>V1.14 (19-Feb-24)</h4>
|
||||
<ul>
|
||||
<li>Now requires minimum version 2022.2.
|
||||
<li>Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
|
||||
<li>Reworked JUnit 5 test framework to work again. However, all the tests are broken.
|
||||
I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
|
||||
Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
|
||||
<li>This is very likely the last version.
|
||||
</ul>
|
||||
<h4>V1.13 (18-Aug-22)</h4>
|
||||
<ul>
|
||||
<li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
|
||||
<li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
|
||||
<li>Tried to fix unreproducible issue #9.
|
||||
<li>Added AssertThatIsZeroOne inspection demanded by issue #5.
|
||||
<li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
|
||||
</ul>
|
||||
<p>Full changelog available at <a href="https://git.platon42.de/chrisly42/cajon-plugin#changelog">Gitea project site</a>.</p>
|
||||
"""
|
||||
)
|
||||
}
|
||||
|
||||
publishPlugin {
|
||||
token.set(System.getProperty("org.gradle.project.intellijPublishToken"))
|
||||
}
|
||||
|
||||
runIde {
|
||||
enabled = true
|
||||
if (project.hasProperty("ideDir")) {
|
||||
ideDir.set(file(project.property("ideDir")!!))
|
||||
jbrVersion.set(project.property("ideJBR")!! as String)
|
||||
}
|
||||
autoReloadPlugins.set(false)
|
||||
}
|
||||
|
||||
|
||||
runPluginVerifier {
|
||||
ideVersions.set(listOf("IC-222.4167.29", "IC-233.14015.106")) // 2022.2.2 - 2023.3.3
|
||||
downloadDir.set(System.getenv("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier")
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
//tasks.coveralls {
|
||||
// dependsOn(jacocoTestReport)
|
||||
//}
|
||||
|
||||
//jacoco {
|
||||
// toolVersion = '0.8.8'
|
||||
//}
|
||||
//
|
||||
//jacocoTestReport {
|
||||
// reports {
|
||||
// xml.required.set(true)
|
||||
// csv.required.set(false)
|
||||
// }
|
||||
//}
|
||||
2
gradle/wrapper/gradle-wrapper.properties
vendored
2
gradle/wrapper/gradle-wrapper.properties
vendored
@ -1,5 +1,5 @@
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
<idea-plugin>
|
||||
<id>de.platon42.cajon</id>
|
||||
<name>Concise AssertJ Optimizing Nitpicker (Cajon)</name>
|
||||
<vendor email="chrisly@platon42.de" url="https://github.com/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
|
||||
<vendor email="chrisly@platon42.de" url="https://git.platon42.de/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
|
||||
|
||||
<description><![CDATA[
|
||||
Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
|
||||
@ -14,8 +14,6 @@
|
||||
<a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
|
||||
]]></description>
|
||||
|
||||
<idea-version since-build="193.5662.53"/>
|
||||
|
||||
<depends>com.intellij.modules.lang</depends>
|
||||
<depends>com.intellij.modules.platform</depends>
|
||||
<depends>com.intellij.modules.java</depends>
|
||||
|
||||
@ -0,0 +1,151 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.jarRepository.JarRepositoryManager
|
||||
import com.intellij.jarRepository.RemoteRepositoryDescription
|
||||
import com.intellij.openapi.module.Module
|
||||
import com.intellij.openapi.roots.ContentEntry
|
||||
import com.intellij.openapi.roots.DependencyScope
|
||||
import com.intellij.openapi.roots.ModifiableRootModel
|
||||
import com.intellij.openapi.vfs.LocalFileSystem
|
||||
import com.intellij.testFramework.IdeaTestUtil
|
||||
import com.intellij.testFramework.LightProjectDescriptor
|
||||
import com.intellij.testFramework.PlatformTestUtil
|
||||
import com.intellij.testFramework.PsiTestUtil
|
||||
import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase
|
||||
import com.intellij.testFramework.rules.TestNameExtension
|
||||
import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties
|
||||
import org.junit.jupiter.api.extension.AfterEachCallback
|
||||
import org.junit.jupiter.api.extension.BeforeEachCallback
|
||||
import org.junit.jupiter.api.extension.ExtensionContext
|
||||
import org.junit.jupiter.api.extension.RegisterExtension
|
||||
import java.nio.file.Paths
|
||||
import java.util.*
|
||||
import java.util.function.Consumer
|
||||
import java.util.stream.Collectors
|
||||
import java.util.stream.Stream
|
||||
|
||||
|
||||
abstract class AbstractJUnit5TestCase {
|
||||
|
||||
@RegisterExtension
|
||||
protected val testNameRule = TestNameExtension()
|
||||
|
||||
@RegisterExtension
|
||||
protected val edtInterceptorExtension = EdtInterceptorExtension()
|
||||
|
||||
protected fun getTestName(lowercaseFirstLetter: Boolean): String {
|
||||
return PlatformTestUtil.getTestName(testNameRule.methodName, lowercaseFirstLetter)
|
||||
}
|
||||
|
||||
@RegisterExtension
|
||||
private val testCase = object : LightJavaCodeInsightFixtureTestCase(), BeforeEachCallback, AfterEachCallback {
|
||||
|
||||
lateinit var extensionContext: ExtensionContext
|
||||
|
||||
override fun getProjectDescriptor(): LightProjectDescriptor {
|
||||
val testJdk = getMethodOrClassAnnotation(TestJdk::class.java) ?: return super.getProjectDescriptor()
|
||||
val projectDescriptor: DefaultLightProjectDescriptor = object : DefaultLightProjectDescriptor({ IdeaTestUtil.getMockJdk(testJdk.value.toJavaVersion()) }) {
|
||||
override fun configureModule(module: Module, model: ModifiableRootModel, contentEntry: ContentEntry) {
|
||||
super.configureModule(module, model, contentEntry)
|
||||
val localJars = getMethodOrClassAnnotation(AddLocalJarToModule::class.java)
|
||||
if (localJars != null) {
|
||||
localJars.value.forEach {
|
||||
addJarContaining(
|
||||
model,
|
||||
it.java
|
||||
)
|
||||
}
|
||||
}
|
||||
val mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule::class.java)
|
||||
mavenDependencies.forEach(Consumer { it: AddMavenDependencyToModule ->
|
||||
addFromMaven(
|
||||
model,
|
||||
it.value,
|
||||
it.includeTransitiveDependencies,
|
||||
it.scope
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return projectDescriptor
|
||||
}
|
||||
|
||||
fun addJarContaining(model: ModifiableRootModel?, clazz: Class<*>) {
|
||||
val filename = clazz.getResource(clazz.simpleName + ".class").file
|
||||
val jarName = filename.substring(0, filename.indexOf(".jar") + 4).removePrefix("file:")
|
||||
val jarPath = Paths.get(jarName)
|
||||
|
||||
val jarFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(jarName)
|
||||
myFixture.allowTreeAccessForFile(jarFile!!)
|
||||
PsiTestUtil.addLibrary(
|
||||
model!!,
|
||||
jarPath.fileName.toString().replace(".jar", ""),
|
||||
jarPath.parent.toString(),
|
||||
jarPath.fileName.toString()
|
||||
)
|
||||
}
|
||||
|
||||
fun addFromMaven(
|
||||
model: ModifiableRootModel, mavenCoordinates: String,
|
||||
includeTransitiveDependencies: Boolean, dependencyScope: DependencyScope?
|
||||
) {
|
||||
val remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES
|
||||
val libraryProperties = RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies)
|
||||
val roots =
|
||||
JarRepositoryManager.loadDependenciesModal(model.project, libraryProperties, false, false, null, remoteRepositoryDescriptions)
|
||||
val tableModel = model.moduleLibraryTable.modifiableModel
|
||||
val library = tableModel.createLibrary(mavenCoordinates)
|
||||
val libraryModel = library.modifiableModel
|
||||
check(!roots.isEmpty()) { String.format("No roots for '%s'", mavenCoordinates) }
|
||||
|
||||
for (root in roots) {
|
||||
libraryModel.addRoot(root.file, root.type)
|
||||
}
|
||||
|
||||
val libraryOrderEntry = model.findLibraryOrderEntry(library) ?: throw java.lang.IllegalStateException("Unable to find registered library $mavenCoordinates")
|
||||
libraryOrderEntry.scope = dependencyScope!!
|
||||
|
||||
libraryModel.commit()
|
||||
tableModel.commit()
|
||||
}
|
||||
|
||||
override fun getTestDataPath(): String {
|
||||
val testDataPath = getMethodOrClassAnnotation(TestDataPath::class.java) ?: return super.getTestDataPath()
|
||||
val testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath::class.java) ?: return testDataPath.value
|
||||
return Paths.get(testDataPath.value, testDataSubPath.value).toString()
|
||||
}
|
||||
|
||||
fun getMyFixture(): JavaCodeInsightTestFixture = myFixture
|
||||
|
||||
private fun <T : Annotation?> getMethodOrClassAnnotation(clazz: Class<T>): T? {
|
||||
var annotation = extensionContext.requiredTestMethod.getAnnotation(clazz)
|
||||
if (annotation == null) {
|
||||
annotation = extensionContext.requiredTestClass.getAnnotation(clazz)
|
||||
}
|
||||
return annotation
|
||||
}
|
||||
|
||||
private fun <T : Annotation?> getMethodOrClassAnnotations(clazz: Class<T>): List<T> {
|
||||
return Stream.of(
|
||||
extensionContext.requiredTestMethod.getAnnotationsByType(clazz),
|
||||
extensionContext.requiredTestClass.getAnnotationsByType(clazz)
|
||||
)
|
||||
.flatMap { array: Array<T>? -> Arrays.stream(array) }
|
||||
.collect(Collectors.toList())
|
||||
}
|
||||
|
||||
override fun beforeEach(context: ExtensionContext) {
|
||||
extensionContext = context
|
||||
setUp()
|
||||
}
|
||||
|
||||
override fun afterEach(context: ExtensionContext) {
|
||||
tearDown()
|
||||
}
|
||||
}
|
||||
|
||||
protected val fixture: JavaCodeInsightTestFixture get() = testCase.getMyFixture()
|
||||
}
|
||||
@ -1,10 +1,9 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import java.lang.annotation.*;
|
||||
import java.lang.annotation.Inherited
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
public @interface AddLocalJarToModule {
|
||||
Class<?>[] value();
|
||||
}
|
||||
annotation class AddLocalJarToModule(vararg val value: KClass<*>)
|
||||
|
||||
@ -1,24 +1,17 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.openapi.roots.DependencyScope;
|
||||
import com.intellij.openapi.roots.DependencyScope
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
@Repeatable(AddMavenDependencyToModule.List.class)
|
||||
public @interface AddMavenDependencyToModule {
|
||||
String value();
|
||||
|
||||
boolean includeTransitiveDependencies = false;
|
||||
|
||||
DependencyScope scope = DependencyScope.COMPILE;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@JvmRepeatable(
|
||||
AddMavenDependencyToModule.List::class
|
||||
)
|
||||
annotation class AddMavenDependencyToModule(val value: String, val includeTransitiveDependencies: Boolean = false, val scope: DependencyScope = DependencyScope.COMPILE) {
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
@interface List {
|
||||
AddMavenDependencyToModule[] value();
|
||||
}
|
||||
annotation class List(vararg val value: AddMavenDependencyToModule)
|
||||
}
|
||||
@ -0,0 +1,50 @@
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.testFramework.TestLoggerFactory
|
||||
import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy
|
||||
import com.intellij.testFramework.runInEdtAndWait
|
||||
import org.junit.jupiter.api.extension.ExtensionContext
|
||||
import org.junit.jupiter.api.extension.InvocationInterceptor
|
||||
import org.junit.jupiter.api.extension.ReflectiveInvocationContext
|
||||
import java.lang.reflect.Method
|
||||
|
||||
class EdtInterceptorExtension : InvocationInterceptor {
|
||||
|
||||
override fun interceptTestMethod(
|
||||
invocation: InvocationInterceptor.Invocation<Void>,
|
||||
invocationContext: ReflectiveInvocationContext<Method>,
|
||||
extensionContext: ExtensionContext
|
||||
) {
|
||||
val throwables = arrayOfNulls<Throwable>(1)
|
||||
|
||||
val runnable = Runnable {
|
||||
try {
|
||||
TestLoggerFactory.onTestStarted()
|
||||
invocation.proceed()
|
||||
TestLoggerFactory.onTestFinished(true, extensionContext.displayName)
|
||||
} catch (e: Throwable) {
|
||||
TestLoggerFactory.onTestFinished(false, extensionContext.displayName)
|
||||
throwables[0] = e
|
||||
}
|
||||
}
|
||||
|
||||
invokeTestRunnable(runnable)
|
||||
|
||||
if (throwables[0] != null) {
|
||||
throw throwables[0]!!
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private fun invokeTestRunnable(runnable: Runnable) {
|
||||
val policy = IdeaTestExecutionPolicy.current()
|
||||
if (policy != null && !policy.runInDispatchThread()) {
|
||||
runnable.run()
|
||||
} else {
|
||||
runInEdtAndWait {
|
||||
runnable.run()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,259 +0,0 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import com.intellij.jarRepository.JarRepositoryManager;
|
||||
import com.intellij.jarRepository.RemoteRepositoryDescription;
|
||||
import com.intellij.openapi.Disposable;
|
||||
import com.intellij.openapi.module.Module;
|
||||
import com.intellij.openapi.projectRoots.Sdk;
|
||||
import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
|
||||
import com.intellij.openapi.roots.ContentEntry;
|
||||
import com.intellij.openapi.roots.DependencyScope;
|
||||
import com.intellij.openapi.roots.LibraryOrderEntry;
|
||||
import com.intellij.openapi.roots.ModifiableRootModel;
|
||||
import com.intellij.openapi.roots.libraries.Library;
|
||||
import com.intellij.openapi.roots.libraries.LibraryTable;
|
||||
import com.intellij.openapi.roots.libraries.ui.OrderRoot;
|
||||
import com.intellij.openapi.util.Disposer;
|
||||
import com.intellij.openapi.vfs.LocalFileSystem;
|
||||
import com.intellij.openapi.vfs.VirtualFile;
|
||||
import com.intellij.testFramework.EdtTestUtilKt;
|
||||
import com.intellij.testFramework.LightProjectDescriptor;
|
||||
import com.intellij.testFramework.PsiTestUtil;
|
||||
import com.intellij.testFramework.TestLoggerFactory;
|
||||
import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
|
||||
import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties;
|
||||
import org.junit.jupiter.api.extension.*;
|
||||
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
|
||||
import org.junit.jupiter.api.extension.ExtensionContext.Store;
|
||||
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Parameter;
|
||||
import java.net.URISyntaxException;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback, InvocationInterceptor {
|
||||
|
||||
private static final Logger LOG = Logger.getLogger(LightCodeInsightExtension.class.getName());
|
||||
|
||||
@Override
|
||||
public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
|
||||
Parameter parameter = parameterContext.getParameter();
|
||||
return parameter.isAnnotationPresent(MyFixture.class)
|
||||
|| parameter.isAnnotationPresent(MyTestCase.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
|
||||
LightCodeInsightFixtureTestCaseWrapper testCase = getWrapper(extensionContext);
|
||||
Parameter parameter = parameterContext.getParameter();
|
||||
if (parameter.isAnnotationPresent(MyFixture.class)) {
|
||||
return testCase.getMyFixture();
|
||||
} else if (parameter.isAnnotationPresent(MyTestCase.class)) {
|
||||
return testCase;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private LightCodeInsightFixtureTestCaseWrapper getWrapper(ExtensionContext extensionContext) {
|
||||
Store store = getStore(extensionContext);
|
||||
return (LightCodeInsightFixtureTestCaseWrapper) store.getOrComputeIfAbsent("testCase",
|
||||
key -> {
|
||||
LightCodeInsightFixtureTestCaseWrapper wrapper = new LightCodeInsightFixtureTestCaseWrapper(extensionContext);
|
||||
try {
|
||||
wrapper.setUp();
|
||||
} catch (Exception e) {
|
||||
LOG.severe("Exception during setUp(): " + e);
|
||||
throw new IllegalStateException("Exception during setUp()", e);
|
||||
}
|
||||
return wrapper;
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public void afterTestExecution(ExtensionContext context) throws Exception {
|
||||
Store store = getStore(context);
|
||||
LightCodeInsightFixtureTestCaseWrapper testCase = (LightCodeInsightFixtureTestCaseWrapper) store.get("testCase");
|
||||
if (testCase != null) {
|
||||
testCase.tearDown();
|
||||
}
|
||||
}
|
||||
|
||||
private static Store getStore(ExtensionContext context) {
|
||||
return context.getStore(Namespace.create(LightCodeInsightExtension.class, context.getRequiredTestMethod()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
|
||||
Throwable[] throwables = new Throwable[1];
|
||||
|
||||
Runnable runnable = () -> {
|
||||
try {
|
||||
TestLoggerFactory.onTestStarted();
|
||||
invocation.proceed();
|
||||
TestLoggerFactory.onTestFinished(true);
|
||||
} catch (Throwable e) {
|
||||
TestLoggerFactory.onTestFinished(false);
|
||||
throwables[0] = e;
|
||||
}
|
||||
};
|
||||
|
||||
invokeTestRunnable(runnable);
|
||||
|
||||
if (throwables[0] != null) {
|
||||
throw throwables[0];
|
||||
}
|
||||
}
|
||||
|
||||
private static void invokeTestRunnable(@NotNull Runnable runnable) {
|
||||
IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
|
||||
if (policy != null && !policy.runInDispatchThread()) {
|
||||
runnable.run();
|
||||
} else {
|
||||
EdtTestUtilKt.runInEdtAndWait(() -> {
|
||||
runnable.run();
|
||||
return null;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private static class LightCodeInsightFixtureTestCaseWrapper extends LightJavaCodeInsightFixtureTestCase {
|
||||
private final ExtensionContext extensionContext;
|
||||
|
||||
private LightCodeInsightFixtureTestCaseWrapper(ExtensionContext extensionContext) {
|
||||
this.extensionContext = extensionContext;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setUp() throws Exception {
|
||||
super.setUp();
|
||||
Store store = getStore(extensionContext);
|
||||
store.put("disposable", Disposer.newDisposable("LightCodeInsightFixtureTestCaseWrapper"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tearDown() throws Exception {
|
||||
Store store = getStore(extensionContext);
|
||||
Disposable disposable = (Disposable) store.get("disposable");
|
||||
if (myFixture != null && disposable != null) {
|
||||
Disposer.dispose(disposable);
|
||||
store.remove("disposable");
|
||||
}
|
||||
super.tearDown();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
protected LightProjectDescriptor getProjectDescriptor() {
|
||||
TestJdk testJdk = getMethodOrClassAnnotation(TestJdk.class);
|
||||
if (testJdk == null) {
|
||||
return super.getProjectDescriptor();
|
||||
}
|
||||
return new ProjectDescriptor(testJdk.value(), testJdk.annotations()) {
|
||||
@Override
|
||||
public Sdk getSdk() {
|
||||
return testJdk.useInternal()
|
||||
? JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk()
|
||||
: super.getSdk();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @NotNull ContentEntry contentEntry) {
|
||||
super.configureModule(module, model, contentEntry);
|
||||
AddLocalJarToModule localJars = getMethodOrClassAnnotation(AddLocalJarToModule.class);
|
||||
if (localJars != null) {
|
||||
Stream.of(localJars.value()).forEach(it -> addJarContaining(model, it));
|
||||
}
|
||||
List<AddMavenDependencyToModule> mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule.class);
|
||||
mavenDependencies.forEach(it -> addFromMaven(model, it.value(), it.includeTransitiveDependencies, it.scope));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
void addJarContaining(ModifiableRootModel model, Class<?> clazz) {
|
||||
try {
|
||||
Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
|
||||
|
||||
VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
|
||||
myFixture.allowTreeAccessForFile(jarFile);
|
||||
PsiTestUtil.addLibrary(
|
||||
model,
|
||||
jarPath.getFileName().toString().replace(".jar", ""),
|
||||
jarPath.getParent().toString(),
|
||||
jarPath.getFileName().toString()
|
||||
);
|
||||
} catch (URISyntaxException e) {
|
||||
throw new IllegalArgumentException("Class URL malformed", e);
|
||||
}
|
||||
}
|
||||
|
||||
void addFromMaven(ModifiableRootModel model, String mavenCoordinates,
|
||||
boolean includeTransitiveDependencies, DependencyScope dependencyScope) {
|
||||
List<RemoteRepositoryDescription> remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES;
|
||||
RepositoryLibraryProperties libraryProperties = new RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies);
|
||||
Collection<OrderRoot> roots =
|
||||
JarRepositoryManager.loadDependenciesModal(model.getProject(), libraryProperties, false, false, null, remoteRepositoryDescriptions);
|
||||
LibraryTable.ModifiableModel tableModel = model.getModuleLibraryTable().getModifiableModel();
|
||||
Library library = tableModel.createLibrary(mavenCoordinates);
|
||||
Library.ModifiableModel libraryModel = library.getModifiableModel();
|
||||
if (roots.isEmpty()) {
|
||||
throw new IllegalStateException(String.format("No roots for '%s'", mavenCoordinates));
|
||||
}
|
||||
|
||||
for (OrderRoot root : roots) {
|
||||
libraryModel.addRoot(root.getFile(), root.getType());
|
||||
}
|
||||
|
||||
LibraryOrderEntry libraryOrderEntry = model.findLibraryOrderEntry(library);
|
||||
if (libraryOrderEntry == null) {
|
||||
throw new IllegalStateException("Unable to find registered library " + mavenCoordinates);
|
||||
}
|
||||
libraryOrderEntry.setScope(dependencyScope);
|
||||
|
||||
libraryModel.commit();
|
||||
tableModel.commit();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String getTestDataPath() {
|
||||
TestDataPath testDataPath = getMethodOrClassAnnotation(TestDataPath.class);
|
||||
if (testDataPath == null) {
|
||||
return super.getTestDataPath();
|
||||
}
|
||||
TestDataSubPath testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath.class);
|
||||
if (testDataSubPath == null) {
|
||||
return testDataPath.value();
|
||||
}
|
||||
return Paths.get(testDataPath.value(), testDataSubPath.value()).toString();
|
||||
}
|
||||
|
||||
public JavaCodeInsightTestFixture getMyFixture() {
|
||||
return myFixture;
|
||||
}
|
||||
|
||||
private <T extends Annotation> T getMethodOrClassAnnotation(Class<T> clazz) {
|
||||
T annotation = extensionContext.getRequiredTestMethod().getAnnotation(clazz);
|
||||
if (annotation == null) {
|
||||
annotation = extensionContext.getRequiredTestClass().getAnnotation(clazz);
|
||||
}
|
||||
return annotation;
|
||||
}
|
||||
|
||||
private <T extends Annotation> List<T> getMethodOrClassAnnotations(Class<T> clazz) {
|
||||
return Stream.of(extensionContext.getRequiredTestMethod().getAnnotationsByType(clazz),
|
||||
extensionContext.getRequiredTestClass().getAnnotationsByType(clazz))
|
||||
.flatMap(Arrays::stream)
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
@Target(ElementType.PARAMETER)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface MyFixture {
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
@Target(ElementType.PARAMETER)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface MyTestCase {
|
||||
}
|
||||
@ -1,10 +1,8 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import java.lang.annotation.*;
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
public @interface TestDataPath {
|
||||
String value();
|
||||
}
|
||||
annotation class TestDataPath(val value: String)
|
||||
|
||||
@ -1,10 +1,8 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import java.lang.annotation.*;
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
public @interface TestDataSubPath {
|
||||
String value();
|
||||
}
|
||||
annotation class TestDataSubPath(val value: String)
|
||||
|
||||
@ -1,16 +1,9 @@
|
||||
package de.platon42.intellij.jupiter;
|
||||
package de.platon42.intellij.jupiter
|
||||
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.pom.java.LanguageLevel
|
||||
import java.lang.annotation.Inherited
|
||||
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target({ElementType.TYPE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
|
||||
@Retention(AnnotationRetention.RUNTIME)
|
||||
@Inherited
|
||||
public @interface TestJdk {
|
||||
LanguageLevel value();
|
||||
|
||||
boolean annotations() default false;
|
||||
|
||||
boolean useInternal() default false;
|
||||
}
|
||||
annotation class TestJdk(val value: LanguageLevel)
|
||||
|
||||
@ -2,45 +2,44 @@ package de.platon42.intellij.plugins.cajon
|
||||
|
||||
import com.intellij.codeInsight.intention.IntentionAction
|
||||
import com.intellij.pom.java.LanguageLevel
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import de.platon42.intellij.jupiter.LightCodeInsightExtension
|
||||
import de.platon42.intellij.jupiter.AbstractJUnit5TestCase
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.TestDataPath
|
||||
import de.platon42.intellij.jupiter.TestJdk
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.assertj.core.api.Condition
|
||||
import org.junit.jupiter.api.DisplayNameGeneration
|
||||
import org.junit.jupiter.api.DisplayNameGenerator
|
||||
import org.junit.jupiter.api.extension.ExtendWith
|
||||
import java.lang.reflect.Method
|
||||
|
||||
@ExtendWith(LightCodeInsightExtension::class)
|
||||
@TestDataPath("src/test/resources")
|
||||
@TestJdk(LanguageLevel.JDK_1_8, annotations = true, useInternal = true)
|
||||
//@AddLocalJarToModule(Assertions::class)
|
||||
@AddMavenDependencyToModule("org.assertj:assertj-core:3.15.0")
|
||||
@TestJdk(LanguageLevel.JDK_1_8)
|
||||
@AddLocalJarToModule(Assertions::class)
|
||||
//@AddMavenDependencyToModule("org.assertj:assertj-core:3.25.3", includeTransitiveDependencies = false, DependencyScope.COMPILE)
|
||||
@DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
|
||||
abstract class AbstractCajonTest {
|
||||
abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
|
||||
|
||||
protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
|
||||
protected fun executeQuickFixes(regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(regex, expectedFixes)
|
||||
assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
|
||||
quickfixes.forEach(myFixture::launchAction)
|
||||
quickfixes.forEach(fixture::launchAction)
|
||||
}
|
||||
|
||||
protected fun executeQuickFixesNoFamilyNameCheck(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
|
||||
quickfixes.forEach(myFixture::launchAction)
|
||||
protected fun executeQuickFixesNoFamilyNameCheck(regex: Regex, expectedFixes: Int) {
|
||||
val quickfixes = getQuickFixes(regex, expectedFixes)
|
||||
quickfixes.forEach(fixture::launchAction)
|
||||
}
|
||||
|
||||
protected fun getQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int): List<IntentionAction> {
|
||||
val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
|
||||
assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
|
||||
protected fun getQuickFixes(regex: Regex, expectedFixes: Int): List<IntentionAction> {
|
||||
val allFixes = fixture.getAllQuickFixes()
|
||||
val quickfixes = allFixes.filter { it.text.matches(regex) }
|
||||
assertThat(quickfixes).`as`("Fixes matched by $regex: ${allFixes.map { it.text }}").hasSize(expectedFixes)
|
||||
return quickfixes
|
||||
}
|
||||
|
||||
protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
|
||||
assertThat(myFixture.doHighlighting())
|
||||
protected fun assertHighlightings(count: Int, snippet: String) {
|
||||
assertThat(fixture.doHighlighting())
|
||||
.areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
|
||||
}
|
||||
|
||||
|
||||
@ -1,19 +1,19 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import com.intellij.testFramework.RunsInEdt
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/BinaryExpression")
|
||||
internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/BinaryExpression")
|
||||
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()"), 161)
|
||||
myFixture.checkResultByFile("BinaryExpressionAfter.java")
|
||||
@RunsInEdt
|
||||
internal fun assertThat_of_binary_expression_can_be_moved_out() {
|
||||
fixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
|
||||
fixture.configureByFile("BinaryExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
|
||||
fixture.checkResultByFile("BinaryExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,22 +1,20 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/BooleanCondition")
|
||||
internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/BooleanCondition")
|
||||
internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
|
||||
myFixture.configureByFile("BooleanConditionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
|
||||
myFixture.checkResultByFile("BooleanConditionAfter.java")
|
||||
internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse() {
|
||||
fixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
|
||||
fixture.configureByFile("BooleanConditionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
|
||||
fixture.checkResultByFile("BooleanConditionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,7 +1,5 @@
|
||||
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.assertj.core.api.Assertions.assertThat
|
||||
@ -11,68 +9,68 @@ import org.junit.jupiter.api.Test
|
||||
internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
|
||||
myFixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
|
||||
myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods() {
|
||||
fixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
|
||||
fixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
|
||||
fixture.checkResultByFile("CollectionMapExpressionAfter.java")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 3
|
||||
myFixture.enableInspections(inspection)
|
||||
myFixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
myFixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
|
||||
fixture.enableInspections(inspection)
|
||||
fixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
fixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 0
|
||||
|
||||
myFixture.enableInspections(inspection)
|
||||
myFixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
fixture.enableInspections(inspection)
|
||||
fixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 1
|
||||
|
||||
myFixture.enableInspections(inspection)
|
||||
myFixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
val highlights = myFixture.doHighlighting()
|
||||
fixture.enableInspections(inspection)
|
||||
fixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
val highlights = fixture.doHighlighting()
|
||||
.asSequence()
|
||||
.filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
|
||||
.filter {
|
||||
@ -81,24 +79,24 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
|
||||
.toList()
|
||||
assertThat(highlights).hasSize(4)
|
||||
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
|
||||
val inspection = AssertThatCollectionOrMapExpressionInspection()
|
||||
inspection.behaviorForMapValueEqualsNull = 4
|
||||
|
||||
myFixture.enableInspections(inspection)
|
||||
myFixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
fixture.enableInspections(inspection)
|
||||
fixture.configureByFile("CollectionMapExpressionBefore.java")
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
|
||||
getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
|
||||
}
|
||||
}
|
||||
@ -1,24 +1,22 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/Comparable")
|
||||
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")
|
||||
internal fun assertThat_with_compareTo_method() {
|
||||
fixture.enableInspections(AssertThatComparableInspection::class.java)
|
||||
fixture.configureByFile("ComparableBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
|
||||
fixture.checkResultByFile("ComparableAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,23 +1,21 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/EnumerableIsEmpty")
|
||||
internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/EnumerableIsEmpty")
|
||||
internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
|
||||
myFixture.configureByFile("EnumerableIsEmptyBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
|
||||
myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
|
||||
internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty() {
|
||||
fixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
|
||||
fixture.configureByFile("EnumerableIsEmptyBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
|
||||
fixture.checkResultByFile("EnumerableIsEmptyAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,38 +1,36 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/FileExpression")
|
||||
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")
|
||||
internal fun assertThat_with_certain_File_methods() {
|
||||
fixture.enableInspections(AssertThatFileExpressionInspection::class.java)
|
||||
fixture.configureByFile("FileExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
|
||||
fixture.checkResultByFile("FileExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,48 +1,45 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
|
||||
@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
|
||||
@TestDataSubPath("inspections/GuavaOptional")
|
||||
internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
|
||||
myFixture.configureByFile("GuavaOptionalBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
|
||||
myFixture.checkResultByFile("GuavaOptionalAfter.java")
|
||||
internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified() {
|
||||
fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
|
||||
fixture.configureByFile("GuavaOptionalBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
|
||||
fixture.checkResultByFile("GuavaOptionalAfter.java")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
|
||||
myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 4)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
|
||||
myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
|
||||
internal fun adds_missing_Guava_import_any_order() {
|
||||
fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
|
||||
fixture.configureByFile("WithoutPriorGuavaImportBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(Regex(".*eplace .* with .*"), 4)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Remove .*"), 3)
|
||||
fixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun adds_missing_Guava_import_isAbsent_first(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
|
||||
myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 3)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
|
||||
myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
|
||||
internal fun adds_missing_Guava_import_isAbsent_first() {
|
||||
fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
|
||||
fixture.configureByFile("WithoutPriorGuavaImportBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex(".*eplace .* with .*"), 3)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Remove .*"), 3)
|
||||
fixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,20 +1,18 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/InstanceOf")
|
||||
internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/InstanceOf")
|
||||
internal fun assertThat_with_instanceof_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
|
||||
myFixture.configureByFile("InstanceOfBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
|
||||
myFixture.checkResultByFile("InstanceOfAfter.java")
|
||||
internal fun assertThat_with_instanceof_can_be_moved_out() {
|
||||
fixture.enableInspections(AssertThatInstanceOfInspection::class.java)
|
||||
fixture.configureByFile("InstanceOfBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
|
||||
fixture.checkResultByFile("InstanceOfAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,21 +1,19 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/InvertedBooleanCondition")
|
||||
internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/InvertedBooleanCondition")
|
||||
internal fun assertThat_with_inverted_boolean_condition_can_be_inverted(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
|
||||
myFixture.configureByFile("InvertedBooleanConditionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
|
||||
myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
|
||||
internal fun assertThat_with_inverted_boolean_condition_can_be_inverted() {
|
||||
fixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
|
||||
fixture.configureByFile("InvertedBooleanConditionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Invert condition in assertThat()"), 25)
|
||||
executeQuickFixes(Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
|
||||
fixture.checkResultByFile("InvertedBooleanConditionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,21 +1,19 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/IsZeroOne")
|
||||
internal class AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/IsZeroOne")
|
||||
internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
|
||||
myFixture.configureByFile("IsZeroOneBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
|
||||
myFixture.checkResultByFile("IsZeroOneAfter.java")
|
||||
internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero() {
|
||||
fixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
|
||||
fixture.configureByFile("IsZeroOneBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
|
||||
fixture.checkResultByFile("IsZeroOneAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,27 +1,25 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/Java8Optional")
|
||||
internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/Java8Optional")
|
||||
internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
|
||||
myFixture.configureByFile("Java8OptionalBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
|
||||
myFixture.checkResultByFile("Java8OptionalAfter.java")
|
||||
internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified() {
|
||||
fixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
|
||||
fixture.configureByFile("Java8OptionalBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
|
||||
fixture.checkResultByFile("Java8OptionalAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,22 +1,20 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/ObjectExpression")
|
||||
internal class AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/ObjectExpression")
|
||||
internal fun assertThat_with_certain_Object_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
|
||||
myFixture.configureByFile("ObjectExpressionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
|
||||
myFixture.checkResultByFile("ObjectExpressionAfter.java")
|
||||
internal fun assertThat_with_certain_Object_methods() {
|
||||
fixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
|
||||
fixture.configureByFile("ObjectExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
|
||||
fixture.checkResultByFile("ObjectExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,20 +1,18 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/ObjectIsNullOrNotNull")
|
||||
internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/ObjectIsNullOrNotNull")
|
||||
internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
|
||||
myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
|
||||
myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
|
||||
internal fun assertThat_with_isEqualTo_null_can_use_isNull() {
|
||||
fixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
|
||||
fixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
|
||||
fixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,24 +1,22 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/PathExpression")
|
||||
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")
|
||||
internal fun assertThat_with_certain_Path_methods() {
|
||||
fixture.enableInspections(AssertThatPathExpressionInspection::class.java)
|
||||
fixture.configureByFile("PathExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
|
||||
fixture.checkResultByFile("PathExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,34 +1,32 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/Size")
|
||||
internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/Size")
|
||||
internal fun assertThat_size_of_array_collection_or_map_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatSizeInspection::class.java)
|
||||
myFixture.configureByFile("SizeBefore.java")
|
||||
assertHighlightings(myFixture, 1, "Try to operate on the iterable itself rather than its size")
|
||||
internal fun assertThat_size_of_array_collection_or_map_can_be_simplified() {
|
||||
fixture.enableInspections(AssertThatSizeInspection::class.java)
|
||||
fixture.configureByFile("SizeBefore.java")
|
||||
assertHighlightings(1, "Try to operate on the iterable itself rather than its size")
|
||||
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
|
||||
myFixture.checkResultByFile("SizeAfter.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
|
||||
fixture.checkResultByFile("SizeAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,41 +1,39 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/StringExpression")
|
||||
internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/StringExpression")
|
||||
internal fun assertThat_with_certain_String_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
|
||||
myFixture.configureByFile("StringExpressionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
|
||||
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)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
|
||||
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")
|
||||
internal fun assertThat_with_certain_String_methods() {
|
||||
fixture.enableInspections(AssertThatStringExpressionInspection::class.java)
|
||||
fixture.configureByFile("StringExpressionBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
|
||||
executeQuickFixes(Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
|
||||
fixture.checkResultByFile("StringExpressionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,27 +1,25 @@
|
||||
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.assertj.core.api.Assertions.assertThat
|
||||
import org.assertj.core.api.extrakting
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/StringIsEmpty")
|
||||
internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/StringIsEmpty")
|
||||
internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
|
||||
myFixture.configureByFile("StringIsEmptyBefore.java")
|
||||
val highlights = myFixture.doHighlighting()
|
||||
internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty() {
|
||||
fixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
|
||||
fixture.configureByFile("StringIsEmptyBefore.java")
|
||||
val highlights = fixture.doHighlighting()
|
||||
.asSequence()
|
||||
.filter { it.description?.contains(" can be simplified to") ?: false }
|
||||
.toList()
|
||||
assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
|
||||
myFixture.checkResultByFile("StringIsEmptyAfter.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
|
||||
executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
|
||||
fixture.checkResultByFile("StringIsEmptyAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,22 +1,20 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddLocalJarToModule(Assertions::class, Test::class, org.junit.Test::class)
|
||||
@AddMavenDependencyToModule("junit:junit:4.13.2")
|
||||
@AddMavenDependencyToModule("org.junit.jupiter:junit-jupiter-api:5.10.2")
|
||||
@TestDataSubPath("inspections/AssumeThat")
|
||||
internal class AssumeThatInsteadOfReturnInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/AssumeThat")
|
||||
internal fun conditional_returns_can_be_replaced_by_assumeThat(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
|
||||
myFixture.configureByFile("AssumeThatBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
|
||||
myFixture.checkResultByFile("AssumeThatAfter.java")
|
||||
internal fun conditional_returns_can_be_replaced_by_assumeThat() {
|
||||
fixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
|
||||
fixture.configureByFile("AssumeThatBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
|
||||
fixture.checkResultByFile("AssumeThatAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,19 +1,17 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/BogusAssertion")
|
||||
internal class BogusAssertionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/BogusAssertion")
|
||||
internal fun reports_bogus_assertions(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(BogusAssertionInspection::class.java)
|
||||
myFixture.configureByFile("BogusAssertionBefore.java")
|
||||
assertHighlightings(myFixture, 14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
|
||||
assertHighlightings(myFixture, 3, "Same actual and expected expression, but may be testing equals() or hashCode()")
|
||||
internal fun reports_bogus_assertions() {
|
||||
fixture.enableInspections(BogusAssertionInspection::class.java)
|
||||
fixture.configureByFile("BogusAssertionBefore.java")
|
||||
assertHighlightings(14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
|
||||
assertHighlightings(3, "Same actual and expected expression, but may be testing equals() or hashCode()")
|
||||
}
|
||||
}
|
||||
@ -1,24 +1,21 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
|
||||
@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
|
||||
@TestDataSubPath("inspections/ImplicitAssertion")
|
||||
internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/ImplicitAssertion")
|
||||
internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(ImplicitAssertionInspection::class.java)
|
||||
myFixture.configureByFile("ImplicitAssertionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
|
||||
myFixture.checkResultByFile("ImplicitAssertionAfter.java")
|
||||
internal fun implicit_assertions_can_be_removed() {
|
||||
fixture.enableInspections(ImplicitAssertionInspection::class.java)
|
||||
fixture.configureByFile("ImplicitAssertionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
|
||||
fixture.checkResultByFile("ImplicitAssertionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,24 +1,20 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.AddLocalJarToModule
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.AddMavenDependencyToModule
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.assertj.core.api.Assertions
|
||||
import org.junit.Assert
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@AddLocalJarToModule(Assert::class, Assertions::class)
|
||||
@AddMavenDependencyToModule("junit:junit:4.13.2")
|
||||
@TestDataSubPath("inspections/JUnitAssertToAssertJ")
|
||||
internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/JUnitAssertToAssertJ")
|
||||
internal fun junit_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
|
||||
myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
|
||||
myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
|
||||
internal fun junit_Assertions_can_be_converted_into_AssertJ() {
|
||||
fixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
|
||||
fixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
|
||||
fixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,19 +1,17 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/JoinStatements")
|
||||
internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/JoinStatements")
|
||||
internal fun assertThat_statements_can_be_joined_together(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
|
||||
myFixture.configureByFile("JoinStatementsBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
|
||||
myFixture.checkResultByFile("JoinStatementsAfter.java")
|
||||
internal fun assertThat_statements_can_be_joined_together() {
|
||||
fixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
|
||||
fixture.configureByFile("JoinStatementsBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Join assertThat() statements"), 5)
|
||||
fixture.checkResultByFile("JoinStatementsAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,19 +1,17 @@
|
||||
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
|
||||
|
||||
@TestDataSubPath("inspections/JoinVarArgsContains")
|
||||
internal class JoinVarArgsContainsInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/JoinVarArgsContains")
|
||||
internal fun join_contains_and_doesNotContain_together_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(JoinVarArgsContainsInspection::class.java)
|
||||
myFixture.configureByFile("JoinVarArgsContainsBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
|
||||
myFixture.checkResultByFile("JoinVarArgsContainsAfter.java")
|
||||
internal fun join_contains_and_doesNotContain_together_where_possible() {
|
||||
fixture.enableInspections(JoinVarArgsContainsInspection::class.java)
|
||||
fixture.configureByFile("JoinVarArgsContainsBefore.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
|
||||
fixture.checkResultByFile("JoinVarArgsContainsAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,23 +1,21 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
|
||||
import de.platon42.intellij.jupiter.MyFixture
|
||||
import de.platon42.intellij.jupiter.TestDataSubPath
|
||||
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
@TestDataSubPath("inspections/TwistedAssertion")
|
||||
internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/TwistedAssertion")
|
||||
internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(TwistedAssertionInspection::class.java)
|
||||
myFixture.configureByFile("TwistedAssertionBefore.java")
|
||||
assertHighlightings(myFixture, 9, "Actual expression in assertThat() is a constant")
|
||||
assertHighlightings(myFixture, 10, "Twisted actual and expected expressions")
|
||||
internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible() {
|
||||
fixture.enableInspections(TwistedAssertionInspection::class.java)
|
||||
fixture.configureByFile("TwistedAssertionBefore.java")
|
||||
assertHighlightings(9, "Actual expression in assertThat() is a constant")
|
||||
assertHighlightings(10, "Twisted actual and expected expressions")
|
||||
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Replace .* by .* and swap actual and expected expressions"), 4)
|
||||
myFixture.checkResultByFile("TwistedAssertionAfter.java")
|
||||
executeQuickFixes(Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
|
||||
executeQuickFixesNoFamilyNameCheck(Regex("Replace .* by .* and swap actual and expected expressions"), 4)
|
||||
fixture.checkResultByFile("TwistedAssertionAfter.java")
|
||||
}
|
||||
}
|
||||
@ -1,7 +1,5 @@
|
||||
package de.platon42.intellij.plugins.cajon.references
|
||||
|
||||
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.assertj.core.api.Assertions.assertThat
|
||||
@ -13,68 +11,68 @@ import org.junit.jupiter.api.Test
|
||||
internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_field_extracting(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
internal fun extractor_is_able_to_find_reference_for_field_extracting() {
|
||||
fixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
|
||||
internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path() {
|
||||
fixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).isEqualTo("protected Address address;")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
|
||||
internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field() {
|
||||
fixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_on_a_bare_method_call(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
|
||||
internal fun extractor_is_able_to_find_reference_on_a_bare_method_call() {
|
||||
fixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
|
||||
internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part() {
|
||||
fixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_using_byName_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
internal fun extractor_is_able_to_find_reference_using_byName_extractor() {
|
||||
fixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_using_resultOf_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
|
||||
internal fun extractor_is_able_to_find_reference_using_resultOf_extractor() {
|
||||
fixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list() {
|
||||
fixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
|
||||
internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list() {
|
||||
fixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
|
||||
assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
|
||||
internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method() {
|
||||
fixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
|
||||
assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
|
||||
}
|
||||
|
||||
@Test
|
||||
internal fun extractor_is_unable_to_find_reference(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
|
||||
assertThatThrownBy { myFixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
|
||||
internal fun extractor_is_unable_to_find_reference() {
|
||||
fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
|
||||
assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user