Last update 1.14. Reworked so much without success it was just painful.

Added PluginVerifier to build.gradle.

.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

LICENSE.TXT

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

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
 
 Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
@@ -40,18 +40,25 @@ Cajon also warns about bogus or incorrect uses of AssertJ.
 
 ## Lookup and refactoring of string-based extracting()
 
-AssertJ allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
+AssertJ
+allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
 
 Using strings is not safe for refactoring (and before Java 8 Lambdas were available,
 creating extractor functions just for testing purpose was a bit too tedious).
 
 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).
 
@@ -60,6 +67,7 @@ Applying a quick fix might result in further optimization possibilities, so
 you might need to perform a couple of fixes before you get to the final result.
 
 Check out this example where every line represents the result after a Cajon quickfix:
+
 ```
 assertFalse(!(array.length == collection.size()));
 
@@ -87,7 +95,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 +144,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
@@ -158,6 +173,23 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(object).isNotInstanceOf(classname.class);
   ```
 
+- AssertThatIsZeroOne
+
+  Uses ```isZero()```, ```isNotZero()``` and ```isOne()``` instead.
+  Works with shorts, integers, longs, floats and doubles, and tries to evaluate
+  constant expressions, too.
+
+  ```
+  from: assertThat(numeric).isEqualTo(0);
+    to: assertThat(numeric).isZero();
+
+  from: assertThat(numeric).isNotEqualTo(0);
+    to: assertThat(numeric).isNotZero();
+
+  from: assertThat(numeric).isEqualTo(1);
+    to: assertThat(numeric).isOne();
+  ```
+
 - AssertThatStringIsEmpty
 
   Uses ```isEmpty()``` for empty string assertions.
@@ -308,10 +340,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 +441,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
@@ -503,6 +545,15 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   There are, of course, more variations of the theme.
 
+  If both sides of an assertion are constant expressions, the problem will only appear as
+  a weak warning without a quick fix.
+
+  Constants used on the actual side of ```.matches()``` and ```doesNotMatch()``` will not be
+  reported for regular expression testing.
+
+  Neither will a ```Class``` type be considered a constant in the classic sense, so
+  ```assertThat(SomeClass.class).isAssignableFrom(SomeOtherClass.class)``` will not be reported.
+
 - BogusAssertion
 
   Sometimes programmers make copy and paste or logical errors writing down assertions
@@ -549,6 +600,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   assertThat(map).hasSameSizeAs(map);
   ```
 
+  Note that expressions with method calls will not cause a warning as the method call might have side effects
+  that result in the assertion not being bogus at all.
+
+  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
+  level.
+
 - ImplicitAssertion
 
   Detects and removes implicit use of ```isNotNull()```, ```isNotEmpty()``` and
@@ -737,8 +796,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ### Implemented referencing
 
-  You can ctrl-click on references inside .extracting() method parameters to go the
+You can ctrl-click on references inside .extracting() method parameters to go the
-  referencing method definition.
+referencing method definition.
+
   ```
   .extracting("field")
   .extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
@@ -752,37 +812,92 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   .flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
   .flatExtracting(Extractors.resultOf("bareMethod")
   ```
-  This works on both POJOs and ```Iterable```s/```Array```s. 
+
-  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+This works on both POJOs and ```Iterable```s/```Array```s.
-  If there's demand, I could add it.
+Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+If there's demand, I could add it.
 
 ## Development notice
 
-Cajon is written in Kotlin 1.3.
+Cajon is written in Kotlin 1.7.
 
-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
 
   ```
   from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
     to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
   ```
+- Support primitives in assertThat(map.containsKey(1)).isTrue();
 
 ## Changelog
 
+### V1.14 (19-Feb-24)
+
+- Now requires minimum version 2022.2.
+- Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
+- Reworked JUnit 5 test framework to work again. However, all the tests are broken.
+  I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ.
+  Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
+- This is very likely the last version.
+
+### V1.13 (18-Aug-22)
+
+- API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
+- Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
+- Tried to fix unreproducible issue #9.
+- Added AssertThatIsZeroOne inspection demanded by issue #5.
+- Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
+
+### 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.
+  If the actual expression is of ```Class``` type, this will no longer be reported.
+- If the expected expression in TwistedAssertion is also a constant, the warning will be weakened and
+  no quick fix will be available.
+- 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.
+
 #### V1.8 (14-Feb-20) Valentine Edition
+
 - Maintenance. Removed experimental API use. Updated dependencies. Fixed testing problems introduced with IntelliJ IDEA 2019.3
 - Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating
   swapped use of actual and expected expressions.
 - Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
 
 #### V1.7 (19-Nov-19)
+
 - Fixed a lapsuus in AssertThatFileExpression also transforming ```.listFiles()``` with a filter argument.
 - Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
   but requires detection and transformation of static ```Files```-methods).
@@ -790,6 +905,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added ```hasSize(), isEmpty()``` and ```isNotEmpty()``` for AssertThatFileExpression when using AssertJ >= 3.14.0.
 
 #### V1.6 (30-Sep-19)
+
 - Really fixed AssertThatGuavaOptional inspections to avoid conversions from ```.get()``` to ```.contains()```
   for array types. Sigh. Shouldn't be working >12h a day and then do some more stuff at home.
 - Fixed a bug in AssertThatBinaryExpression inspection for ```assertThat(null != expression)``` and related
@@ -800,21 +916,24 @@ 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
   combinations for ```.hasSameSizeAs()``` are supported.
 
 #### V1.4 (25-Aug-19)
+
 - Minor fix for highlighting of JoinVarArgsContains inspection.
 - Extended AssertThatSize inspection to Maps, too.
 - Extended AssertThatCollectionOrMap inspection for several ```assertThat(map.get())``` cases as suggested by Georgij G.
 
 #### V1.3 (03-Aug-19)
+
 - New JoinVarArgsContains inspection that will detect multiple ```.contains()```, ```.doesNotContain()```,
   and ```.containsOnlyOnce()``` calls within the same statement that could be joined together using variadic arguments.
 - AssertJ 3.13.0 broke some inspections due to new ```AbstractStringAssert::isEqualTo()``` method.
@@ -823,10 +942,12 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   when ```expression``` is not a non-null constant expression.
 
 #### V1.2 (23-Jun-19)
+
 - Due to popular demand the JoinAssertThatStatements inspection will now add line breaks on joining statements.
   The amount of statements joined without causing line breaks can be configured but defaults to 1 (always).
 
 #### V1.1 (09-Jun-19)
+
 - Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
 - Added Guava Optional ```opt.orNull() == null``` case. You know, I'm not making this stuff up, people actually write this kind of code.
 - Added Java 8 Optional ```opt.orElse(null) == null``` case, too.
@@ -837,14 +958,18 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added new AssertThatObjectExpression inspection for ```toString()``` and ```hashCode()``` and moved ```equals()``` from AssertThatBinaryExpression there.
 
 #### V1.0 (06-May-19)
+
 - First release to be considered stable enough for production use.
 - Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
 - Fixed missing description for AssumeThatInsteadOfReturn inspection.
-- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()``` expression.
+- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()```
+  expression.
 
 #### V0.8 (05-May-19)
+
 - Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
-- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()``` and ```isNull()``` return void.
+- Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()```
+  and ```isNull()``` return void.
 - Heavily reworked inspections for edge cases, such as multiple ```isEqualTo()``` calls inside a single statement.
 - Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
 - Corrected highlighting for many inspections.
@@ -853,6 +978,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - Added a first version of a new inspection that tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
 
 #### V0.7 (28-Apr-19)
+
 - Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
   (really, Jetbrains, this sucks for no reason).
 - Extended AssertThatSize inspection to transform ```hasSize()``` into ```hasSameSizeAs()```, if possible.
@@ -860,6 +986,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   actual object together, preserving comments.
 
 #### V0.6 (22-Apr-19)
+
 - New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
   ```startsWith()```, and ```endsWith()``` out of actual expression.
 - Extended AssertThatSize inspection to take ```String```s and ```CharSequences``` into account, too.
@@ -868,6 +995,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 - New AssertThatInstanceOf inspection that moves instanceof expressions out of ```assertThat()```.
 
 #### V0.5 (18-Apr-19)
+
 - Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
 - Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
 - Added support for referencing and refactoring inside ```.extracting()``` methods with fields, properties and methods (though
@@ -876,20 +1004,27 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
 
 #### V0.4 (11-Apr-19)
+
 - Reduced minimal supported IDEA version from 2018.2 to 2017.2.
-- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```, and ```isNotPresent()``` instead.
+- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```,
+  and ```isNotPresent()``` instead.
 - New inspection AssertThatGuavaOptional that operates on Guava ```Optional``` objects and tries to use ```contains()```, ```isPresent()```, and ```isAbsent()``` instead.
 - Added support in AssertThatBinaryExpressionIsTrueOrFalse for ```is(Not)EqualTo(Boolean.TRUE/FALSE)```.
 
 #### V0.3 (07-Apr-19)
-- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations) inside ```assertThat()```.
+
+- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations)
+  inside ```assertThat()```.
 - Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
-- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with AssertJ >=3.12.0).
+- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with
+  AssertJ >=3.12.0).
 - Really fixed highlighting for JUnit conversion. Sorry.
 
 #### V0.2 (01-Apr-19)
+
 - Fixed descriptions and quick fix texts.
-- Fixed highlighting of found problems and 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,77 +0,0 @@
-plugins {
-    id 'java'
-    id 'org.jetbrains.intellij' version '0.4.16'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.61'
-    id 'jacoco'
-    id 'com.github.kt3k.coveralls' version '2.9.0'
-}
-
-group 'de.platon42'
-version '1.8'
-
-repositories {
-    mavenCentral()
-}
-
-/*
-  To run tests in IntelliJ use these VM Options for run configuration 
-  -ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
- */
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testCompile "org.assertj:assertj-core:3.15.0"
-    testCompile "org.assertj:assertj-guava:3.3.0"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
-    testImplementation "org.jetbrains.kotlin:kotlin-test"
-//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
-}
-
-compileKotlin {
-    kotlinOptions.jvmTarget = "1.8"
-}
-compileTestKotlin {
-    kotlinOptions.jvmTarget = "1.8"
-}
-intellij {
-    version '2019.3.3'
-//    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
-    updateSinceUntilBuild false
-    plugins = ['java']
-}
-
-patchPluginXml {
-    changeNotes """
-  <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 {
-    useJUnitPlatform()
-    testLogging {
-        events "passed", "skipped", "failed"
-    }
-}
-
-jacoco {
-    toolVersion = '0.8.5'
-}
-
-jacocoTestReport {
-    reports {
-        xml.enabled true
-        csv.enabled false
-    }
-}
-
-publishPlugin {
-    token intellijPublishToken
-}

build.gradle.kts

@@ -0,0 +1,131 @@
+plugins {
+    id("java")
+    id("org.jetbrains.intellij") version "1.17.1"
+    id("org.jetbrains.kotlin.jvm") version "1.9.22"
+    id("jacoco")
+    id("com.github.kt3k.coveralls") version "2.12.2"
+}
+
+group = "de.platon42"
+version = "1.14"
+
+repositories {
+    mavenCentral()
+}
+
+/*
+  To run tests in IntelliJ use these VM Options for run configuration
+  -ea -Didea.system.path=build/idea-sandbox/system-test -Didea.config.path=build/idea-sandbox/config-test -Didea.plugins.path=build/idea-sandbox/plugins-test
+ */
+
+dependencies {
+    //implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    testImplementation("org.assertj:assertj-core:3.25.3")
+    testImplementation("org.assertj:assertj-guava:3.25.3")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
+    testImplementation("org.jetbrains.kotlin:kotlin-test")
+    testImplementation("org.jetbrains.kotlin:kotlin-reflect")
+    testImplementation("org.junit.platform:junit-platform-launcher:1.10.2")
+//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
+}
+
+intellij {
+    version.set("2022.2") // LATEST-EAP-SNAPSHOT
+    //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
+    updateSinceUntilBuild.set(false)
+    plugins.set(listOf("com.intellij.java"))
+}
+
+tasks {
+    withType<JavaCompile> {
+        sourceCompatibility = "11"
+        targetCompatibility = "11"
+    }
+    withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+        kotlinOptions.jvmTarget = "11"
+    }
+
+    test {
+        useJUnitPlatform()
+        testLogging {
+            events("passed", "skipped", "failed")
+        }
+    }
+
+
+    prepareSandbox {
+        enabled = true
+    }
+
+    verifyPlugin {
+        enabled = true
+    }
+
+    verifyPluginConfiguration {
+        enabled = true
+    }
+
+    patchPluginXml {
+        enabled = true
+        sinceBuild.set("222")
+        changeNotes.set(
+            """
+  <h4>V1.14 (19-Feb-24)</h4>
+    <ul>
+      <li>Now requires minimum version 2022.2.
+      <li>Maintenance. Updated various dependencies (Kotlin 1.9.22) and AssertJ 3.25.3 and AssertJ-Guava 3.25.3.
+      <li>Reworked JUnit 5 test framework to work again. However, all the tests are broken.
+      I spent several days trying to figure out what is going on, but I'm giving up on this pile of crap called IntelliJ. 
+      Jetbrains keeps breaking the APIs and implementations every year and I just cannot be bothered anymore.
+      <li>This is very likely the last version.
+    </ul>
+  <h4>V1.13 (18-Aug-22)</h4>
+    <ul>
+      <li>API change in IntelliJ platforms now requires minimum version 2019.3.1. Sorry, giving up to maintain compatibility after four attempts.
+      <li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
+      <li>Tried to fix unreproducible issue #9.
+      <li>Added AssertThatIsZeroOne inspection demanded by issue #5.
+      <li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
+    </ul>
+  <p>Full changelog available at <a href="https://git.platon42.de/chrisly42/cajon-plugin#changelog">Gitea project site</a>.</p>
+"""
+        )
+    }
+
+    publishPlugin {
+        token.set(System.getProperty("org.gradle.project.intellijPublishToken"))
+    }
+
+    runIde {
+        enabled = true
+        if (project.hasProperty("ideDir")) {
+            ideDir.set(file(project.property("ideDir")!!))
+            jbrVersion.set(project.property("ideJBR")!! as String)
+        }
+        autoReloadPlugins.set(false)
+    }
+
+
+    runPluginVerifier {
+        ideVersions.set(listOf("IC-222.4167.29", "IC-233.14015.106")) // 2022.2.2 - 2023.3.3
+        downloadDir.set(System.getenv("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier")
+    }
+
+
+}
+
+//tasks.coveralls {
+//    dependsOn(jacocoTestReport)
+//}
+
+//jacoco {
+//    toolVersion = '0.8.8'
+//}
+//
+//jacocoTestReport {
+//    reports {
+//        xml.required.set(true)
+//        csv.required.set(false)
+//    }
+//}

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-8.6-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/AssertJClassNames.kt

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

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

@@ -21,24 +21,50 @@ 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 FILTERED_ON = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "filteredOn", "filteredOnNull", "filteredOnAssertions")!!
+
 val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
+    EXTRACTING_CALL_MATCHERS,
     DESCRIBED_AS,
     WITH_REPRESENTATION_AND_SUCH,
+    FILTERED_ON,
+    USING_COMPARATOR,
+    IN_HEXADECIMAL_OR_BINARY
+)!!
+
+val COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE = CallMatcher.anyOf(
+    EXTRACTING_CALL_MATCHERS,
+    WITH_REPRESENTATION_AND_SUCH,
+    FILTERED_ON,
     USING_COMPARATOR,
     IN_HEXADECIMAL_OR_BINARY
 )!!

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

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

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

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

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

@@ -15,6 +15,7 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_D
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_FLOAT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_LONG_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_SHORT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_STRING_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
@@ -72,6 +73,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)!!
@@ -86,6 +89,8 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_EQUAL_TO_STRING = CallMatcher.instanceCall(ABSTRACT_STRING_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
+        val IS_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+            .parameterTypes("short")!!
         val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("int")!!
         val IS_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
@@ -101,6 +106,8 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes("boolean")!!
+        val IS_NOT_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
+            .parameterTypes("short")!!
         val IS_NOT_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes("int")!!
         val IS_NOT_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
@@ -126,6 +133,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")!!
@@ -145,15 +160,15 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterCount(0)!!
         val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
             .parameterCount(0)!!
-        val IS_ONE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
+        val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
             .parameterCount(0)!!
-        val IS_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
+        val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
             .parameterCount(0)!!
-        val IS_NOT_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
+        val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
             .parameterCount(0)!!
-        val IS_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
+        val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
             .parameterCount(0)!!
-        val IS_NOT_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
+        val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
             .parameterCount(0)!!
 
         val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)
@@ -167,12 +182,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 +201,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,51 @@ 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"
+
         @NonNls
         const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
 
         @NonNls
         const val ASSERT_TRUE_METHOD = "assertTrue"
+
         @NonNls
         const val ASSERT_FALSE_METHOD = "assertFalse"
+
         @NonNls
         const val ASSERT_NULL_METHOD = "assertNull"
+
         @NonNls
         const val ASSERT_NOT_NULL_METHOD = "assertNotNull"
+
         @NonNls
         const val ASSERT_EQUALS_METHOD = "assertEquals"
+
         @NonNls
         const val ASSERT_NOT_EQUALS_METHOD = "assertNotEquals"
+
         @NonNls
         const val ASSERT_SAME_METHOD = "assertSame"
+
         @NonNls
         const val ASSERT_NOT_SAME_METHOD = "assertNotSame"
+
         @NonNls
         const val ASSERT_ARRAY_EQUALS_METHOD = "assertArrayEquals"
 
         @NonNls
         const val ASSUME_TRUE_METHOD = "assumeTrue"
+
         @NonNls
         const val ASSUME_FALSE_METHOD = "assumeFalse"
+
         @NonNls
         const val ASSUME_NOT_NULL_METHOD = "assumeNotNull"
+
         @NonNls
         const val ASSUME_NO_EXCEPTION = "assumeNoException"
 

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

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

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

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

src/main/java/de/platon42/intellij/plugins/cajon/inspections/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(
@@ -94,7 +94,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
 
             MoveOutMapping(
                 STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
+                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,
@@ -119,7 +119,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,

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

@@ -1,10 +1,8 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.*
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiExpressionStatement
-import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.util.PsiTreeUtil
 import com.siyeh.ig.callMatcher.CallMatcher
 import com.siyeh.ig.psiutils.EquivalenceChecker
@@ -15,6 +13,7 @@ class BogusAssertionInspection : AbstractAssertJInspection() {
     companion object {
         private const val DISPLAY_NAME = "Bogus assertion due to same actual and expected expressions"
         private const val ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE = "Actual expression in assertThat() is the same as expected"
+        private const val WEAK_ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE = "Same actual and expected expression, but may be testing equals() or hashCode()"
 
         private val SAME_OBJECT =
             CallMatcher.instanceCall(
@@ -26,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 =
@@ -57,6 +56,12 @@ class BogusAssertionInspection : AbstractAssertJInspection() {
         private val SAME_OBJECT_ARRAY_CONTENTS =
             CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME, *ARRAY_METHODS).parameterCount(1)
 
+        private val HASHCODE_OR_IS_EQUAL_TO =
+            CallMatcher.instanceCall(
+                AssertJClassNames.ASSERT_INTERFACE,
+                MethodNames.IS_EQUAL_TO, "hasSameHashCodeAs"
+            ).parameterCount(1)
+
         private val SAME_ENUMERABLE_CONTENTS =
             CallMatcher.instanceCall(
                 AssertJClassNames.ENUMERABLE_ASSERT_INTERFACE,
@@ -127,12 +132,46 @@ 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) {
-                    holder.registerProblem(statement, ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE)
+                    if (!hasExpressionWithSideEffects(actualExpression)) {
+                        if (allCalls.any(HASHCODE_OR_IS_EQUAL_TO::test)) {
+                            val method = PsiTreeUtil.getParentOfType(statement, PsiMethod::class.java, true)
+                            val methodName = method?.name
+                            if ((methodName != null)
+                                && ((methodName.contains("equal", ignoreCase = true) || methodName.contains("hashcode", ignoreCase = true)))
+                            ) {
+                                if (isOnTheFly) {
+                                    holder.registerProblem(statement, WEAK_ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE, ProblemHighlightType.INFORMATION)
+                                }
+                                return
+                            }
+                        }
+                        holder.registerProblem(statement, ACTUAL_IS_EQUAL_TO_EXPECTED_MESSAGE)
+                    }
                 }
             }
+
+            private fun hasExpressionWithSideEffects(actualExpression: PsiExpression): Boolean {
+                var result = false
+                PsiTreeUtil.processElements(actualExpression) { element ->
+                    val matched = when (element) {
+                        is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
+                                || (element.operationTokenType == JavaTokenType.MINUSMINUS)
+                        is PsiMethodCallExpression -> true
+                        else -> false
+                    }
+                    if (matched) {
+                        result = true
+                        false
+                    } else {
+                        true
+                    }
+                }
+                return result
+            }
         }
     }
 }

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

@@ -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/JoinAssertThatStatementsInspection.kt

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

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

@@ -1,10 +1,9 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
+import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.*
-import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.PsiExpressionStatement
-import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.util.PsiTreeUtil
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
@@ -32,6 +31,8 @@ class TwistedAssertionInspection : AbstractAssertJInspection() {
 
         private val STRING_IS_EQUAL_TO_IC = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO_IC).parameterCount(1)
 
+        private val STRING_REGEX_MATCHING = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, "matches", "doesNotMatch").parameterCount(1)
+
         private val CALL_MATCHER_TO_REPLACEMENT_MAP = mapOf(
             GENERIC_IS_EQUAL_TO to MethodNames.IS_EQUAL_TO,
             GENERIC_IS_NOT_EQUAL_TO to MethodNames.IS_NOT_EQUAL_TO,
@@ -60,31 +61,47 @@ class TwistedAssertionInspection : AbstractAssertJInspection() {
                 actualExpression.calculateConstantValue() ?: return
                 val allCalls = assertThatCall.collectMethodCallsUpToStatement().toList()
                 val tooComplex = allCalls.find(USING_COMPARATOR::test) != null
+                var severity = ProblemHighlightType.GENERIC_ERROR_OR_WARNING
+                if (actualExpression.type is PsiClassType) {
+                    val psiManager = PsiManager.getInstance(statement.project)
+                    val javaLangClass = PsiType.getJavaLangClass(psiManager, GlobalSearchScope.allScope(statement.project))
+                    if (actualExpression.type!!.isAssignableFrom(javaLangClass)) {
+                        return
+                    }
+                }
+
                 if (!tooComplex) {
                     val onlyAssertionCalls = allCalls
                         .filterNot(NOT_ACTUAL_ASSERTIONS::test)
                         .toList()
                     if (onlyAssertionCalls.size == 1) {
-                        val originalMethodCall = onlyAssertionCalls.first()
+                        val expectedMethodCall = onlyAssertionCalls.first()
-                        val matchedMethod = CALL_MATCHER_TO_REPLACEMENT_MAP.asSequence().firstOrNull { it.key.test(originalMethodCall) }
+                        if (STRING_REGEX_MATCHING.test(expectedMethodCall)) {
-                        if (matchedMethod != null) {
-                            val originalMethodName = getOriginalMethodName(originalMethodCall)
-                            val replacementMethod = matchedMethod.value
-                            val description = if (originalMethodName == replacementMethod) {
-                                SWAP_ACTUAL_AND_EXPECTED_DESCRIPTION
-                            } else {
-                                SWAP_ACTUAL_AND_EXPECTED_AND_REPLACE_DESCRIPTION_TEMPLATE.format(originalMethodName, replacementMethod)
-                            }
-                            holder.registerProblem(
-                                statement,
-                                TWISTED_ACTUAL_AND_EXPECTED_MESSAGE,
-                                SwapActualAndExpectedExpressionMethodCallQuickFix(description, replacementMethod)
-                            )
                             return
                         }
+                        if (expectedMethodCall.getArgOrNull(0)?.calculateConstantValue() == null) {
+                            val matchedMethod = CALL_MATCHER_TO_REPLACEMENT_MAP.asSequence().firstOrNull { it.key.test(expectedMethodCall) }
+                            if (matchedMethod != null) {
+                                val originalMethodName = getOriginalMethodName(expectedMethodCall)
+                                val replacementMethod = matchedMethod.value
+                                val description = if (originalMethodName == replacementMethod) {
+                                    SWAP_ACTUAL_AND_EXPECTED_DESCRIPTION
+                                } else {
+                                    SWAP_ACTUAL_AND_EXPECTED_AND_REPLACE_DESCRIPTION_TEMPLATE.format(originalMethodName, replacementMethod)
+                                }
+                                holder.registerProblem(
+                                    statement,
+                                    TWISTED_ACTUAL_AND_EXPECTED_MESSAGE,
+                                    SwapActualAndExpectedExpressionMethodCallQuickFix(description, replacementMethod)
+                                )
+                                return
+                            }
+                        } else {
+                            severity = ProblemHighlightType.WEAK_WARNING
+                        }
                     }
                 }
-                holder.registerProblem(statement, ACTUAL_IS_A_CONSTANT_MESSAGE)
+                holder.registerProblem(statement, ACTUAL_IS_A_CONSTANT_MESSAGE, severity)
             }
         }
     }

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

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

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/META-INF/plugin.xml

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

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

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

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

@@ -0,0 +1,151 @@
+package de.platon42.intellij.jupiter
+
+import com.intellij.jarRepository.JarRepositoryManager
+import com.intellij.jarRepository.RemoteRepositoryDescription
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.roots.ContentEntry
+import com.intellij.openapi.roots.DependencyScope
+import com.intellij.openapi.roots.ModifiableRootModel
+import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.testFramework.IdeaTestUtil
+import com.intellij.testFramework.LightProjectDescriptor
+import com.intellij.testFramework.PlatformTestUtil
+import com.intellij.testFramework.PsiTestUtil
+import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase
+import com.intellij.testFramework.rules.TestNameExtension
+import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties
+import org.junit.jupiter.api.extension.AfterEachCallback
+import org.junit.jupiter.api.extension.BeforeEachCallback
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.api.extension.RegisterExtension
+import java.nio.file.Paths
+import java.util.*
+import java.util.function.Consumer
+import java.util.stream.Collectors
+import java.util.stream.Stream
+
+
+abstract class AbstractJUnit5TestCase {
+
+    @RegisterExtension
+    protected val testNameRule = TestNameExtension()
+
+    @RegisterExtension
+    protected val edtInterceptorExtension = EdtInterceptorExtension()
+
+    protected fun getTestName(lowercaseFirstLetter: Boolean): String {
+        return PlatformTestUtil.getTestName(testNameRule.methodName, lowercaseFirstLetter)
+    }
+
+    @RegisterExtension
+    private val testCase = object : LightJavaCodeInsightFixtureTestCase(), BeforeEachCallback, AfterEachCallback {
+
+        lateinit var extensionContext: ExtensionContext
+
+        override fun getProjectDescriptor(): LightProjectDescriptor {
+            val testJdk = getMethodOrClassAnnotation(TestJdk::class.java) ?: return super.getProjectDescriptor()
+            val projectDescriptor: DefaultLightProjectDescriptor = object : DefaultLightProjectDescriptor({ IdeaTestUtil.getMockJdk(testJdk.value.toJavaVersion()) }) {
+                override fun configureModule(module: Module, model: ModifiableRootModel, contentEntry: ContentEntry) {
+                    super.configureModule(module, model, contentEntry)
+                    val localJars = getMethodOrClassAnnotation(AddLocalJarToModule::class.java)
+                    if (localJars != null) {
+                        localJars.value.forEach {
+                            addJarContaining(
+                                model,
+                                it.java
+                            )
+                        }
+                    }
+                    val mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule::class.java)
+                    mavenDependencies.forEach(Consumer { it: AddMavenDependencyToModule ->
+                        addFromMaven(
+                            model,
+                            it.value,
+                            it.includeTransitiveDependencies,
+                            it.scope
+                        )
+                    })
+                }
+            }
+
+            return projectDescriptor
+        }
+
+        fun addJarContaining(model: ModifiableRootModel?, clazz: Class<*>) {
+            val filename = clazz.getResource(clazz.simpleName + ".class").file
+            val jarName = filename.substring(0, filename.indexOf(".jar") + 4).removePrefix("file:")
+            val jarPath = Paths.get(jarName)
+
+            val jarFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(jarName)
+            myFixture.allowTreeAccessForFile(jarFile!!)
+            PsiTestUtil.addLibrary(
+                model!!,
+                jarPath.fileName.toString().replace(".jar", ""),
+                jarPath.parent.toString(),
+                jarPath.fileName.toString()
+            )
+        }
+
+        fun addFromMaven(
+            model: ModifiableRootModel, mavenCoordinates: String,
+            includeTransitiveDependencies: Boolean, dependencyScope: DependencyScope?
+        ) {
+            val remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES
+            val libraryProperties = RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies)
+            val roots =
+                JarRepositoryManager.loadDependenciesModal(model.project, libraryProperties, false, false, null, remoteRepositoryDescriptions)
+            val tableModel = model.moduleLibraryTable.modifiableModel
+            val library = tableModel.createLibrary(mavenCoordinates)
+            val libraryModel = library.modifiableModel
+            check(!roots.isEmpty()) { String.format("No roots for '%s'", mavenCoordinates) }
+
+            for (root in roots) {
+                libraryModel.addRoot(root.file, root.type)
+            }
+
+            val libraryOrderEntry = model.findLibraryOrderEntry(library) ?: throw java.lang.IllegalStateException("Unable to find registered library $mavenCoordinates")
+            libraryOrderEntry.scope = dependencyScope!!
+
+            libraryModel.commit()
+            tableModel.commit()
+        }
+
+        override fun getTestDataPath(): String {
+            val testDataPath = getMethodOrClassAnnotation(TestDataPath::class.java) ?: return super.getTestDataPath()
+            val testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath::class.java) ?: return testDataPath.value
+            return Paths.get(testDataPath.value, testDataSubPath.value).toString()
+        }
+
+        fun getMyFixture(): JavaCodeInsightTestFixture = myFixture
+
+        private fun <T : Annotation?> getMethodOrClassAnnotation(clazz: Class<T>): T? {
+            var annotation = extensionContext.requiredTestMethod.getAnnotation(clazz)
+            if (annotation == null) {
+                annotation = extensionContext.requiredTestClass.getAnnotation(clazz)
+            }
+            return annotation
+        }
+
+        private fun <T : Annotation?> getMethodOrClassAnnotations(clazz: Class<T>): List<T> {
+            return Stream.of(
+                extensionContext.requiredTestMethod.getAnnotationsByType(clazz),
+                extensionContext.requiredTestClass.getAnnotationsByType(clazz)
+            )
+                .flatMap { array: Array<T>? -> Arrays.stream(array) }
+                .collect(Collectors.toList())
+        }
+
+        override fun beforeEach(context: ExtensionContext) {
+            extensionContext = context
+            setUp()
+        }
+
+        override fun afterEach(context: ExtensionContext) {
+            tearDown()
+        }
+    }
+
+    protected val fixture: JavaCodeInsightTestFixture get() = testCase.getMyFixture()
+}

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

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

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

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

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

@@ -1,24 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import com.intellij.openapi.roots.DependencyScope;
-
-import java.lang.annotation.*;
-
-@Target({ElementType.TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@Inherited
-@Repeatable(AddMavenDependencyToModule.List.class)
-public @interface AddMavenDependencyToModule {
-    String value();
-
-    boolean includeTransitiveDependencies = false;
-
-    DependencyScope scope = DependencyScope.COMPILE;
-
-    @Target({ElementType.TYPE, ElementType.METHOD})
-    @Retention(RetentionPolicy.RUNTIME)
-    @Inherited
-    @interface List {
-        AddMavenDependencyToModule[] value();
-    }
-}

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

@@ -0,0 +1,17 @@
+package de.platon42.intellij.jupiter
+
+import com.intellij.openapi.roots.DependencyScope
+import java.lang.annotation.Inherited
+
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+@Retention(AnnotationRetention.RUNTIME)
+@Inherited
+@JvmRepeatable(
+    AddMavenDependencyToModule.List::class
+)
+annotation class AddMavenDependencyToModule(val value: String, val includeTransitiveDependencies: Boolean = false, val scope: DependencyScope = DependencyScope.COMPILE) {
+    @Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+    @Retention(AnnotationRetention.RUNTIME)
+    @Inherited
+    annotation class List(vararg val value: AddMavenDependencyToModule)
+}

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

@@ -0,0 +1,50 @@
+package de.platon42.intellij.jupiter
+
+import com.intellij.testFramework.TestLoggerFactory
+import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy
+import com.intellij.testFramework.runInEdtAndWait
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.api.extension.InvocationInterceptor
+import org.junit.jupiter.api.extension.ReflectiveInvocationContext
+import java.lang.reflect.Method
+
+class EdtInterceptorExtension : InvocationInterceptor {
+
+    override fun interceptTestMethod(
+        invocation: InvocationInterceptor.Invocation<Void>,
+        invocationContext: ReflectiveInvocationContext<Method>,
+        extensionContext: ExtensionContext
+    ) {
+        val throwables = arrayOfNulls<Throwable>(1)
+
+        val runnable = Runnable {
+            try {
+                TestLoggerFactory.onTestStarted()
+                invocation.proceed()
+                TestLoggerFactory.onTestFinished(true, extensionContext.displayName)
+            } catch (e: Throwable) {
+                TestLoggerFactory.onTestFinished(false, extensionContext.displayName)
+                throwables[0] = e
+            }
+        }
+
+        invokeTestRunnable(runnable)
+
+        if (throwables[0] != null) {
+            throw throwables[0]!!
+        }
+    }
+
+    companion object {
+        private fun invokeTestRunnable(runnable: Runnable) {
+            val policy = IdeaTestExecutionPolicy.current()
+            if (policy != null && !policy.runInDispatchThread()) {
+                runnable.run()
+            } else {
+                runInEdtAndWait {
+                    runnable.run()
+                }
+            }
+        }
+    }
+}

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

@@ -1,251 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import com.intellij.jarRepository.JarRepositoryManager;
-import com.intellij.jarRepository.RemoteRepositoryDescription;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
-import com.intellij.openapi.roots.ContentEntry;
-import com.intellij.openapi.roots.DependencyScope;
-import com.intellij.openapi.roots.LibraryOrderEntry;
-import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.libraries.LibraryTable;
-import com.intellij.openapi.roots.libraries.ui.OrderRoot;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.testFramework.*;
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
-import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties;
-import org.junit.jupiter.api.extension.*;
-import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
-import org.junit.jupiter.api.extension.ExtensionContext.Store;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.lang.reflect.Parameter;
-import java.net.URISyntaxException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.logging.Logger;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback, InvocationInterceptor {
-
-    private static final Logger LOG = Logger.getLogger(LightCodeInsightExtension.class.getName());
-
-    @Override
-    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
-        Parameter parameter = parameterContext.getParameter();
-        return parameter.isAnnotationPresent(MyFixture.class)
-                || parameter.isAnnotationPresent(MyTestCase.class);
-    }
-
-    @Override
-    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
-        LightCodeInsightFixtureTestCaseWrapper testCase = getWrapper(extensionContext);
-        Parameter parameter = parameterContext.getParameter();
-        if (parameter.isAnnotationPresent(MyFixture.class)) {
-            return testCase.getMyFixture();
-        } else if (parameter.isAnnotationPresent(MyTestCase.class)) {
-            return testCase;
-        }
-        return null;
-    }
-
-    private LightCodeInsightFixtureTestCaseWrapper getWrapper(ExtensionContext extensionContext) {
-        Store store = getStore(extensionContext);
-        return (LightCodeInsightFixtureTestCaseWrapper) store.getOrComputeIfAbsent("testCase",
-                key -> {
-                    LightCodeInsightFixtureTestCaseWrapper wrapper = new LightCodeInsightFixtureTestCaseWrapper(extensionContext);
-                    try {
-                        wrapper.setUp();
-                    } catch (Exception e) {
-                        LOG.severe("Exception during setUp(): " + e);
-                        throw new IllegalStateException("Exception during setUp()", e);
-                    }
-                    return wrapper;
-                });
-    }
-
-    @Override
-    public void afterTestExecution(ExtensionContext context) throws Exception {
-        Store store = getStore(context);
-        LightCodeInsightFixtureTestCaseWrapper testCase = (LightCodeInsightFixtureTestCaseWrapper) store.get("testCase");
-        if (testCase != null) {
-            testCase.tearDown();
-        }
-    }
-
-    private static Store getStore(ExtensionContext context) {
-        return context.getStore(Namespace.create(LightCodeInsightExtension.class, context.getRequiredTestMethod()));
-    }
-
-    @Override
-    public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
-        Throwable[] throwables = new Throwable[1];
-
-        Runnable runnable = () -> {
-            try {
-                TestLoggerFactory.onTestStarted();
-                invocation.proceed();
-                TestLoggerFactory.onTestFinished(true);
-            } catch (Throwable e) {
-                TestLoggerFactory.onTestFinished(false);
-                throwables[0] = e;
-            }
-        };
-
-        invokeTestRunnable(runnable);
-
-        if (throwables[0] != null) {
-            throw throwables[0];
-        }
-    }
-
-    private static void invokeTestRunnable(@NotNull Runnable runnable) {
-        IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
-        if (policy != null && !policy.runInDispatchThread()) {
-            runnable.run();
-        } else {
-            EdtTestUtilKt.runInEdtAndWait(() -> {
-                runnable.run();
-                return null;
-            });
-        }
-    }
-
-    private static class LightCodeInsightFixtureTestCaseWrapper extends LightJavaCodeInsightFixtureTestCase {
-        private final ExtensionContext extensionContext;
-
-        private LightCodeInsightFixtureTestCaseWrapper(ExtensionContext extensionContext) {
-            this.extensionContext = extensionContext;
-        }
-
-        @Override
-        public void setUp() throws Exception {
-            super.setUp();
-        }
-
-        @Override
-        public void tearDown() throws Exception {
-            super.tearDown();
-            UsefulTestCase.clearFields(this);
-            if (myFixture != null && getProject() != null && !getProject().isDisposed()) {
-                Disposer.dispose(getProject());
-            }
-        }
-
-        @NotNull
-        @Override
-        protected LightProjectDescriptor getProjectDescriptor() {
-            TestJdk testJdk = getMethodOrClassAnnotation(TestJdk.class);
-            if (testJdk == null) {
-                return super.getProjectDescriptor();
-            }
-            return new ProjectDescriptor(testJdk.value(), testJdk.annotations()) {
-                @Override
-                public Sdk getSdk() {
-                    return testJdk.useInternal()
-                            ? JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk()
-                            : super.getSdk();
-                }
-
-                @Override
-                public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @NotNull ContentEntry contentEntry) {
-                    super.configureModule(module, model, contentEntry);
-                    AddLocalJarToModule localJars = getMethodOrClassAnnotation(AddLocalJarToModule.class);
-                    if (localJars != null) {
-                        Stream.of(localJars.value()).forEach(it -> addJarContaining(model, it));
-                    }
-                    List<AddMavenDependencyToModule> mavenDependencies = getMethodOrClassAnnotations(AddMavenDependencyToModule.class);
-                    mavenDependencies.forEach(it -> addFromMaven(model, it.value(), it.includeTransitiveDependencies, it.scope));
-                }
-            };
-        }
-
-        void addJarContaining(ModifiableRootModel model, Class clazz) {
-            try {
-                Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
-
-                VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
-                myFixture.allowTreeAccessForFile(jarFile);
-                PsiTestUtil.addLibrary(
-                        model,
-                        jarPath.getFileName().toString().replace(".jar", ""),
-                        jarPath.getParent().toString(),
-                        jarPath.getFileName().toString()
-                );
-            } catch (URISyntaxException e) {
-                throw new IllegalArgumentException("Class URL malformed", e);
-            }
-        }
-
-        void addFromMaven(ModifiableRootModel model, String mavenCoordinates,
-                          boolean includeTransitiveDependencies, DependencyScope dependencyScope) {
-            List<RemoteRepositoryDescription> remoteRepositoryDescriptions = RemoteRepositoryDescription.DEFAULT_REPOSITORIES;
-            RepositoryLibraryProperties libraryProperties = new RepositoryLibraryProperties(mavenCoordinates, includeTransitiveDependencies);
-            Collection<OrderRoot> roots =
-                    JarRepositoryManager.loadDependenciesModal(model.getProject(), libraryProperties, false, false, null, remoteRepositoryDescriptions);
-            LibraryTable.ModifiableModel tableModel = model.getModuleLibraryTable().getModifiableModel();
-            Library library = tableModel.createLibrary(mavenCoordinates);
-            Library.ModifiableModel libraryModel = library.getModifiableModel();
-            if (roots.isEmpty()) {
-                throw new IllegalStateException(String.format("No roots for '%s'", mavenCoordinates));
-            }
-
-            for (OrderRoot root : roots) {
-                libraryModel.addRoot(root.getFile(), root.getType());
-            }
-
-            LibraryOrderEntry libraryOrderEntry = model.findLibraryOrderEntry(library);
-            if (libraryOrderEntry == null) {
-                throw new IllegalStateException("Unable to find registered library " + mavenCoordinates);
-            }
-            libraryOrderEntry.setScope(dependencyScope);
-
-            libraryModel.commit();
-            tableModel.commit();
-        }
-
-        @Override
-        protected String getTestDataPath() {
-            TestDataPath testDataPath = getMethodOrClassAnnotation(TestDataPath.class);
-            if (testDataPath == null) {
-                return super.getTestDataPath();
-            }
-            TestDataSubPath testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath.class);
-            if (testDataSubPath == null) {
-                return testDataPath.value();
-            }
-            return Paths.get(testDataPath.value(), testDataSubPath.value()).toString();
-        }
-
-        public JavaCodeInsightTestFixture getMyFixture() {
-            return myFixture;
-        }
-
-        private <T extends Annotation> T getMethodOrClassAnnotation(Class<T> clazz) {
-            T annotation = extensionContext.getRequiredTestMethod().getAnnotation(clazz);
-            if (annotation == null) {
-                annotation = extensionContext.getRequiredTestClass().getAnnotation(clazz);
-            }
-            return annotation;
-        }
-
-        private <T extends Annotation> List<T> getMethodOrClassAnnotations(Class<T> clazz) {
-            return Stream.of(extensionContext.getRequiredTestMethod().getAnnotationsByType(clazz),
-                    extensionContext.getRequiredTestClass().getAnnotationsByType(clazz))
-                    .flatMap(Arrays::stream)
-                    .collect(Collectors.toList());
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.PARAMETER)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface MyFixture {
-}

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

@@ -1,11 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.PARAMETER)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface MyTestCase {
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,48 +2,45 @@ package de.platon42.intellij.plugins.cajon
 
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.pom.java.LanguageLevel
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AbstractJUnit5TestCase
-import de.platon42.intellij.jupiter.AddMavenDependencyToModule
+import de.platon42.intellij.jupiter.AddLocalJarToModule
-import de.platon42.intellij.jupiter.LightCodeInsightExtension
 import de.platon42.intellij.jupiter.TestDataPath
 import de.platon42.intellij.jupiter.TestJdk
+import org.assertj.core.api.Assertions
 import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Condition
 import org.junit.jupiter.api.DisplayNameGeneration
 import org.junit.jupiter.api.DisplayNameGenerator
-import org.junit.jupiter.api.extension.ExtendWith
 import java.lang.reflect.Method
 
-@ExtendWith(LightCodeInsightExtension::class)
 @TestDataPath("src/test/resources")
-@TestJdk(LanguageLevel.JDK_1_8, annotations = true, useInternal = true)
+@TestJdk(LanguageLevel.JDK_1_8)
-//@AddLocalJarToModule(Assertions::class)
+@AddLocalJarToModule(Assertions::class)
-@AddMavenDependencyToModule("org.assertj:assertj-core:3.15.0")
+//@AddMavenDependencyToModule("org.assertj:assertj-core:3.25.3", includeTransitiveDependencies = false, DependencyScope.COMPILE)
 @DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
-abstract class AbstractCajonTest {
+abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
 
-    protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
+    protected fun executeQuickFixes(regex: Regex, expectedFixes: Int) {
-        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
+        val quickfixes = getQuickFixes(regex, expectedFixes)
         assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
-        quickfixes.forEach(myFixture::launchAction)
+        quickfixes.forEach(fixture::launchAction)
     }
 
-    protected fun executeQuickFixesNoFamilyNameCheck(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
+    protected fun executeQuickFixesNoFamilyNameCheck(regex: Regex, expectedFixes: Int) {
-        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
+        val quickfixes = getQuickFixes(regex, expectedFixes)
-        quickfixes.forEach(myFixture::launchAction)
+        quickfixes.forEach(fixture::launchAction)
     }
 
-    protected fun getQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int): List<IntentionAction> {
+    protected fun getQuickFixes(regex: Regex, expectedFixes: Int): List<IntentionAction> {
-        val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
+        val allFixes = fixture.getAllQuickFixes()
-        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
+        val quickfixes = allFixes.filter { it.text.matches(regex) }
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${allFixes.map { it.text }}").hasSize(expectedFixes)
         return quickfixes
     }
 
-    protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
+    protected fun assertHighlightings(count: Int, snippet: String) {
-        val highlights = myFixture.doHighlighting()
+        assertThat(fixture.doHighlighting())
-            .asSequence()
+            .areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
-            .filter { it.description?.contains(snippet) ?: false }
-            .toList()
-        assertThat(highlights).hasSize(count);
     }
 
     class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {

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

@@ -1,19 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import com.intellij.testFramework.RunsInEdt
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/BinaryExpression")
 internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/BinaryExpression")
+    @RunsInEdt
-    internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_of_binary_expression_can_be_moved_out() {
-        myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
+        fixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
-        myFixture.configureByFile("BinaryExpressionBefore.java")
+        fixture.configureByFile("BinaryExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
+        executeQuickFixes(Regex.fromLiteral("Split binary expression out of assertThat()"), 161)
-        myFixture.checkResultByFile("BinaryExpressionAfter.java")
+        fixture.checkResultByFile("BinaryExpressionAfter.java")
     }
 }

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

@@ -1,22 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/BooleanCondition")
 internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/BooleanCondition")
+    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse() {
-    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
-        myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
+        fixture.configureByFile("BooleanConditionBefore.java")
-        myFixture.configureByFile("BooleanConditionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
+        fixture.checkResultByFile("BooleanConditionAfter.java")
-        myFixture.checkResultByFile("BooleanConditionAfter.java")
     }
 }

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

@@ -1,7 +1,5 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
@@ -11,68 +9,68 @@ import org.junit.jupiter.api.Test
 internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods() {
-        myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
+        fixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
-        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
+        fixture.checkResultByFile("CollectionMapExpressionAfter.java")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 3
-        myFixture.enableInspections(inspection)
+        fixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
-        myFixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
+        fixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 0
 
-        myFixture.enableInspections(inspection)
+        fixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 1
 
-        myFixture.enableInspections(inspection)
+        fixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
-        val highlights = myFixture.doHighlighting()
+        val highlights = fixture.doHighlighting()
             .asSequence()
             .filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
             .filter {
@@ -81,24 +79,24 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
             .toList()
         assertThat(highlights).hasSize(4)
 
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
     }
 
     @Test
-    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
         val inspection = AssertThatCollectionOrMapExpressionInspection()
         inspection.behaviorForMapValueEqualsNull = 4
 
-        myFixture.enableInspections(inspection)
+        fixture.enableInspections(inspection)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
     }
 }

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

@@ -1,24 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/Comparable")
 internal class AssertThatComparableInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/Comparable")
+    internal fun assertThat_with_compareTo_method() {
-    internal fun assertThat_with_compareTo_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatComparableInspection::class.java)
-        myFixture.enableInspections(AssertThatComparableInspection::class.java)
+        fixture.configureByFile("ComparableBefore.java")
-        myFixture.configureByFile("ComparableBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
+        fixture.checkResultByFile("ComparableAfter.java")
-        myFixture.checkResultByFile("ComparableAfter.java")
     }
 }

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

@@ -1,19 +1,21 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/EnumerableIsEmpty")
 internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/EnumerableIsEmpty")
+    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty() {
-    internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
-        myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
+        fixture.configureByFile("EnumerableIsEmptyBefore.java")
-        myFixture.configureByFile("EnumerableIsEmptyBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
-        myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
+        fixture.checkResultByFile("EnumerableIsEmptyAfter.java")
     }
 }

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

@@ -1,38 +1,36 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/FileExpression")
 internal class AssertThatFileExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/FileExpression")
+    internal fun assertThat_with_certain_File_methods() {
-    internal fun assertThat_with_certain_File_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatFileExpressionInspection::class.java)
-        myFixture.enableInspections(AssertThatFileExpressionInspection::class.java)
+        fixture.configureByFile("FileExpressionBefore.java")
-        myFixture.configureByFile("FileExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
+        fixture.checkResultByFile("FileExpressionAfter.java")
-        myFixture.checkResultByFile("FileExpressionAfter.java")
     }
 }

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

@@ -1,48 +1,45 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
-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(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
+@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
 @TestDataSubPath("inspections/GuavaOptional")
 internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
 
     @Test
-    internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified() {
-        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-        myFixture.configureByFile("GuavaOptionalBefore.java")
+        fixture.configureByFile("GuavaOptionalBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
-        myFixture.checkResultByFile("GuavaOptionalAfter.java")
+        fixture.checkResultByFile("GuavaOptionalAfter.java")
     }
 
     @Test
-    internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun adds_missing_Guava_import_any_order() {
-        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+        fixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 4)
+        executeQuickFixesNoFamilyNameCheck(Regex(".*eplace .* with .*"), 4)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(Regex("Remove .*"), 3)
-        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
+        fixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
 
     @Test
-    internal fun adds_missing_Guava_import_isAbsent_first(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun adds_missing_Guava_import_isAbsent_first() {
-        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        fixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+        fixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(Regex(".*eplace .* with .*"), 3)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(Regex("Remove .*"), 3)
-        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
+        fixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
 }

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

@@ -1,20 +1,18 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/InstanceOf")
 internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/InstanceOf")
+    internal fun assertThat_with_instanceof_can_be_moved_out() {
-    internal fun assertThat_with_instanceof_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatInstanceOfInspection::class.java)
-        myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
+        fixture.configureByFile("InstanceOfBefore.java")
-        myFixture.configureByFile("InstanceOfBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
+        fixture.checkResultByFile("InstanceOfAfter.java")
-        myFixture.checkResultByFile("InstanceOfAfter.java")
     }
 }

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

@@ -1,19 +1,19 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/InvertedBooleanCondition")
 internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/InvertedBooleanCondition")
+    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted() {
-    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
-        myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
+        fixture.configureByFile("InvertedBooleanConditionBefore.java")
-        myFixture.configureByFile("InvertedBooleanConditionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Invert condition in assertThat()"), 25)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
+        executeQuickFixes(Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
-        myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
+        executeQuickFixes(Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
+        fixture.checkResultByFile("InvertedBooleanConditionAfter.java")
     }
 }

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

@@ -0,0 +1,19 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.junit.jupiter.api.Test
+
+@TestDataSubPath("inspections/IsZeroOne")
+internal class AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
+
+    @Test
+    internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero() {
+        fixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
+        fixture.configureByFile("IsZeroOneBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
+        fixture.checkResultByFile("IsZeroOneAfter.java")
+    }
+}

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

@@ -1,27 +1,25 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/Java8Optional")
 internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/Java8Optional")
+    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified() {
-    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
-        myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
+        fixture.configureByFile("Java8OptionalBefore.java")
-        myFixture.configureByFile("Java8OptionalBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+        fixture.checkResultByFile("Java8OptionalAfter.java")
-        myFixture.checkResultByFile("Java8OptionalAfter.java")
     }
 }

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

@@ -1,22 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/ObjectExpression")
 internal class AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/ObjectExpression")
+    internal fun assertThat_with_certain_Object_methods() {
-    internal fun assertThat_with_certain_Object_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
-        myFixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
+        fixture.configureByFile("ObjectExpressionBefore.java")
-        myFixture.configureByFile("ObjectExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
+        fixture.checkResultByFile("ObjectExpressionAfter.java")
-        myFixture.checkResultByFile("ObjectExpressionAfter.java")
     }
 }

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

@@ -1,20 +1,18 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/ObjectIsNullOrNotNull")
 internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
+    internal fun assertThat_with_isEqualTo_null_can_use_isNull() {
-    internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
-        myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+        fixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-        myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
+        fixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
-        myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
     }
 }

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

@@ -1,24 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/PathExpression")
 internal class AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/PathExpression")
+    internal fun assertThat_with_certain_Path_methods() {
-    internal fun assertThat_with_certain_Path_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatPathExpressionInspection::class.java)
-        myFixture.enableInspections(AssertThatPathExpressionInspection::class.java)
+        fixture.configureByFile("PathExpressionBefore.java")
-        myFixture.configureByFile("PathExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
+        fixture.checkResultByFile("PathExpressionAfter.java")
-        myFixture.checkResultByFile("PathExpressionAfter.java")
     }
 }

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

@@ -1,34 +1,32 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/Size")
 internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/Size")
+    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified() {
-    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatSizeInspection::class.java)
-        myFixture.enableInspections(AssertThatSizeInspection::class.java)
+        fixture.configureByFile("SizeBefore.java")
-        myFixture.configureByFile("SizeBefore.java")
+        assertHighlightings(1, "Try to operate on the iterable itself rather than its size")
-        assertHighlightings(myFixture, 1, "Try to operate on the iterable itself rather than its size")
 
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
+        executeQuickFixes(Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
-        myFixture.checkResultByFile("SizeAfter.java")
+        fixture.checkResultByFile("SizeAfter.java")
     }
 }

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

@@ -1,41 +1,39 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/StringExpression")
 internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/StringExpression")
+    internal fun assertThat_with_certain_String_methods() {
-    internal fun assertThat_with_certain_String_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatStringExpressionInspection::class.java)
-        myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
+        fixture.configureByFile("StringExpressionBefore.java")
-        myFixture.configureByFile("StringExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().matches() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove matches() of actual expression and use assertThat().doesNotMatch() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove compareToIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().startsWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().contains() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove indexOf() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove trim() of actual expression and use assertThat().isNotBlank() instead"), 1)
+        fixture.checkResultByFile("StringExpressionAfter.java")
-        myFixture.checkResultByFile("StringExpressionAfter.java")
     }
 }

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

@@ -1,27 +1,25 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.extrakting
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/StringIsEmpty")
 internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/StringIsEmpty")
+    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty() {
-    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
-        myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
+        fixture.configureByFile("StringIsEmptyBefore.java")
-        myFixture.configureByFile("StringIsEmptyBefore.java")
+        val highlights = fixture.doHighlighting()
-        val highlights = myFixture.doHighlighting()
             .asSequence()
             .filter { it.description?.contains(" can be simplified to") ?: false }
             .toList()
         assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
-        myFixture.checkResultByFile("StringIsEmptyAfter.java")
+        fixture.checkResultByFile("StringIsEmptyAfter.java")
     }
 }

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

@@ -1,22 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
-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(Assertions::class, Test::class, org.junit.Test::class)
+@AddMavenDependencyToModule("junit:junit:4.13.2")
+@AddMavenDependencyToModule("org.junit.jupiter:junit-jupiter-api:5.10.2")
+@TestDataSubPath("inspections/AssumeThat")
 internal class AssumeThatInsteadOfReturnInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/AssumeThat")
+    internal fun conditional_returns_can_be_replaced_by_assumeThat() {
-    internal fun conditional_returns_can_be_replaced_by_assumeThat(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
-        myFixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
+        fixture.configureByFile("AssumeThatBefore.java")
-        myFixture.configureByFile("AssumeThatBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
+        fixture.checkResultByFile("AssumeThatAfter.java")
-        myFixture.checkResultByFile("AssumeThatAfter.java")
     }
 }

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

@@ -1,18 +1,17 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/BogusAssertion")
 internal class BogusAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/BogusAssertion")
+    internal fun reports_bogus_assertions() {
-    internal fun reports_bogus_assertions(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(BogusAssertionInspection::class.java)
-        myFixture.enableInspections(BogusAssertionInspection::class.java)
+        fixture.configureByFile("BogusAssertionBefore.java")
-        myFixture.configureByFile("BogusAssertionBefore.java")
+        assertHighlightings(14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
-        assertHighlightings(myFixture, 14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
+        assertHighlightings(3, "Same actual and expected expression, but may be testing equals() or hashCode()")
     }
 }

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

@@ -1,24 +1,21 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
-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(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
+@AddMavenDependencyToModule("org.assertj:assertj-guava:3.25.3")
+@TestDataSubPath("inspections/ImplicitAssertion")
 internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/ImplicitAssertion")
+    internal fun implicit_assertions_can_be_removed() {
-    internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(ImplicitAssertionInspection::class.java)
-        myFixture.enableInspections(ImplicitAssertionInspection::class.java)
+        fixture.configureByFile("ImplicitAssertionBefore.java")
-        myFixture.configureByFile("ImplicitAssertionBefore.java")
+        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 101)
+        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
+        executeQuickFixesNoFamilyNameCheck(Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
+        fixture.checkResultByFile("ImplicitAssertionAfter.java")
-        myFixture.checkResultByFile("ImplicitAssertionAfter.java")
     }
 }

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

@@ -1,24 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddMavenDependencyToModule
-import de.platon42.intellij.jupiter.AddLocalJarToModule
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
-import org.assertj.core.api.Assertions
-import org.junit.Assert
 import org.junit.jupiter.api.Test
 
-@AddLocalJarToModule(Assert::class, Assertions::class)
+@AddMavenDependencyToModule("junit:junit:4.13.2")
+@TestDataSubPath("inspections/JUnitAssertToAssertJ")
 internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/JUnitAssertToAssertJ")
+    internal fun junit_Assertions_can_be_converted_into_AssertJ() {
-    internal fun junit_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
-        myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
+        fixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-        myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
+        executeQuickFixesNoFamilyNameCheck(Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+        executeQuickFixesNoFamilyNameCheck(Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
+        fixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
-        myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
     }
 }

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

@@ -1,19 +1,17 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/JoinStatements")
 internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/JoinStatements")
+    internal fun assertThat_statements_can_be_joined_together() {
-    internal fun assertThat_statements_can_be_joined_together(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
-        myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
+        fixture.configureByFile("JoinStatementsBefore.java")
-        myFixture.configureByFile("JoinStatementsBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Join assertThat() statements"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
+        fixture.checkResultByFile("JoinStatementsAfter.java")
-        myFixture.checkResultByFile("JoinStatementsAfter.java")
     }
 }

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

@@ -1,19 +1,17 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/JoinVarArgsContains")
 internal class JoinVarArgsContainsInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/JoinVarArgsContains")
+    internal fun join_contains_and_doesNotContain_together_where_possible() {
-    internal fun join_contains_and_doesNotContain_together_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(JoinVarArgsContainsInspection::class.java)
-        myFixture.enableInspections(JoinVarArgsContainsInspection::class.java)
+        fixture.configureByFile("JoinVarArgsContainsBefore.java")
-        myFixture.configureByFile("JoinVarArgsContainsBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
+        fixture.checkResultByFile("JoinVarArgsContainsAfter.java")
-        myFixture.checkResultByFile("JoinVarArgsContainsAfter.java")
     }
 }

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

@@ -1,23 +1,21 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/TwistedAssertion")
 internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/TwistedAssertion")
+    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible() {
-    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        fixture.enableInspections(TwistedAssertionInspection::class.java)
-        myFixture.enableInspections(TwistedAssertionInspection::class.java)
+        fixture.configureByFile("TwistedAssertionBefore.java")
-        myFixture.configureByFile("TwistedAssertionBefore.java")
+        assertHighlightings(9, "Actual expression in assertThat() is a constant")
-        assertHighlightings(myFixture, 4, "Actual expression in assertThat() is a constant")
+        assertHighlightings(10, "Twisted actual and expected expressions")
-        assertHighlightings(myFixture, 10, "Twisted actual and expected expressions")
 
-        executeQuickFixes(myFixture, Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
+        executeQuickFixes(Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Replace .* by .* and swap actual and expected expressions"), 4)
+        executeQuickFixesNoFamilyNameCheck(Regex("Replace .* by .* and swap actual and expected expressions"), 4)
-        myFixture.checkResultByFile("TwistedAssertionAfter.java")
+        fixture.checkResultByFile("TwistedAssertionAfter.java")
     }
 }

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

@@ -1,7 +1,5 @@
 package de.platon42.intellij.plugins.cajon.references
 
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
@@ -13,68 +11,68 @@ import org.junit.jupiter.api.Test
 internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extracting(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_for_field_extracting() {
-        myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path() {
-        myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("protected Address address;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field() {
-        myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
+        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call() {
-        myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
+        assertThat(fixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part() {
-        myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
+        assertThat(fixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_byName_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_using_byName_extractor() {
-        myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor() {
-        myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
+        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list() {
-        myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list() {
-        myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
+        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method() {
-        myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
+        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_unable_to_find_reference(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun extractor_is_unable_to_find_reference() {
-        myFixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
+        fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
-        assertThatThrownBy { myFixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
+        assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
     }
 }

src/test/resources/inspections/BogusAssertion/BogusAssertionBefore.java

@@ -1,3 +1,4 @@
+import java.io.File;
 import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -190,7 +191,28 @@ public class BogusAssertions {
 
         assertThat(bar).isEqualTo(string);
 
+        assertThat(new Random().nextBoolean()).isEqualTo(new Random().nextBoolean());
+        assertThat(generateString()).isEqualTo(generateString());
+
+        int number = 4;
+        assertThat(number++).isEqualTo(number++);
+        assertThat(number++).isEqualTo(number++);
+
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");
     }
+
+    private void test_equals() {
+        assertThat("foo").isEqualTo("foo");
+        assertThat(new File("foo")).isEqualTo(new File("foo"));
+    }
+
+    private void test_HasHCode() {
+        assertThat("foo").hasSameHashCodeAs("foo");
+    }
+
+    private String generateString()
+    {
+        return "foo";
+    }
 }

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/IsZeroOne/IsZeroOneAfter.java

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

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

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

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

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

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

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

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

@@ -1,4 +1,5 @@
 import java.util.*;
+import java.util.regex.Pattern;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
@@ -30,7 +31,18 @@ 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(".."));
+        assertThat("XX").matches(".."));
+        assertThat("XX").doesNotMatch(Pattern.compile(".."));
+        assertThat("XX").doesNotMatch(".."));
+        assertThat(SOME_CONST).isEqualTo(10);
 
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");

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

@@ -1,4 +1,5 @@
 import java.util.*;
+import java.util.regex.Pattern;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
@@ -30,7 +31,18 @@ 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(".."));
+        assertThat("XX").matches(".."));
+        assertThat("XX").doesNotMatch(Pattern.compile(".."));
+        assertThat("XX").doesNotMatch(".."));
+        assertThat(SOME_CONST).isEqualTo(10);
 
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");