.idea/saveactions_settings.xml

@@ -18,7 +18,6 @@
     <option name="configurationPath" value="" />
     <option name="exclusions">
       <set>
-        <option value=".*\.md" />
         <option value="src/test/resources/.*" />
       </set>
     </option>

.travis.yml

@@ -1,10 +0,0 @@
-language: java
-jdk:
-  - openjdk11
-
-before_script:
-  - chmod +x gradlew
-  - chmod +x gradle/wrapper/gradle-wrapper.jar
-
-script:
-  - ./gradlew clean test jacocoTestReport coveralls

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.
@@ -10,4 +10,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
+limitations under the License.

build.gradle

@@ -0,0 +1,78 @@
+plugins {
+    id 'java'
+    id 'org.jetbrains.intellij' version '0.4.3'
+    id 'org.jetbrains.kotlin.jvm' version '1.3.30'
+}
+
+group 'de.platon42'
+version '0.5'
+
+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"
+    testCompile "org.assertj:assertj-core:3.12.2"
+    testCompile "org.assertj:assertj-guava:3.2.1"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
+    testImplementation "org.jetbrains.kotlin:kotlin-test"
+//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+compileTestKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+intellij {
+    version '2019.1'
+//    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
+    updateSinceUntilBuild false
+}
+
+patchPluginXml {
+    changeNotes """
+  <h4>V0.5 (18-Apr-19)</h4>
+    <ul>
+      <li>Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
+      <li>Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
+      <li>Added support for referencing and refactoring inside .extracting() methods with fields, properties and methods (though
+      getter renaming does not work that perfect, but I'm giving up for now as the IntelliJ SDK docs are seriously lacking).
+      <li>Fixed an exception in batch mode if the description string was the same but for different fixes. 
+          Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
+    </ul>
+  <h4>V0.4 (11-Apr-19)</h4>
+    <ul>
+      <li>Reduced minimal supported IDEA version from 2018.2 to 2017.2.
+      <li>New inspection AssertThatJava8Optional that operates on Java 8 Optional objects and tries to use contains(), containsSame(), isPresent(), and isNotPresent() instead.
+      <li>New inspection AssertThatGuavaOptional that operates on Guava Optional objects and tries to use contains(), isPresent(), and isAbsent() instead.
+      <li>Added support in AssertThatBinaryExpressionIsTrueOrFalse for is(Not)EqualTo(Boolean.TRUE/FALSE).
+    </ul>
+  <h4>V0.3 (07-Apr-19)</h4>
+    <ul>
+      <li>New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and equals() statements (more than 150 combinations) inside assertThat().
+      <li>Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
+      <li>Support for hasSizeLessThan(), hasSizeLessThanOrEqualTo(), hasSizeGreaterThanOrEqualTo(), and hasSizeGreaterThan() for AssertThatSizeInspection (with AssertJ >=13.2.0).
+      <li>Really fixed highlighting for JUnit conversion. Sorry.
+    </ul>
+"""
+}
+
+test {
+    useJUnitPlatform()
+//    testLogging {
+//        events "passed", "skipped", "failed"
+//    }
+}
+
+publishPlugin {
+    token 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.properties

@@ -1,4 +1,3 @@
 kotlin.code.style=official
 kotlin.incremental=true
-intellijPublishToken=perm:dummy
+intellijPublishToken=perm:dummy
-systemProp.jdk.tls.client.protocols="TLSv1,TLSv1.1,TLSv1.2"

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Thu Feb 21 17:35:51 CET 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip

gradlew

@@ -1,21 +1,5 @@
 #!/usr/bin/env sh
 
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
 ##############################################################################
 ##
 ##  Gradle start up script for UN*X
@@ -44,7 +28,7 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+DEFAULT_JVM_OPTS=""
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -72,7 +56,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MSYS* | MINGW* )
+  MINGW* )
     msys=true
     ;;
   NONSTOP* )
@@ -82,7 +66,6 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
-
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -126,11 +109,10 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin or MSYS, switch paths to Windows format before running java
+# For Cygwin, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
@@ -156,19 +138,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=`expr $i + 1`
+        i=$((i+1))
     done
     case $i in
-        0) set -- ;;
+        (0) set -- ;;
-        1) set -- "$args0" ;;
+        (1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
+        (2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -177,9 +159,14 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=`save "$@"`
+APP_ARGS=$(save "$@")
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,19 +1,3 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -29,18 +13,15 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set DEFAULT_JVM_OPTS=
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if "%ERRORLEVEL%" == "0" goto init
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +35,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto execute
+if exist "%JAVA_EXE%" goto init
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,14 +45,28 @@ echo location of your Java installation.
 
 goto fail
 
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
-
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 
 :end
 @rem End local scope for the variables with windows NT shell

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

@@ -7,106 +7,32 @@ class AssertJClassNames {
         @NonNls
         const val ASSERTIONS_CLASSNAME = "org.assertj.core.api.Assertions"
 
-        @NonNls
-        const val ASSUMPTIONS_CLASSNAME = "org.assertj.core.api.Assumptions"
-
-        @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"
+        const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
-
-        @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"
+        const val GUAVA_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
     }
-}
+}

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

@@ -1,79 +0,0 @@
-package de.platon42.intellij.plugins.cajon
-
-import com.intellij.psi.CommonClassNames
-import com.siyeh.ig.callMatcher.CallMatcher
-
-val CORE_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
-val GUAVA_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
-val ALL_ASSERT_THAT_MATCHERS = CallMatcher.anyOf(CORE_ASSERT_THAT_MATCHER, GUAVA_ASSERT_THAT_MATCHER)!!
-
-val EXTRACTING_FROM_OBJECT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME, "extracting")!!
-val EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extracting")!!
-val FLAT_EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "flatExtracting")!!
-val EXTRACTING_RESULT_OF_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extractingResultOf")!!
-
-val EXTRACTING_CALL_MATCHERS = CallMatcher.anyOf(
-    EXTRACTING_FROM_OBJECT,
-    EXTRACTING_FROM_ITERABLE,
-    FLAT_EXTRACTING_FROM_ITERABLE,
-    EXTRACTING_RESULT_OF_FROM_ITERABLE
-)!!
-
-val DESCRIBED_AS = CallMatcher.instanceCall(AssertJClassNames.DESCRIPTABLE_INTERFACE, MethodNames.DESCRIBED_AS, MethodNames.AS)!!
-val WITH_REPRESENTATION_AND_SUCH = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "withRepresentation", "withThreadDumpOnError")!!
-val USING_COMPARATOR = CallMatcher.anyOf(
-    CallMatcher.instanceCall(
-        AssertJClassNames.ASSERT_INTERFACE,
-        "usingComparator",
-        "usingDefaultComparator"
-    ),
-    CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ASSERT_CLASSNAME, "usingRecursiveComparison"),
-    CallMatcher.instanceCall(
-        AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME,
-        "usingComparatorForFields",
-        "usingComparatorForType"
-    )
-)!!
-
-val IN_HEXADECIMAL_OR_BINARY = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ASSERT_CLASSNAME, MethodNames.IN_HEXADECIMAL, MethodNames.IN_BINARY)!!
-val EXTENSION_POINTS = CallMatcher.instanceCall(
-    AssertJClassNames.EXTENSION_POINTS_INTERFACE,
-    "is", "isNot", "has", "doesNotHave",
-    "satisfies"
-)!!
-
-val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
-    AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
-    "are", "areNot", "have", "doNotHave",
-    "areAtLeast", "areAtLeastOne", "areAtMost", "areExactly",
-    "haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
-    "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
-)!!
-
-val NOT_ACTUAL_ASSERTIONS = CallMatcher.anyOf(
-    ALL_ASSERT_THAT_MATCHERS,
-    COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY
-)!!
-
-val KNOWN_METHODS_WITH_SIDE_EFFECTS = CallMatcher.anyOf(
-    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_ITERATOR, "next")
-)!!

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

@@ -4,72 +4,36 @@ import com.intellij.psi.*
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.codeStyle.JavaCodeStyleManager
 import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.psi.util.PsiUtil
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.inspections.AbstractAssertJInspection
 
-val PsiMethodCallExpression.qualifierExpression: PsiExpression get() = methodExpression.qualifierExpression!!
+val PsiMethodCallExpression.qualifierExpression: PsiExpression get() = this.methodExpression.qualifierExpression!!
-val PsiMethodCallExpression.firstArg: PsiExpression get() = getArg(0)
+val PsiMethodCallExpression.firstArg: PsiExpression get() = this.argumentList.expressions[0]!!
-
-fun PsiElement.hasAssertThat(): Boolean {
-    val elementText = text
-    return elementText.startsWith("${MethodNames.ASSERT_THAT}(") || elementText.contains(".${MethodNames.ASSERT_THAT}(")
-}
 
 fun PsiMethodCallExpression.replaceQualifier(qualifier: PsiElement) {
-    qualifierExpression.replace(qualifier)
+    this.qualifierExpression.replace(qualifier)
 }
 
 fun PsiMethodCallExpression.replaceQualifierFromMethodCall(oldMethodCall: PsiMethodCallExpression) {
-    qualifierExpression.replace(oldMethodCall.qualifierExpression)
+    this.qualifierExpression.replace(oldMethodCall.qualifierExpression)
 }
 
 fun PsiElement.findOutmostMethodCall(): PsiMethodCallExpression? {
-    val statement = PsiTreeUtil.getParentOfType(this, PsiStatement::class.java, false) ?: return null
+    val statement = PsiTreeUtil.getParentOfType(this, PsiStatement::class.java) ?: return null
     return PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java)
 }
 
-fun PsiElement.findStaticMethodCall(): PsiMethodCallExpression? {
+fun PsiMethodCallExpression.getArg(n: Int): PsiExpression = this.argumentList.expressions[n]
-    var elem: PsiElement? = this
-    while (elem != null) {
-        if ((elem is PsiMethodCallExpression) && (elem.resolveMethod()?.hasModifierProperty(PsiModifier.STATIC) == true)) {
-            return elem
-        }
-        elem = elem.firstChild
-    }
-    return null
-}
-
-fun PsiElement.gatherAssertionCalls(): List<PsiMethodCallExpression> {
-    val assertThatMethodCall = findStaticMethodCall() ?: return emptyList()
-    return assertThatMethodCall.collectMethodCallsUpToStatement()
-        .filterNot(NOT_ACTUAL_ASSERTIONS::test)
-        .toList()
-}
-
-fun PsiMethodCallExpression.collectMethodCallsUpToStatement(): Sequence<PsiMethodCallExpression> {
-    return generateSequence(this) { PsiTreeUtil.getParentOfType(it, PsiMethodCallExpression::class.java, true, PsiStatement::class.java) }
-}
-
-fun PsiMethodCallExpression.findFluentCallTo(matcher: CallMatcher): PsiMethodCallExpression? {
-    return collectMethodCallsUpToStatement().find { matcher.test(it) }
-}
-
-fun PsiMethodCallExpression.getArg(n: Int): PsiExpression = PsiUtil.skipParenthesizedExprDown(argumentList.expressions[n])!!
-
-fun PsiMethodCallExpression.getArgOrNull(n: Int): PsiExpression? = argumentList.expressions.getOrNull(n)
 
 fun <T> Boolean.map(forTrue: T, forFalse: T) = if (this) forTrue else forFalse
 
 fun PsiMethod.addAsStaticImport(context: PsiElement, vararg allowedClashes: String) {
     val factory = JavaPsiFacade.getElementFactory(context.project)
-    val methodName = name
+    val methodName = this.name
-    val containingClass = containingClass ?: return
+    val containingClass = this.containingClass ?: return
     val importList = (context.containingFile as PsiJavaFile).importList ?: return
     val notImportedStatically = importList.importStaticStatements.none {
         val targetClass = it.resolveTargetClass() ?: return@none false
         ((it.referenceName == methodName) && !allowedClashes.contains(targetClass.qualifiedName))
-                || (it.isOnDemand && (targetClass == containingClass))
+                || (it.isOnDemand && (targetClass == this.containingClass))
     }
     if (notImportedStatically) {
         importList.add(factory.createImportStaticStatement(containingClass, methodName))
@@ -80,104 +44,4 @@ fun PsiElement.shortenAndReformat() {
     val codeStyleManager = JavaCodeStyleManager.getInstance(project)
     codeStyleManager.shortenClassReferences(this)
     CodeStyleManager.getInstance(project).reformat(this)
-}
+}
-
-fun PsiMethodCallExpression.getExpectedBooleanResult(): Boolean? {
-    val isTrue = AbstractAssertJInspection.IS_TRUE.test(this)
-    val isFalse = AbstractAssertJInspection.IS_FALSE.test(this)
-    if (isTrue || isFalse) {
-        return isTrue
-    } else {
-        val isEqualTo = AbstractAssertJInspection.IS_EQUAL_TO_BOOLEAN.test(this) || AbstractAssertJInspection.IS_EQUAL_TO_OBJECT.test(this)
-        val isNotEqualTo =
-            AbstractAssertJInspection.IS_NOT_EQUAL_TO_BOOLEAN.test(this) || AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT.test(this)
-        if (isEqualTo || isNotEqualTo) {
-            val constValue = calculateConstantParameterValue(0) as? Boolean ?: return null
-            return isNotEqualTo xor constValue
-        }
-    }
-    return null
-}
-
-fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
-    val isNull = AbstractAssertJInspection.IS_NULL.test(this)
-    val isNotNull = AbstractAssertJInspection.IS_NOT_NULL.test(this)
-    if (isNull || isNotNull) {
-        return isNotNull
-    } else {
-        val isEqualTo = CallMatcher.anyOf(AbstractAssertJInspection.IS_EQUAL_TO_OBJECT, AbstractAssertJInspection.IS_EQUAL_TO_STRING).test(this)
-        val isNotEqualTo = AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT.test(this)
-        if ((isEqualTo || isNotEqualTo) && firstArg.type == PsiType.NULL) {
-            return isNotEqualTo
-        }
-    }
-    return null
-}
-
-fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
-    return getArgOrNull(argIndex)?.calculateConstantValue()
-}
-
-fun PsiExpression.calculateConstantValue(): Any? {
-    val constantEvaluationHelper = JavaPsiFacade.getInstance(project).constantEvaluationHelper
-    val value = constantEvaluationHelper.computeConstantExpression(this)
-    if (value == null) {
-        val field = (this as? PsiReferenceExpression)?.resolve() as? PsiField
-        if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
-            return when (field.name) {
-                "TRUE" -> true
-                "FALSE" -> false
-                else -> null
-            }
-        }
-    }
-    return value
-}
-
-fun PsiExpression.getAllTheSameExpectedBooleanConstants(): Boolean? {
-    val assertThatMethodCall = findStaticMethodCall() ?: return null
-    var lockedResult: Boolean? = null
-    val methodsToView = generateSequence(assertThatMethodCall) { PsiTreeUtil.getParentOfType(it, PsiMethodCallExpression::class.java) }
-
-    for (methodCall in methodsToView) {
-        val expectedResult = methodCall.getExpectedBooleanResult()
-        if (expectedResult != null) {
-            if ((lockedResult != null) && (lockedResult != expectedResult)) return null
-            lockedResult = expectedResult
-        } else {
-            val isNotConstant = CallMatcher.anyOf(
-                EXTENSION_POINTS,
-                MORE_EXTENSION_POINTS,
-                AbstractAssertJInspection.IS_EQUAL_TO_BOOLEAN,
-                AbstractAssertJInspection.IS_EQUAL_TO_OBJECT,
-                AbstractAssertJInspection.IS_NOT_EQUAL_TO_BOOLEAN,
-                AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT
-            ).test(methodCall)
-            if (isNotConstant) return null
-        }
-    }
-    return lockedResult
-}
-
-fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
-    val assertThatMethodCall = findStaticMethodCall() ?: return null
-    var lockedResult: Boolean? = null
-    val methodsToView = generateSequence(assertThatMethodCall) { PsiTreeUtil.getParentOfType(it, PsiMethodCallExpression::class.java) }
-
-    for (methodCall in methodsToView) {
-        val expectedResult = methodCall.getExpectedNullNonNullResult()
-        if (expectedResult != null) {
-            if ((lockedResult != null) && (lockedResult != expectedResult)) return null
-            lockedResult = expectedResult
-        } else {
-            val isNotConstant = CallMatcher.anyOf(
-                EXTENSION_POINTS,
-                MORE_EXTENSION_POINTS,
-                AbstractAssertJInspection.IS_EQUAL_TO_OBJECT,
-                AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT
-            ).test(methodCall)
-            if (isNotConstant) return null
-        }
-    }
-    return lockedResult
-}

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

@@ -4,7 +4,9 @@ import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiExpression
 import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.search.GlobalSearchScope
+import com.siyeh.ig.callMatcher.CallMatcher
+
+val CORE_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
 
 fun createAssertThat(context: PsiElement, actualExpression: PsiExpression): PsiMethodCallExpression {
     return createAssertThat(context, AssertJClassNames.ASSERTIONS_CLASSNAME, actualExpression)
@@ -18,10 +20,6 @@ fun createAssertThat(context: PsiElement, baseclass: String, actualExpression: P
     return createMethodCall(context, "$baseclass.${MethodNames.ASSERT_THAT}", actualExpression)
 }
 
-fun createAssumeThat(context: PsiElement, actualExpression: PsiExpression): PsiMethodCallExpression {
-    return createMethodCall(context, "${AssertJClassNames.ASSUMPTIONS_CLASSNAME}.${MethodNames.ASSUME_THAT}", actualExpression)
-}
-
 fun createExpectedMethodCall(context: PsiElement, methodName: String, vararg arguments: PsiElement): PsiMethodCallExpression {
     return createMethodCall(context, "a.$methodName", *arguments)
 }
@@ -34,11 +32,4 @@ fun createMethodCall(context: PsiElement, fullQualifiedMethodName: String, varar
     ) as PsiMethodCallExpression
     arguments.forEachIndexed { index, newArg -> expectedExpression.getArg(index).replace(newArg) }
     return expectedExpression
-}
-
-fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
-    val findClass =
-        JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
-            ?: return false
-    return findClass.allMethods.any { it.name == methodname }
 }

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

@@ -11,166 +11,65 @@ class MethodNames {
 
         @NonNls
         const val ASSERT_THAT = "assertThat"
-
-        @NonNls
-        const val ASSUME_THAT = "assumeThat"
-
         @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"
-
-        @NonNls
-        const val HAS_TO_STRING = "hasToString"
-
         @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
+        const val IS_NULL = "isNull"
-
         @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"
+        const val IS_EMPTY = "isEmpty"
-
-        @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

@@ -3,30 +3,25 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.util.PsiTypesUtil
 import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_DOUBLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME
-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
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ENUMERABLE_ASSERT_INTERFACE
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_OPTIONAL_CLASSNAME
 import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.getArg
 import de.platon42.intellij.plugins.cajon.qualifierExpression
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
 
-abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
+open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
         const val SIMPLIFY_MESSAGE_TEMPLATE = "%s() can be simplified to %s()"
@@ -34,8 +29,7 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
 
         const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with %s()"
         const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap expected expression and replace %s() with %s()"
-        const val MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE = "Remove %s() of actual expression and use assertThat().%s() instead"
+        const val REMOVE_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap actual expression and replace %s() with %s()"
-        const val MOVING_OUT_MESSAGE_TEMPLATE = "Moving %s() expression out of assertThat() would be more concise"
 
         val TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP = mapOf<IElementType, String>(
             JavaTokenType.EQEQ to MethodNames.IS_EQUAL_TO,
@@ -73,8 +67,6 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
 
         val ASSERT_THAT_BOOLEAN = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
             .parameterTypes("boolean")!!
-        val ASSERT_THAT_BOOLEAN_OBJ = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
-            .parameterTypes(CommonClassNames.JAVA_LANG_BOOLEAN)!!
 
         val ASSERT_THAT_ANY = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
             .parameterCount(1)!!
@@ -82,66 +74,28 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
         val ASSERT_THAT_JAVA8_OPTIONAL = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
             .parameterTypes(CommonClassNames.JAVA_UTIL_OPTIONAL)!!
 
-        val GUAVA_ASSERT_THAT_ANY = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+        val ASSERT_THAT_GUAVA_OPTIONAL = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
-            .parameterCount(1)!!
+            .parameterTypes(GUAVA_OPTIONAL_CLASSNAME)!!
 
-        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_EQUAL_TO)
+        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
+        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .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)
-            .parameterTypes("long")!!
-        val IS_EQUAL_TO_FLOAT = CallMatcher.instanceCall(ABSTRACT_FLOAT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
-            .parameterTypes("float")!!
-        val IS_EQUAL_TO_DOUBLE = CallMatcher.instanceCall(ABSTRACT_DOUBLE_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
-            .parameterTypes("double")!!
         val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("boolean")!!
-
+        val IS_NOT_EQUAL_TO_BOOLEAN =
-        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_EQUAL_TO)
+            CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
+                .parameterTypes("boolean")!!
+        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_SAME_AS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
+        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_SAME_AS)
-            .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)
-            .parameterTypes("long")!!
-        val IS_NOT_EQUAL_TO_FLOAT = CallMatcher.instanceCall(ABSTRACT_FLOAT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
-            .parameterTypes("float")!!
-        val IS_NOT_EQUAL_TO_DOUBLE = CallMatcher.instanceCall(ABSTRACT_DOUBLE_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
-            .parameterTypes("double")!!
-
-        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_SAME_AS)
-            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_SAME_AS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
 
-        val IS_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NULL)
+        val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)
-            .parameterCount(0)!!
-        val IS_NOT_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_NULL)
-            .parameterCount(0)!!
-
-        val IS_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_EMPTY)
-            .parameterCount(0)!!
-        val IS_NOT_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_NOT_EMPTY)
-            .parameterCount(0)!!
-        val HAS_SIZE = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE)
-            .parameterTypes("int")!!
-        val HAS_SIZE_GREATER_THAN_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_GREATER_THAN)
-            .parameterTypes("int")!!
-        val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO)
-            .parameterTypes("int")!!
-        val HAS_SIZE_LESS_THAN_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_LESS_THAN)
-            .parameterTypes("int")!!
-        val HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_LESS_THAN_OR_EQUAL_TO)
             .parameterTypes("int")!!
 
+        val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+            .parameterTypes("int")!!
         val IS_GREATER_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN)
             .parameterTypes("int")!!
         val IS_GREATER_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN_OR_EQUAL_TO)
@@ -152,23 +106,9 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
         val IS_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN_OR_EQUAL_TO)
             .parameterTypes("int")!!
 
-        val IS_ZERO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
+        val IS_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
             .parameterCount(0)!!
-        val IS_NOT_ZERO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
+        val IS_NOT_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
-            .parameterCount(0)!!
-        val IS_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
-            .parameterCount(0)!!
-        val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
-            .parameterCount(0)!!
-        val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
-            .parameterCount(0)!!
-        val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
-            .parameterCount(0)!!
-        val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
-            .parameterCount(0)!!
-        val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
-            .parameterCount(0)!!
-        val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
             .parameterCount(0)!!
 
         val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)
@@ -178,19 +118,13 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
 
         val COLLECTION_SIZE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "size")
             .parameterCount(0)!!
-        val MAP_SIZE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "size")
+        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "equals")
-            .parameterCount(0)!!
-        val CHAR_SEQUENCE_LENGTH = CallMatcher.instanceCall("java.lang.CharSequence", "length")
-            .parameterCount(0)!!
-        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, MethodNames.EQUALS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
 
         val OPTIONAL_GET = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "get")
             .parameterCount(0)!!
-        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, MethodNames.IS_PRESENT)
+        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "isPresent")
             .parameterCount(0)!!
-        val OPTIONAL_OR_ELSE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "orElse")
-            .parameterCount(1)!!
 
         val OPTIONAL_OF = CallMatcher.staticCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "of")
             .parameterCount(1)!!
@@ -201,9 +135,7 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
 
         val GUAVA_OPTIONAL_GET = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "get")
             .parameterCount(0)!!
-        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, MethodNames.IS_PRESENT)
+        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "isPresent")
-            .parameterCount(0)!!
-        val GUAVA_OPTIONAL_OR_NULL = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "orNull")
             .parameterCount(0)!!
 
         val GUAVA_OPTIONAL_OF = CallMatcher.staticCall(GUAVA_OPTIONAL_CLASSNAME, "of")
@@ -240,36 +172,7 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
         val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
         val quickFix = ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
-        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, message, quickFix)
-        holder.registerProblem(expression, textRange, message, quickFix)
-    }
-
-    protected fun registerMoveOutMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldActualExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
-        val description = MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
-    }
-
-    protected fun registerMoveOutMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldActualExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String) -> List<LocalQuickFix>
-    ) {
-        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
-        val description = MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
-        val quickfixes = quickFixSupplier(description)
-        holder.registerProblem(expression, message, *quickfixes.toTypedArray())
     }
 
     protected fun registerReplaceMethod(
@@ -279,23 +182,22 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        registerConciseMethod(REPLACE_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
+        registerConciseMethod(REPLACE_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
     }
 
-    protected fun registerConciseMethod(
+    private fun registerConciseMethod(
         descriptionTemplate: String,
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
         oldExpectedCallExpression: PsiMethodCallExpression,
         replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
+        quickFixSupplier: (String, String) -> LocalQuickFix,
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression
     ) {
         val originalMethod = getOriginalMethodName(oldExpectedCallExpression) ?: return
         val description = descriptionTemplate.format(originalMethod, replacementMethod)
         val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
-        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, message, quickfix)
-        holder.registerProblem(expression, textRange, message, quickfix)
     }
 
     protected fun registerRemoveExpectedOutmostMethod(
@@ -305,6 +207,57 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
+        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
     }
-}
+
+    protected fun registerRemoveActualOutmostMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        registerConciseMethod(REMOVE_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
+    }
+
+    protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
+        if (argIndex >= expression.argumentList.expressions.size) return null
+        val valueExpression = expression.getArg(argIndex)
+        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+        val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
+        if (value == null) {
+            val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
+            if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
+                return when (field.name) {
+                    "TRUE" -> true
+                    "FALSE" -> false
+                    else -> null
+                }
+            }
+        }
+        return value
+    }
+
+    protected fun getExpectedBooleanResult(expectedCallExpression: PsiMethodCallExpression): Boolean? {
+        val isTrue = IS_TRUE.test(expectedCallExpression)
+        val isFalse = IS_FALSE.test(expectedCallExpression)
+        if (isTrue || isFalse) {
+            return isTrue
+        } else {
+            val isEqualTo = IS_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
+            val isNotEqualTo = IS_NOT_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
+            if (isEqualTo || isNotEqualTo) {
+                val constValue = calculateConstantParameterValue(expectedCallExpression, 0) as? Boolean ?: return null
+                return isNotEqualTo xor constValue
+            }
+        }
+        return null
+    }
+
+    protected fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
+        val findClass =
+            JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
+                ?: return false
+        return findClass.allMethods.any { it.name == methodname }
+    }
+}

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

@@ -4,54 +4,34 @@ import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
 import com.intellij.psi.PsiMethodCallExpression
 import org.jetbrains.annotations.NonNls
 
-abstract class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
+open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
+        const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
+
+        const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with assertThat().%s()"
+
         @NonNls
         const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
 
-        @NonNls
-        const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
-
         @NonNls
         const val ASSERT_TRUE_METHOD = "assertTrue"
-
         @NonNls
         const val ASSERT_FALSE_METHOD = "assertFalse"
-
         @NonNls
         const val ASSERT_NULL_METHOD = "assertNull"
-
         @NonNls
         const val ASSERT_NOT_NULL_METHOD = "assertNotNull"
-
         @NonNls
         const val ASSERT_EQUALS_METHOD = "assertEquals"
-
         @NonNls
         const val ASSERT_NOT_EQUALS_METHOD = "assertNotEquals"
-
         @NonNls
         const val ASSERT_SAME_METHOD = "assertSame"
-
         @NonNls
         const val ASSERT_NOT_SAME_METHOD = "assertNotSame"
-
         @NonNls
         const val ASSERT_ARRAY_EQUALS_METHOD = "assertArrayEquals"
-
-        @NonNls
-        const val ASSUME_TRUE_METHOD = "assumeTrue"
-
-        @NonNls
-        const val ASSUME_FALSE_METHOD = "assumeFalse"
-
-        @NonNls
-        const val ASSUME_NOT_NULL_METHOD = "assumeNotNull"
-
-        @NonNls
-        const val ASSUME_NO_EXCEPTION = "assumeNoException"
-
     }
 
     override fun getGroupDisplayName(): String {

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

@@ -1,64 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.PsiExpressionStatement
-import com.intellij.psi.PsiMethodCallExpression
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
-
-abstract class AbstractMoveOutInspection : AbstractAssertJInspection() {
-
-    protected fun createInspectionsForMappings(
-        statement: PsiExpressionStatement,
-        holder: ProblemsHolder,
-        mappings: List<MoveOutMapping>
-    ) {
-        if (!statement.hasAssertThat()) return
-
-        val staticMethodCall = statement.findStaticMethodCall() ?: return
-
-        val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
-        val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-
-        for (mapping in mappings.filter { it.callMatcher.test(assertThatArgument) }) {
-            if (mapping.expectBoolean && ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
-                val expectedBooleanResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: continue
-                if (mapping.additionalCondition?.invoke(statement, expectedCallExpression) == false) continue
-                val replacementMethod = if (expectedBooleanResult) mapping.replacementForTrue else mapping.replacementForFalse ?: return
-                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
-                    MoveOutMethodCallExpressionQuickFix(desc, method)
-                }
-            } else if (mapping.expectNullNonNull != null) {
-                val expectedNullNonNullResult = expectedCallExpression.getExpectedNullNonNullResult() ?: continue
-                if (mapping.additionalCondition?.invoke(statement, expectedCallExpression) == false) continue
-                val replacementMethod = if (expectedNullNonNullResult xor mapping.expectNullNonNull) mapping.replacementForTrue else mapping.replacementForFalse ?: continue
-                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
-                    MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
-                }
-            } else if (mapping.expectedMatcher?.test(expectedCallExpression) == true) {
-                if (mapping.additionalCondition?.invoke(statement, expectedCallExpression) == false) continue
-                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, mapping.replacementForTrue) { desc, method ->
-                    MoveOutMethodCallExpressionQuickFix(
-                        desc, method,
-                        replaceOnlyThisMethod = mapping.expectedMatcher,
-                        replaceFromOriginalMethod = mapping.replaceFromOriginalMethod,
-                        noExpectedExpression = mapping.noExpectedExpression
-                    )
-                }
-            }
-        }
-    }
-
-    class MoveOutMapping(
-        val callMatcher: CallMatcher,
-        val replacementForTrue: String,
-        val replacementForFalse: String? = null,
-        val expectBoolean: Boolean = false,
-        val expectNullNonNull: Boolean? = null,
-        val expectedMatcher: CallMatcher? = null,
-        val replaceFromOriginalMethod: Boolean = false,
-        val noExpectedExpression: Boolean = false,
-        val additionalCondition: ((PsiExpressionStatement, PsiMethodCallExpression) -> Boolean)? = null
-    )
-}

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

@@ -1,86 +0,0 @@
-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.util.TypeConversionUtil
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix
-
-class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a binary expression"
-        private const val SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split binary expression out of assertThat()"
-        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving binary expression out of assertThat() would be more meaningful"
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
-
-                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
-
-                val binaryExpression = staticMethodCall.firstArg as? PsiBinaryExpression ?: return
-
-                val leftType = binaryExpression.lOperand.type ?: return
-                val rightType = binaryExpression.rOperand?.type ?: return
-
-                val bothTypes = listOf(leftType, rightType)
-                val (isLeftNull, isRightNull) = bothTypes.map(TypeConversionUtil::isNullType)
-
-                if (isLeftNull && isRightNull) return
-                if (isLeftNull || isRightNull) {
-                    val expectedResultOnOp =
-                        when (binaryExpression.operationTokenType) {
-                            JavaTokenType.EQEQ -> expectedResult
-                            JavaTokenType.NE -> !expectedResult
-                            else -> return
-                        }
-                    val replacementMethod = expectedResultOnOp.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
-                    registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
-                        SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
-                    }
-                    return
-                }
-
-                val isPrimitive = bothTypes.all(TypeConversionUtil::isPrimitiveAndNotNull)
-                val isNumericType = bothTypes.all(TypeConversionUtil::isNumericType)
-                val constantEvaluationHelper = JavaPsiFacade.getInstance(statement.project).constantEvaluationHelper
-                val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
-
-                val tokenType = binaryExpression.operationTokenType
-                    .let {
-                        if (swapExpectedAndActual) SWAP_SIDE_OF_BINARY_OPERATOR.getOrDefault(it, it) else it
-                    }
-                    .let {
-                        if (expectedResult) it else INVERT_BINARY_OPERATOR.getOrDefault(it, it)
-                    }
-                val mappingToUse =
-                    (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
-                val replacementMethod = mappingToUse[tokenType] ?: return
-
-                registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
-                    SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
-                }
-            }
-        }
-    }
-
-    private fun registerSplitMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val quickfix = quickFixSupplier(SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE, replacementMethod)
-        holder.registerProblem(expression, MORE_MEANINGFUL_MESSAGE_TEMPLATE, quickfix)
-    }
-}

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

@@ -0,0 +1,96 @@
+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.util.TypeConversionUtil
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.MethodNames.Companion.IS_NOT_NULL
+import de.platon42.intellij.plugins.cajon.MethodNames.Companion.IS_NULL
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
+import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.SplitEqualsExpressionMethodCallQuickFix
+
+class AssertThatBinaryExpressionIsTrueOrFalseInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting a binary expression"
+        private const val SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split %s expression out of assertThat()"
+        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving %s expression out of assertThat() would be more meaningful"
+    }
+
+    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 (!ASSERT_THAT_BOOLEAN.test(expression)) {
+                    return
+                }
+
+                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
+                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+
+                val assertThatArgument = expression.firstArg
+                if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
+                    val replacementMethod = if (expectedResult) MethodNames.IS_EQUAL_TO else MethodNames.IS_NOT_EQUAL_TO
+                    registerSplitMethod(holder, expression, "${MethodNames.EQUALS}()", replacementMethod, ::SplitEqualsExpressionMethodCallQuickFix)
+                    return
+                }
+
+                val binaryExpression = assertThatArgument as? PsiBinaryExpression ?: return
+
+                val leftType = binaryExpression.lOperand.type ?: return
+                val rightType = binaryExpression.rOperand?.type ?: return
+
+                val bothTypes = listOf(leftType, rightType)
+                val (isLeftNull, isRightNull) = bothTypes.map(TypeConversionUtil::isNullType)
+                if (isLeftNull && isRightNull) {
+                    return
+                } else if (isLeftNull || isRightNull) {
+                    val replacementMethod = if (expectedResult) IS_NULL else IS_NOT_NULL
+                    registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                        SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
+                    }
+                    return
+                }
+
+                val isPrimitive = bothTypes.all(TypeConversionUtil::isPrimitiveAndNotNull)
+                val isNumericType = bothTypes.all(TypeConversionUtil::isNumericType)
+                val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+                val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
+
+                val tokenType = binaryExpression.operationSign.tokenType
+                    .let {
+                        if (swapExpectedAndActual) SWAP_SIDE_OF_BINARY_OPERATOR.getOrDefault(it, it) else it
+                    }
+                    .let {
+                        if (expectedResult) it else INVERT_BINARY_OPERATOR.getOrDefault(it, it)
+                    } ?: return
+                val mappingToUse =
+                    (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
+                val replacementMethod = mappingToUse[tokenType] ?: return
+
+                registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                    SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
+                }
+            }
+
+            private fun registerSplitMethod(
+                holder: ProblemsHolder,
+                expression: PsiMethodCallExpression,
+                type: String,
+                replacementMethod: String,
+                quickFixSupplier: (String, String) -> LocalQuickFix
+            ) {
+                val description = SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE.format(type)
+                val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
+                val quickfix = quickFixSupplier(description, replacementMethod)
+                holder.registerProblem(expression, message, quickfix)
+            }
+        }
+    }
+}

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

@@ -5,13 +5,15 @@ import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.util.TypeConversionUtil
-import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
 
-class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
+class AssertThatBooleanIsTrueOrFalseInspection : AbstractAssertJInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Asserting a boolean condition"
+        private const val DISPLAY_NAME = "Asserting true or false"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -20,20 +22,23 @@ class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
+                val matchingCalls = listOf(
-                val isEqualToObject = IS_EQUAL_TO_OBJECT.test(expression)
+                    IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_BOOLEAN,
-                val isEqualToPrimitive = IS_EQUAL_TO_BOOLEAN.test(expression)
+                    IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_BOOLEAN
-                val isNotEqualToObject = IS_NOT_EQUAL_TO_OBJECT.test(expression)
+                ).map { it.test(expression) }
-                val isNotEqualToPrimitive = IS_NOT_EQUAL_TO_BOOLEAN.test(expression)
+                if (matchingCalls.none { it }) {
-
+                    return
-                if (!(isEqualToObject || isEqualToPrimitive || isNotEqualToObject || isNotEqualToPrimitive)) return
+                }
-                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) return
+                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) {
+                    return
+                }
 
                 val expectedExpression = expression.firstArg
-                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) return
+                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) {
-
+                    return
-                val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
+                }
-                val flippedBooleanTest = isNotEqualToObject || isNotEqualToPrimitive
+                val expectedResult = calculateConstantParameterValue(expression, 0) as? Boolean ?: return
+                val flippedBooleanTest = matchingCalls.drop(2).any { it }
 
                 val replacementMethod = (expectedResult xor flippedBooleanTest).map(MethodNames.IS_TRUE, MethodNames.IS_FALSE)
                 registerSimplifyMethod(holder, expression, replacementMethod)

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

@@ -1,158 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.ui.ComboBox
-import com.intellij.psi.*
-import com.intellij.util.ui.FormBuilder
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
-import java.awt.BorderLayout
-import javax.swing.JComponent
-import javax.swing.JPanel
-
-
-class AssertThatCollectionOrMapExpressionInspection : AbstractMoveOutInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a collection or map specific expression"
-        private const val DEFAULT_MAP_VALUES_NEVER_NULL = 2
-
-        private val MAP_GET_MATCHER = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "get").parameterCount(1)
-
-        private val ANY_IS_EQUAL_TO_MATCHER = CallMatcher.anyOf(
-            IS_EQUAL_TO_OBJECT,
-            IS_EQUAL_TO_STRING,
-            IS_EQUAL_TO_INT,
-            IS_EQUAL_TO_LONG,
-            IS_EQUAL_TO_FLOAT,
-            IS_EQUAL_TO_DOUBLE,
-            IS_EQUAL_TO_BOOLEAN
-        )
-        private val ANY_IS_NOT_EQUAL_TO_MATCHER = CallMatcher.anyOf(
-            IS_NOT_EQUAL_TO_OBJECT,
-            IS_NOT_EQUAL_TO_INT,
-            IS_NOT_EQUAL_TO_LONG,
-            IS_NOT_EQUAL_TO_FLOAT,
-            IS_NOT_EQUAL_TO_DOUBLE,
-            IS_NOT_EQUAL_TO_BOOLEAN
-        )
-
-        private val MAPPINGS = listOf(
-            MoveOutMapping(
-                CallMatcher.anyOf(
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.IS_EMPTY).parameterCount(0),
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.IS_EMPTY).parameterCount(0)
-                ),
-                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS).parameterCount(1),
-                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS_ALL).parameterCount(1),
-                MethodNames.CONTAINS_ALL, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_KEY).parameterCount(1),
-                MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_VALUE).parameterCount(1),
-                MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE, expectBoolean = true
-            )
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    @JvmField
-    var behaviorForMapValueEqualsNull: Int = DEFAULT_MAP_VALUES_NEVER_NULL
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-
-                val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
-                if (MAP_GET_MATCHER.test(assertThatArgument)) {
-                    val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-                    val nullOrNotNull = expectedCallExpression.getAllTheSameNullNotNullConstants()
-                    if (nullOrNotNull == true) {
-                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_KEY) { desc, method ->
-                            MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
-                        }
-                    } else if (nullOrNotNull == false) {
-                        when (behaviorForMapValueEqualsNull) {
-                            1 -> // warning only
-                                registerMoveOutMethod(
-                                    holder,
-                                    expectedCallExpression,
-                                    assertThatArgument,
-                                    ""
-                                ) { _ -> emptyList() }
-                            2 -> // as doesNotContainKey(key)
-                                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.DOES_NOT_CONTAIN_KEY) { desc, method ->
-                                    MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
-                                }
-                            3 -> // as containsEntry(key, null)
-                                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_ENTRY) { desc, method ->
-                                    MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true, useNullNonNull = true)
-                                }
-                            4 -> // both
-                                registerMoveOutMethod(
-                                    holder,
-                                    expectedCallExpression,
-                                    assertThatArgument,
-                                    MethodNames.DOES_NOT_CONTAIN_KEY + "/" + MethodNames.CONTAINS_ENTRY
-                                ) { _ ->
-                                    listOf(
-                                        MoveOutMethodCallExpressionQuickFix(
-                                            "Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)",
-                                            MethodNames.DOES_NOT_CONTAIN_KEY,
-                                            useNullNonNull = true
-                                        ),
-                                        MoveOutMethodCallExpressionQuickFix(
-                                            "Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)",
-                                            MethodNames.CONTAINS_ENTRY,
-                                            keepExpectedAsSecondArgument = true,
-                                            useNullNonNull = true
-                                        )
-                                    )
-                                }
-                        }
-                    } else {
-                        if (ANY_IS_EQUAL_TO_MATCHER.test(expectedCallExpression)) {
-                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_ENTRY) { desc, method ->
-                                MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true)
-                            }
-                        } else if (ANY_IS_NOT_EQUAL_TO_MATCHER.test(expectedCallExpression)) {
-                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.DOES_NOT_CONTAIN_ENTRY) { desc, method ->
-                                MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true)
-                            }
-                        }
-                    }
-                } else {
-                    createInspectionsForMappings(statement, holder, MAPPINGS)
-                }
-            }
-        }
-    }
-
-    override fun createOptionsPanel(): JComponent {
-        val comboBox = ComboBox(
-            arrayOf("ignore", "warning only, no fixes", "as doesNotContainKey(key)", "as containsEntry(key, null)", "both choices")
-        )
-        comboBox.selectedIndex = behaviorForMapValueEqualsNull
-        comboBox.addActionListener { behaviorForMapValueEqualsNull = comboBox.selectedIndex }
-        val panel = JPanel(BorderLayout())
-        panel.add(
-            FormBuilder.createFormBuilder().addLabeledComponent("Fix get() on maps expecting null values:", comboBox).panel,
-            BorderLayout.NORTH
-        )
-        return panel
-    }
-}

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

@@ -1,115 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.calculateConstantValue
-import de.platon42.intellij.plugins.cajon.firstArg
-
-class AssertThatComparableInspection : AbstractMoveOutInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a compareTo() expression"
-
-        private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
-        private val ARG_IS_PLUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 1 }
-        private val ARG_IS_MINUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == -1 }
-
-        private val COMPARABLE_COMPARE_TO =
-            CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_COMPARABLE, "compareTo").parameterCount(1)
-
-        private val MAPPINGS = listOf(
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                "isEqualByComparingTo", expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                "isEqualByComparingTo", expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                "isNotEqualByComparingTo", expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                "isNotEqualByComparingTo", expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_GREATER_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = CallMatcher.anyOf(IS_NOT_EQUAL_TO_INT, IS_GREATER_THAN_INT), replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_MINUS_ONE_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_INT, IS_GREATER_THAN_OR_EQUAL_TO_INT), replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_PLUS_ONE_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN, expectedMatcher = IS_GREATER_THAN_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE_INT, IS_ONE_INT), replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_LESS_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = CallMatcher.anyOf(IS_NOT_EQUAL_TO_INT, IS_LESS_THAN_INT), replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_PLUS_ONE_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_INT, IS_LESS_THAN_OR_EQUAL_TO_INT), replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_MINUS_ONE_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN, expectedMatcher = IS_LESS_THAN_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
-            )
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                createInspectionsForMappings(statement, holder, MAPPINGS)
-            }
-        }
-    }
-}

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

@@ -4,16 +4,12 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiStatement
-import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.calculateConstantParameterValue
-import de.platon42.intellij.plugins.cajon.hasAssertThat
 
 class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Asserting an empty or not empty enumerable"
+        private const val DISPLAY_NAME = "Asserting an empty enumerable"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -22,19 +18,13 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
+                if (!HAS_SIZE.test(expression)) {
-                val isLastExpression = expression.parent is PsiStatement
+                    return
-                val value = expression.calculateConstantParameterValue(0) ?: return
+                }
 
-                val isEmpty = (CallMatcher.anyOf(HAS_SIZE, HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT).test(expression) && (value == 0)) ||
+                val value = calculateConstantParameterValue(expression, 0) ?: return
-                        (HAS_SIZE_LESS_THAN_INT.test(expression) && (value == 1))
+                if (value == 0) {
-                val isNotEmpty = (HAS_SIZE_GREATER_THAN_INT.test(expression) && (value == 0)) ||
-                        (HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (value == 1))
-
-                if (isEmpty && isLastExpression) {
                     registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
-                } else if (isNotEmpty) {
-                    registerSimplifyMethod(holder, expression, MethodNames.IS_NOT_EMPTY)
                 }
             }
         }

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

@@ -1,119 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-
-
-class AssertThatFileExpressionInspection : AbstractMoveOutInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a file specific expression"
-
-        private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
-        private val ARG_IS_NOT_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call ->
-            val constant =
-                call.firstArg.calculateConstantValue()
-            (constant != null) && (constant != 0)
-        }
-
-        private val MAPPINGS = listOf(
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "canRead").parameterCount(0),
-                "canRead", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "canWrite").parameterCount(0),
-                "canWrite", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "exists").parameterCount(0),
-                "exists", "doesNotExist", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isAbsolute").parameterCount(0),
-                "isAbsolute", "isRelative", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isDirectory").parameterCount(0),
-                "isDirectory", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "isFile").parameterCount(0),
-                "isFile", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getName").parameterCount(0),
-                "hasName",
-                expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParent", "getParentFile").parameterCount(0),
-                "hasNoParent", expectNullNonNull = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParent").parameterCount(0),
-                "hasParent",
-                expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "getParentFile").parameterCount(0),
-                "hasParent",
-                expectedMatcher = IS_EQUAL_TO_OBJECT
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "list", "listFiles").parameterCount(0),
-                "isEmptyDirectory",
-                expectedMatcher = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, MethodNames.IS_EMPTY)
-                    .parameterCount(0)
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "list", "listFiles").parameterCount(0),
-                "isNotEmptyDirectory",
-                expectedMatcher = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, MethodNames.IS_NOT_EMPTY)
-                    .parameterCount(0)
-            )
-        )
-
-        private val MAPPINGS_SINCE_ASSERTJ_3_14_0 = listOf(
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                MethodNames.IS_EMPTY, expectedMatcher = IS_ZERO_LONG, noExpectedExpression = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                MethodNames.IS_EMPTY, expectedMatcher = IS_EQUAL_TO_LONG, noExpectedExpression = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                MethodNames.IS_NOT_EMPTY, expectedMatcher = IS_NOT_ZERO_LONG, noExpectedExpression = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                MethodNames.IS_NOT_EMPTY, expectedMatcher = IS_NOT_EQUAL_TO_LONG, noExpectedExpression = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                MethodNames.HAS_SIZE, expectedMatcher = IS_EQUAL_TO_LONG,
-                additionalCondition = ARG_IS_NOT_ZERO_CONST
-            )
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                createInspectionsForMappings(statement, holder, MAPPINGS)
-                if (hasAssertJMethod(statement, AssertJClassNames.ABSTRACT_FILE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)) {
-                    createInspectionsForMappings(statement, holder, MAPPINGS_SINCE_ASSERTJ_3_14_0)
-                }
-            }
-        }
-    }
-}

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

@@ -1,8 +1,10 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
+import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.*
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.search.GlobalSearchScope
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
@@ -12,105 +14,97 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting an Optional (Guava)"
-        private const val REPLACE_GUAVA_DESCRIPTION_TEMPLATE = "Replace %s() with Guava assertThat().%s()"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-
-                if (!checkPreconditions(staticMethodCall)) return
-
-                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
-                val outmostMethodCall = statement.findOutmostMethodCall() ?: return
-                if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
-                    if (actualExpression.type is PsiArrayType) return
-                    val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
-                    if (CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expectedCallExpression)) {
-                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
-                            QuickFixWithPostfixDelegate(
-                                RemoveActualOutmostMethodCallQuickFix(desc, method),
-                                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
-                            )
-                        }
-                    }
-                } else if (GUAVA_OPTIONAL_IS_PRESENT.test(actualExpression)) {
-                    val expectedPresence = outmostMethodCall.getAllTheSameExpectedBooleanConstants() ?: return
-                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_ABSENT)
-                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
-                        QuickFixWithPostfixDelegate(
-                            MoveOutMethodCallExpressionQuickFix(desc, method),
-                            ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
-                        )
-                    }
-                } else if (GUAVA_OPTIONAL_OR_NULL.test(actualExpression)) {
-                    val expectedPresence = outmostMethodCall.getAllTheSameNullNotNullConstants() ?: return
-                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_ABSENT)
-                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
-                        QuickFixWithPostfixDelegate(
-                            MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true),
-                            ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
-                        )
-                    }
-                }
-            }
-
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
+                JavaPsiFacade.getInstance(expression.project)
-                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                    .findClass(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                if (!checkPreconditions(staticMethodCall)) return
+                val assertThatGuava = ASSERT_THAT_GUAVA_OPTIONAL.test(expression)
+                if (!(ASSERT_THAT_ANY.test(expression) || assertThatGuava)) {
+                    return
+                }
+                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
 
-                // We're not calling an assertThat() from Guava, but a core-AssertJ one!
+                val isEqualTo = IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
-                // We need to replace that by the Guava one, if we want to apply a formally correct fix.
+                val isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
-                if (IS_EQUAL_TO_OBJECT.test(expression)) {
+                if (assertThatGuava) {
-                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    if (isEqualTo) {
-                    if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
-                        if (GUAVA_OPTIONAL_FROM_NULLABLE.test(innerExpectedCall)) {
+                        if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
-                            innerExpectedCall.firstArg.calculateConstantValue() ?: return
+                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS, ::RemoveExpectedOutmostMethodCallQuickFix)
+                        } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_ABSENT)
                         }
-                        registerRemoveExpectedOutmostMethod(holder, expression, expression, MethodNames.CONTAINS) { desc, method ->
+                    } else if (isNotEqualTo) {
-                            QuickFixWithPostfixDelegate(
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
-                                UnwrapExpectedStaticMethodCallQuickFix(desc, method),
+                        if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
-                                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
-                            )
                         }
-                    } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
-                        registerSimplifyForGuavaMethod(holder, expression, MethodNames.IS_ABSENT)
                     }
-                } else if (IS_NOT_EQUAL_TO_OBJECT.test(expression)) {
+                } else {
-                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    // we're not calling an assertThat() from Guava, but a core-AssertJ one!
-                    if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                    // We need to replace that by the Guava one, if we want to apply a formally correct fix.
-                        registerSimplifyForGuavaMethod(holder, expression, MethodNames.IS_PRESENT)
+                    val actualExpression = expression.firstArg as? PsiMethodCallExpression
+                    if (actualExpression != null) {
+                        if (GUAVA_OPTIONAL_GET.test(actualExpression) && isEqualTo) {
+                            registerRemoveActualOutmostForGuavaMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS)
+                        } else if (GUAVA_OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                            val expectedPresence = getExpectedBooleanResult(expectedCallExpression) ?: return
+                            val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_ABSENT)
+                            registerRemoveActualOutmostForGuavaMethod(holder, expression, expectedCallExpression, replacementMethod, noExpectedExpression = true)
+                        }
+                    }
+                    if (isEqualTo) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
+                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS) { desc, method ->
+                                QuickFixWithPostfixDelegate(
+                                    RemoveExpectedOutmostMethodCallQuickFix(desc, method),
+                                    ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                                )
+                            }
+                        } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyForGuavaMethod(holder, expectedCallExpression, MethodNames.IS_ABSENT)
+                        }
+                    } else if (isNotEqualTo) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyForGuavaMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
+                        }
                     }
                 }
             }
+        }
+    }
 
-            private fun checkPreconditions(staticMethodCall: PsiMethodCallExpression): Boolean {
+    private fun registerRemoveActualOutmostForGuavaMethod(
-                if (CallMatcher.anyOf(ASSERT_THAT_ANY, GUAVA_ASSERT_THAT_ANY).test(staticMethodCall)) {
+        holder: ProblemsHolder,
-                    JavaPsiFacade.getInstance(staticMethodCall.project)
+        expression: PsiMethodCallExpression,
-                        .findClass(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(staticMethodCall.project)) ?: return false
+        oldExpectedCallExpression: PsiMethodCallExpression,
-                    return true
+        replacementMethod: String,
-                }
+        noExpectedExpression: Boolean = false
-                return false
+    ) {
-            }
+        registerRemoveActualOutmostMethod(holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
+            QuickFixWithPostfixDelegate(
+                RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression),
+                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+            )
         }
     }
 
     private fun registerSimplifyForGuavaMethod(holder: ProblemsHolder, expression: PsiMethodCallExpression, replacementMethod: String) {
         val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = REPLACE_GUAVA_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
         val quickFix = QuickFixWithPostfixDelegate(
             ReplaceSimpleMethodCallQuickFix(description, replacementMethod),
             ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
         )
-        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, message, quickFix)
-        holder.registerProblem(expression, textRange, message, quickFix)
     }
 }

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

@@ -1,48 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.LocalQuickFix
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutInstanceOfExpressionQuickFix
-
-class AssertThatInstanceOfInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a class instance"
-        private const val REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE = "Remove instanceof in actual expression and use assertThat().%s() instead"
-        private const val MOVE_OUT_INSTANCEOF_MESSAGE = "instanceof expression could be moved out of assertThat()"
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
-
-                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
-
-                if (staticMethodCall.firstArg is PsiInstanceOfExpression) {
-                    val replacementMethod = expectedResult.map(MethodNames.IS_INSTANCE_OF, MethodNames.IS_NOT_INSTANCE_OF)
-                    registerMoveOutInstanceOfMethod(holder, expectedCallExpression, replacementMethod, ::MoveOutInstanceOfExpressionQuickFix)
-                }
-            }
-        }
-    }
-
-    private fun registerMoveOutInstanceOfMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val description = REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(replacementMethod)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, MOVE_OUT_INSTANCEOF_MESSAGE, quickfix)
-    }
-}

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

@@ -1,55 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
-import com.intellij.psi.*
-import com.intellij.psi.util.PsiUtil
-import com.intellij.psi.util.TypeConversionUtil
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryExpressionQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryStatementQuickFix
-
-class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting an inverted boolean condition"
-        private const val INVERT_CONDITION_MESSAGE = "Condition inside assertThat() could be inverted"
-        private const val REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE = "Invert condition in %s() and use %s() instead"
-        private const val INVERT_OUTSIDE_CONDITION_MESSAGE = "Condition outside assertThat() could be inverted"
-    }
-
-    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 staticMethodCall = expression.findStaticMethodCall() ?: return
-                if (expression.getExpectedBooleanResult() != null) {
-                    if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
-                    val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
-                    if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
-                        val outmostMethodCall = expression.findOutmostMethodCall() ?: return
-                        holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
-                    }
-                } else {
-                    if (!CallMatcher.anyOf(ASSERT_THAT_BOOLEAN, ASSERT_THAT_BOOLEAN_OBJ).test(staticMethodCall)) return
-                    val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_BOOLEAN, IS_EQUAL_TO_OBJECT).test(expression)
-                    val isNotEqualTo = CallMatcher.anyOf(IS_NOT_EQUAL_TO_BOOLEAN, IS_NOT_EQUAL_TO_OBJECT).test(expression)
-                    if (!(isEqualTo || isNotEqualTo)) return
-                    val prefixExpression = expression.firstArg as? PsiPrefixExpression ?: return
-                    val operand = PsiUtil.skipParenthesizedExprDown(prefixExpression.operand) ?: return
-                    if (!TypeConversionUtil.isPrimitiveAndNotNull(operand.type)) return
-                    val originalMethod = getOriginalMethodName(expression) ?: return
-
-                    val replacementMethod = isEqualTo.map(MethodNames.IS_NOT_EQUAL_TO, MethodNames.IS_EQUAL_TO)
-                    val description = REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-                    val textRange = TextRange(staticMethodCall.textLength, expression.textLength)
-                    holder.registerProblem(expression, textRange, INVERT_OUTSIDE_CONDITION_MESSAGE, InvertUnaryExpressionQuickFix(description, replacementMethod))
-                }
-            }
-        }
-    }
-}

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/AssertThatJava8OptionalInspection.kt

@@ -1,12 +1,16 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
 import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
 import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.UnwrapExpectedStaticMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.RemoveExpectedOutmostMethodCallQuickFix
 
 class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
 
@@ -18,62 +22,49 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_ANY.test(staticMethodCall)) return
-
-                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
-                val outmostMethodCall = statement.findOutmostMethodCall() ?: return
-                if (OPTIONAL_GET.test(actualExpression)) {
-                    val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
-                    if (CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expectedCallExpression)) {
-                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
-                            RemoveActualOutmostMethodCallQuickFix(desc, method)
-                        }
-                    } else if (IS_SAME_AS_OBJECT.test(expectedCallExpression)) {
-                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS_SAME) { desc, method ->
-                            RemoveActualOutmostMethodCallQuickFix(desc, method)
-                        }
-                    }
-                } else if (OPTIONAL_IS_PRESENT.test(actualExpression)) {
-                    val expectedPresence = outmostMethodCall.getAllTheSameExpectedBooleanConstants() ?: return
-                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
-                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
-                        MoveOutMethodCallExpressionQuickFix(desc, method)
-                    }
-                } else if (OPTIONAL_OR_ELSE.test(actualExpression) && (actualExpression.firstArg.type == PsiType.NULL)) {
-                    val expectedPresence = outmostMethodCall.getAllTheSameNullNotNullConstants() ?: return
-                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
-                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
-                        MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true, noExpectedExpression = true)
-                    }
-                }
-            }
-
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
+                if (!ASSERT_THAT_ANY.test(expression)) {
-                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                    return
-                if (!ASSERT_THAT_JAVA8_OPTIONAL.test(staticMethodCall)) return
+                }
-                if (IS_EQUAL_TO_OBJECT.test(expression)) {
+                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+
-                    if (CallMatcher.anyOf(OPTIONAL_OF, OPTIONAL_OF_NULLABLE).test(innerExpectedCall)) {
+                if (ASSERT_THAT_JAVA8_OPTIONAL.test(expression)) {
-                        if (OPTIONAL_OF_NULLABLE.test(innerExpectedCall)) {
+                    if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
-                            innerExpectedCall.firstArg.calculateConstantValue() ?: return
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (CallMatcher.anyOf(OPTIONAL_OF, OPTIONAL_OF_NULLABLE).test(innerExpectedCall)) {
+                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS, ::RemoveExpectedOutmostMethodCallQuickFix)
+                        } else if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_NOT_PRESENT)
+                        }
+                    } else if (IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
                         }
-                        registerRemoveExpectedOutmostMethod(holder, expression, expression, MethodNames.CONTAINS, ::UnwrapExpectedStaticMethodCallQuickFix)
-                    } else if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
-                        registerSimplifyMethod(holder, expression, MethodNames.IS_NOT_PRESENT)
                     }
-                } else if (IS_NOT_EQUAL_TO_OBJECT.test(expression)) {
+                } else {
-                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    val actualExpression = expression.firstArg as? PsiMethodCallExpression ?: return
-                    if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+
-                        registerSimplifyMethod(holder, expression, MethodNames.IS_PRESENT)
+                    if (OPTIONAL_GET.test(actualExpression)) {
+                        if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                            registerRemoveActualOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS) { desc, method ->
+                                RemoveActualOutmostMethodCallQuickFix(desc, method)
+                            }
+                        } else if (IS_SAME_AS_OBJECT.test(expectedCallExpression)) {
+                            registerRemoveActualOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS_SAME) { desc, method ->
+                                RemoveActualOutmostMethodCallQuickFix(desc, method)
+                            }
+                        }
+                    } else if (OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                        val expectedPresence = getExpectedBooleanResult(expectedCallExpression) ?: return
+                        val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
+                        registerRemoveActualOutmostMethod(holder, expression, expectedCallExpression, replacementMethod) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression = true)
+                        }
                     }
                 }
             }
         }
     }
-}
+}

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

@@ -1,53 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.HasHashCodeQuickFix
-
-class AssertThatObjectExpressionInspection : AbstractMoveOutInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting equals(), toString(), or hashCode()"
-        private const val HASHCODE_MESSAGE_TEMPLATE = "Replacing hashCode() expressions by hasSameHashCode() would be more concise"
-
-        private val OBJECT_TO_STRING = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "toString").parameterCount(0)
-        private val OBJECT_HASHCODE = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "hashCode").parameterCount(0)
-
-        private val MAPPINGS = listOf(
-            MoveOutMapping(
-                OBJECT_EQUALS,
-                MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
-            ),
-            MoveOutMapping(
-                OBJECT_TO_STRING,
-                MethodNames.HAS_TO_STRING, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
-            )
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-                val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
-                if (OBJECT_HASHCODE.test(assertThatArgument)) {
-                    val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-                    val isEqualTo = staticMethodCall.findFluentCallTo(IS_EQUAL_TO_INT) ?: return
-                    val expectedExpression = isEqualTo.firstArg as? PsiMethodCallExpression ?: return
-                    if (OBJECT_HASHCODE.test(expectedExpression)) {
-                        holder.registerProblem(expectedCallExpression, HASHCODE_MESSAGE_TEMPLATE, HasHashCodeQuickFix())
-                    }
-                } else {
-                    createInspectionsForMappings(statement, holder, MAPPINGS)
-                }
-            }
-        }
-    }
-}

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

@@ -1,11 +1,12 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
+import com.intellij.psi.JavaElementVisitor
-import com.siyeh.ig.callMatcher.CallMatcher
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiType
 import de.platon42.intellij.plugins.cajon.MethodNames
 import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.hasAssertThat
 import de.platon42.intellij.plugins.cajon.map
 
 class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
@@ -20,11 +21,11 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
                 val isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expression)
-                val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expression)
+                val isEqualTo = IS_EQUAL_TO_OBJECT.test(expression)
-                val isLastExpression = expression.parent is PsiStatement
+                if (!(isEqualTo || isNotEqualTo)) {
-                if (!((isEqualTo && isLastExpression) || isNotEqualTo)) return
+                    return
+                }
 
                 if (expression.firstArg.type == PsiType.NULL) {
                     registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL))
@@ -32,4 +33,4 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
+}

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

@@ -1,52 +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.PsiExpressionStatement
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.MethodNames
-
-
-class AssertThatPathExpressionInspection : AbstractMoveOutInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a path specific expression"
-        private const val JAVA_NIO_PATH = "java.nio.file.Path"
-
-        private val MAPPINGS = listOf(
-            MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "isAbsolute").parameterCount(0),
-                "isAbsolute", "isRelative", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, MethodNames.STARTS_WITH).parameterTypes(JAVA_NIO_PATH),
-                "startsWithRaw", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, MethodNames.ENDS_WITH).parameterTypes(JAVA_NIO_PATH),
-                "endsWithRaw", expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "getParent").parameterCount(0),
-                "hasParentRaw",
-                expectedMatcher = IS_EQUAL_TO_OBJECT
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "getParent").parameterCount(0),
-                "hasNoParentRaw", expectNullNonNull = true
-            )
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                createInspectionsForMappings(statement, holder, MAPPINGS)
-            }
-        }
-    }
-}

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

@@ -2,19 +2,17 @@ package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ITERABLE_ASSERT_CLASSNAME
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_MAP_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceHasSizeMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickFix
 
 class AssertThatSizeInspection : AbstractAssertJInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Asserting the size of an collection, map, array or string"
+        private const val DISPLAY_NAME = "Asserting the size of an collection or array"
-        private const val REMOVE_SIZE_DESCRIPTION_TEMPLATE = "Remove size determination of expected expression and replace %s() with %s()"
-        private const val REMOVE_ALL_MESSAGE = "Try to operate on the iterable itself rather than its size"
 
         private val BONUS_EXPRESSIONS_CALL_MATCHER_MAP = listOf(
             IS_LESS_THAN_INT to MethodNames.HAS_SIZE_LESS_THAN,
@@ -22,127 +20,69 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
             IS_GREATER_THAN_INT to MethodNames.HAS_SIZE_GREATER_THAN,
             IS_GREATER_THAN_OR_EQUAL_TO_INT to MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO
         )
-
-        private fun isCharSequenceLength(expression: PsiExpression) = (expression is PsiMethodCallExpression) && CHAR_SEQUENCE_LENGTH.test(expression)
-
-        private fun isCollectionSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && COLLECTION_SIZE.test(expression)
-
-        private fun isMapSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && MAP_SIZE.test(expression)
-
-        private fun isArrayLength(expression: PsiExpression): Boolean {
-            val psiReferenceExpression = expression as? PsiReferenceExpression ?: return false
-            return ((psiReferenceExpression.qualifierExpression?.type is PsiArrayType)
-                    && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
-        }
-
-        fun getMatch(expression: PsiMethodCallExpression, isForArrayOrCollection: Boolean, isForMap: Boolean, isForString: Boolean): Match? {
-            val isLastExpression = expression.parent is PsiStatement
-            val constValue = expression.calculateConstantParameterValue(0)
-            if (IS_EQUAL_TO_INT.test(expression)) {
-                return if ((constValue == 0) && isLastExpression) {
-                    Match(expression, MethodNames.IS_EMPTY, noExpectedExpression = true)
-                } else {
-                    val equalToExpression = expression.firstArg
-                    val equalsArrayOrCollectionSize = isArrayLength(equalToExpression) ||
-                            isCollectionSize(equalToExpression)
-                    if ((isForArrayOrCollection && equalsArrayOrCollectionSize)
-                        || (isForMap && (equalsArrayOrCollectionSize || isMapSize(equalToExpression)))
-                        || (isForString && (equalsArrayOrCollectionSize || isCharSequenceLength(equalToExpression)))
-                    ) {
-                        Match(expression, MethodNames.HAS_SAME_SIZE_AS, expectedIsCollection = true)
-                    } else {
-                        Match(expression, MethodNames.HAS_SIZE)
-                    }
-                }
-            } else {
-                val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 0))
-                        || (IS_LESS_THAN_INT.test(expression) && (constValue == 1))
-                        || IS_ZERO_INT.test(expression))
-                val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expression) && (constValue == 0))
-                        || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 1))
-                        || IS_NOT_ZERO_INT.test(expression))
-                if ((isTestForEmpty && isLastExpression) || isTestForNotEmpty) {
-                    val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
-                    return Match(expression, replacementMethod, noExpectedExpression = true)
-                } else if (hasAssertJMethod(expression, ABSTRACT_ITERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE_LESS_THAN)) {
-                    // new stuff in AssertJ 3.12.0
-                    val replacementMethod = BONUS_EXPRESSIONS_CALL_MATCHER_MAP.find { it.first.test(expression) }?.second ?: return null
-                    return Match(expression, replacementMethod)
-                }
-                return null
-            }
-        }
     }
 
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitExpressionStatement(statement)
+                super.visitMethodCallExpression(expression)
-                if (!statement.hasAssertThat()) return
+                if (!ASSERT_THAT_INT.test(expression)) {
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
+                    return
-                if (!ASSERT_THAT_INT.test(staticMethodCall)) return
+                }
+                val actualExpression = expression.firstArg
 
-                val actualExpression = staticMethodCall.firstArg
+                if (isArrayLength(actualExpression) || isCollectionSize(actualExpression)) {
-                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                    val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val isForMap = isMapSize(actualExpression)
+                    val constValue = calculateConstantParameterValue(expectedCallExpression, 0)
-                val isForString = isCharSequenceLength(actualExpression)
+                    if (IS_EQUAL_TO_INT.test(expectedCallExpression)) {
-                if (!(isForArrayOrCollection || isForMap || isForString)) return
+                        if (constValue == 0) {
-
+                            registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.IS_EMPTY) { desc, method ->
-                val matches = staticMethodCall.collectMethodCallsUpToStatement()
+                                ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = true)
-                    .mapNotNull { getMatch(it, isForArrayOrCollection, isForMap, isForString) }
+                            }
-                    .toList()
+                        } else {
-                if (matches.isNotEmpty()) {
+                            val equalToExpression = expectedCallExpression.firstArg
-                    if (matches.size == 1) {
+                            if (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) {
-                        val match = matches.single()
+                                registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.HAS_SAME_SIZE_AS) { desc, method ->
-                        val expression = match.methodCall
+                                    ReplaceSizeMethodCallQuickFix(desc, method, expectedIsCollection = true)
-                        registerReplaceMethod(
+                                }
-                            holder,
+                            } else {
-                            expression,
+                                registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.HAS_SIZE) { desc, method ->
-                            expression,
+                                    ReplaceSizeMethodCallQuickFix(desc, method)
-                            match.replacementMethod
+                                }
-                        )
+                            }
-                        { desc, method ->
-                            ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = match.noExpectedExpression, expectedIsCollection = match.expectedIsCollection)
                         }
                     } else {
-                        // I could try to create a quickfix for this, too, but it's probably not worth the effort
+                        val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 0))
-                        holder.registerProblem(statement, REMOVE_ALL_MESSAGE)
+                                || (IS_LESS_THAN_INT.test(expectedCallExpression) && (constValue == 1))
+                                || IS_ZERO.test(expectedCallExpression))
+                        val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expectedCallExpression) && (constValue == 0))
+                                || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 1))
+                                || IS_NOT_ZERO.test(expectedCallExpression))
+                        if (isTestForEmpty || isTestForNotEmpty) {
+                            val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
+                            registerReplaceMethod(holder, expression, expectedCallExpression, replacementMethod) { desc, method ->
+                                ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = true)
+                            }
+                        } else if (hasAssertJMethod(expression, ABSTRACT_ITERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE_LESS_THAN)) {
+                            // new stuff in AssertJ 13.2.0
+                            val matchedMethod = BONUS_EXPRESSIONS_CALL_MATCHER_MAP.find { it.first.test(expectedCallExpression) }?.second ?: return
+                            registerReplaceMethod(holder, expression, expectedCallExpression, matchedMethod) { desc, method ->
+                                ReplaceSizeMethodCallQuickFix(desc, method)
+                            }
+                        }
                     }
                 }
             }
 
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+            private fun isCollectionSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && COLLECTION_SIZE.test(expression)
-                super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
-                if (!HAS_SIZE.test(expression)) return
-                val actualExpression = expression.firstArg
 
-                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+            private fun isArrayLength(expression: PsiExpression): Boolean {
-                val isForMap = isMapSize(actualExpression)
+                val psiReferenceExpression = expression as? PsiReferenceExpression ?: return false
-                val isForString = isCharSequenceLength(actualExpression)
+                return ((psiReferenceExpression.qualifierExpression?.type is PsiArrayType)
-                if (!(isForArrayOrCollection
+                        && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
-                            || (isForMap && checkAssertedType(expression, ABSTRACT_MAP_ASSERT_CLASSNAME))
-                            || (isForString && checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)))
-                ) return
-
-                registerConciseMethod(
-                    REMOVE_SIZE_DESCRIPTION_TEMPLATE,
-                    holder,
-                    expression,
-                    expression,
-                    MethodNames.HAS_SAME_SIZE_AS,
-                    ::ReplaceHasSizeMethodCallQuickFix
-                )
             }
         }
     }
-
-    class Match(
-        val methodCall: PsiMethodCallExpression,
-        val replacementMethod: String,
-        val noExpectedExpression: Boolean = false,
-        val expectedIsCollection: Boolean = false
-    )
 }

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

@@ -1,152 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.calculateConstantValue
-import de.platon42.intellij.plugins.cajon.firstArg
-
-class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting a string specific expression"
-
-        private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
-        private val ARG_IS_MINUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == -1 }
-
-        private val STRING_COMPARE_TO_IGNORE_CASE =
-            CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "compareToIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING)
-        private val STRING_INDEX_OF = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "indexOf").parameterTypes(CommonClassNames.JAVA_LANG_STRING)
-        private val STRING_TRIM = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "trim").parameterCount(0)
-
-        private val MAPPINGS = listOf(
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.IS_EMPTY).parameterCount(0),
-                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.anyOf(
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.EQUALS).parameterCount(1),
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contentEquals").parameterCount(1)
-                ),
-                MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equalsIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.CONTAINS).parameterCount(1),
-                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.STARTS_WITH).parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.ENDS_WITH).parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH, expectBoolean = true
-            ),
-            MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "matches").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                "matches", "doesNotMatch", expectBoolean = true
-            ),
-
-            MoveOutMapping(
-                STRING_COMPARE_TO_IGNORE_CASE,
-                MethodNames.IS_EQUAL_TO_IC, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                STRING_COMPARE_TO_IGNORE_CASE,
-                MethodNames.IS_EQUAL_TO_IC, expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
-            ),
-            MoveOutMapping(
-                STRING_COMPARE_TO_IGNORE_CASE,
-                MethodNames.IS_NOT_EQUAL_TO_IC, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                STRING_COMPARE_TO_IGNORE_CASE,
-                MethodNames.IS_NOT_EQUAL_TO_IC, expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.STARTS_WITH, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.STARTS_WITH, expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.DOES_NOT_START_WITH, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.DOES_NOT_START_WITH, expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
-            ),
-
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_MINUS_ONE_CONST
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_GREATER_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_GREATER_THAN_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_MINUS_ONE_CONST
-            ),
-
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_MINUS_ONE_CONST
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_LESS_THAN_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_ZERO_CONST
-            ),
-            MoveOutMapping(
-                STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_LESS_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
-                additionalCondition = ARG_IS_MINUS_ONE_CONST
-            ),
-
-            MoveOutMapping(
-                STRING_TRIM,
-                "isNotBlank", expectedMatcher = IS_NOT_EMPTY
-            )
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                createInspectionsForMappings(statement, holder, MAPPINGS)
-            }
-        }
-    }
-}

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

@@ -4,12 +4,8 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiStatement
-import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.calculateConstantParameterValue
-import de.platon42.intellij.plugins.cajon.hasAssertThat
 
 class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
 
@@ -23,15 +19,17 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) return
+                val isEqual = IS_EQUAL_TO_OBJECT.test(expression)
-                val isEqual = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expression)
                 val hasSize = HAS_SIZE.test(expression)
-                val isLastExpression = expression.parent is PsiStatement
+                if (!(isEqual || hasSize)) {
-                if (!((isEqual || hasSize) && isLastExpression)) return
+                    return
+                }
 
-                if (!checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)) return
+                if (!checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)) {
+                    return
+                }
 
-                val value = expression.calculateConstantParameterValue(0) ?: return
+                val value = calculateConstantParameterValue(expression, 0) ?: return
                 if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
                     registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                 }

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

@@ -1,144 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemHighlightType
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import de.platon42.intellij.plugins.cajon.hasAssertThat
-import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceIfByAssumeThatQuickFix
-
-class AssumeThatInsteadOfReturnInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Replace conditional test exits by assumeThat() statements with same actual expression"
-        private const val REPLACE_RETURN_BY_ASSUME_THAT_DESCRIPTION = "Conditional return should probably be an assumeThat() statement instead"
-
-        private const val MAX_RECURSION_DEPTH = 5
-        private const val MAX_STATEMENTS_COUNT = 50
-
-        private val TEST_ANNOTATIONS = setOf(
-            "org.junit.Test",
-            "org.junit.jupiter.api.Test",
-            "org.junit.jupiter.api.TestTemplate",
-            "org.junit.jupiter.api.params.ParameterizedTest"
-        )
-
-        private fun hasEmptyReturn(statement: PsiStatement): Boolean {
-            return when (statement) {
-                is PsiBlockStatement -> {
-                    val psiReturnStatement = (statement.firstChild as? PsiCodeBlock)?.statements?.singleOrNull() as? PsiReturnStatement
-                    (psiReturnStatement != null) && (psiReturnStatement.returnValue == null)
-                }
-                is PsiReturnStatement -> statement.returnValue == null
-                else -> false
-            }
-        }
-
-        private fun registerProblem(holder: ProblemsHolder, isOnTheFly: Boolean, statement: PsiStatement, removeElse: Boolean) {
-            val problemDescriptor = holder.manager.createProblemDescriptor(
-                statement,
-                statement,
-                REPLACE_RETURN_BY_ASSUME_THAT_DESCRIPTION,
-                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                isOnTheFly,
-                ReplaceIfByAssumeThatQuickFix(removeElse)
-            )
-            holder.registerProblem(problemDescriptor)
-        }
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitMethod(method: PsiMethod) {
-                super.visitMethod(method)
-                // Note: replace with if(TEST_ANNOTATIONS.none(method::hasAnnotation)) for IDEA >= 2018.2
-                val annotations = method.annotations.mapNotNull { it.qualifiedName }
-                if (annotations.none(TEST_ANNOTATIONS::contains)) return
-                val containingClass = method.containingClass ?: return
-                val visitor: PsiElementVisitor = TestMethodVisitor(holder, isOnTheFly, containingClass)
-                method.accept(visitor)
-            }
-        }
-    }
-
-    class TestMethodVisitor(
-        private val holder: ProblemsHolder,
-        private val isOnTheFly: Boolean,
-        private val containingClass: PsiClass
-    ) : JavaRecursiveElementWalkingVisitor() {
-
-        private var contSearch = true
-
-        override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-            if (contSearch) {
-                val methodCallExpression = statement.expression as? PsiMethodCallExpression
-                if (methodCallExpression != null) {
-                    if (methodCallExpression.hasAssertThat()) {
-                        contSearch = false
-                    } else {
-                        val method = methodCallExpression.resolveMethod()
-                        if (method?.containingClass == containingClass) {
-                            val recursionVisitor = CheckForAssertThatCallsVisitor(containingClass, 1)
-                            method.accept(recursionVisitor)
-                            if (recursionVisitor.aborted || recursionVisitor.foundAssertThat) {
-                                contSearch = false
-                            }
-                        }
-                    }
-                }
-            }
-            if (contSearch) {
-                super.visitExpressionStatement(statement)
-            }
-        }
-
-        override fun visitIfStatement(statement: PsiIfStatement) {
-            if (contSearch) {
-                checkBranch(statement, statement.thenBranch, false)
-                checkBranch(statement, statement.elseBranch, true)
-            }
-        }
-
-        private fun checkBranch(statement: PsiIfStatement, branch: PsiStatement?, removeElse: Boolean) {
-            if (branch != null) {
-                if (hasEmptyReturn(branch)) {
-                    registerProblem(holder, isOnTheFly, statement, removeElse)
-                } else {
-                    branch.accept(TestMethodVisitor(holder, isOnTheFly, containingClass))
-                }
-            }
-        }
-    }
-
-    class CheckForAssertThatCallsVisitor(private val containingClass: PsiClass, private var depth: Int) : JavaRecursiveElementWalkingVisitor() {
-        var foundAssertThat = false
-        private var statementCount = 0
-        var aborted = false
-
-        override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-            if (foundAssertThat || aborted) return
-            if (++statementCount > MAX_STATEMENTS_COUNT) {
-                aborted = true
-                return
-            }
-            super.visitExpressionStatement(statement)
-            val methodCallExpression = statement.expression as? PsiMethodCallExpression
-            if (methodCallExpression != null) {
-                foundAssertThat = methodCallExpression.hasAssertThat()
-                val method = methodCallExpression.resolveMethod()
-                if (method?.containingClass == containingClass) {
-                    if (depth < MAX_RECURSION_DEPTH) {
-                        val recursionVisitor = CheckForAssertThatCallsVisitor(containingClass, depth + 1)
-                        method.accept(recursionVisitor)
-                        foundAssertThat = recursionVisitor.foundAssertThat
-                        statementCount += recursionVisitor.statementCount
-                        aborted = recursionVisitor.aborted
-                    } else {
-                        aborted = true
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,177 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemHighlightType
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.intellij.psi.util.PsiTreeUtil
-import com.siyeh.ig.callMatcher.CallMatcher
-import com.siyeh.ig.psiutils.EquivalenceChecker
-import de.platon42.intellij.plugins.cajon.*
-
-class BogusAssertionInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Bogus assertion due to same actual and expected expressions"
-        private const val ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE = "Actual expression in assertThat() is the same as expected"
-        private const val WEAK_ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE = "Same actual and expected expression, but may be testing equals() or hashCode()"
-
-        private val SAME_OBJECT =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ASSERT_INTERFACE,
-                MethodNames.IS_EQUAL_TO,
-                MethodNames.IS_SAME_AS,
-                "hasSameClassAs",
-                "hasSameHashCodeAs"
-            ).parameterCount(1)
-
-        private val ARRAY_METHODS = arrayOf(
-            MethodNames.HAS_SAME_SIZE_AS,
-            MethodNames.CONTAINS,
-            "containsAnyOf",
-            MethodNames.CONTAINS_EXACTLY,
-            "containsExactlyInAnyOrder",
-            "containsOnly",
-            "containsSequence",
-            "containsSubsequence",
-            MethodNames.STARTS_WITH,
-            MethodNames.ENDS_WITH
-        )
-
-        private val SAME_BOOLEAN_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_BOOLEAN_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_BYTE_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_BYTE_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_SHORT_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_SHORT_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_INT_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_INT_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_LONG_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_LONG_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_FLOAT_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_FLOAT_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_DOUBLE_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_DOUBLE_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_CHAR_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_CHAR_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-        private val SAME_OBJECT_ARRAY_CONTENTS =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
-
-        private val HASHCODE_OR_IS_EQUAL_TO =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ASSERT_INTERFACE,
-                MethodNames.IS_EQUAL_TO, "hasSameHashCodeAs"
-            ).parameterCount(1)
-
-        private val SAME_ENUMERABLE_CONTENTS =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ENUMERABLE_ASSERT_INTERFACE,
-                MethodNames.HAS_SAME_SIZE_AS
-            ).parameterCount(1)
-
-        private val SAME_ITERABLE_CONTENTS =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME,
-                "hasSameElementsAs",
-                MethodNames.CONTAINS_ALL,
-                "containsAnyElementsOf",
-                "containsOnlyElementsOf",
-                "containsExactlyElementsOf",
-                "containsSequence",
-                "containsSubsequence"
-            ).parameterCount(1)
-
-        private val SAME_MAP_CONTENTS =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ABSTRACT_MAP_ASSERT_CLASSNAME,
-                "containsAllEntriesOf",
-                "containsExactlyEntriesOf",
-                "containsExactlyInAnyOrderEntriesOf",
-                MethodNames.HAS_SAME_SIZE_AS
-            ).parameterCount(1)
-
-        private val SAME_CHAR_SEQUENCE_CONTENTS =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME,
-                MethodNames.IS_EQUAL_TO,
-                MethodNames.IS_EQUAL_TO_IC,
-                MethodNames.STARTS_WITH,
-                MethodNames.ENDS_WITH,
-                "containsSequence",
-                "containsSubsequence"
-            ).parameterCount(1)
-
-        private val SAME_ACTUAL_AND_EXPECTED_MATCHERS = CallMatcher.anyOf(
-            SAME_OBJECT,
-            SAME_ENUMERABLE_CONTENTS,
-            SAME_ITERABLE_CONTENTS,
-            SAME_MAP_CONTENTS,
-            SAME_CHAR_SEQUENCE_CONTENTS,
-
-            SAME_BOOLEAN_ARRAY_CONTENTS,
-            SAME_BYTE_ARRAY_CONTENTS,
-            SAME_SHORT_ARRAY_CONTENTS,
-            SAME_INT_ARRAY_CONTENTS,
-            SAME_LONG_ARRAY_CONTENTS,
-            SAME_FLOAT_ARRAY_CONTENTS,
-            SAME_DOUBLE_ARRAY_CONTENTS,
-            SAME_CHAR_ARRAY_CONTENTS,
-            SAME_OBJECT_ARRAY_CONTENTS
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) } ?: return
-                val actualExpression = assertThatCall.firstArg
-                val allCalls = assertThatCall.collectMethodCallsUpToStatement().toList()
-                // Note: replace with TrackingEquivalenceChecker() for IDEA >= 2019.1
-                val equivalenceChecker = EquivalenceChecker.getCanonicalPsiEquivalence()!!
-                val isSameExpression = allCalls
-                    .filter { it.argumentList.expressions.size == 1 }
-                    .filter(SAME_ACTUAL_AND_EXPECTED_MATCHERS::test)
-                    .any { equivalenceChecker.expressionsAreEquivalent(actualExpression, it.firstArg) }
-                if (isSameExpression) {
-                    if (!hasExpressionWithSideEffects(actualExpression)) {
-                        if (allCalls.any(HASHCODE_OR_IS_EQUAL_TO::test)) {
-                            val method = PsiTreeUtil.getParentOfType(statement, PsiMethod::class.java, true)
-                            val methodName = method?.name
-                            if ((methodName != null)
-                                && ((methodName.contains("equal", ignoreCase = true) || methodName.contains("hashcode", ignoreCase = true)))
-                            ) {
-                                if (isOnTheFly) {
-                                    holder.registerProblem(statement, WEAK_ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE, ProblemHighlightType.INFORMATION)
-                                }
-                                return
-                            }
-                        }
-                        holder.registerProblem(statement, ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE)
-                    }
-                }
-            }
-
-            private fun hasExpressionWithSideEffects(actualExpression: PsiExpression): Boolean {
-                var result = false
-                PsiTreeUtil.processElements(actualExpression) { element ->
-                    val matched = when (element) {
-                        is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
-                                || (element.operationTokenType == JavaTokenType.MINUSMINUS)
-                        is PsiMethodCallExpression -> true
-                        else -> false
-                    }
-                    if (matched) {
-                        result = true
-                        false
-                    } else {
-                        true
-                    }
-                }
-                return result
-            }
-        }
-    }
-}

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

@@ -1,129 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.DeleteMethodCallQuickFix
-
-class ImplicitAssertionInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting implicitly covered conditions"
-        private const val DELETE_IMPLICIT_DESCRIPTION_TEMPLATE = "Delete implicit %s() covered by %s()"
-        private const val SURPLUS_ASSERTION_MESSAGE = "Implicit %s() assertion is covered by %s()"
-
-        private val IS_PRESENT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OPTIONAL_ASSERT_CLASSNAME, MethodNames.IS_PRESENT, MethodNames.IS_NOT_EMPTY)
-            .parameterCount(0)!!
-        private val IS_NOT_PRESENT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OPTIONAL_ASSERT_CLASSNAME, MethodNames.IS_NOT_PRESENT, MethodNames.IS_EMPTY)
-            .parameterCount(0)!!
-        private val OPTIONAL_CONTAINS =
-            CallMatcher.instanceCall(
-                AssertJClassNames.ABSTRACT_OPTIONAL_ASSERT_CLASSNAME,
-                MethodNames.CONTAINS, MethodNames.CONTAINS_SAME,
-                "hasValue", "hasValueSatisfying", "containsInstanceOf"
-            ).parameterCount(1)!!
-
-        private val OBJECT_ENUMERABLE_ANY_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
-            AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
-            MethodNames.CONTAINS, "containsOnly", "containsOnlyNulls", MethodNames.CONTAINS_ONLY_ONCE,
-            MethodNames.CONTAINS_EXACTLY, "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
-            MethodNames.CONTAINS_ALL, "containsAnyOf",
-            "containsAnyElementsOf", "containsExactlyElementsOf", "containsOnlyElementsOf",
-            "isSubsetOf", "containsSequence", "containsSubsequence",
-            "doesNotContainSequence", "doesNotContainSubsequence", MethodNames.DOES_NOT_CONTAIN,
-            "doesNotContainAnyElementsOf", "doesNotHaveDuplicates",
-            MethodNames.STARTS_WITH, MethodNames.ENDS_WITH, "containsNull", "doesNotContainNull",
-            "are", "areNot", "have", "doNotHave", "areAtLeastOne", "areAtLeast", "areAtMost", "areExactly",
-            "haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
-            "hasAtLeastOneElementOfType", "hasOnlyElementsOfType", "hasOnlyElementsOfTypes",
-            "doesNotHaveAnyElementsOfTypes",
-            "has", "doesNotHave",
-            "singleElement", "hasOnlyOneElementSatisfying", "hasSameElementsAs",
-            "allMatch", "allSatisfy", "anyMatch", "anySatisfy", "noneMatch", "noneSatisfy"
-        )!!
-
-        private val OBJECT_ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
-            AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
-            "containsOnlyNulls",
-            MethodNames.STARTS_WITH, MethodNames.ENDS_WITH, "containsNull",
-            "areAtLeastOne",
-            "haveAtLeastOne",
-            "hasAtLeastOneElementOfType",
-            "anyMatch", "anySatisfy"
-        )!!
-
-        private val ENUMERABLE_NON_NULL_ASSERTIONS = CallMatcher.instanceCall(
-            AssertJClassNames.ENUMERABLE_ASSERT_INTERFACE,
-            MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY,
-            MethodNames.HAS_SIZE, MethodNames.HAS_SIZE_GREATER_THAN, MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO,
-            MethodNames.HAS_SIZE_LESS_THAN, MethodNames.HAS_SIZE_LESS_THAN_OR_EQUAL_TO,
-            "hasSizeBetween", MethodNames.HAS_SAME_SIZE_AS
-        )!!
-
-        private val ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
-            AssertJClassNames.ENUMERABLE_ASSERT_INTERFACE,
-            MethodNames.HAS_SIZE, MethodNames.HAS_SIZE_GREATER_THAN,
-            MethodNames.HAS_SAME_SIZE_AS
-        )!!
-
-        private val NON_NULL_CORE_ASSERTIONS = CallMatcher.instanceCall(
-            AssertJClassNames.ASSERT_INTERFACE,
-            MethodNames.IS_INSTANCE_OF, "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
-            MethodNames.IS_NOT_INSTANCE_OF, "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
-            "hasSameClassAs", "doesNotHaveSameClassAs",
-            MethodNames.HAS_TO_STRING, "hasSameHashCodeAs"
-        )!!
-
-        private val GUAVA_IS_PRESENT = CallMatcher.instanceCall(AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME, MethodNames.IS_PRESENT)
-            .parameterCount(0)!!
-        private val GUAVA_IS_ABSENT = CallMatcher.instanceCall(AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME, MethodNames.IS_ABSENT)
-            .parameterCount(0)!!
-        private val GUAVA_OPTIONAL_CONTAINS = CallMatcher.instanceCall(
-            AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME,
-            MethodNames.CONTAINS, "extractingValue", "extractingCharSequence"
-        )!!
-
-        private val MAPPINGS = listOf(
-            IS_NOT_NULL to CallMatcher.anyOf(
-                NON_NULL_CORE_ASSERTIONS,
-                ENUMERABLE_NON_NULL_ASSERTIONS,
-                OBJECT_ENUMERABLE_ANY_CONTENT_ASSERTIONS,
-                IS_PRESENT, IS_NOT_PRESENT, OPTIONAL_CONTAINS,
-                GUAVA_IS_PRESENT, GUAVA_IS_ABSENT, GUAVA_OPTIONAL_CONTAINS
-            )!!,
-
-            IS_NOT_EMPTY to CallMatcher.anyOf(
-                ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS,
-                OBJECT_ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS
-            )!!,
-
-            IS_PRESENT to OPTIONAL_CONTAINS,
-            GUAVA_IS_PRESENT to GUAVA_OPTIONAL_CONTAINS
-        )
-    }
-
-    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 mapping = MAPPINGS.firstOrNull { it.first.test(expression) } ?: return
-                val followupExpression = expression.findFluentCallTo(mapping.second) ?: return
-                val redundantName = getOriginalMethodName(expression) ?: return
-                val followupName = getOriginalMethodName(followupExpression) ?: return
-                val description = DELETE_IMPLICIT_DESCRIPTION_TEMPLATE.format(redundantName, followupName)
-                val quickFix = DeleteMethodCallQuickFix(description)
-
-                val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
-                holder.registerProblem(expression, textRange, SURPLUS_ASSERTION_MESSAGE.format(redundantName, followupName), quickFix)
-            }
-        }
-    }
-}

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

@@ -10,44 +10,41 @@ import com.siyeh.ig.callMatcher.CallMatcher.staticCall
 import de.platon42.intellij.plugins.cajon.AssertJClassNames
 import de.platon42.intellij.plugins.cajon.MethodNames
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssertMethodCallQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssumeMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitDeltaAssertMethodCallQuickFix
 
 class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Convert JUnit assertions/assumptions to AssertJ"
+        private const val DISPLAY_NAME = "Convert JUnit assertions to AssertJ"
-        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 val ASSERT_MAPPINGS = listOf(
+        private val 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")
                 ),
-                MethodNames.IS_TRUE, hasExpected = false
+                MethodNames.IS_TRUE, 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")
                 ),
-                MethodNames.IS_FALSE, hasExpected = false
+                MethodNames.IS_FALSE, 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)
                 ),
-                MethodNames.IS_NULL, hasExpected = false
+                MethodNames.IS_NULL, 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)
                 ),
-                MethodNames.IS_NOT_NULL, hasExpected = false
+                MethodNames.IS_NOT_NULL, false
             ),
             Mapping(
                 anyOf(
@@ -112,34 +109,6 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
                 MethodNames.CONTAINS_EXACTLY
             )
         )
-
-        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")
-                ),
-                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")
-                ),
-                MethodNames.IS_FALSE, hasExpected = false
-            ),
-            Mapping(
-                staticCall(JUNIT_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)
-                ),
-                "doesNotThrowAnyException", hasExpected = false
-            )
-        )
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -148,28 +117,18 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                when (expression.resolveMethod()?.containingClass?.qualifiedName) {
+                val isJUnitAssertCall = expression.resolveMethod()?.containingClass?.qualifiedName == JUNIT_ASSERT_CLASSNAME
-                    JUNIT_ASSERT_CLASSNAME -> {
+                if (!isJUnitAssertCall) {
-                        JavaPsiFacade.getInstance(expression.project)
+                    return // early exit
-                            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                }
-                        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                JavaPsiFacade.getInstance(expression.project)
-                        if (mapping.hasDelta) {
+                    .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
+                val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
-                        } else {
+                if (mapping.hasDelta) {
-                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
+                    registerConvertMethod(holder, expression, mapping.replacement, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
-                                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
+                } else {
-                            }
+                    registerConvertMethod(holder, expression, mapping.replacement) { 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)
-                            }
-                        }
                     }
                 }
             }
@@ -180,11 +139,10 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
         replacementMethod: String,
-        staticMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
         val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, staticMethod, replacementMethod)
+        val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
         holder.registerProblem(expression, message, quickfix)
@@ -194,7 +152,6 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         val callMatcher: CallMatcher,
         val replacement: String,
         val hasExpected: Boolean = true,
-        val hasDelta: Boolean = false,
+        val hasDelta: Boolean = false
-        val singleArgument: Boolean = false
     )
 }

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

@@ -1,117 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemHighlightType
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.codeInspection.ui.SingleIntegerFieldOptionsPanel
-import com.intellij.psi.*
-import com.intellij.psi.util.PsiTreeUtil
-import com.siyeh.ig.psiutils.EquivalenceChecker
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.JoinStatementsQuickFix
-import javax.swing.JComponent
-
-class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Join multiple assertThat() statements with same actual expression"
-        private const val CAN_BE_JOINED_DESCRIPTION = "Multiple assertThat() statements can be joined together"
-        private const val DEFAULT_SEPARATE_LINE_LIMIT = 1
-    }
-
-    @JvmField
-    var separateLineLimit: Int = DEFAULT_SEPARATE_LINE_LIMIT
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitCodeBlock(block: PsiCodeBlock) {
-                super.visitCodeBlock(block)
-                var lastActualExpression: PsiExpression? = null
-                var sameCount = 0
-                var firstStatement: PsiStatement? = null
-                var lastStatement: PsiStatement? = null
-                // Note: replace with TrackingEquivalenceChecker() for IDEA >= 2019.1
-                val equivalenceChecker = EquivalenceChecker.getCanonicalPsiEquivalence()!!
-                for (statement in block.statements) {
-                    val assertThatCall = isLegitAssertThatCall(statement)
-                    var reset = true
-                    var actualExpression: PsiExpression? = null
-                    if (assertThatCall != null) {
-                        reset = (lastActualExpression == null)
-                        actualExpression = assertThatCall.firstArg
-                        if (!reset) {
-                            val isSame = equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                                    && !hasExpressionWithSideEffects(actualExpression)
-
-                            if (isSame) {
-                                sameCount++
-                                lastStatement = statement
-                            } else {
-                                reset = true
-                            }
-                        }
-                    }
-                    if (reset) {
-                        if (sameCount > 1) {
-                            registerProblem(holder, isOnTheFly, firstStatement!!, lastStatement!!)
-                        }
-                        firstStatement = statement
-                        lastStatement = null
-                        lastActualExpression = actualExpression
-                        sameCount = 1
-                    }
-                }
-                if (sameCount > 1) {
-                    registerProblem(holder, isOnTheFly, firstStatement!!, lastStatement!!)
-                }
-            }
-
-            private fun isLegitAssertThatCall(statement: PsiStatement?): PsiMethodCallExpression? {
-                if ((statement is PsiExpressionStatement) && (statement.expression is PsiMethodCallExpression)) {
-                    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 null
-            }
-
-            private fun hasExpressionWithSideEffects(actualExpression: PsiExpression): Boolean {
-                var result = false
-                PsiTreeUtil.processElements(actualExpression) { element ->
-                    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
-                    }
-                    if (matched) {
-                        result = true
-                        false
-                    } else {
-                        true
-                    }
-                }
-                return result
-            }
-        }
-    }
-
-    override fun createOptionsPanel(): JComponent {
-        return SingleIntegerFieldOptionsPanel("Limit for joins before adding line breaks:", this, "separateLineLimit")
-    }
-
-    private fun registerProblem(holder: ProblemsHolder, isOnTheFly: Boolean, firstStatement: PsiStatement, lastStatement: PsiStatement) {
-        val problemDescriptor = holder.manager.createProblemDescriptor(
-            firstStatement,
-            lastStatement,
-            CAN_BE_JOINED_DESCRIPTION,
-            ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-            isOnTheFly,
-            JoinStatementsQuickFix(separateLineLimit)
-        )
-        holder.registerProblem(problemDescriptor)
-    }
-}

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

@@ -1,53 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiExpressionStatement
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.util.PsiTreeUtil
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.JoinVarArgsContainsQuickFix
-
-class JoinVarArgsContainsInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Join arguments to variadic for contains()/containsOnlyOnce()/doesNotContain()"
-        private const val JOIN_VARARGS_MESSAGE = "Calls to same methods may be joined to variadic version"
-
-        private val MATCHERS = listOf(MethodNames.CONTAINS, MethodNames.CONTAINS_ONLY_ONCE, MethodNames.DOES_NOT_CONTAIN)
-            .map { CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, it) }
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) } ?: return
-
-                val allCalls = assertThatCall.collectMethodCallsUpToStatement().toList()
-
-                if (allCalls.find(COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY::test) != null) return
-
-                val onlyAssertionCalls = allCalls
-                    .filterNot(NOT_ACTUAL_ASSERTIONS::test)
-                    .toList()
-
-                for (methodMatcher in MATCHERS) {
-                    if (onlyAssertionCalls.count(methodMatcher::test) > 1) {
-                        val outmostMethodCall = statement.findOutmostMethodCall() ?: return
-                        val quickFix = JoinVarArgsContainsQuickFix(MATCHERS)
-                        val textRange = TextRange(assertThatCall.textLength, outmostMethodCall.textLength)
-                        holder.registerProblem(outmostMethodCall, textRange, JOIN_VARARGS_MESSAGE, quickFix)
-                        return
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,108 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemHighlightType
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.util.PsiTreeUtil
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.SwapActualAndExpectedExpressionMethodCallQuickFix
-
-class TwistedAssertionInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Twisted or suspicious actual and expected expressions"
-        private const val TWISTED_ACTUAL_AND_EXPECTED_MESSAGE = "Twisted actual and expected expressions in assertion"
-        private const val SWAP_ACTUAL_AND_EXPECTED_DESCRIPTION = "Swap actual and expected expressions in assertion"
-        private const val SWAP_ACTUAL_AND_EXPECTED_AND_REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() by %s() and swap actual and expected expressions"
-        private const val ACTUAL_IS_A_CONSTANT_MESSAGE = "Actual expression in assertThat() is a constant"
-
-        private val GENERIC_IS_EQUAL_TO = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, MethodNames.IS_EQUAL_TO).parameterCount(1)
-        private val GENERIC_IS_NOT_EQUAL_TO = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, MethodNames.IS_NOT_EQUAL_TO).parameterCount(1)
-        private val GENERIC_IS_SAME_AS = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, MethodNames.IS_SAME_AS).parameterCount(1)
-        private val GENERIC_IS_NOT_SAME_AS = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, MethodNames.IS_NOT_SAME_AS).parameterCount(1)
-        private val GENERIC_IS_GREATER_THAN = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN).parameterCount(1)
-        private val GENERIC_IS_GREATER_THAN_OR_EQUAL_TO =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN_OR_EQUAL_TO).parameterCount(1)
-        private val GENERIC_IS_LESS_THAN = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN).parameterCount(1)
-        private val GENERIC_IS_LESS_THAN_OR_EQUAL_TO =
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN_OR_EQUAL_TO).parameterCount(1)
-
-        private val STRING_IS_EQUAL_TO_IC = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO_IC).parameterCount(1)
-
-        private val STRING_REGEX_MATCHING = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, "matches", "doesNotMatch").parameterCount(1)
-
-        private val CALL_MATCHER_TO_REPLACEMENT_MAP = mapOf(
-            GENERIC_IS_EQUAL_TO to MethodNames.IS_EQUAL_TO,
-            GENERIC_IS_NOT_EQUAL_TO to MethodNames.IS_NOT_EQUAL_TO,
-            GENERIC_IS_SAME_AS to MethodNames.IS_SAME_AS,
-            GENERIC_IS_NOT_SAME_AS to MethodNames.IS_NOT_SAME_AS,
-            GENERIC_IS_GREATER_THAN to MethodNames.IS_LESS_THAN_OR_EQUAL_TO,
-            GENERIC_IS_GREATER_THAN_OR_EQUAL_TO to MethodNames.IS_LESS_THAN,
-            GENERIC_IS_LESS_THAN to MethodNames.IS_GREATER_THAN_OR_EQUAL_TO,
-            GENERIC_IS_LESS_THAN_OR_EQUAL_TO to MethodNames.IS_GREATER_THAN,
-
-            STRING_IS_EQUAL_TO_IC to MethodNames.IS_EQUAL_TO_IC,
-            CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO_IC).parameterCount(1)
-                    to MethodNames.IS_NOT_EQUAL_TO_IC
-        )
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) } ?: return
-                val actualExpression = assertThatCall.firstArg
-                actualExpression.calculateConstantValue() ?: return
-                val allCalls = assertThatCall.collectMethodCallsUpToStatement().toList()
-                val tooComplex = allCalls.find(USING_COMPARATOR::test) != null
-                var severity = ProblemHighlightType.GENERIC_ERROR_OR_WARNING
-                if (actualExpression.type is PsiClassType) {
-                    val psiManager = PsiManager.getInstance(statement.project)
-                    val javaLangClass = PsiType.getJavaLangClass(psiManager, GlobalSearchScope.allScope(statement.project))
-                    if (actualExpression.type!!.isAssignableFrom(javaLangClass)) {
-                        return
-                    }
-                }
-
-                if (!tooComplex) {
-                    val onlyAssertionCalls = allCalls
-                        .filterNot(NOT_ACTUAL_ASSERTIONS::test)
-                        .toList()
-                    if (onlyAssertionCalls.size == 1) {
-                        val expectedMethodCall = onlyAssertionCalls.first()
-                        if (STRING_REGEX_MATCHING.test(expectedMethodCall)) {
-                            return
-                        }
-                        if (expectedMethodCall.getArgOrNull(0)?.calculateConstantValue() == null) {
-                            val matchedMethod = CALL_MATCHER_TO_REPLACEMENT_MAP.asSequence().firstOrNull { it.key.test(expectedMethodCall) }
-                            if (matchedMethod != null) {
-                                val originalMethodName = getOriginalMethodName(expectedMethodCall)
-                                val replacementMethod = matchedMethod.value
-                                val description = if (originalMethodName == replacementMethod) {
-                                    SWAP_ACTUAL_AND_EXPECTED_DESCRIPTION
-                                } else {
-                                    SWAP_ACTUAL_AND_EXPECTED_AND_REPLACE_DESCRIPTION_TEMPLATE.format(originalMethodName, replacementMethod)
-                                }
-                                holder.registerProblem(
-                                    statement,
-                                    TWISTED_ACTUAL_AND_EXPECTED_MESSAGE,
-                                    SwapActualAndExpectedExpressionMethodCallQuickFix(description, replacementMethod)
-                                )
-                                return
-                            }
-                        } else {
-                            severity = ProblemHighlightType.WEAK_WARNING
-                        }
-                    }
-                }
-                holder.registerProblem(statement, ACTUAL_IS_A_CONSTANT_MESSAGE, severity)
-            }
-        }
-    }
-}

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

@@ -4,7 +4,6 @@ import com.intellij.codeInspection.LocalQuickFix
 
 abstract class AbstractCommonQuickFix(private val description: String) : LocalQuickFix {
 
-    override fun getName() = description
-
     override fun getFamilyName() = description
+
 }

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

@@ -1,23 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import de.platon42.intellij.plugins.cajon.qualifierExpression
-
-class DeleteMethodCallQuickFix(description: String) : AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val DELETE_METHOD_DESCRIPTION = "Delete unnecessary method calls"
-    }
-
-    override fun getFamilyName(): String {
-        return DELETE_METHOD_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val methodCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-
-        methodCallExpression.replace(methodCallExpression.qualifierExpression)
-    }
-}

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

@@ -8,13 +8,12 @@ import com.intellij.psi.util.PsiTreeUtil
 import de.platon42.intellij.plugins.cajon.*
 
 class ForGuavaPostFix {
-
     companion object {
         val REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT: (Project, ProblemDescriptor) -> Unit = exit@
         { _, descriptor ->
             val element = descriptor.startElement
             val statement = PsiTreeUtil.getParentOfType(element, PsiStatement::class.java) ?: return@exit
-            val assertThatCall = statement.findStaticMethodCall() ?: return@exit
+            val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return@exit
 
             val newMethodCall = createGuavaAssertThat(element, assertThatCall.firstArg)
             newMethodCall.resolveMethod()?.addAsStaticImport(element, AssertJClassNames.ASSERTIONS_CLASSNAME)

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

@@ -1,37 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import de.platon42.intellij.plugins.cajon.*
-
-class HasHashCodeQuickFix :
-    AbstractCommonQuickFix(HASHCODE_DESCRIPTION) {
-
-    companion object {
-        private const val HASHCODE_DESCRIPTION = "Replace calls to hashCode() with hasSameHashCodeAs()"
-    }
-
-    override fun getFamilyName(): String {
-        return HASHCODE_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
-
-        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
-
-        val methodsToFix = assertThatMethodCall.gatherAssertionCalls()
-
-        assertExpression.replace(assertExpression.qualifierExpression)
-
-        methodsToFix
-            .forEach {
-                val innerHashCodeObject = (it.firstArg as PsiMethodCallExpression).qualifierExpression
-                val expectedExpression = createExpectedMethodCall(it, "hasSameHashCodeAs", innerHashCodeObject)
-                expectedExpression.replaceQualifierFromMethodCall(it)
-                it.replace(expectedExpression)
-            }
-    }
-}

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

@@ -1,31 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiUnaryExpression
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
-
-class InvertUnaryExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val INVERT_CONDITION_DESCRIPTION = "Invert condition in isEqualTo()/isNotEqualTo() expressions"
-    }
-
-    override fun getFamilyName(): String {
-        return INVERT_CONDITION_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val methodCall = descriptor.startElement as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCall.firstArg as? PsiUnaryExpression ?: return
-        val operand = PsiUtil.skipParenthesizedExprDown(assertExpression.operand) ?: return
-
-        val expectedExpression = createExpectedMethodCall(assertExpression, replacementMethod, operand)
-        expectedExpression.replaceQualifierFromMethodCall(methodCall)
-        methodCall.replace(expectedExpression)
-    }
-}

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

@@ -1,37 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiUnaryExpression
-import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.*
-
-class InvertUnaryStatementQuickFix : AbstractCommonQuickFix(INVERT_CONDITION_DESCRIPTION) {
-
-    companion object {
-        private const val INVERT_CONDITION_DESCRIPTION = "Invert condition in assertThat()"
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
-        val assertExpression = assertThatMethodCall.firstArg as? PsiUnaryExpression ?: return
-        val operand = PsiUtil.skipParenthesizedExprDown(assertExpression.operand) ?: return
-        assertExpression.replace(operand)
-
-        var methodCall: PsiMethodCallExpression? = assertThatMethodCall
-        while (methodCall != null) {
-            val expectedResult = methodCall.getExpectedBooleanResult()
-            val nextMethodCall = PsiTreeUtil.getParentOfType(methodCall, PsiMethodCallExpression::class.java)
-            if (expectedResult != null) {
-                val replacementMethod = expectedResult.map(MethodNames.IS_FALSE, MethodNames.IS_TRUE)
-                val expectedExpression = createExpectedMethodCall(methodCall, replacementMethod)
-                expectedExpression.replaceQualifierFromMethodCall(methodCall)
-                methodCall.replace(expectedExpression)
-            }
-            methodCall = nextMethodCall
-        }
-    }
-}

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

@@ -1,79 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.*
-import com.intellij.psi.util.PsiTreeUtil
-import de.platon42.intellij.plugins.cajon.findStaticMethodCall
-import de.platon42.intellij.plugins.cajon.shortenAndReformat
-
-class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
-
-    companion object {
-        private const val JOIN_STATEMENTS_MESSAGE = "Join assertThat() statements"
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val firstStatement = descriptor.startElement as PsiExpressionStatement
-        val lastStatement = descriptor.endElement as PsiExpressionStatement
-
-        val expressionCount = countExpressions(firstStatement, lastStatement)
-        val addLineBreaks = (expressionCount > separateLineLimit)
-
-        do {
-            val commentsToKeep = ArrayList<PsiComment>()
-            val stuffToDelete = ArrayList<PsiElement>()
-            var previousStatement = lastStatement.prevSibling!!
-            while (previousStatement !is PsiExpressionStatement) {
-                if (previousStatement is PsiComment) {
-                    commentsToKeep.add(previousStatement.copy() as PsiComment)
-                }
-                stuffToDelete.add(previousStatement)
-                previousStatement = previousStatement.prevSibling!!
-            }
-            stuffToDelete.forEach { if (it.isValid) it.delete() }
-
-            val statementComments = PsiTreeUtil.getChildrenOfAnyType(previousStatement, PsiComment::class.java)
-            commentsToKeep.addAll(statementComments)
-
-            val assertThatCallOfCursorStatement = lastStatement.findStaticMethodCall()!!
-
-            val lastElementBeforeConcat = assertThatCallOfCursorStatement.parent
-            commentsToKeep.forEach {
-                lastElementBeforeConcat.addAfter(it, lastElementBeforeConcat.firstChild)
-                addLineBreak(project, lastElementBeforeConcat)
-            }
-            if (commentsToKeep.isEmpty() && addLineBreaks) {
-                addLineBreak(project, lastElementBeforeConcat)
-            }
-
-            val newLeaf = previousStatement.firstChild
-            assertThatCallOfCursorStatement.replace(newLeaf)
-            previousStatement.delete()
-        } while (previousStatement !== firstStatement)
-        val codeBlock = PsiTreeUtil.getParentOfType(lastStatement, PsiCodeBlock::class.java) ?: return
-        codeBlock.shortenAndReformat()
-    }
-
-    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")
-        lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
-    }
-
-    private fun countExpressions(firstStatement: PsiElement, lastStatement: PsiElement): Int {
-        var count = 0
-        var currentStatement = firstStatement
-        do {
-            while (currentStatement !is PsiExpressionStatement) {
-                currentStatement = currentStatement.nextSibling!!
-            }
-            count++
-            if (currentStatement === lastStatement) {
-                break
-            }
-            currentStatement = currentStatement.nextSibling!!
-        } while (true)
-        return count
-    }
-}

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

@@ -1,38 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-
-class JoinVarArgsContainsQuickFix(private val matchers: Iterable<CallMatcher>) : AbstractCommonQuickFix(JOIN_VARARGS_DESCRIPTION) {
-
-    companion object {
-        private const val JOIN_VARARGS_DESCRIPTION = "Join multiple arguments to variadic argument method calls"
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        var outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-
-        for (matcher in matchers) {
-            val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
-            val methodsToFix = assertThatMethodCall.gatherAssertionCalls()
-            val matchedCalls = methodsToFix.filter(matcher::test)
-            if (matchedCalls.size > 1) {
-                val mainCall = matchedCalls.first()
-                val args = mutableListOf(*mainCall.argumentList.expressions)
-                for (secondaryCall in matchedCalls.asSequence().drop(1)) {
-                    args.addAll(secondaryCall.argumentList.expressions)
-                }
-                val newMainCall = createExpectedMethodCall(mainCall, mainCall.methodExpression.qualifiedName, *args.toTypedArray())
-                newMainCall.replaceQualifierFromMethodCall(mainCall)
-                mainCall.replace(newMainCall)
-                for (secondaryCall in matchedCalls.asSequence().drop(1)) {
-                    val newQualifier = secondaryCall.qualifierExpression
-                    outmostCallExpression = secondaryCall.replace(newQualifier).findOutmostMethodCall() ?: return
-                }
-            }
-        }
-    }
-}

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

@@ -1,44 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiInstanceOfExpression
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.*
-
-class MoveOutInstanceOfExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val REMOVE_INSTANCEOF_DESCRIPTION = "Move instanceof in actual expressions out of assertThat()"
-    }
-
-    override fun getFamilyName(): String {
-        return REMOVE_INSTANCEOF_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
-        val assertExpression = assertThatMethodCall.firstArg as? PsiInstanceOfExpression ?: return
-        val expectedClass = assertExpression.checkType ?: return
-
-        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-            .filter { it.getExpectedBooleanResult() != null }
-            .toList()
-
-        val factory = JavaPsiFacade.getElementFactory(project)
-        val classObjectAccess = factory.createExpressionFromText("${expectedClass.type.canonicalText}.class", null)
-
-        val operand = PsiUtil.deparenthesizeExpression(assertExpression.operand) ?: return
-        assertExpression.replace(operand)
-
-        methodsToFix
-            .forEach {
-                val expectedExpression = createExpectedMethodCall(it, replacementMethod, classObjectAccess)
-                expectedExpression.replaceQualifierFromMethodCall(it)
-                it.replace(expectedExpression)
-            }
-    }
-}

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

@@ -1,82 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiExpression
-import com.intellij.psi.PsiMethodCallExpression
-import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-
-class MoveOutMethodCallExpressionQuickFix(
-    description: String,
-    private val replacementMethod: String,
-    private val useNullNonNull: Boolean = false,
-    private val noExpectedExpression: Boolean = false,
-    private val keepExpectedAsSecondArgument: Boolean = false,
-    private val replaceOnlyThisMethod: CallMatcher? = null,
-    private val replaceFromOriginalMethod: Boolean = false
-) :
-    AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val REMOVE_ACTUAL_EXPRESSION_DESCRIPTION = "Move method calls in actual expressions out of assertThat()"
-    }
-
-    override fun getFamilyName(): String {
-        return REMOVE_ACTUAL_EXPRESSION_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
-        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
-        val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy() as PsiExpression?
-
-        when {
-            replaceOnlyThisMethod != null -> {
-                val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-                    .filter(replaceOnlyThisMethod::test)
-                    .toList()
-
-                assertExpression.replace(assertExpression.qualifierExpression)
-
-                methodsToFix
-                    .forEach {
-                        val expectedExpression = createExpectedMethodCall(
-                            it,
-                            replacementMethod,
-                            *if (replaceFromOriginalMethod || noExpectedExpression) listOfNotNull(assertExpressionArg).toTypedArray() else it.argumentList.expressions
-                        )
-                        expectedExpression.replaceQualifierFromMethodCall(it)
-                        it.replace(expectedExpression)
-                    }
-            }
-            keepExpectedAsSecondArgument -> {
-                assertExpressionArg ?: return
-                val secondArg =
-                    if (useNullNonNull) JavaPsiFacade.getElementFactory(project).createExpressionFromText("null", null) else outmostCallExpression.getArgOrNull(0)?.copy() ?: return
-
-                assertExpression.replace(assertExpression.qualifierExpression)
-
-                val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, assertExpressionArg, secondArg)
-                expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression)
-                outmostCallExpression.replace(expectedExpression)
-            }
-            else -> {
-                val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-                    .filter { (if (useNullNonNull) it.getExpectedNullNonNullResult() else it.getExpectedBooleanResult()) != null }
-                    .toList()
-
-                assertExpression.replace(assertExpression.qualifierExpression)
-
-                methodsToFix
-                    .forEach {
-                        val expectedExpression = createExpectedMethodCall(it, replacementMethod, *listOfNotNull(assertExpressionArg).toTypedArray())
-                        expectedExpression.replaceQualifierFromMethodCall(it)
-                        it.replace(expectedExpression)
-                    }
-            }
-        }
-    }
-}

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

@@ -9,10 +9,6 @@ class QuickFixWithPostfixDelegate(
     private val postfix: (Project, ProblemDescriptor) -> Unit
 ) : LocalQuickFix by mainFix {
 
-    override fun getName(): String {
-        return mainFix.name
-    }
-
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         mainFix.applyFix(project, descriptor)
         postfix(project, descriptor)

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

@@ -11,29 +11,16 @@ class RemoveActualOutmostMethodCallQuickFix(
     private val noExpectedExpression: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
-    companion object {
-        private const val REMOVE_ACTUAL_EXPRESSION_DESCRIPTION = "Remove method calls in actual expressions and use better assertion"
-    }
-
-    override fun getFamilyName(): String {
-        return REMOVE_ACTUAL_EXPRESSION_DESCRIPTION
-    }
-
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val element = descriptor.startElement
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
+        val assertExpression = methodCallExpression.firstArg as? PsiMethodCallExpression ?: return
-
-        val methodsToFix = assertThatMethodCall.gatherAssertionCalls()
-
         assertExpression.replace(assertExpression.qualifierExpression)
 
-        methodsToFix
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-            .forEach {
+        val args = if (noExpectedExpression) emptyArray() else oldExpectedExpression.argumentList.expressions
-                val args = if (noExpectedExpression) emptyArray() else it.argumentList.expressions
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
-                val expectedExpression = createExpectedMethodCall(it, replacementMethod, *args)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-                expectedExpression.replaceQualifierFromMethodCall(it)
+        oldExpectedExpression.replace(expectedExpression)
-                it.replace(expectedExpression)
-            }
     }
 }

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

@@ -8,15 +8,7 @@ import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
 import de.platon42.intellij.plugins.cajon.firstArg
 import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
 
-class UnwrapExpectedStaticMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+class RemoveExpectedOutmostMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION = "Unwrap expected expressions and use better assertion"
-    }
-
-    override fun getFamilyName(): String {
-        return REMOVE_EXPECTED_OUTMOST_DESCRIPTION
-    }
 
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement

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

@@ -1,35 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiExpression
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiReferenceExpression
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.qualifierExpression
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
-
-class ReplaceHasSizeMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val methodCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-
-        replaceCollectionAndMapSizeOrArrayLength(methodCallExpression.firstArg)
-
-        val expectedExpression = createExpectedMethodCall(methodCallExpression, replacementMethod, methodCallExpression.firstArg)
-
-        expectedExpression.replaceQualifierFromMethodCall(methodCallExpression)
-        methodCallExpression.replace(expectedExpression)
-    }
-
-    private fun replaceCollectionAndMapSizeOrArrayLength(assertExpression: PsiExpression) {
-        assertExpression.replace(
-            when (assertExpression) {
-                is PsiReferenceExpression -> assertExpression.qualifierExpression!!
-                is PsiMethodCallExpression -> assertExpression.qualifierExpression
-                else -> return
-            }
-        )
-    }
-}

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

@@ -1,51 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiBlockStatement
-import com.intellij.psi.PsiDeclarationStatement
-import com.intellij.psi.PsiIfStatement
-import de.platon42.intellij.plugins.cajon.*
-
-class ReplaceIfByAssumeThatQuickFix(private val removeElse: Boolean) : AbstractCommonQuickFix(REPLACE_IF_MESSAGE) {
-
-    companion object {
-        private const val REPLACE_IF_MESSAGE = "Replace if statement by assumeTrue()"
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val ifStatement = descriptor.startElement as PsiIfStatement
-
-        val condition = ifStatement.condition ?: return
-        val factory = JavaPsiFacade.getElementFactory(ifStatement.project)
-        val assumptionExpression = if (removeElse) MethodNames.IS_TRUE else MethodNames.IS_FALSE
-        val assumeThatStatement = factory.createStatementFromText(
-            "${AssertJClassNames.ASSUMPTIONS_CLASSNAME}.${MethodNames.ASSUME_THAT}(true).$assumptionExpression();",
-            ifStatement
-        )
-        val assumeThatMethodCall = assumeThatStatement.findStaticMethodCall() ?: return
-        assumeThatMethodCall.firstArg.replace(condition)
-        assumeThatMethodCall.resolveMethod()?.addAsStaticImport(ifStatement)
-
-        val branchToKeep = (if (removeElse) ifStatement.thenBranch else ifStatement.elseBranch)?.copy()
-        val parentBlock = ifStatement.parent
-        if (branchToKeep != null) {
-            val anchorElement = ifStatement.nextSibling
-            if (branchToKeep is PsiBlockStatement) {
-                val codeBlock = branchToKeep.codeBlock
-                if (codeBlock.statements.isNotEmpty()) {
-                    val hasDeclarations = codeBlock.statements.any { it is PsiDeclarationStatement }
-                    if (hasDeclarations) {
-                        parentBlock.addAfter(branchToKeep, anchorElement)
-                    } else {
-                        parentBlock.addRangeAfter(codeBlock.firstBodyElement, codeBlock.lastBodyElement, anchorElement)
-                    }
-                }
-            } else {
-                parentBlock.addAfter(branchToKeep, anchorElement)
-            }
-        }
-        ifStatement.replace(assumeThatStatement).shortenAndReformat()
-    }
-}

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

@@ -10,21 +10,13 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSE
 class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean) :
     AbstractCommonQuickFix(description) {
 
-    companion object {
-        private const val CONVERT_DESCRIPTION = "Convert JUnit assertions to assertJ"
-    }
-
-    override fun getFamilyName(): String {
-        return CONVERT_DESCRIPTION
-    }
-
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement
         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 (expectedExpression, messageExpression) = if (noExpectedExpression) {
             val message = args.expressions.getOrNull(count - 2)
             emptyArray<PsiExpression>() to message
         } else {
@@ -33,15 +25,8 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
             arrayOf(expected) to message
         }
 
-        val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, *expectedExpression)
-                && (actualExpression.calculateConstantValue() != null))
+        val newMethodCall = createAssertThat(element, actualExpression)
-        val (expectedMethodCall, newMethodCall) = if (swapActualAndExpected) {
-            createExpectedMethodCall(element, replacementMethod, actualExpression) to
-                    createAssertThat(element, expectedExpressions.single())
-        } else {
-            createExpectedMethodCall(element, replacementMethod, *expectedExpressions) to
-                    createAssertThat(element, actualExpression)
-        }
 
         if (messageExpression != null) {
             val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)

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

@@ -1,41 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-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) :
-    AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val CONVERT_DESCRIPTION = "Convert JUnit assumptions to assertJ"
-    }
-
-    override fun getFamilyName(): String {
-        return CONVERT_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        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 expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
-        val newMethodCall = createAssumeThat(element, actualExpression)
-
-        if (messageExpression != null) {
-            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
-            asExpression.replaceQualifier(newMethodCall)
-            expectedMethodCall.replaceQualifier(asExpression)
-        } else {
-            expectedMethodCall.replaceQualifier(newMethodCall)
-        }
-
-        newMethodCall.resolveMethod()?.addAsStaticImport(element)
-        element.replace(expectedMethodCall).shortenAndReformat()
-    }
-}

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

@@ -8,14 +8,6 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSE
 
 class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
 
-    companion object {
-        private const val CONVERT_DESCRIPTION = "Convert JUnit assertions with delta to assertJ"
-    }
-
-    override fun getFamilyName(): String {
-        return CONVERT_DESCRIPTION
-    }
-
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
@@ -27,16 +19,8 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
         val deltaExpression = args.expressions[count - 1] ?: return
 
         val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
-
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall)
-        val swapActualAndExpected = ((expectedExpression.calculateConstantValue() == null)
+        val newMethodCall = createAssertThat(element, actualExpression)
-                && (actualExpression.calculateConstantValue() != null))
-        val (expectedMethodCall, newMethodCall) = if (swapActualAndExpected) {
-            createExpectedMethodCall(element, replacementMethod, actualExpression, offsetMethodCall) to
-                    createAssertThat(element, expectedExpression)
-        } else {
-            createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall) to
-                    createAssertThat(element, actualExpression)
-        }
 
         if (messageExpression != null) {
             val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)

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

@@ -6,15 +6,10 @@ import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
 import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
 
-class ReplaceSimpleMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+class ReplaceSimpleMethodCallQuickFix(
-
+    description: String,
-    companion object {
+    private val replacementMethod: String
-        private const val REPLACE_DESCRIPTION = "Replace methods by better ones"
+) : AbstractCommonQuickFix(description) {
-    }
-
-    override fun getFamilyName(): String {
-        return REPLACE_DESCRIPTION
-    }
 
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement

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

@@ -14,32 +14,25 @@ class ReplaceSizeMethodCallQuickFix(
     private val expectedIsCollection: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
-    companion object {
-        private const val REPLACE_DESCRIPTION = "Replace methods by better ones"
-    }
-
-    override fun getFamilyName(): String {
-        return REPLACE_DESCRIPTION
-    }
-
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val element = descriptor.startElement
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = assertThatMethodCall.firstArg
+        val assertExpression = methodCallExpression.firstArg
-        replaceCollectionAndMapSizeOrArrayLength(assertExpression)
+        replaceCollectionSizeOrArrayLength(assertExpression)
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
 
         if (expectedIsCollection) {
-            replaceCollectionAndMapSizeOrArrayLength(outmostCallExpression.firstArg)
+            replaceCollectionSizeOrArrayLength(oldExpectedExpression.firstArg)
         }
 
-        val args = if (noExpectedExpression) emptyArray() else arrayOf(outmostCallExpression.firstArg)
+        val args = if (noExpectedExpression) emptyArray() else arrayOf(oldExpectedExpression.firstArg)
-        val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, *args)
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
 
-        expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        outmostCallExpression.replace(expectedExpression)
+        oldExpectedExpression.replace(expectedExpression)
     }
 
-    private fun replaceCollectionAndMapSizeOrArrayLength(assertExpression: PsiExpression) {
+    private fun replaceCollectionSizeOrArrayLength(assertExpression: PsiExpression) {
         assertExpression.replace(
             when (assertExpression) {
                 is PsiReferenceExpression -> assertExpression.qualifierExpression!!

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

@@ -4,7 +4,10 @@ import com.intellij.codeInspection.ProblemDescriptor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiBinaryExpression
 import com.intellij.psi.PsiMethodCallExpression
-import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
 
 class SplitBinaryExpressionMethodCallQuickFix(
     description: String,
@@ -13,33 +16,17 @@ class SplitBinaryExpressionMethodCallQuickFix(
     private val noExpectedExpression: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
-    companion object {
-        private const val SPLIT_EXPRESSION_DESCRIPTION = "Split binary expressions out of assertThat()"
-    }
-
-    override fun getFamilyName(): String {
-        return SPLIT_EXPRESSION_DESCRIPTION
-    }
-
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val element = descriptor.startElement
-        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-
+        val binaryExpression = methodCallExpression.firstArg as? PsiBinaryExpression ?: return
-        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-            .filter { it.getExpectedBooleanResult() != null }
-            .toList()
-
-        val binaryExpression = assertThatMethodCall.firstArg as? PsiBinaryExpression ?: return
         val expectedArgument = (if (pickRightOperand) binaryExpression.lOperand else binaryExpression.rOperand)?.copy() ?: return
         binaryExpression.replace(if (pickRightOperand) binaryExpression.rOperand!! else binaryExpression.lOperand)
 
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
         val args = if (noExpectedExpression) emptyArray() else arrayOf(expectedArgument)
-
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
-        methodsToFix
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-            .forEach {
+        oldExpectedExpression.replace(expectedExpression)
-                val expectedExpression = createExpectedMethodCall(it, replacementMethod, *args)
-                expectedExpression.replaceQualifierFromMethodCall(it)
-                it.replace(expectedExpression)
-            }
     }
 }

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

@@ -0,0 +1,22 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.*
+
+class SplitEqualsExpressionMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val equalsMethodCall = methodCallExpression.firstArg as? PsiMethodCallExpression ?: return
+        val expectedArgument = equalsMethodCall.firstArg.copy()
+        equalsMethodCall.replace(equalsMethodCall.qualifierExpression)
+
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, expectedArgument)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}

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

@@ -1,34 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import de.platon42.intellij.plugins.cajon.*
-
-class SwapActualAndExpectedExpressionMethodCallQuickFix(
-    description: String,
-    private val replacementMethod: String
-) : AbstractCommonQuickFix(description) {
-
-    companion object {
-        private const val SPLIT_EXPRESSION_DESCRIPTION = "Swap actual and expected expressions of assertions"
-    }
-
-    override fun getFamilyName(): String {
-        return SPLIT_EXPRESSION_DESCRIPTION
-    }
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val assertThatMethodCall = descriptor.startElement.findStaticMethodCall() ?: return
-
-        val methodToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-            .filterNot(NOT_ACTUAL_ASSERTIONS::test)
-            .first()
-
-        val oldActualExpression = assertThatMethodCall.firstArg.copy()!!
-        assertThatMethodCall.firstArg.replace(methodToFix.firstArg)
-
-        val expectedExpression = createExpectedMethodCall(methodToFix, replacementMethod, oldActualExpression)
-        expectedExpression.replaceQualifierFromMethodCall(methodToFix)
-        methodToFix.replace(expectedExpression)
-    }
-}

src/main/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributor.kt

@@ -1,19 +1,27 @@
 package de.platon42.intellij.plugins.cajon.references
 
+import com.intellij.lang.jvm.JvmModifier
 import com.intellij.openapi.util.TextRange
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.psi.*
 import com.intellij.psi.util.PropertyUtilBase
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.PsiTypesUtil
-import com.intellij.util.ArrayUtil
 import com.intellij.util.ProcessingContext
 import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.AssertJClassNames
+import de.platon42.intellij.plugins.cajon.CORE_ASSERT_THAT_MATCHER
+import de.platon42.intellij.plugins.cajon.firstArg
 
 class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     companion object {
+
+        private val EXTRACTING_FROM_OBJECT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME, "extracting")
+        private val EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extracting")
+        private val FLAT_EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "flatExtracting")
+        private val EXTRACTING_RESULT_OF_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extractingResultOf")
+
         private val BY_NAME = CallMatcher.staticCall(AssertJClassNames.EXTRACTORS_CLASSNAME, "byName")
         private val RESULT_OF = CallMatcher.staticCall(AssertJClassNames.EXTRACTORS_CLASSNAME, "resultOf")
             .parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
@@ -29,7 +37,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
             val matchedGetter = PropertyUtilBase.findPropertyGetter(containingClass, partName, false, true)
             val fieldResult = PropertyUtilBase.findPropertyField(containingClass, partName, false)
             val textRange = TextRange(startOffset + 1, nextOffset)
-            val matchedBareMethod = containingClass.allMethods.find { (it.name == partName) && !it.hasModifierProperty(PsiModifier.STATIC) }
+            val matchedBareMethod = containingClass.allMethods.find { (it.name == partName) && !it.hasModifier(JvmModifier.STATIC) }
             val targets = listOfNotNull<PsiElement>(fieldResult, matchedGetter, matchedBareMethod)
             if (targets.isNotEmpty()) {
                 val results = listOf(textRange to targets)
@@ -43,21 +51,24 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
         }
 
         private fun lookupMethod(containingClass: PsiClass, methodName: String): List<Pair<TextRange, List<PsiElement>>>? {
-            val matchedMethod = containingClass.allMethods.find { (it.name == methodName) && !it.hasModifierProperty(PsiModifier.STATIC) } ?: return null
+            val matchedMethod = containingClass.allMethods.find { (it.name == methodName) && !it.hasModifier(JvmModifier.STATIC) } ?: return null
             val textRange = TextRange(1, methodName.length + 1)
             return listOf(textRange to listOf(matchedMethod))
         }
 
         private fun findActualType(element: PsiElement): PsiClassType? {
-            val assertThatCall = element.findStaticMethodCall()
+            val assertThatCall = PsiTreeUtil.findChildrenOfType(element, PsiMethodCallExpression::class.java)
-            return assertThatCall?.firstArg?.type as? PsiClassType
+                .find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return null
+            return assertThatCall.firstArg.type as? PsiClassType
         }
 
         private fun findAndCreateReferences(element: PsiElement, finder: (PsiLiteralExpression) -> List<Pair<TextRange, List<PsiElement>>>?): Array<PsiReference> {
             val literal = element as PsiLiteralExpression
-            val results = finder(literal) ?: return PsiReference.EMPTY_ARRAY
+            val results = finder(literal)
-
+            if (results != null) {
-            return results.map { ExtractorReference(literal, it.first, it.second) }.toTypedArray()
+                return results.map { ExtractorReference(literal, it.first, it.second) }.toTypedArray()
+            }
+            return PsiReference.EMPTY_ARRAY
         }
     }
 
@@ -70,11 +81,6 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
     class ExtractorReference(literal: PsiLiteralExpression, range: TextRange, private val targets: List<PsiElement>) :
         PsiPolyVariantReferenceBase<PsiLiteralExpression>(literal, range, true) {
 
-        // Do not remove due to compatibility issue with IDEA <= 2018.2
-        override fun getVariants(): Array<Any> {
-            return ArrayUtil.EMPTY_OBJECT_ARRAY
-        }
-
         override fun resolve(): PsiElement? {
             return multiResolve(false).map(ResolveResult::getElement).firstOrNull()
         }
@@ -86,7 +92,9 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class PropertyOrFieldReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            return findAndCreateReferences(element, ::findReferences)
+        }
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
@@ -108,7 +116,9 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class IterablePropertyOrFieldReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            return findAndCreateReferences(element, ::findReferences)
+        }
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
@@ -121,10 +131,10 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
                 isResultOf = true
             }
 
-            if (!CallMatcher.anyOf(EXTRACTING_FROM_ITERABLE, FLAT_EXTRACTING_FROM_ITERABLE).test(methodCallExpression)) return null
+            if (!CallMatcher.anyOf(EXTRACTING_FROM_ITERABLE, FLAT_EXTRACTING_FROM_ITERABLE).test(methodCallExpression)) {
-
+                return null
+            }
             val iterableType = findActualType(methodCallExpression) ?: return null
-            if (iterableType.parameters.isEmpty()) return null
             val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
             val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null
             return if (isResultOf) lookupMethod(containingClass, literal) else lookupFieldOrProperty(containingClass, literal, 0)
@@ -133,13 +143,16 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class IterableResultOfReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            return findAndCreateReferences(element, ::findReferences)
+        }
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
             val methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression::class.java) ?: return null
-            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) return null
+            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) {
-
+                return null
+            }
             val iterableType = findActualType(methodCallExpression) ?: return null
             val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
             val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null

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

@@ -1,19 +1,20 @@
 <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">Platon42</vendor>
 
     <description><![CDATA[
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
-    It adds several <b>inspections and quick fixes</b> to fully use the fluent assertion methods
+    It adds inspections and quick fixes to fully make use of the AssertJ methods
-    and thus makes the intention clear and concise, also generating better messages on test failures.
+    to make the intention clear and concise. It can also convert JUnit 4 assertions to AssertJ.
-    It can also be used to <b>convert JUnit 4 assertions and assumptions to AssertJ</b>.
+    It supports referencing inside extracting()-methods with strings, adding refactoring safety.
-    It supports <b>referencing inside extracting</b>()-methods with strings, adding refactoring safety.
-    <b>Bogus or twisted assertions</b> are also reported.
-    <p>
-    <a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
     ]]></description>
 
+    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
+    <idea-version since-build="173.2290.1"/>
+
+    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
+         on how to target different products -->
     <depends>com.intellij.modules.lang</depends>
     <depends>com.intellij.modules.platform</depends>
     <depends>com.intellij.modules.java</depends>
@@ -22,14 +23,8 @@
         <psi.referenceContributor implementation="de.platon42.intellij.plugins.cajon.references.ExtractorReferenceContributor"/>
         <localInspection groupPath="Java" shortName="AssertThatObjectIsNullOrNotNull" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNullOrNotNullInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatBooleanCondition" enabledByDefault="true" level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatBooleanIsTrueOrFalse" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanConditionInspection"/>
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanIsTrueOrFalseInspection"/>
-        <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"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringIsEmptyInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true" level="WARNING"
@@ -38,45 +33,18 @@
         <localInspection groupPath="Java" shortName="AssertThatSize" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatSizeInspection"/>
 
-        <localInspection groupPath="Java" shortName="AssertThatBinaryExpression" enabledByDefault="true" level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatBinaryExpressionIsTrueOrFalse" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionInspection"/>
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionIsTrueOrFalseInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatObjectExpression" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectExpressionInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatComparable" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatComparableInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatStringExpression" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringExpressionInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatCollectionOrMapExpression" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatCollectionOrMapExpressionInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatFileExpression" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatFileExpressionInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatPathExpression" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatPathExpressionInspection"/>
-
-        <localInspection groupPath="Java" shortName="JoinAssertThatStatements" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinAssertThatStatementsInspection"/>
-        <localInspection groupPath="Java" shortName="JoinVarArgsContains" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinVarArgsContainsInspection"/>
-        <localInspection groupPath="Java" shortName="AssumeThatInsteadOfReturn" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssumeThatInsteadOfReturnInspection"/>
 
         <localInspection groupPath="Java" shortName="AssertThatJava8Optional" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatJava8OptionalInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatGuavaOptional" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatGuavaOptionalInspection"/>
 
-        <localInspection groupPath="Java" shortName="ImplicitAssertion" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.ImplicitAssertionInspection"/>
-
-        <localInspection groupPath="Java" shortName="TwistedAssertion" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.TwistedAssertionInspection"/>
-        <localInspection groupPath="Java" shortName="BogusAssertion" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.BogusAssertionInspection"/>
-
         <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.JUnitAssertToAssertJInspection"/>
     </extensions>
 
     <actions>
     </actions>
-</idea-plugin>
+</idea-plugin>

src/main/resources/inspectionDescriptions/AssertThatBinaryExpressionIsTrueOrFalse.html

@@ -4,6 +4,7 @@ Turns a binary expression in the kind of assertThat(actual <operator> expe
 into assertThat(actual).is<operator>(expected).
 <!-- tooltip end -->
 There are over 150 combinations that are found with this inspections.
+It also detects assertThat(actual.equals(expected)) assertions.
 Also works with constant expressions on the expected side.
 Swaps actual and expected when actual is a constant expression (correctly transforming the used operator).
 </body>

src/main/resources/inspectionDescriptions/AssertThatBooleanIsTrueOrFalse.html

@@ -2,6 +2,6 @@
 <body>
 Turns assertThat(condition).isEqualTo(true/false) into assertThat(condition).isTrue()/isFalse().
 <!-- tooltip end -->
-<br>Also works with constant expressions and Boolean.TRUE/FALSE.
+Also works with constant expressions and Boolean.TRUE/FALSE.
 </body>
 </html>

src/main/resources/inspectionDescriptions/AssertThatCollectionOrMapExpression.html

@@ -1,18 +0,0 @@
-<html>
-<body>
-Turns assertThat(collectionOrMap.someMethod(arg)).isTrue/isFalse() into assertThat(collectionOrMap).someMethod(arg) and
-assertThat(map.get(key)).isEqualTo/isNotEqualTo(value) into assertThat(map).containsEntry(key, value).
-<!-- tooltip end -->
-<br>someMethod() can be isEmpty(), contains(), and containsAll() for collections and
-isEmpty(), containsKey(), and containsValue() for maps.
-get() may be transformed into containsKey(), doesNotContainKey(), containsEntry() or doesNotContainEntry().
-<br>
-If you are using degenerated maps in your project that may contain null values (i.e.
-map.contains(key) == true AND map.get(key) == null
-is valid for some entries in your map), the default behavior of the quickfix
-assertThat(map.get(key)).isNull() turning into assertThat(map).doesNotContainKey(key)
-is not an equivalent transformation. The settings below can change this behavior to instead transform it into
-assertThat(map).containsEntry(key, null) for those cases, create both quickfix choices or simply ignore this
-case altogether (if in doubt).
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatComparable.html

@@ -1,5 +0,0 @@
-<html>
-<body>
-Turns assertThat(obj1.compareTo(obj2)) into assertThat(obj1).someMethod(obj2).
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html

@@ -1,6 +1,6 @@
 <html>
 <body>
-Turns assertThat(enumerable).hasSize(0) and similar into assertThat(enumerable).isEmpty() or .isNotEmpty().
+Turns assertThat(enumerable).hasSize(0) into assertThat(enumerable).isEmpty().
 <!-- tooltip end -->
 <br>Works with anything that is enumerable such as arrays, iterables, collections, etc.
 </body>

src/main/resources/inspectionDescriptions/AssertThatFileExpression.html

@@ -1,8 +0,0 @@
-<html>
-<body>
-Operates on assertions on objects of type File. Turns assertThat(file.someMethod(arg)).someAssertion() into assertThat(file).someMethod(arg).
-<!-- tooltip end -->
-<br>someMethod() can be canRead(), canWrite(), exists(), isAbsolute(), isDirectory(), isFile(),
-getName(), getParent(), getParentFile(), list() and listFiles().
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatGuavaOptional.html

@@ -3,6 +3,6 @@
 Looks at expected and actual expression being of Guava Optional type and whether the statement effectively tries to assert the
 presence, absence or content and then replaces the statement by isPresent(), isAbsent(), or contains().
 <!-- tooltip end -->
-<br>Requires AssertJ-Guava to be in classpath.
+Requires AssertJ-Guava to be in classpath.
 </body>
 </html>

src/main/resources/inspectionDescriptions/AssertThatInstanceOf.html

@@ -1,7 +0,0 @@
-<html>
-<body>
-Turns assertThat(object instanceof classname).isEqualTo(true/false) into assertThat(object).is(Not)InstanceOf(classname.class).
-<!-- tooltip end -->
-<br>Also works with constant expressions and Boolean.TRUE/FALSE.
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatInvertedBooleanCondition.html

@@ -1,7 +0,0 @@
-<html>
-<body>
-Turns assertThat(!condition).isEqualTo(true/false) into assertThat(condition).isFalse()/isTrue() and negates .is(Not)EqualTo(!var).
-<!-- tooltip end -->
-<br>Also works with constant expressions and Boolean.TRUE/FALSE.
-</body>
-</html>

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/main/resources/inspectionDescriptions/AssertThatObjectExpression.html

@@ -1,9 +0,0 @@
-<html>
-<body>
-Tries to simplify Object method calls such as toString, hashCode() and equals().
-<!-- tooltip end -->
-<br>Turns assertThat(object.toString()).isEqualTo(expression) into assertThat(object).hasToString(expression).
-<br>Turns assertThat(object.hashCode()).isEqualTo(otherObject.hashCode()) into assertThat(object).hasSameHashCodeAs(otherObject).
-<br>Turns assertThat(object.equals(otherObject)).isEqualTo(true) into assertThat(object).isEqualTo(otherObject) (and variations).
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatPathExpression.html

@@ -1,7 +0,0 @@
-<html>
-<body>
-Operates on assertions on objects of type Path. Turns assertThat(file.someMethod(arg)).someAssertion() into assertThat(path).someMethod(arg).
-<!-- tooltip end -->
-<br>someMethod() can be isAbsolute(), getParent(), startsWith() and endsWith().
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatSize.html

@@ -1,7 +1,6 @@
 <html>
 <body>
-Makes assertions on sizes of arrays, collections, maps, strings, or CharSequences more concise by replacing them with isEmpty(), isNotEmpty(), hasSize(), or hasSameSizeAs().
+Makes assertions on sizes of arrays or collections more concise by replacing them with isEmpty(), isNotEmpty(), hasSize(), or hasSameSizeAs().
 <!-- tooltip end -->
-<br>Several more conversions are available with AssertJ 3.12.0 or later.
 </body>
 </html>

src/main/resources/inspectionDescriptions/AssertThatStringExpression.html

@@ -1,8 +0,0 @@
-<html>
-<body>
-Turns assertThat(string.someMethod(arg)).isTrue/isFalse() into assertThat(string).someMethod(arg).
-<!-- tooltip end -->
-<br>someMethod() can be isEmpty(), equals(), equalsIgnoreCase(), contentEquals(), contains(), startsWith(), endsWith(),
-matches(), compareToIgnoreCase(), indexOf(), and trim().
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssumeThatInsteadOfReturn.html

@@ -1,18 +0,0 @@
-<html>
-<body>
-Tries to detect bogus uses of return statements in test methods and replaces them by assumeThat() calls.
-<!-- tooltip end -->
-<br>
-Novices will use these to skip test execution by bailing out early on some preconditions not met.
-However, this suggests that the test has actually been run and passed instead of showing the test
-as being skipped.
-<p>Return statements in if statements in main test methods
-    (must be annotated with JUnit 4 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.
-</p>
-<p>Currently, the quickfix may lose some comments during operation. The other branch of the if statement
-    will be inlined (blocks with declarations will remain a code block due to variable scope).</p>
-</body>
-</html>

src/main/resources/inspectionDescriptions/BogusAssertion.html

@@ -1,6 +0,0 @@
-<html>
-<body>
-Finds typical copy and paste errors where the assertion will never fail, such as assertThat(foo).isEqualTo(foo), because actual
-and expected expressions are the same.
-</body>
-</html>

src/main/resources/inspectionDescriptions/ImplicitAssertion.html

@@ -1,8 +0,0 @@
-<html>
-<body>
-Finds assertion method calls that are already implicitly covered by prior assertions.
-<!-- tooltip end -->
-This works for isNotNull(), isNotEmpty() and isPresent(). It does not cover all edge cases, such as .isNotNull().isNullOrEmpty()
-or comparing against non-null literals and is conservative to not eliminate legitimate assertions.
-</body>
-</html>

src/main/resources/inspectionDescriptions/JUnitAssertToAssertJ.html

@@ -1,12 +1,10 @@
 <html>
 <body>
-Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
+Tries to convert most of the JUnit 4 assertions to AssertJ-Format.
 <!-- tooltip end -->
 <br>Works for assertTrue(), assertFalse(), assertNull(), assertNotNull(), assertEquals(), assertNotEquals(), assertSame() assertNotSame(), assertArrayEquals().
 Copes with variants with message and without, handles special versions for double and float types (including arrays).
-Also converts assumeTrue(), assumeFalse(), assumeNotNull(), assumeNoException() to assumeThat().
+<p></p>
-<p>
+Does not support Hamcrest-Matchers. If you need that kind of conversion, you might want to check out the Assertions2AssertJ plugin by Ric Emery.
-    Does not support Hamcrest-Matchers. If you need that kind of conversion, you might want to check out the Assertions2AssertJ plugin by Ric Emery.
-</p>
 </body>
 </html>

src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html

@@ -1,10 +0,0 @@
-<html>
-<body>
-Joins consecutive assertThat() statements with the same actual expression together.
-<!-- tooltip end -->
-<br>If the AssertThat()-Statement contains .extracting() methods, they will not be joined.
-<br>During joining multiple statements, line breaks may be added to avoid too long lines. The number of statements to join without
-adding line breaks can be configured.
-<br>Also retains comments during operation and forces a line break for these cases.
-</body>
-</html>

src/main/resources/inspectionDescriptions/JoinVarArgsContains.html

@@ -1,11 +0,0 @@
-<html>
-<body>
-Finds assertions where multiple .contains(), .containsOnlyOnce() or .doesNotContain() are
-used in a single statement that could be joined together.
-<!-- tooltip end -->
-Only works when variadic arguments are possible and will not be performed on more complex
-statements with .extracting() or .as() to avoid changing semantics.
-<br>
-Note that the quickfix does not handle comments very well and might remove them during the operation.
-</body>
-</html>

src/main/resources/inspectionDescriptions/TwistedAssertion.html

@@ -1,7 +0,0 @@
-<html>
-<body>
-Finds assertion method calls that have the expected and actual expressions twisted, such as assertThat(5).isEqualTo(foo).
-<!-- tooltip end -->
-For some obvious cases, a quickfix to swap the actual and expected expressions is provided.
-</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.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,169 @@
+package de.platon42.intellij.jupiter;
+
+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.ModifiableRootModel;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.testFramework.LightProjectDescriptor;
+import com.intellij.testFramework.PsiTestUtil;
+import com.intellij.testFramework.UsefulTestCase;
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
+import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
+import org.jetbrains.annotations.NotNull;
+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.Parameter;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.logging.Logger;
+import java.util.stream.Stream;
+
+public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback {
+
+    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()));
+    }
+
+    private static class LightCodeInsightFixtureTestCaseWrapper extends LightCodeInsightFixtureTestCase {
+        private final ExtensionContext extensionContext;
+
+        private LightCodeInsightFixtureTestCaseWrapper(ExtensionContext extensionContext) {
+            this.extensionContext = extensionContext;
+        }
+
+        @Override
+        public void setUp() throws Exception {
+            super.setUp();
+        }
+
+        @Override
+        public void tearDown() throws Exception {
+            super.tearDown();
+            UsefulTestCase.clearFields(this);
+            if (myFixture != null && getProject() != null && !getProject().isDisposed()) {
+                Disposer.dispose(getProject());
+            }
+        }
+
+        @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 methodOrClassAnnotation = getMethodOrClassAnnotation(AddLocalJarToModule.class);
+                    if (methodOrClassAnnotation != null) {
+                        Stream.of(methodOrClassAnnotation.value()).forEach(it -> addJarContaining(model, it));
+                    }
+                }
+            };
+        }
+
+        protected 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);
+            }
+        }
+
+        @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;
+        }
+    }
+}

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)