Add support for converting JUnit 5 tests to AssertJ

Upgraded kotlin to 1.4.10.
Upgraded assertj to 3.17.2.
Upgraded junit-jupiter to 5.7.0.
Other minor upgrades.

.idea/saveactions_settings.xml

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

.travis.yml

@@ -1,6 +1,6 @@
 language: java
 jdk:
-  - openjdk8
+  - openjdk11
 
 before_script:
   - chmod +x gradlew

README.md

@@ -1,4 +1,4 @@
-# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://travis-ci.org/chrisly42/cajon-plugin.svg?branch=master)](https://travis-ci.org/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
+# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://travis-ci.com/chrisly42/cajon-plugin.svg?branch=master)](https://travis-ci.com/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
 
 Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
@@ -32,7 +32,7 @@ Then AssertJ would tell you the _actual contents_ of the collection on failure.
 
 ## Conversion of JUnit assertions to AssertJ
 
-The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
+The plugin also supports the conversion of the most common JUnit 4 and JUnit 5 assertions to AssertJ.
 
 ## Wrong use of AssertJ
 
@@ -46,12 +46,18 @@ Using strings is not safe for refactoring (and before Java 8 Lambdas were availa
 creating extractor functions just for testing purpose was a bit too tedious).
 
 This plugin adds support for referencing these fields (so you can ctrl(/cmd)-click on the 
-string to go to the definition) and also allows safe refactoring on the 
+string to go to the definition) and allows safe refactoring on the 
 fields (refactoring a getter method without a corresponding field will not work 
-correctly right now).
+correctly right now) too.
 
 ## Usage
 
+Cajon (though written in Kotlin) *only works with Java projects*.
+There does not seem too much demand for AssertJ within Kotlin projects
+and although possible, it would require a complete rewrite as the PSI
+stuff in IntelliJ is very Java focused. Almost zero feedback is also not helping.
+Enough bickering.
+
 The plugin will report inspections in your opened editor file as warnings.
 You can then quick-fix these with your quick-fix hotkey (usually Alt-Return or Opt-Return).
 
@@ -87,7 +93,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
                             .anotherCondition();
   ```
   Joining will work on actual expressions inside ```assertThat()``` that are equivalent expressions,
-  except for method calls with known side-effect methods such as ```Iterator.next()``` and
+  except for method calls with known side effect methods such as ```Iterator.next()``` and
   pre/post-increment/decrement operations -- please notify me about others.
 
   The comments of the statements will be preserved. When using ```extracting()``` or similar,
@@ -136,12 +142,19 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 - AssertThatInvertedBooleanCondition
 
-  Inverts the boolean condition to make it more readable.
+  Inverts the boolean condition in either ```assertThat()``` or ```isEqualTo()```/```isNotEqualTo()```
+  to make it more readable.
   
   ```
   from: assertThat(!booleanValue).isEqualTo(true/false/Boolean.TRUE/Boolean.FALSE);  
   from: assertThat(!booleanValue).isTrue()/isFalse();  
     to: assertThat(booleanValue).isFalse()/isTrue();
+
+  from: assertThat(booleanValue).isEqualTo(!primitiveBooleanExpression);  
+    to: assertThat(booleanValue).isNotEqualTo(primitiveBooleanExpression);
+
+  from: assertThat(booleanValue).isNotEqualTo(!primitiveBooleanExpression);  
+    to: assertThat(booleanValue).isEqualTo(primitiveBooleanExpression);
   ```
 
 - AssertThatInstanceOf
@@ -308,10 +321,10 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(map).doesNotContainKey(key);
   ```
   
-  The last transformation is the default, but may not be 100% equivalent depending whether the map
+  The last transformation is the default, but may not be 100% equivalent depending upon the map
-  is a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
+  being a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
   but ```containsKey(key)``` is ```true```.
-  For that special case (which usually is the result of a bad design decision!)
+  For that special case (which is usually the result of a bad design decision!)
   the quickfix should rather generate ```assertThat(map).containsEntry(key, null)```.
   Therefore, the behavior can be configured in the settings for this inspection to either
   create the default case (```doesNotContainKey```), the degenerated case (```containsEntry```),
@@ -409,11 +422,21 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 - AssertThatEnumerableIsEmpty
 
-  Uses ```isEmpty()``` for ```hasSize(0)``` iterable assertions instead.
+  Uses ```isEmpty()``` for ```hasSize(0)```, ```hasSizeLessThanOrEqualTo(0)```, and
+  ```hasSizeLessThan(1)``` iterable (enumerable) assertions instead.
+  
+  Also suggests ```isNotEmpty()``` for ```hasSizeGreaterThan(0)``` and 
+  ```hasSizeGreaterThanOrEqualTo(1)```.
   
   ```
   from: assertThat(enumerable).hasSize(0);
+  from: assertThat(enumerable).hasSizeLessThanOrEqualTo(0);
+  from: assertThat(enumerable).hasSizeLessThan(1);
     to: assertThat(enumerable).isEmpty();
+
+  from: assertThat(enumerable).hasSizeGreaterThan(0);
+  from: assertThat(enumerable).hasSizeGreaterThanOrEqualTo(1);
+    to: assertThat(enumerable).isNotEmpty();
   ```
 
 - AssertThatSize
@@ -563,7 +586,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   If the assertions is either ```isEqualTo()``` or ```hasSameHashCodeAs()``` it may be checking custom
   ```equals()``` or ```hashCode()``` behavior. If the test method name containing the statement has a
-  name that contains 'equal' or 'hashcode' (case insensitive), the warning will be weakened to information
+  name that contains 'equal' or 'hashcode' (case-insensitive), the warning will be weakened to information
   level.
 
 - ImplicitAssertion
@@ -671,7 +694,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   However, this suggests that the test has actually been run and passed instead of showing the test
   as being skipped.
 
-  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or 
+  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or JUnit 5 or
   Jupiter ```@Test``` annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
   Method calls within the same class will be examined for ```assertThat()``` statements, too.
   However, at most 50 statements and down to five recursions will be tolerated before giving up.
@@ -708,7 +731,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 - JUnitAssertToAssertJ
 
-  Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
+  Tries to convert most of the JUnit 4 and JUnit 5 assertions and assumptions to AssertJ format.
   Sometimes the expected and actual expressions are specified in wrong order -- 
   Cajon tries to swap these when it detects the supposed actual expression to be a
   constant while the expected one is not.
@@ -775,15 +798,16 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ## Development notice
 
-Cajon is written in Kotlin 1.3.
+Cajon is written in Kotlin 1.4.
 
-Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one that I'm aware of ;) ).
+Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one I'm aware of ;) ).
-The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing and it took me quite a while to make it work with JUnit 5.
+The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to make it work with JUnit 5.
 Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
 
 ## Planned features
 - More Optional fixes such as ```opt1.get() == opt2.get()``` etc.
 - More moving out of methods for LocalDate/Time etc.
+- assertThat(foo.toLowerCase()/toUpperCase()).isEqualTo("foo") -> assertThat(foo).isEqualToIgnoringCase()
 - Extraction with property names to lambda/method reference with Java 8
 
   ```
@@ -793,6 +817,30 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 ## Changelog
 
+#### V1.13 (unreleased)
+
+- Added support for converting JUnit 5 tests to AssertJ
+
+### V1.12 (06-May-21)
+
+- Maintenance. Updated various dependencies (Kotlin 1.50.0) and AssertJ 3.19.0
+- Fixed issue#3 reported by hankem where usingRecursiveComparison() was not considered a complex transformation.
+
+#### V1.11 (03-Oct-20) Day of German Unity Edition
+
+- Now is being built with JDK 11 (with Java 8 target).
+- Updated various dependencies (Kotlin 1.40.10) and AssertJ 3.17.2.
+- Fixed the ImplicitAssertion inspection that broke the plugin with IntelliJ 2020.3 EAP as reported by Frédéric Thomas.
+  Thanks!
+- Added new singleElement() from AssertJ >= 3.17.0 to ImplicitAssertionInspection.
+- Added several cases for ```hasSizeGreaterThan/LessThan/OrEqualTo()``` for EnumerablesEmpty inspection.
+- Added inversion of boolean conditions inside ```isEqualTo()``` and ```isNotEqualTo()``` for InvertedBooleanCondition
+  inspection.
+
+#### V1.10 (31-Jul-20) Friday the 31st Edition
+- Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
+- Fixed two possible index out-of-bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
+
 #### V1.9 (25-Feb-20) Mardi Gras Edition
 - TwistedAssertion inspection will no longer warn for ```.matches()``` and ```doesNotMatch()``` for regular expressions.
   Apparently, ```assertThat("somestring").matches(regex)``` is a valid test if the regex is what needs to be tested.
@@ -827,10 +875,10 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
 
 #### V1.5 (24-Sep-19)
-- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception.
+- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out-of-bounds exception.
 - AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
   for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
-- Added an settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with ```null``` values.
+- Added a settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with ```null``` values.
   It is now possible to change the behavior for ```map.get(key) == null```, so it can offer either ```.doesNotContainKey()``` (default)
   or ```.containsEntry(key, null)```, or even both.
 - Fixes to AssertThatSize inspection after extending it for Maps in previous release as not all
@@ -916,7 +964,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 #### V0.2 (01-Apr-19)
 - Fixed descriptions and quick fix texts.
-- Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.
+- Fixed highlighting of found problems and 'Run inspection by Name' returning nothing, too.
 
 #### V0.1 (31-Mar-19)
 - Initial release.

build.gradle

@@ -1,13 +1,15 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '0.4.16'
+    id 'org.jetbrains.intellij' version '1.1.3'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.61'
+    id 'org.jetbrains.kotlin.jvm' version '1.5.21'
     id 'jacoco'
-    id 'com.github.kt3k.coveralls' version '2.9.0'
+    id 'com.github.kt3k.coveralls' version '2.11.0'
 }
 
 group 'de.platon42'
-version '1.9'
+version '1.12.1'
+sourceCompatibility = "1.8"
+targetCompatibility = "1.8"
 
 repositories {
     mavenCentral()
@@ -20,49 +22,38 @@ repositories {
 
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testCompile "org.assertj:assertj-core:3.15.0"
+    testImplementation "org.assertj:assertj-core:3.20.2"
-    testCompile "org.assertj:assertj-guava:3.3.0"
+    testImplementation "org.assertj:assertj-guava:3.4.0"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
+    testImplementation "org.jetbrains.kotlin:kotlin-reflect"
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
 }
 
 compileKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
+
 compileTestKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
+
 intellij {
-    version '2019.3.3'
+    setVersion("2021.1.3") // LATEST-EAP-SNAPSHOT
-//    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
+    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
-    updateSinceUntilBuild false
+    setUpdateSinceUntilBuild(false)
-    plugins = ['java']
+    setPlugins(["com.intellij.java"])
 }
 
 patchPluginXml {
-    changeNotes """
+    setChangeNotes("""
-  <h4>V1.9 (25-Feb-20) Mardi Gras Edition</h4>
+  <h4>V1.13 (unreleased)</h4>
     <ul>
-      <li>TwistedAssertion inspection will no longer warn for .matches() and doesNotMatch() for regular expressions.
+      <li>Added support for converting JUnit 5 tests to AssertJ
-          Apparently, assertThat("somestring").matches(regex) is a valid test if the regex is what needs to be tested.
-          If the actual expression is of Class type, this will no longer be reported.
-      <li>If the expected expression in TwistedAssertion is also a constant, the warning will be weakened and
-          no quick fix will be available.
-      <li>BogusAssertion inspection will no longer warn if the expression contains method calls.
-          Moreover, for assertions of isEqualTo() and hasSameHashCodeAs(), AND if the containing method name contains 'equal' or 'hashcode',
-          the warning will be reduced to information level as the assertion may be testing equals() or hashCode() for validity.
-    </ul>
-  <h4>V1.8 (14-Feb-20) Valentine Edition</h4>
-    <ul>
-      <li>Maintenance. Removed experimental API use. Updated dependencies. Fixed testing problems introduced with IntelliJ IDEA 2019.3.x
-      <li>Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating
-          swapped use of actual and expected expressions.
-      <li>Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
-"""
+""")
 }
 
 test {
@@ -73,16 +64,16 @@ test {
 }
 
 jacoco {
-    toolVersion = '0.8.5'
+    toolVersion = '0.8.7'
 }
 
 jacocoTestReport {
     reports {
-        xml.enabled true
+        xml.required.set(true)
-        csv.enabled false
+        csv.required.set(false)
     }
 }
 
 publishPlugin {
-    token intellijPublishToken
+    setToken(intellijPublishToken)
 }

gradle.properties

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

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -1,5 +1,21 @@
 #!/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
@@ -28,7 +44,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=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -56,7 +72,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MINGW* )
+  MSYS* | MINGW* )
     msys=true
     ;;
   NONSTOP* )
@@ -66,6 +82,7 @@ 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
@@ -109,10 +126,11 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
+# For Cygwin or MSYS, switch paths to Windows format before running java
-if $cygwin ; then
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; 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
@@ -138,19 +156,19 @@ if $cygwin ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $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
 
@@ -159,14 +177,9 @@ 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,3 +1,19 @@
+@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
@@ -13,15 +29,18 @@ 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=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @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 init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,28 +64,14 @@ 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 %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

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

@@ -21,19 +21,33 @@ val EXTRACTING_CALL_MATCHERS = CallMatcher.anyOf(
 
 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.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "usingComparator", "usingDefaultComparator")!!
+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",
-    "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
+    "singleElement", "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
 )!!
 
 val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(

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

@@ -72,6 +72,8 @@ 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)!!
@@ -126,6 +128,14 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .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_GREATER_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN)
             .parameterTypes("int")!!
@@ -167,12 +177,12 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterCount(0)!!
         val CHAR_SEQUENCE_LENGTH = CallMatcher.instanceCall("java.lang.CharSequence", "length")
             .parameterCount(0)!!
-        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "equals")
+        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, "isPresent")
+        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, MethodNames.IS_PRESENT)
             .parameterCount(0)!!
         val OPTIONAL_OR_ELSE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "orElse")
             .parameterCount(1)!!
@@ -186,7 +196,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, "isPresent")
+        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, MethodNames.IS_PRESENT)
             .parameterCount(0)!!
         val GUAVA_OPTIONAL_OR_NULL = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "orNull")
             .parameterCount(0)!!

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

@@ -4,39 +4,57 @@ import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
 import com.intellij.psi.PsiMethodCallExpression
 import org.jetbrains.annotations.NonNls
 
-open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
+abstract class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
         @NonNls
-        const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
+        const val JUNIT4_ASSERT_CLASSNAME = "org.junit.Assert"
+
         @NonNls
-        const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
+        const val JUNIT5_ASSERT_CLASSNAME = "org.junit.jupiter.api.Assertions"
+
+        @NonNls
+        const val JUNIT4_ASSUME_CLASSNAME = "org.junit.Assume"
+
+        @NonNls
+        const val JUNIT5_ASSUME_CLASSNAME = "org.junit.jupiter.api.Assumptions"
 
         @NonNls
         const val ASSERT_TRUE_METHOD = "assertTrue"
+
         @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"
 

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

@@ -21,18 +21,19 @@ class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
             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
 
                 val expectedExpression = expression.firstArg
                 if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) return
 
                 val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
-                val flippedBooleanTest = matchingCalls.drop(2).any { it }
+                val flippedBooleanTest = isNotEqualToObject || isNotEqualToPrimitive
 
                 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/AssertThatEnumerableIsEmptyInspection.kt

@@ -5,6 +5,7 @@ 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
@@ -12,7 +13,7 @@ import de.platon42.intellij.plugins.cajon.hasAssertThat
 class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Asserting an empty enumerable"
+        private const val DISPLAY_NAME = "Asserting an empty or not empty enumerable"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -23,11 +24,17 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
                 super.visitMethodCallExpression(expression)
                 if (!expression.hasAssertThat()) return
                 val isLastExpression = expression.parent is PsiStatement
-                if (!(HAS_SIZE.test(expression) && isLastExpression)) return
-
                 val value = expression.calculateConstantParameterValue(0) ?: return
-                if (value == 0) {
+
+                val isEmpty = (CallMatcher.anyOf(HAS_SIZE, HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT).test(expression) && (value == 0)) ||
+                        (HAS_SIZE_LESS_THAN_INT.test(expression) && (value == 1))
+                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

@@ -79,25 +79,25 @@ class AssertThatFileExpressionInspection : AbstractMoveOutInspection() {
         private val MAPPINGS_SINCE_ASSERTJ_3_14_0 = listOf(
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isEmpty", expectedMatcher = IS_ZERO_LONG, noExpectedExpression = true
+                MethodNames.IS_EMPTY, expectedMatcher = IS_ZERO_LONG, noExpectedExpression = true
             ),
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isEmpty", expectedMatcher = IS_EQUAL_TO_LONG, noExpectedExpression = true,
+                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),
-                "isNotEmpty", expectedMatcher = IS_NOT_ZERO_LONG, noExpectedExpression = true
+                MethodNames.IS_NOT_EMPTY, expectedMatcher = IS_NOT_ZERO_LONG, noExpectedExpression = true
             ),
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isNotEmpty", expectedMatcher = IS_NOT_EQUAL_TO_LONG, noExpectedExpression = true,
+                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),
-                "hasSize", expectedMatcher = IS_EQUAL_TO_LONG,
+                MethodNames.HAS_SIZE, expectedMatcher = IS_EQUAL_TO_LONG,
                 additionalCondition = ARG_IS_NOT_ZERO_CONST
             )
         )

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

@@ -1,8 +1,13 @@
 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() {
@@ -10,6 +15,8 @@ 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
@@ -20,13 +27,27 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
                 super.visitMethodCallExpression(expression)
                 if (!expression.hasAssertThat()) return
                 val staticMethodCall = expression.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
+                if (expression.getExpectedBooleanResult() != null) {
-                expression.getExpectedBooleanResult() ?: return
+                    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 prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
+                    val replacementMethod = isEqualTo.map(MethodNames.IS_NOT_EQUAL_TO, MethodNames.IS_EQUAL_TO)
-                if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
+                    val description = REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-                    val outmostMethodCall = expression.findOutmostMethodCall() ?: return
+                    val textRange = TextRange(staticMethodCall.textLength, expression.textLength)
-                    holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
+                    holder.registerProblem(expression, textRange, INVERT_OUTSIDE_CONDITION_MESSAGE, InvertUnaryExpressionQuickFix(description, replacementMethod))
                 }
             }
         }

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

@@ -5,6 +5,7 @@ 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() {
@@ -19,11 +20,11 @@ class AssertThatPathExpressionInspection : AbstractMoveOutInspection() {
                 "isAbsolute", "isRelative", expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "startsWith").parameterTypes(JAVA_NIO_PATH),
+                CallMatcher.instanceCall(JAVA_NIO_PATH, MethodNames.STARTS_WITH).parameterTypes(JAVA_NIO_PATH),
                 "startsWithRaw", expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "endsWith").parameterTypes(JAVA_NIO_PATH),
+                CallMatcher.instanceCall(JAVA_NIO_PATH, MethodNames.ENDS_WITH).parameterTypes(JAVA_NIO_PATH),
                 "endsWithRaw", expectBoolean = true
             ),
             MoveOutMapping(

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

@@ -22,12 +22,12 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
 
         private val MAPPINGS = listOf(
             MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0),
+                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, "equals").parameterCount(1),
+                    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
@@ -37,15 +37,15 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
                 MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC, expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contains").parameterCount(1),
+                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, "startsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                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, "endsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                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(

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

@@ -25,16 +25,16 @@ class BogusAssertionInspection : AbstractAssertJInspection() {
             ).parameterCount(1)
 
         private val ARRAY_METHODS = arrayOf(
-            "hasSameSizeAs",
+            MethodNames.HAS_SAME_SIZE_AS,
             MethodNames.CONTAINS,
             "containsAnyOf",
-            "containsExactly",
+            MethodNames.CONTAINS_EXACTLY,
             "containsExactlyInAnyOrder",
             "containsOnly",
             "containsSequence",
             "containsSubsequence",
-            "startsWith",
+            MethodNames.STARTS_WITH,
-            "endsWith"
+            MethodNames.ENDS_WITH
         )
 
         private val SAME_BOOLEAN_ARRAY_CONTENTS =
@@ -132,6 +132,7 @@ class BogusAssertionInspection : AbstractAssertJInspection() {
                 // 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) {

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

@@ -30,27 +30,26 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
         private val OBJECT_ENUMERABLE_ANY_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
             AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
             MethodNames.CONTAINS, "containsOnly", "containsOnlyNulls", MethodNames.CONTAINS_ONLY_ONCE,
-            "containsExactly", "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
+            MethodNames.CONTAINS_EXACTLY, "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
-            "containsAll", "containsAnyOf",
+            MethodNames.CONTAINS_ALL, "containsAnyOf",
             "containsAnyElementsOf", "containsExactlyElementsOf", "containsOnlyElementsOf",
             "isSubsetOf", "containsSequence", "containsSubsequence",
-            "doesNotContainSequence", "doesNotContainSubsequence", "doesNotContain",
+            "doesNotContainSequence", "doesNotContainSubsequence", MethodNames.DOES_NOT_CONTAIN,
             "doesNotContainAnyElementsOf", "doesNotHaveDuplicates",
-            "startsWith", "endsWith", "containsNull", "doesNotContainNull",
+            MethodNames.STARTS_WITH, MethodNames.ENDS_WITH, "containsNull", "doesNotContainNull",
             "are", "areNot", "have", "doNotHave", "areAtLeastOne", "areAtLeast", "areAtMost", "areExactly",
             "haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
-            "doesNotHave", "doesNotHaveSameClassAs",
             "hasAtLeastOneElementOfType", "hasOnlyElementsOfType", "hasOnlyElementsOfTypes",
             "doesNotHaveAnyElementsOfTypes",
             "has", "doesNotHave",
-            "hasOnlyOneElementSatisfying", "hasSameElementsAs",
+            "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",
-            "startsWith", "endsWith", "containsNull",
+            MethodNames.STARTS_WITH, MethodNames.ENDS_WITH, "containsNull",
             "areAtLeastOne",
             "haveAtLeastOne",
             "hasAtLeastOneElementOfType",
@@ -73,10 +72,10 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
 
         private val NON_NULL_CORE_ASSERTIONS = CallMatcher.instanceCall(
             AssertJClassNames.ASSERT_INTERFACE,
-            "isInstanceOf", "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
+            MethodNames.IS_INSTANCE_OF, "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
-            "isNotInstanceOf", "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
+            MethodNames.IS_NOT_INSTANCE_OF, "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
             "hasSameClassAs", "doesNotHaveSameClassAs",
-            "hasToString", "hasSameHashCodeAs"
+            MethodNames.HAS_TO_STRING, "hasSameHashCodeAs"
         )!!
 
         private val GUAVA_IS_PRESENT = CallMatcher.instanceCall(AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME, MethodNames.IS_PRESENT)

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

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

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

@@ -0,0 +1,31 @@
+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/ReplaceJUnitAssertMethodCallQuickFix.kt

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

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

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

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

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

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

@@ -70,7 +70,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
     class ExtractorReference(literal: PsiLiteralExpression, range: TextRange, private val targets: List<PsiElement>) :
         PsiPolyVariantReferenceBase<PsiLiteralExpression>(literal, range, true) {
 
-        // Do not remove due to compatiblity issue with IDEA <= 2018.2
+        // Do not remove due to compatibility issue with IDEA <= 2018.2
         override fun getVariants(): Array<Any> {
             return ArrayUtil.EMPTY_OBJECT_ARRAY
         }
@@ -124,6 +124,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
             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)

src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html

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

src/main/resources/inspectionDescriptions/AssertThatInvertedBooleanCondition.html

@@ -1,6 +1,6 @@
 <html>
 <body>
-Turns assertThat(!condition).isEqualTo(true/false) into assertThat(condition).isFalse()/isTrue().
+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>

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

@@ -6,5 +6,5 @@ import java.lang.annotation.*;
 @Retention(RetentionPolicy.RUNTIME)
 @Inherited
 public @interface AddLocalJarToModule {
-    Class[] value();
+    Class<?>[] value();
 }

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

@@ -2,6 +2,7 @@ package de.platon42.intellij.jupiter;
 
 import com.intellij.jarRepository.JarRepositoryManager;
 import com.intellij.jarRepository.RemoteRepositoryDescription;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
@@ -15,7 +16,10 @@ import com.intellij.openapi.roots.libraries.ui.OrderRoot;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.testFramework.*;
+import com.intellij.testFramework.EdtTestUtilKt;
+import com.intellij.testFramework.LightProjectDescriptor;
+import com.intellij.testFramework.PsiTestUtil;
+import com.intellij.testFramework.TestLoggerFactory;
 import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
 import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
@@ -133,15 +137,19 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
         @Override
         public void setUp() throws Exception {
             super.setUp();
+            Store store = getStore(extensionContext);
+            store.put("disposable", Disposer.newDisposable("LightCodeInsightFixtureTestCaseWrapper"));
         }
 
         @Override
         public void tearDown() throws Exception {
-            super.tearDown();
+            Store store = getStore(extensionContext);
-            UsefulTestCase.clearFields(this);
+            Disposable disposable = (Disposable) store.get("disposable");
-            if (myFixture != null && getProject() != null && !getProject().isDisposed()) {
+            if (myFixture != null && disposable != null) {
-                Disposer.dispose(getProject());
+                Disposer.dispose(disposable);
+                store.remove("disposable");
             }
+            super.tearDown();
         }
 
         @NotNull
@@ -172,7 +180,7 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
             };
         }
 
-        void addJarContaining(ModifiableRootModel model, Class clazz) {
+        void addJarContaining(ModifiableRootModel model, Class<?> clazz) {
             try {
                 Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
 

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

@@ -43,7 +43,7 @@ abstract class AbstractCajonTest {
             .asSequence()
             .filter { it.description?.contains(snippet) ?: false }
             .toList()
-        assertThat(highlights).hasSize(count);
+        assertThat(highlights).hasSize(count)
     }
 
     class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {

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

@@ -10,10 +10,14 @@ internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
 
     @Test
     @TestDataSubPath("inspections/EnumerableIsEmpty")
-    internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
         myFixture.configureByFile("EnumerableIsEmptyBefore.java")
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
         myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
     }
 }

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

@@ -14,6 +14,8 @@ internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonT
         myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
         myFixture.configureByFile("InvertedBooleanConditionBefore.java")
         executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
         myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
     }
 }

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

@@ -16,7 +16,7 @@ internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
     internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(ImplicitAssertionInspection::class.java)
         myFixture.configureByFile("ImplicitAssertionBefore.java")
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 101)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
         executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
         executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
         myFixture.checkResultByFile("ImplicitAssertionAfter.java")

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

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

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

@@ -13,7 +13,7 @@ internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
     internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(TwistedAssertionInspection::class.java)
         myFixture.configureByFile("TwistedAssertionBefore.java")
-        assertHighlightings(myFixture, 5, "Actual expression in assertThat() is a constant")
+        assertHighlightings(myFixture, 9, "Actual expression in assertThat() is a constant")
         assertHighlightings(myFixture, 10, "Twisted actual and expected expressions")
 
         executeQuickFixes(myFixture, Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)

src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java

@@ -16,7 +16,32 @@ public class EnumerableIsEmpty {
         assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
         assertThat(new Long[1]).as("etc").hasSize(1);
 
+        assertThat("string").as("foo").isEmpty();
+        assertThat(new StringBuilder()).as("bar").isEmpty();
+        assertThat(new ArrayList<Long>()).as("etc").isEmpty();
+        assertThat(new Long[1]).as("etc").isEmpty();
+
+        assertThat("string").as("foo").isEmpty();
+        assertThat(new StringBuilder()).as("bar").isEmpty();
+        assertThat(new ArrayList<Long>()).as("etc").isEmpty();
+        assertThat(new Long[1]).as("etc").isEmpty();
+
+        assertThat("string").as("foo").isNotEmpty();
+        assertThat(new StringBuilder()).as("bar").isNotEmpty();
+        assertThat(new ArrayList<Long>()).as("etc").isNotEmpty();
+        assertThat(new Long[1]).as("etc").isNotEmpty();
+
+        assertThat("string").as("foo").isNotEmpty();
+        assertThat(new StringBuilder()).as("bar").isNotEmpty();
+        assertThat(new ArrayList<Long>()).as("etc").isNotEmpty();
+        assertThat(new Long[1]).as("etc").isNotEmpty();
+
         assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").isEmpty();
+        assertThat("string").as("foo").hasSizeLessThanOrEqualTo(0).hasSameSizeAs("foo").isEmpty();
+        assertThat("string").as("foo").hasSizeLessThan(1).hasSameSizeAs("foo").isEmpty();
+
+        assertThat("string").as("foo").isNotEmpty().hasSameSizeAs("foo").isNotEmpty();
+        assertThat("string").as("foo").isNotEmpty().hasSameSizeAs("foo").isNotEmpty();
 
         org.junit.Assert.assertThat("foo", null);
         fail("oh no!");

src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java

@@ -16,7 +16,32 @@ public class EnumerableIsEmpty {
         assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
         assertThat(new Long[1]).as("etc").hasSize(1);
 
+        assertThat("string").as("foo").hasSizeLessThanOrEqualTo(0);
+        assertThat(new StringBuilder()).as("bar").hasSizeLessThanOrEqualTo(0 + 0);
+        assertThat(new ArrayList<Long>()).as("etc").hasSizeLessThanOrEqualTo(10 / 100);
+        assertThat(new Long[1]).as("etc").hasSizeLessThanOrEqualTo(1 - 1);
+
+        assertThat("string").as("foo").hasSizeLessThan(1);
+        assertThat(new StringBuilder()).as("bar").hasSizeLessThan(0 + 1);
+        assertThat(new ArrayList<Long>()).as("etc").hasSizeLessThan(10 / 10);
+        assertThat(new Long[1]).as("etc").hasSizeLessThan(1 - 0);
+
+        assertThat("string").as("foo").hasSizeGreaterThan(0);
+        assertThat(new StringBuilder()).as("bar").hasSizeGreaterThan(0 + 0);
+        assertThat(new ArrayList<Long>()).as("etc").hasSizeGreaterThan(10 / 100);
+        assertThat(new Long[1]).as("etc").hasSizeGreaterThan(1 - 1);
+
+        assertThat("string").as("foo").hasSizeGreaterThanOrEqualTo(1);
+        assertThat(new StringBuilder()).as("bar").hasSizeGreaterThanOrEqualTo(0 + 1);
+        assertThat(new ArrayList<Long>()).as("etc").hasSizeGreaterThanOrEqualTo(10 / 10);
+        assertThat(new Long[1]).as("etc").hasSizeGreaterThanOrEqualTo(1 - 0);
+
         assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").hasSize(0);
+        assertThat("string").as("foo").hasSizeLessThanOrEqualTo(0).hasSameSizeAs("foo").hasSizeLessThanOrEqualTo(0);
+        assertThat("string").as("foo").hasSizeLessThan(1).hasSameSizeAs("foo").hasSizeLessThan(1);
+
+        assertThat("string").as("foo").hasSizeGreaterThan(0).hasSameSizeAs("foo").hasSizeGreaterThan(0);
+        assertThat("string").as("foo").hasSizeGreaterThanOrEqualTo(1).hasSameSizeAs("foo").hasSizeGreaterThanOrEqualTo(1);
 
         org.junit.Assert.assertThat("foo", null);
         fail("oh no!");

src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionAfter.java

@@ -153,6 +153,7 @@ public class ImplicitAssertion {
         assertThat(list).areAtMost(1, stringCondition);
         assertThat(list).areExactly(1, stringCondition);
         assertThat(list).hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).singleElement(as(STRING)).isEqualTo(stringConsumer);
         assertThat(list).haveAtLeastOne(stringCondition);
         assertThat(list).haveAtLeast(1, stringCondition);
         assertThat(list).haveAtMost(1, stringCondition);
@@ -229,6 +230,7 @@ public class ImplicitAssertion {
         assertThat(list).isNotEmpty().areAtMost(1, stringCondition);
         assertThat(list).isNotEmpty().areExactly(1, stringCondition);
         assertThat(list).isNotEmpty().hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).isNotEmpty().singleElement(as(STRING)).isEqualTo(stringConsumer);
         assertThat(list).haveAtLeastOne(stringCondition);
         assertThat(list).isNotEmpty().haveAtLeast(1, stringCondition);
         assertThat(list).isNotEmpty().haveAtMost(1, stringCondition);

src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionBefore.java

@@ -153,6 +153,7 @@ public class ImplicitAssertion {
         assertThat(list).isNotNull().areAtMost(1, stringCondition);
         assertThat(list).isNotNull().areExactly(1, stringCondition);
         assertThat(list).isNotNull().hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).isNotNull().singleElement(as(STRING)).isEqualTo(stringConsumer);
         assertThat(list).isNotNull().haveAtLeastOne(stringCondition);
         assertThat(list).isNotNull().haveAtLeast(1, stringCondition);
         assertThat(list).isNotNull().haveAtMost(1, stringCondition);
@@ -229,6 +230,7 @@ public class ImplicitAssertion {
         assertThat(list).isNotEmpty().areAtMost(1, stringCondition);
         assertThat(list).isNotEmpty().areExactly(1, stringCondition);
         assertThat(list).isNotEmpty().hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).isNotEmpty().singleElement(as(STRING)).isEqualTo(stringConsumer);
         assertThat(list).isNotEmpty().haveAtLeastOne(stringCondition);
         assertThat(list).isNotEmpty().haveAtLeast(1, stringCondition);
         assertThat(list).isNotEmpty().haveAtMost(1, stringCondition);

src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java

@@ -3,7 +3,7 @@ import static org.assertj.core.api.Assertions.fail;
 
 public class InvertedBooleanCondition {
 
-    private void invertedBooleanCondition() {
+    private void invertedBooleanCondition(boolean primitiveVariable, Boolean objectVariable) {
         boolean primitive = false;
         Boolean object = Boolean.TRUE;
 
@@ -37,6 +37,23 @@ public class InvertedBooleanCondition {
         assertThat(primitive).as("foo").isFalse().as("bar").isFalse();
         assertThat(primitive).as("foo").isFalse().as("bar").isTrue();
 
+        assertThat(primitive).isNotEqualTo(primitiveVariable);
+        assertThat(primitive).isEqualTo(primitiveVariable);
+
+        assertThat(object).isNotEqualTo(primitiveVariable);
+        assertThat(object).isEqualTo(primitiveVariable);
+
+        assertThat(primitive).isEqualTo(!objectVariable); // not safe for null value
+        assertThat(primitive).isNotEqualTo(!objectVariable); // not safe for null value
+
+        assertThat(object).isEqualTo(!objectVariable); // not safe for null value
+        assertThat(object).isNotEqualTo(!objectVariable); // not safe for null value
+
+        assertThat(primitive).isNotEqualTo(primitiveVariable);
+        assertThat(primitive).isNotEqualTo(primitiveVariable);
+
+        assertThat(primitive).isEqualTo(!primitiveVariable && objectVariable);
+
         org.junit.Assert.assertThat(object, null);
         fail("oh no!");
     }

src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java

@@ -3,7 +3,7 @@ import static org.assertj.core.api.Assertions.fail;
 
 public class InvertedBooleanCondition {
 
-    private void invertedBooleanCondition() {
+    private void invertedBooleanCondition(boolean primitiveVariable, Boolean objectVariable) {
         boolean primitive = false;
         Boolean object = Boolean.TRUE;
 
@@ -37,6 +37,23 @@ public class InvertedBooleanCondition {
         assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(false);
         assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(true);
 
+        assertThat(primitive).isEqualTo(!primitiveVariable);
+        assertThat(primitive).isNotEqualTo(!primitiveVariable);
+
+        assertThat(object).isEqualTo(!primitiveVariable);
+        assertThat(object).isNotEqualTo(!primitiveVariable);
+
+        assertThat(primitive).isEqualTo(!objectVariable); // not safe for null value
+        assertThat(primitive).isNotEqualTo(!objectVariable); // not safe for null value
+
+        assertThat(object).isEqualTo(!objectVariable); // not safe for null value
+        assertThat(object).isNotEqualTo(!objectVariable); // not safe for null value
+
+        assertThat(primitive).isEqualTo((!primitiveVariable));
+        assertThat(primitive).isEqualTo(!(primitiveVariable));
+
+        assertThat(primitive).isEqualTo(!primitiveVariable && objectVariable);
+
         org.junit.Assert.assertThat(object, null);
         fail("oh no!");
     }

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

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

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

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

src/test/resources/inspections/TwistedAssertion/TwistedAssertionAfter.java

@@ -31,7 +31,11 @@ public class TwistedAssertions {
         assertThat(bar).isEqualTo(foo);
 
         assertThat(4).isEqualTo(number).isNotEqualTo(number * 2);
+        assertThat(4).usingDefaultComparator().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingRecursiveComparison().isGreaterThanOrEqualTo(number);
         assertThat(4).usingComparator(Comparator.reverseOrder()).isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForFields().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForType(Integer::compare).isGreaterThanOrEqualTo(number);
 
         assertThat(String.class).isEqualTo(Class.forName("java.lang.String"));
         assertThat("XX").matches(Pattern.compile(".."));

src/test/resources/inspections/TwistedAssertion/TwistedAssertionBefore.java

@@ -31,7 +31,11 @@ public class TwistedAssertions {
         assertThat(bar).isEqualTo(foo);
 
         assertThat(4).isEqualTo(number).isNotEqualTo(number * 2);
+        assertThat(4).usingDefaultComparator().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingRecursiveComparison().isGreaterThanOrEqualTo(number);
         assertThat(4).usingComparator(Comparator.reverseOrder()).isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForFields().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForType(Integer::compare).isGreaterThanOrEqualTo(number);
 
         assertThat(String.class).isEqualTo(Class.forName("java.lang.String"));
         assertThat("XX").matches(Pattern.compile(".."));