Add support for converting JUnit 5 tests to AssertJ

LICENSE.TXT

@@ -1,4 +1,4 @@
-Copyright 2019-2024 Chris Hodges <chrisly@platon42.de>
+Copyright 2019 Chris Hodges <chrisly@platon42.de>
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

README.md

@@ -1,4 +1,4 @@
-# Cajon - Concise AssertJ Optimizing Nitpicker
+# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://travis-ci.com/chrisly42/cajon-plugin.svg?branch=master)](https://travis-ci.com/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
 
 Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
@@ -32,7 +32,7 @@ Then AssertJ would tell you the _actual contents_ of the collection on failure.
 
 ## Conversion of JUnit assertions to AssertJ
 
-The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
+The plugin also supports the conversion of the most common JUnit 4 and JUnit 5 assertions to AssertJ.
 
 ## Wrong use of AssertJ
 
@@ -40,8 +40,7 @@ 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).
@@ -67,7 +66,6 @@ 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()));
 
@@ -173,23 +171,6 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(object).isNotInstanceOf(classname.class);
   ```
 
-- AssertThatIsZeroOne
-
-  Uses ```isZero()```, ```isNotZero()``` and ```isOne()``` instead.
-  Works with shorts, integers, longs, floats and doubles, and tries to evaluate
-  constant expressions, too.
-
-  ```
-  from: assertThat(numeric).isEqualTo(0);
-    to: assertThat(numeric).isZero();
-
-  from: assertThat(numeric).isNotEqualTo(0);
-    to: assertThat(numeric).isNotZero();
-
-  from: assertThat(numeric).isEqualTo(1);
-    to: assertThat(numeric).isOne();
-  ```
-
 - AssertThatStringIsEmpty
 
   Uses ```isEmpty()``` for empty string assertions.
@@ -713,7 +694,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   However, this suggests that the test has actually been run and passed instead of showing the test
   as being skipped.
 
-  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or
+  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or JUnit 5 or
   Jupiter ```@Test``` annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
   Method calls within the same class will be examined for ```assertThat()``` statements, too.
   However, at most 50 statements and down to five recursions will be tolerated before giving up.
@@ -750,7 +731,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 - JUnitAssertToAssertJ
 
-  Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
+  Tries to convert most of the JUnit 4 and JUnit 5 assertions and assumptions to AssertJ format.
   Sometimes the expected and actual expressions are specified in wrong order -- 
   Cajon tries to swap these when it detects the supposed actual expression to be a
   constant while the expected one is not.
@@ -796,9 +777,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ### Implemented referencing
 
-You can ctrl-click on references inside .extracting() method parameters to go the
-referencing method definition.
-
+  You can ctrl-click on references inside .extracting() method parameters to go the
+  referencing method definition.
   ```
   .extracting("field")
   .extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
@@ -812,21 +792,19 @@ referencing method definition.
   .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
 
-Cajon is written in Kotlin 1.7.
+Cajon is written in Kotlin 1.4.
 
 Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one I'm aware of ;) ).
 The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to make it work with JUnit 5.
 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()
@@ -836,26 +814,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
     to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
   ```
-- Support primitives in assertThat(map.containsKey(1)).isTrue();
 
 ## Changelog
 
-### V1.14 (19-Feb-24)
+#### V1.13 (unreleased)
 
-- 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 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.
-- Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
+- Added support for converting JUnit 5 tests to AssertJ
 
 ### V1.12 (06-May-21)
 
@@ -874,12 +838,10 @@ 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.
@@ -890,14 +852,12 @@ 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).
@@ -905,7 +865,6 @@ 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
@@ -916,7 +875,6 @@ 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).
@@ -927,13 +885,11 @@ 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.
@@ -942,12 +898,10 @@ 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.
@@ -958,18 +912,14 @@ 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.
@@ -978,7 +928,6 @@ 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.
@@ -986,7 +935,6 @@ 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.
@@ -995,7 +943,6 @@ 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
@@ -1004,27 +951,20 @@ 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.

build.gradle

@@ -0,0 +1,79 @@
+plugins {
+    id 'java'
+    id 'org.jetbrains.intellij' version '1.1.3'
+    id 'org.jetbrains.kotlin.jvm' version '1.5.21'
+    id 'jacoco'
+    id 'com.github.kt3k.coveralls' version '2.11.0'
+}
+
+group 'de.platon42'
+version '1.12.1'
+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.20.2"
+    testImplementation "org.assertj:assertj-guava:3.4.0"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
+    testImplementation "org.jetbrains.kotlin:kotlin-test"
+    testImplementation "org.jetbrains.kotlin:kotlin-reflect"
+//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+compileTestKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+intellij {
+    setVersion("2021.1.3") // LATEST-EAP-SNAPSHOT
+    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
+    setUpdateSinceUntilBuild(false)
+    setPlugins(["com.intellij.java"])
+}
+
+patchPluginXml {
+    setChangeNotes("""
+  <h4>V1.13 (unreleased)</h4>
+    <ul>
+      <li>Added support for converting JUnit 5 tests to AssertJ
+    </ul>
+  <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
+""")
+}
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+}
+
+jacoco {
+    toolVersion = '0.8.7'
+}
+
+jacocoTestReport {
+    reports {
+        xml.required.set(true)
+        csv.required.set(false)
+    }
+}
+
+publishPlugin {
+    setToken(intellijPublishToken)
+}

build.gradle.kts

@@ -1,131 +0,0 @@
-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)
-//    }
-//}

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt

@@ -12,100 +12,68 @@ class AssertJClassNames {
 
         @NonNls
         const val DESCRIPTABLE_INTERFACE = "org.assertj.core.api.Descriptable"
-
         @NonNls
         const val EXTENSION_POINTS_INTERFACE = "org.assertj.core.api.ExtensionPoints"
-
         @NonNls
         const val ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.EnumerableAssert"
-
         @NonNls
         const val OBJECT_ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.ObjectEnumerableAssert"
 
         @NonNls
         const val ASSERT_INTERFACE = "org.assertj.core.api.Assert"
-
         @NonNls
         const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
-
         @NonNls
         const val ABSTRACT_OBJECT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectAssert"
-
         @NonNls
         const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
-
-        @NonNls
-        const val ABSTRACT_SHORT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortAssert"
-
         @NonNls
         const val ABSTRACT_INTEGER_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntegerAssert"
-
         @NonNls
         const val ABSTRACT_LONG_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongAssert"
-
         @NonNls
         const val ABSTRACT_FLOAT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatAssert"
-
         @NonNls
         const val ABSTRACT_DOUBLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleAssert"
-
         @NonNls
         const val ABSTRACT_COMPARABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractComparableAssert"
-
         @NonNls
         const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
-
         @NonNls
         const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
-
         @NonNls
         const val ABSTRACT_MAP_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractMapAssert"
-
         @NonNls
         const val ABSTRACT_BOOLEAN_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanArrayAssert"
-
         @NonNls
         const val ABSTRACT_BYTE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractByteArrayAssert"
-
         @NonNls
         const val ABSTRACT_SHORT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortArrayAssert"
-
         @NonNls
         const val ABSTRACT_INT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntArrayAssert"
-
         @NonNls
         const val ABSTRACT_LONG_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongArrayAssert"
-
         @NonNls
         const val ABSTRACT_FLOAT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatArrayAssert"
-
         @NonNls
         const val ABSTRACT_DOUBLE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleArrayAssert"
-
         @NonNls
         const val ABSTRACT_CHAR_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharArrayAssert"
-
         @NonNls
         const val ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectArrayAssert"
-
         @NonNls
         const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
-
         @NonNls
         const val ABSTRACT_FILE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFileAssert"
-
         @NonNls
         const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"
-
         @NonNls
         const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"
 
         @NonNls
         const val GUAVA_OPTIONAL_CLASSNAME = "com.google.common.base.Optional"
-
         @NonNls
         const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
-
         @NonNls
         const val GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
     }

src/main/java/de/platon42/intellij/plugins/cajon/CommonMatchers.kt

@@ -50,21 +50,9 @@ val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
     "singleElement", "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
 )!!
 
-val FILTERED_ON = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "filteredOn", "filteredOnNull", "filteredOnAssertions")!!
-
 val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
-    EXTRACTING_CALL_MATCHERS,
     DESCRIBED_AS,
     WITH_REPRESENTATION_AND_SUCH,
-    FILTERED_ON,
-    USING_COMPARATOR,
-    IN_HEXADECIMAL_OR_BINARY
-)!!
-
-val COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE = CallMatcher.anyOf(
-    EXTRACTING_CALL_MATCHERS,
-    WITH_REPRESENTATION_AND_SUCH,
-    FILTERED_ON,
     USING_COMPARATOR,
     IN_HEXADECIMAL_OR_BINARY
 )!!

src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt

@@ -115,7 +115,8 @@ fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
 }
 
 fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
-    return getArgOrNull(argIndex)?.calculateConstantValue()
+    if (argIndex >= argumentList.expressions.size) return null
+    return getArg(argIndex).calculateConstantValue()
 }
 
 fun PsiExpression.calculateConstantValue(): Any? {

src/main/java/de/platon42/intellij/plugins/cajon/MethodNames.kt

@@ -17,25 +17,19 @@ class MethodNames {
 
         @NonNls
         const val AS = "as"
-
         @NonNls
         const val DESCRIBED_AS = "describedAs"
-
         @NonNls
         const val IN_HEXADECIMAL = "inHexadecimal"
-
         @NonNls
         const val IN_BINARY = "inBinary"
 
         @NonNls
         const val IS_EQUAL_TO = "isEqualTo"
-
         @NonNls
         const val IS_NOT_EQUAL_TO = "isNotEqualTo"
-
         @NonNls
         const val IS_SAME_AS = "isSameAs"
-
         @NonNls
         const val IS_NOT_SAME_AS = "isNotSameAs"
 
@@ -44,133 +38,89 @@ class MethodNames {
 
         @NonNls
         const val IS_GREATER_THAN = "isGreaterThan"
-
         @NonNls
         const val IS_GREATER_THAN_OR_EQUAL_TO = "isGreaterThanOrEqualTo"
-
         @NonNls
         const val IS_LESS_THAN = "isLessThan"
-
         @NonNls
         const val IS_LESS_THAN_OR_EQUAL_TO = "isLessThanOrEqualTo"
-
         @NonNls
         const val IS_ZERO = "isZero"
-
         @NonNls
         const val IS_NOT_ZERO = "isNotZero"
-
-        @NonNls
-        const val IS_ONE = "isOne"
-
         @NonNls
         const val IS_TRUE = "isTrue"
-
         @NonNls
         const val IS_FALSE = "isFalse"
-
         @NonNls
         const val IS_NULL = "isNull" // terminal, returns void
-
         @NonNls
         const val IS_NOT_NULL = "isNotNull"
-
         @NonNls
         const val IS_CLOSE_TO = "isCloseTo"
-
         @NonNls
         const val IS_NOT_CLOSE_TO = "isNotCloseTo"
-
         @NonNls
         const val IS_INSTANCE_OF = "isInstanceOf"
-
         @NonNls
         const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"
 
         @NonNls
         const val IS_NULL_OR_EMPTY = "isNullOrEmpty" // terminal, returns void
-
         @NonNls
         const val IS_EMPTY = "isEmpty" // terminal, returns void
-
         @NonNls
         const val IS_NOT_EMPTY = "isNotEmpty"
-
         @NonNls
         const val HAS_SIZE = "hasSize"
-
         @NonNls
         const val HAS_SIZE_LESS_THAN = "hasSizeLessThan"
-
         @NonNls
         const val HAS_SIZE_LESS_THAN_OR_EQUAL_TO = "hasSizeLessThanOrEqualTo"
-
         @NonNls
         const val HAS_SIZE_GREATER_THAN = "hasSizeGreaterThan"
-
         @NonNls
         const val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO = "hasSizeGreaterThanOrEqualTo"
-
         @NonNls
         const val HAS_SAME_SIZE_AS = "hasSameSizeAs"
-
         @NonNls
         const val CONTAINS = "contains"
-
         @NonNls
         const val CONTAINS_ONLY_ONCE = "containsOnlyOnce"
-
         @NonNls
         const val DOES_NOT_CONTAIN = "doesNotContain"
-
         @NonNls
         const val CONTAINS_EXACTLY = "containsExactly"
-
         @NonNls
         const val CONTAINS_ALL = "containsAll"
-
         @NonNls
         const val CONTAINS_KEY = "containsKey"
-
         @NonNls
         const val DOES_NOT_CONTAIN_KEY = "doesNotContainKey"
-
         @NonNls
         const val CONTAINS_VALUE = "containsValue"
-
         @NonNls
         const val DOES_NOT_CONTAIN_VALUE = "doesNotContainValue"
-
         @NonNls
         const val CONTAINS_ENTRY = "containsEntry"
-
         @NonNls
         const val DOES_NOT_CONTAIN_ENTRY = "doesNotContainEntry"
-
         @NonNls
         const val IS_EQUAL_TO_IC = "isEqualToIgnoringCase"
-
         @NonNls
         const val IS_NOT_EQUAL_TO_IC = "isNotEqualToIgnoringCase"
-
         @NonNls
         const val STARTS_WITH = "startsWith"
-
         @NonNls
         const val ENDS_WITH = "endsWith"
-
         @NonNls
         const val DOES_NOT_START_WITH = "doesNotStartWith"
-
         @NonNls
         const val DOES_NOT_END_WITH = "doesNotEndWith"
-
         @NonNls
         const val CONTAINS_SAME = "containsSame"
-
         @NonNls
         const val IS_PRESENT = "isPresent"
-
         @NonNls
         const val IS_NOT_PRESENT = "isNotPresent"
 

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt

@@ -15,7 +15,6 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_D
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_FLOAT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_LONG_ASSERT_CLASSNAME
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_SHORT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_STRING_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
@@ -89,8 +88,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_EQUAL_TO_STRING = CallMatcher.instanceCall(ABSTRACT_STRING_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
-        val IS_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
-            .parameterTypes("short")!!
         val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("int")!!
         val IS_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
@@ -106,8 +103,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes("boolean")!!
-        val IS_NOT_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
-            .parameterTypes("short")!!
         val IS_NOT_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes("int")!!
         val IS_NOT_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
@@ -160,15 +155,15 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterCount(0)!!
         val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
             .parameterCount(0)!!
-        val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
+        val IS_ONE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
             .parameterCount(0)!!
-        val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
+        val IS_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
             .parameterCount(0)!!
-        val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
+        val IS_NOT_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
             .parameterCount(0)!!
-        val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
+        val IS_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
             .parameterCount(0)!!
-        val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
+        val IS_NOT_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
             .parameterCount(0)!!
 
         val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt

@@ -8,10 +8,16 @@ abstract class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTo
 
     companion object {
         @NonNls
-        const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
+        const val JUNIT4_ASSERT_CLASSNAME = "org.junit.Assert"
 
         @NonNls
-        const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
+        const val JUNIT5_ASSERT_CLASSNAME = "org.junit.jupiter.api.Assertions"
+
+        @NonNls
+        const val JUNIT4_ASSUME_CLASSNAME = "org.junit.Assume"
+
+        @NonNls
+        const val JUNIT5_ASSUME_CLASSNAME = "org.junit.jupiter.api.Assumptions"
 
         @NonNls
         const val ASSERT_TRUE_METHOD = "assertTrue"

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatComparableInspection.kt

@@ -52,7 +52,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
+                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
             ),
 
             MoveOutMapping(
@@ -67,7 +67,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE_INT, IS_ONE_INT), replaceFromOriginalMethod = true
+                MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE, IS_ONE), replaceFromOriginalMethod = true
             ),
 
             MoveOutMapping(
@@ -82,7 +82,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE_INT, replaceFromOriginalMethod = true
+                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE, replaceFromOriginalMethod = true
             ),
 
             MoveOutMapping(
@@ -97,7 +97,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
+                MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
             )
         )
     }

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatIsZeroOneInspection.kt

@@ -1,81 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.util.TypeConversionUtil
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-
-class AssertThatIsZeroOneInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a zero or one value"
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
-                val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_SHORT, IS_EQUAL_TO_INT, IS_EQUAL_TO_LONG, IS_EQUAL_TO_FLOAT, IS_EQUAL_TO_DOUBLE).test(expression)
-                val isNotEqualTo =
-                    CallMatcher.anyOf(IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_SHORT, IS_NOT_EQUAL_TO_INT, IS_NOT_EQUAL_TO_LONG, IS_NOT_EQUAL_TO_FLOAT, IS_NOT_EQUAL_TO_DOUBLE)
-                        .test(expression)
-
-                if (!(isEqualTo || isNotEqualTo)) return
-
-                val expectedExpression = expression.firstArg
-                if (!TypeConversionUtil.isNumericType(expectedExpression.type)) return
-
-                val expectedResult = expression.calculateConstantParameterValue(0) ?: return
-                var isZero = false
-                var isOne = false
-                when (expectedResult) {
-                    is Short -> {
-                        isZero = (expectedResult == 0.toShort())
-                        isOne = (expectedResult == 1.toShort())
-                    }
-
-                    is Int -> {
-                        isZero = (expectedResult == 0)
-                        isOne = (expectedResult == 1)
-                    }
-
-                    is Long -> {
-                        isZero = (expectedResult == 0L)
-                        isOne = (expectedResult == 1L)
-                    }
-
-                    is Float -> {
-                        isZero = (expectedResult == 0.0f)
-                        isOne = (expectedResult == 1.0f)
-                    }
-
-                    is Double -> {
-                        isZero = (expectedResult == 0.0)
-                        isOne = (expectedResult == 1.0)
-                    }
-                }
-                if (isZero || isOne) {
-                    val numericBaseClass = listOf(
-                        AssertJClassNames.ABSTRACT_SHORT_ASSERT_CLASSNAME,
-                        AssertJClassNames.ABSTRACT_INTEGER_ASSERT_CLASSNAME,
-                        AssertJClassNames.ABSTRACT_LONG_ASSERT_CLASSNAME,
-                        AssertJClassNames.ABSTRACT_FLOAT_ASSERT_CLASSNAME,
-                        AssertJClassNames.ABSTRACT_DOUBLE_ASSERT_CLASSNAME
-                    ).any { checkAssertedType(expression, it) }
-                    if (!numericBaseClass) return
-                }
-                if (isZero) {
-                    registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_ZERO, MethodNames.IS_NOT_ZERO))
-                } else if (isOne && isEqualTo) {
-                    registerSimplifyMethod(holder, expression, MethodNames.IS_ONE)
-                }
-            }
-        }
-    }
-}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt

@@ -94,7 +94,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
 
             MoveOutMapping(
                 STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
+                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,
@@ -119,7 +119,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,

src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt

@@ -3,6 +3,8 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
+import com.intellij.psi.CommonClassNames.*
+import com.intellij.psi.PsiKeyword.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.siyeh.ig.callMatcher.CallMatcher
 import com.siyeh.ig.callMatcher.CallMatcher.anyOf
@@ -20,94 +22,127 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
         private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"
 
+        private const val DOUBLE_ARR = "$DOUBLE[]"
+        private const val FLOAT_ARR = "$FLOAT[]"
+
         private val ASSERT_MAPPINGS = listOf(
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
                 ),
                 MethodNames.IS_TRUE, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
                 ),
                 MethodNames.IS_FALSE, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
                 ),
                 MethodNames.IS_NULL, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
                 ),
                 MethodNames.IS_NOT_NULL, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
                 ),
                 MethodNames.IS_CLOSE_TO, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
                 ),
                 MethodNames.IS_EQUAL_TO
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
                 ),
                 MethodNames.IS_NOT_CLOSE_TO, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
                 ),
                 MethodNames.IS_NOT_EQUAL_TO
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
                 ),
                 MethodNames.IS_SAME_AS
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
                 ),
                 MethodNames.IS_NOT_SAME_AS
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double[]", "double[]", "double"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("double[]", "double[]", "double"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float[]", "float[]", "float"),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT_ARR, FLOAT_ARR, FLOAT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
                 ),
                 MethodNames.CONTAINS_EXACTLY, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
-                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
                 ),
                 MethodNames.CONTAINS_EXACTLY
             )
@@ -116,26 +151,35 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         private val ASSUME_MAPPINGS = listOf(
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
-                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
                 ),
                 MethodNames.IS_TRUE, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
-                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
                 ),
                 MethodNames.IS_FALSE, hasExpected = false
             ),
             Mapping(
-                staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
+                anyOf(
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
+                ),
                 MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_THROWABLE),
-                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_THROWABLE)
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_THROWABLE),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE, JAVA_LANG_STRING),
+                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
+                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
                 ),
                 "doesNotThrowAnyException", hasExpected = false
             )
@@ -149,33 +193,41 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
                 when (expression.resolveMethod()?.containingClass?.qualifiedName) {
-                    JUNIT_ASSERT_CLASSNAME -> {
-                        JavaPsiFacade.getInstance(expression.project)
-                            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
-                        if (mapping.hasDelta) {
-                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
-                        } else {
-                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
-                                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
-                            }
-                        }
-                    }
-                    JUNIT_ASSUME_CLASSNAME -> {
-                        JavaPsiFacade.getInstance(expression.project)
-                            .findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                        val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
-                        if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
-                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
-                                ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
-                            }
-                        }
-                    }
+                    JUNIT4_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, false)
+                    JUNIT5_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, true)
+                    JUNIT4_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, false)
+                    JUNIT5_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, true)
                 }
             }
         }
     }
 
+    private fun visitMethodCallExpressionAssert(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
+        JavaPsiFacade.getInstance(expression.project)
+            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+        if (mapping.hasDelta) {
+            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
+                ReplaceJUnitDeltaAssertMethodCallQuickFix(desc, method, junit5)
+            }
+        } else {
+            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
+                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected, junit5)
+            }
+        }
+    }
+
+    private fun visitMethodCallExpressionAssume(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
+        JavaPsiFacade.getInstance(expression.project)
+            .findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+        val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+        if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
+            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
+                ReplaceJUnitAssumeMethodCallQuickFix(desc, method, junit5)
+            }
+        }
+    }
+
     private fun registerConvertMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,

src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt

@@ -72,7 +72,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                     if (!statement.hasAssertThat()) return null
 
                     val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
-                    return assertThatCall?.takeIf { it.findFluentCallTo(COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE) == null }
+                    return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
                 }
                 return null
             }
@@ -83,7 +83,6 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                     val matched = when (element) {
                         is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
                                 || (element.operationTokenType == JavaTokenType.MINUSMINUS)
-
                         is PsiMethodCallExpression -> KNOWN_METHODS_WITH_SIDE_EFFECTS.test(element)
                         else -> false
                     }

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/JoinStatementsQuickFix.kt

@@ -56,8 +56,9 @@ class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommo
     }
 
     private fun addLineBreak(project: Project, lastElementBeforeConcat: PsiElement) {
-        // was PsiParserFacade.getInstance(project).createWhiteSpaceFromText("\n\t"), changed due to breaking API changes
-        val newLineNode = project.getService(PsiParserFacade::class.java).createWhiteSpaceFromText("\n\t")
+        val newLineNode =
+            PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
+
         lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
     }
 

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt

@@ -7,7 +7,7 @@ import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 
-class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean) :
+class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean, private val junit5: Boolean) :
     AbstractCommonQuickFix(description) {
 
     companion object {
@@ -23,14 +23,20 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
         val count = args.expressions.size
-        val actualExpression = args.expressions[count - 1] ?: return
-        val (expectedExpressions, messageExpression) = if (noExpectedExpression) {
-            val message = args.expressions.getOrNull(count - 2)
-            emptyArray<PsiExpression>() to message
+        val hasMessage = if (noExpectedExpression) count == 1 else count == 2;
+
+        val actualExpression: PsiExpression
+        val expectedExpressions: Array<PsiExpression>
+        val messageExpression: PsiExpression?
+
+        if (junit5) {
+            actualExpression = args.expressions[if (noExpectedExpression) 0 else 1] ?: return
+            messageExpression = if (hasMessage) null else args.expressions[count - 1]
+            expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[0])
         } else {
-            val expected = args.expressions[count - 2] ?: return
-            val message = args.expressions.getOrNull(count - 3)
-            arrayOf(expected) to message
+            actualExpression = args.expressions[count - 1] ?: return
+            messageExpression = if (hasMessage) null else args.expressions[0]
+            expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[count - 2])
         }
 
         val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssumeMethodCallQuickFix.kt

@@ -5,7 +5,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*
 
-class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
+class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) :
     AbstractCommonQuickFix(description) {
 
     companion object {
@@ -21,8 +21,8 @@ class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val repl
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
         val count = args.expressions.size
-        val actualExpression = args.expressions[count - 1] ?: return
-        val messageExpression = args.expressions.getOrNull(count - 2)
+        val actualExpression = args.expressions[if (junit5) 0 else count - 1] ?: return
+        val messageExpression = args.expressions.getOrNull(if (junit5) 1 else count - 2)
 
         val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
         val newMethodCall = createAssumeThat(element, actualExpression)

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt

@@ -6,7 +6,7 @@ import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 
-class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) : AbstractCommonQuickFix(description) {
 
     companion object {
         private const val CONVERT_DESCRIPTION = "Convert JUnit assertions with delta to assertJ"
@@ -21,10 +21,10 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
         val count = args.expressions.size
-        val messageExpression = args.expressions.getOrNull(count - 4)
-        val expectedExpression = args.expressions[count - 3] ?: return
-        val actualExpression = args.expressions[count - 2] ?: return
-        val deltaExpression = args.expressions[count - 1] ?: return
+        val messageExpression = args.expressions.getOrNull(if (junit5) 3 else count - 4)
+        val expectedExpression = args.expressions[if (junit5) 0 else count - 3] ?: return
+        val actualExpression = args.expressions[if (junit5) 1 else count - 2] ?: return
+        val deltaExpression = args.expressions[if (junit5) 2 else count - 1] ?: return
 
         val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
 

src/main/resources/META-INF/plugin.xml

@@ -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://git.platon42.de/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
+    <vendor email="chrisly@platon42.de" url="https://github.com/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
 
     <description><![CDATA[
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
@@ -14,6 +14,8 @@
     <a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
     ]]></description>
 
+    <idea-version since-build="173.2696.26"/>
+
     <depends>com.intellij.modules.lang</depends>
     <depends>com.intellij.modules.platform</depends>
     <depends>com.intellij.modules.java</depends>
@@ -26,8 +28,6 @@
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanConditionInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatInvertedBooleanCondition" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInvertedBooleanConditionInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatIsZeroOne" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatIsZeroOneInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatInstanceOf" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInstanceOfInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"

src/main/resources/inspectionDescriptions/AssertThatIsZeroOne.html

@@ -1,8 +0,0 @@
-<html>
-<body>
-Turns assertThat(numeric).isEqualTo(0/1) into assertThat(numeric).isZero()/isOne()
-or assertThat(numeric).isNotEqualTo(0) into assertThat(numeric).isNotZero().
-<!-- tooltip end -->
-<br>Also works with constant expressions.
-</body>
-</html>

src/test/java/de/platon42/intellij/jupiter/AbstractJUnit5TestCase.kt

@@ -1,151 +0,0 @@
-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()
-}

src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.java

@@ -0,0 +1,10 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface AddLocalJarToModule {
+    Class<?>[] value();
+}

src/test/java/de/platon42/intellij/jupiter/AddLocalJarToModule.kt

@@ -1,9 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import java.lang.annotation.Inherited
-import kotlin.reflect.KClass
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class AddLocalJarToModule(vararg val value: KClass<*>)

src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.java

@@ -0,0 +1,24 @@
+package de.platon42.intellij.jupiter;
+
+import com.intellij.openapi.roots.DependencyScope;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.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)
+    @Inherited
+    @interface List {
+        AddMavenDependencyToModule[] value();
+    }
+}

src/test/java/de/platon42/intellij/jupiter/AddMavenDependencyToModule.kt

@@ -1,17 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import com.intellij.openapi.roots.DependencyScope
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-@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
-    annotation class List(vararg val value: AddMavenDependencyToModule)
-}

src/test/java/de/platon42/intellij/jupiter/EdtInterceptorExtension.kt

@@ -1,50 +0,0 @@
-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()
-                }
-            }
-        }
-    }
-}

src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java

@@ -0,0 +1,259 @@
+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());
+        }
+    }
+}

src/test/java/de/platon42/intellij/jupiter/MyFixture.java

@@ -0,0 +1,11 @@
+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 {
+}

src/test/java/de/platon42/intellij/jupiter/MyTestCase.java

@@ -0,0 +1,11 @@
+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 {
+}

src/test/java/de/platon42/intellij/jupiter/TestDataPath.java

@@ -0,0 +1,10 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestDataPath {
+    String value();
+}

src/test/java/de/platon42/intellij/jupiter/TestDataPath.kt

@@ -1,8 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class TestDataPath(val value: String)

src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.java

@@ -0,0 +1,10 @@
+package de.platon42.intellij.jupiter;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestDataSubPath {
+    String value();
+}

src/test/java/de/platon42/intellij/jupiter/TestDataSubPath.kt

@@ -1,8 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class TestDataSubPath(val value: String)

src/test/java/de/platon42/intellij/jupiter/TestJdk.java

@@ -0,0 +1,16 @@
+package de.platon42.intellij.jupiter;
+
+import com.intellij.pom.java.LanguageLevel;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestJdk {
+    LanguageLevel value();
+
+    boolean annotations() default false;
+
+    boolean useInternal() default false;
+}

src/test/java/de/platon42/intellij/jupiter/TestJdk.kt

@@ -1,9 +0,0 @@
-package de.platon42.intellij.jupiter
-
-import com.intellij.pom.java.LanguageLevel
-import java.lang.annotation.Inherited
-
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
-@Retention(AnnotationRetention.RUNTIME)
-@Inherited
-annotation class TestJdk(val value: LanguageLevel)

src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt

@@ -2,45 +2,48 @@ package de.platon42.intellij.plugins.cajon
 
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.pom.java.LanguageLevel
-import de.platon42.intellij.jupiter.AbstractJUnit5TestCase
-import de.platon42.intellij.jupiter.AddLocalJarToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import de.platon42.intellij.jupiter.LightCodeInsightExtension
 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)
-@AddLocalJarToModule(Assertions::class)
-//@AddMavenDependencyToModule("org.assertj:assertj-core:3.25.3", includeTransitiveDependencies = false, DependencyScope.COMPILE)
+@TestJdk(LanguageLevel.JDK_1_8, annotations = true, useInternal = true)
+//@AddLocalJarToModule(Assertions::class)
+@AddMavenDependencyToModule("org.assertj:assertj-core:3.15.0")
 @DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
-abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
+abstract class AbstractCajonTest {
 
-    protected fun executeQuickFixes(regex: Regex, expectedFixes: Int) {
-        val quickfixes = getQuickFixes(regex, expectedFixes)
+    protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
+        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
         assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
-        quickfixes.forEach(fixture::launchAction)
+        quickfixes.forEach(myFixture::launchAction)
     }
 
-    protected fun executeQuickFixesNoFamilyNameCheck(regex: Regex, expectedFixes: Int) {
-        val quickfixes = getQuickFixes(regex, expectedFixes)
-        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 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)
+    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)
         return quickfixes
     }
 
-    protected fun assertHighlightings(count: Int, snippet: String) {
-        assertThat(fixture.doHighlighting())
-            .areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
+    protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
+        val highlights = myFixture.doHighlighting()
+            .asSequence()
+            .filter { it.description?.contains(snippet) ?: false }
+            .toList()
+        assertThat(highlights).hasSize(count)
     }
 
     class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt

@@ -1,19 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.RunsInEdt
+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/BinaryExpression")
 internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspectionTest.kt

@@ -1,20 +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/BooleanCondition")
 internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspectionTest.kt

@@ -1,5 +1,7 @@
 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
@@ -9,68 +11,68 @@ import org.junit.jupiter.api.Test
 internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    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")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 3
-        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")
+        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")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 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)
+        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)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 1
 
-        fixture.enableInspections(inspection)
-        fixture.configureByFile("CollectionMapExpressionBefore.java")
-        val highlights = fixture.doHighlighting()
+        myFixture.enableInspections(inspection)
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        val highlights = myFixture.doHighlighting()
             .asSequence()
             .filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
             .filter {
@@ -79,24 +81,24 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
             .toList()
         assertThat(highlights).hasSize(4)
 
-        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)
+        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)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 4
 
-        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)
+        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)
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatComparableInspectionTest.kt

@@ -1,22 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/Comparable")
 internal class AssertThatComparableInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt

@@ -1,21 +1,23 @@
 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
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatFileExpressionInspectionTest.kt

@@ -1,36 +1,38 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/FileExpression")
 internal class AssertThatFileExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt

@@ -1,45 +1,48 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
+@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
 @TestDataSubPath("inspections/GuavaOptional")
 internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    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")
     }
 
     @Test
-    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")
+    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")
     }
 
     @Test
-    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")
+    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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt

@@ -1,18 +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/InstanceOf")
 internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt

@@ -1,19 +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/InvertedBooleanCondition")
 internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatIsZeroOneInspectionTest.kt

@@ -1,19 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-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
-    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")
-    }
-}

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt

@@ -1,25 +1,27 @@
 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
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspectionTest.kt

@@ -1,20 +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/ObjectExpression")
 internal class AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspectionTest.kt

@@ -1,18 +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/ObjectIsNullOrNotNull")
 internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt

@@ -1,22 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-@TestDataSubPath("inspections/PathExpression")
 internal class AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt

@@ -1,32 +1,34 @@
 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
-    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")
+    @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")
 
-        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")
+        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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt

@@ -1,39 +1,41 @@
 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
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt

@@ -1,25 +1,27 @@
 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
-    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty() {
-        fixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
-        fixture.configureByFile("StringIsEmptyBefore.java")
-        val highlights = fixture.doHighlighting()
+    @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()
             .asSequence()
             .filter { it.description?.contains(" can be simplified to") ?: false }
             .toList()
         assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
-        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
-        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
-        fixture.checkResultByFile("StringIsEmptyAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
+        myFixture.checkResultByFile("StringIsEmptyAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspectionTest.kt

@@ -1,20 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("junit:junit:4.13.2")
-@AddMavenDependencyToModule("org.junit.jupiter:junit-jupiter-api:5.10.2")
-@TestDataSubPath("inspections/AssumeThat")
+@AddLocalJarToModule(Assertions::class, Test::class, org.junit.Test::class)
 internal class AssumeThatInsteadOfReturnInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/BogusAssertionInspectionTest.kt

@@ -1,17 +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/BogusAssertion")
 internal class BogusAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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()")
+    @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()")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspectionTest.kt

@@ -1,21 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
-@TestDataSubPath("inspections/ImplicitAssertion")
+@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
 internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnit5AssertToAssertJInspectionTest.kt

@@ -0,0 +1,23 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+
+@AddLocalJarToModule(org.junit.jupiter.api.Assertions::class, Assertions::class)
+internal class JUnit5AssertToAssertJInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/JUnit5AssertToAssertJ")
+    internal fun junit5_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
+        myFixture.configureByFile("JUnit5AssertToAssertJInspectionBefore.java")
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 4)
+        myFixture.checkResultByFile("JUnit5AssertToAssertJInspectionAfter.java")
+    }
+}

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt

@@ -1,20 +1,24 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
+import org.junit.Assert
 import org.junit.jupiter.api.Test
 
-@AddMavenDependencyToModule("junit:junit:4.13.2")
-@TestDataSubPath("inspections/JUnitAssertToAssertJ")
+@AddLocalJarToModule(Assert::class, Assertions::class)
 internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt

@@ -1,17 +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/JoinStatements")
 internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinVarArgsContainsInspectionTest.kt

@@ -1,17 +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/JoinVarArgsContains")
 internal class JoinVarArgsContainsInspectionTest : AbstractCajonTest() {
 
     @Test
-    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")
+    @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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/TwistedAssertionInspectionTest.kt

@@ -1,21 +1,23 @@
 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
-    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")
+    @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")
 
-        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")
+        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")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt

@@ -1,5 +1,7 @@
 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
@@ -11,68 +13,68 @@ import org.junit.jupiter.api.Test
 internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
 
     @Test
-    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;")
+    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;")
     }
 
     @Test
-    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;")
+    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;")
     }
 
     @Test
-    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;")
+    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;")
     }
 
     @Test
-    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()")
+    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()")
     }
 
     @Test
-    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()")
+    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()")
     }
 
     @Test
-    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;")
+    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;")
     }
 
     @Test
-    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()")
+    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()")
     }
 
     @Test
-    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;")
+    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;")
     }
 
     @Test
-    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;")
+    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;")
     }
 
     @Test
-    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()")
+    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()")
     }
 
     @Test
-    internal fun extractor_is_unable_to_find_reference() {
-        fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
-        assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
+    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)
     }
 }

src/test/resources/inspections/IsZeroOne/IsZeroOneAfter.java

@@ -1,67 +0,0 @@
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
-public class IsZeroOne {
-
-    private void isZeroOne() {
-        short shortValue = 0;
-        int intValue = 0;
-        long longValue = 0L;
-        float floatValue = 0.0f;
-        double doubleValue = 0.0;
-
-        assertThat(shortValue).as("foo").isZero();
-        assertThat(shortValue).isZero();
-        assertThat(shortValue).as("foo").isOne();
-        assertThat(shortValue).isOne();
-
-        assertThat(shortValue).as("foo").isNotZero();
-        assertThat(shortValue).isNotZero();
-        assertThat(shortValue).as("foo").isNotEqualTo(1);
-        assertThat(shortValue).isNotEqualTo(0 + 1);
-
-        assertThat(intValue).as("foo").isZero();
-        assertThat(intValue).isZero();
-        assertThat(intValue).as("foo").isOne();
-        assertThat(intValue).isOne();
-
-        assertThat(intValue).as("foo").isNotZero();
-        assertThat(intValue).isNotZero();
-        assertThat(intValue).as("foo").isNotEqualTo(1);
-        assertThat(intValue).isNotEqualTo(0 + 1);
-
-        assertThat(longValue).as("foo").isZero();
-        assertThat(longValue).isZero();
-        assertThat(longValue).as("foo").isOne();
-        assertThat(longValue).isOne();
-
-        assertThat(longValue).as("foo").isNotZero();
-        assertThat(longValue).isNotZero();
-        assertThat(longValue).as("foo").isNotEqualTo(1L);
-        assertThat(longValue).isNotEqualTo(0L + 1L);
-
-        assertThat(floatValue).as("foo").isZero();
-        assertThat(floatValue).isZero();
-        assertThat(floatValue).as("foo").isOne();
-        assertThat(floatValue).isOne();
-
-        assertThat(floatValue).as("foo").isNotZero();
-        assertThat(floatValue).isNotZero();
-        assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
-        assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
-
-        assertThat(doubleValue).as("foo").isZero();
-        assertThat(doubleValue).isZero();
-        assertThat(doubleValue).as("foo").isOne();
-        assertThat(doubleValue).isOne();
-
-        assertThat(doubleValue).as("foo").isNotZero();
-        assertThat(doubleValue).isNotZero();
-        assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
-        assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
-
-        assertThat(intValue).as("foo").isEqualTo(2);
-
-        fail("oh no!");
-    }
-}

src/test/resources/inspections/IsZeroOne/IsZeroOneBefore.java

@@ -1,67 +0,0 @@
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
-public class IsZeroOne {
-
-    private void isZeroOne() {
-        short shortValue = 0;
-        int intValue = 0;
-        long longValue = 0L;
-        float floatValue = 0.0f;
-        double doubleValue = 0.0;
-
-        assertThat(shortValue).as("foo").isEqualTo(0);
-        assertThat(shortValue).isEqualTo(1 - 1);
-        assertThat(shortValue).as("foo").isEqualTo(1);
-        assertThat(shortValue).isEqualTo(0 + 1);
-
-        assertThat(shortValue).as("foo").isNotEqualTo(0);
-        assertThat(shortValue).isNotEqualTo(1 - 1);
-        assertThat(shortValue).as("foo").isNotEqualTo(1);
-        assertThat(shortValue).isNotEqualTo(0 + 1);
-
-        assertThat(intValue).as("foo").isEqualTo(0);
-        assertThat(intValue).isEqualTo(1 - 1);
-        assertThat(intValue).as("foo").isEqualTo(1);
-        assertThat(intValue).isEqualTo(0 + 1);
-
-        assertThat(intValue).as("foo").isNotEqualTo(0);
-        assertThat(intValue).isNotEqualTo(1 - 1);
-        assertThat(intValue).as("foo").isNotEqualTo(1);
-        assertThat(intValue).isNotEqualTo(0 + 1);
-
-        assertThat(longValue).as("foo").isEqualTo(0L);
-        assertThat(longValue).isEqualTo(1L - 1L);
-        assertThat(longValue).as("foo").isEqualTo(1L);
-        assertThat(longValue).isEqualTo(0L + 1L);
-
-        assertThat(longValue).as("foo").isNotEqualTo(0L);
-        assertThat(longValue).isNotEqualTo(1L - 1L);
-        assertThat(longValue).as("foo").isNotEqualTo(1L);
-        assertThat(longValue).isNotEqualTo(0L + 1L);
-
-        assertThat(floatValue).as("foo").isEqualTo(0.0f);
-        assertThat(floatValue).isEqualTo(1.0f - 1.0f);
-        assertThat(floatValue).as("foo").isEqualTo(1.0f);
-        assertThat(floatValue).isEqualTo(0.0f + 1.0f);
-
-        assertThat(floatValue).as("foo").isNotEqualTo(0.0f);
-        assertThat(floatValue).isNotEqualTo(1.0f - 1.0f);
-        assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
-        assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
-
-        assertThat(doubleValue).as("foo").isEqualTo(0.0);
-        assertThat(doubleValue).isEqualTo(1.0 - 1.0);
-        assertThat(doubleValue).as("foo").isEqualTo(1.0);
-        assertThat(doubleValue).isEqualTo(0.0 + 1.0);
-
-        assertThat(doubleValue).as("foo").isNotEqualTo(0.0);
-        assertThat(doubleValue).isNotEqualTo(1.0 - 1.0);
-        assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
-        assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
-
-        assertThat(intValue).as("foo").isEqualTo(2);
-
-        fail("oh no!");
-    }
-}

src/test/resources/inspections/JUnit5AssertToAssertJ/JUnit5AssertToAssertJInspectionAfter.java

@@ -0,0 +1,86 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.data.Offset.offset;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assumptions.*;
+
+public class JUnit5AssertToAssertJ {
+
+    private void jUnit5AssertToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        int someInt = 1;
+        double someDouble = 1.0;
+        float someFloat = 1.0f;
+
+        assertThat(foo == "foo").isTrue();
+        assertThat(foo == "foo").as("oh no!").isTrue();
+        assertThat(foo == "bar").isFalse();
+        assertThat(foo == "bar").as("boom!").isFalse();
+
+        assertThat(foo).isNull();
+        assertThat(foo).as("oh no!").isNull();
+        assertThat(foo).isNotNull();
+        assertThat(foo).as("oh no!").isNotNull();
+
+        assertThat(foo).isEqualTo(bar);
+        assertThat(foo).as("equals").isEqualTo(bar);
+        assertThat(foo).isNotEqualTo(bar);
+        assertThat(foo).as("equals").isNotEqualTo(bar);
+
+        assertThat(foo).isSameAs(bar);
+        assertThat(foo).as("same").isSameAs(bar);
+        assertThat(foo).isNotSameAs(bar);
+        assertThat(foo).as("same").isNotSameAs(bar);
+
+        assertThat(2.0).isEqualTo(1.0);
+        assertThat(2.0).isCloseTo(1.0, offset(0.1));
+        assertThat(2.0).as("equals").isEqualTo(1.0);
+        assertThat(2.0).as("equals").isCloseTo(1.0, offset(0.1));
+        assertThat(2.0f).isEqualTo(1.0f);
+        assertThat(2.0f).isCloseTo(1.0f, offset(0.1f));
+        assertThat(2.0f).as("equals").isEqualTo(1.0f);
+        assertThat(2.0f).as("equals").isCloseTo(1.0f, offset(0.1f));
+
+        assertThat(2.0).isNotEqualTo(1.0);
+        assertThat(2.0).isNotCloseTo(1.0, offset(0.1));
+        assertThat(2.0).as("equals").isNotEqualTo(1.0);
+        assertThat(2.0).as("equals").isNotCloseTo(1.0, offset(0.1));
+        assertThat(2.0f).isNotEqualTo(1.0f);
+        assertThat(2.0f).isNotCloseTo(1.0f, offset(0.1f));
+        assertThat(2.0f).as("equals").isNotEqualTo(1.0f);
+        assertThat(2.0f).as("equals").isNotCloseTo(1.0f, offset(0.1f));
+
+        assertThat(new int[1]).containsExactly(new int[2]);
+        assertThat(new int[1]).as("array equals").containsExactly(new int[2]);
+
+        assertThat(new double[1]).containsExactly(new double[2], offset(1.0));
+        assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
+        assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
+        assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
+
+        assertThat(foo).isEqualTo("bar");
+        assertThat(bar).as("equals").isEqualTo("foo");
+        assertThat(bar).isNotEqualTo("foo");
+        assertThat(foo).as("equals").isNotEqualTo("bar");
+
+        assertThat(someInt).isEqualTo(2);
+        assertThat(someDouble).isCloseTo(2.0, offset(0.1));
+        assertThat(someDouble).as("equals").isEqualTo(1.0);
+        assertThat(someDouble).as("equals").isCloseTo(1.0, offset(0.1));
+        assertThat(someFloat).isEqualTo(1.0f);
+        assertThat(someFloat).isCloseTo(2.0f, offset(0.1f));
+
+        fail();
+        fail("oh no!")
+    }
+
+    private void jUnit5AssumeToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        assumeThat(foo == "foo").isTrue();
+        assumeThat(foo == "foo").as("oh no!").isTrue();
+        assumeThat(foo == "bar").isFalse();
+        assumeThat(foo == "bar").as("boom!").isFalse();
+    }
+}

src/test/resources/inspections/JUnit5AssertToAssertJ/JUnit5AssertToAssertJInspectionBefore.java

@@ -0,0 +1,83 @@
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assumptions.*;
+
+public class JUnit5AssertToAssertJ {
+
+    private void jUnit5AssertToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        int someInt = 1;
+        double someDouble = 1.0;
+        float someFloat = 1.0f;
+
+        assertTrue(foo == "foo");
+        assertTrue(foo == "foo", "oh no!");
+        assertFalse(foo == "bar");
+        assertFalse(foo == "bar", "boom!");
+
+        assertNull(foo);
+        assertNull(foo, "oh no!");
+        assertNotNull(foo);
+        assertNotNull(foo, "oh no!");
+
+        assertEquals(bar, foo);
+        assertEquals(bar, foo, "equals");
+        assertNotEquals(bar, foo);
+        assertNotEquals(bar, foo, "equals");
+
+        assertSame(bar, foo);
+        assertSame(bar, foo, "same");
+        assertNotSame(bar, foo);
+        assertNotSame(bar, foo, "same");
+
+        assertEquals(1.0, 2.0);
+        assertEquals(1.0, 2.0, 0.1);
+        assertEquals(1.0, 2.0, "equals");
+        assertEquals(1.0, 2.0, 0.1, "equals");
+        assertEquals(1.0f, 2.0f);
+        assertEquals(1.0f, 2.0f, 0.1f);
+        assertEquals(1.0f, 2.0f, "equals");
+        assertEquals(1.0f, 2.0f, 0.1f, "equals");
+
+        assertNotEquals(1.0, 2.0);
+        assertNotEquals(1.0, 2.0, 0.1);
+        assertNotEquals(1.0, 2.0, "equals");
+        assertNotEquals(1.0, 2.0, 0.1, "equals");
+        assertNotEquals(1.0f, 2.0f);
+        assertNotEquals(1.0f, 2.0f, 0.1f);
+        assertNotEquals(1.0f, 2.0f, "equals");
+        assertNotEquals(1.0f, 2.0f, 0.1f, "equals");
+
+        assertArrayEquals(new int[2], new int[1]);
+        assertArrayEquals(new int[2], new int[1], "array equals");
+
+        assertArrayEquals(new double[2], new double[1], 1.0);
+        assertArrayEquals(new double[2], new double[1], 1.0, "array equals");
+        assertArrayEquals(new float[2], new float[1], 1.0f);
+        assertArrayEquals(new float[2], new float[1], 1.0f, "array equals");
+
+        assertEquals("bar", foo);
+        assertEquals(bar, "foo", "equals");
+        assertNotEquals(bar, "foo");
+        assertNotEquals("bar", foo, "equals");
+
+        assertEquals(someInt, 2);
+        assertEquals(someDouble, 2.0, 0.1);
+        assertEquals(1.0, someDouble, "equals");
+        assertEquals(1.0, someDouble, 0.1, "equals");
+        assertEquals(1.0f, someFloat);
+        assertEquals(someFloat, 2.0f, 0.1f);
+
+        fail();
+        fail("oh no!")
+    }
+
+    private void jUnit5AssumeToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        assumeTrue(foo == "foo");
+        assumeTrue(foo == "foo", "oh no!");
+        assumeFalse(foo == "bar");
+        assumeFalse(foo == "bar", "boom!");
+    }
+}

src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java

@@ -66,9 +66,6 @@ public class JoinStatements {
         assertThat(list.get(--i)).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
 
-        assertThat(list).filteredOn("foo", "foo").contains("narf");
-        assertThat(list).filteredOn("bar", "bar").contains("puit");
-
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");
     }

src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java

@@ -63,9 +63,6 @@ public class JoinStatements {
         assertThat(list.get(--i)).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
 
-        assertThat(list).filteredOn("foo", "foo").contains("narf");
-        assertThat(list).filteredOn("bar", "bar").contains("puit");
-
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");
     }