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

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.
 
@@ -34,28 +34,40 @@ Then AssertJ would tell you the _actual contents_ of the collection on failure.
 
 The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
 
+## Wrong use of AssertJ
+
+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 
-fields (refactoring a getter method without a corresponding field will not work 
-correctly right now).
+This plugin adds support for referencing these fields (so you can ctrl(/cmd)-click 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) 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).
 
 Or, you can use the "Run Inspection by Name..." action to run one inspection on a bigger scope (e.g. the whole project).
-Applying a quick fix might result in further optimization possibilities, so 
+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()));
 
@@ -73,7 +85,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 ## Implemented inspections and quickfixes
 
 - JoinAssertThatStatements
-  
+
   Joins multiple ```assertThat()``` statements with same actual expression together.
 
   ```
@@ -83,21 +95,21 @@ 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,
   the statements will not be merged.
-  
+
   The behavior regarding the insertion of line breaks between the expressions can be configured in the
   inspection settings.
 
 - JoinVarArgsContains
 
-  Looks for ```.contains()```, ```.doesNotContain()```, and .```containsOnlyOnce()``` calls for iterables 
+  Looks for ```.contains()```, ```.doesNotContain()```, and .```containsOnlyOnce()``` calls for iterables
   within the same statement. The available quickfix can join the arguments to variadic version of the call
   and remove the surplus one.
-  
+
   ```
   from: assertThat(expected).contains("foo").doesNotContain("bar").contains("etc").doesNotContain("huh");
     to: assertThat(expected).contains("foo", "etc").doesNotContain("bar", "huh");
@@ -106,7 +118,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   changing semantics or losing descriptions.
 
   Note that the quickfix does not handle comments very well and might remove them during the operation.
-  
+
   You may need to perform some manual reformatting, if the line gets too long after applying the fix.
 
 - AssertThatObjectIsNullOrNotNull
@@ -132,18 +144,25 @@ 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
 
   Moves ```instanceof``` expressions out of ```assertThat()```.
-  
+
   ```
   from: assertThat(object instanceof classname).isEqualTo(true);
   from: assertThat(object instanceof classname).isTrue();
@@ -154,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.
@@ -167,9 +203,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   The ```assertThat(string.length()).isEqualTo(0);``` case is handled in the AssertThatSize inspection.
 
 - AssertThatStringExpression
-  
+
   Moves string operations inside ```assertThat()``` out.
-  
+
   ```
   from: assertThat(stringActual.isEmpty()).isTrue();
     to: assertThat(stringActual).isEmpty();
@@ -189,13 +225,40 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   from: assertThat(stringActual.endsWith(stringExpected)).isTrue();
     to: assertThat(stringActual).endsWith(stringExpected);
+
+  from: assertThat(stringActual.matches(stringExpected)).isTrue();
+    to: assertThat(stringActual).matches(stringExpected);
   ```
   Analogously with ```isFalse()```.
 
+  More funny stuff (excerpt):
+
+  ```
+  from: assertThat(stringActual.compareToIgnoreCase(stringExpected)).isEqualTo(0);
+    to: assertThat(stringActual).isEqualToIgnoringCase(stringExpected);
+
+  from: assertThat(stringActual.indexOf(stringExpected)).isEqualTo(0);
+  from: assertThat(stringActual.indexOf(stringExpected)).isZero();
+    to: assertThat(stringActual).startsWith(stringExpected);
+
+  from: assertThat(stringActual.indexOf(stringExpected)).isNotZero();
+    to: assertThat(stringActual).doesNotStartWith(stringExpected);
+
+  from: assertThat(stringActual.indexOf(stringExpected)).isEqualTo(-1);
+  from: assertThat(stringActual.indexOf(stringExpected)).isNegative();
+    to: assertThat(stringActual).doesNotContain(stringExpected);
+
+  from: assertThat(stringActual.indexOf(stringExpected)).isGreaterThanOrEqualTo(0);
+    to: assertThat(stringActual).contains(stringExpected);
+
+  from: assertThat(stringActual.trim()).isNotEmpty();
+    to: assertThat(stringActual).isNotBlank();
+  ```
+
 - AssertThatObjectExpression
 
-  Handles equals(), toString() and hashCode() inside an expected expression.
-  
+  Handles ```equals()```, ```toString()``` and ```hashCode()``` inside an expected expression.
+
   ```
   from: assertThat(objActual.equals(objExpected)).isTrue();
     to: assertThat(objActual).isEqualTo(objExpected);
@@ -207,9 +270,38 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(objActual).hasSameHashCodeAs(objExpected);
   ```
 
+- AssertThatComparableExpression
+
+  Handles ```compareTo()``` inside an expected expression.
+
+  ```
+  from: assertThat(obj1.compareTo(obj2)).isEqualTo(0);
+    to: assertThat(obj1).isEqualByComparingTo(obj2);
+
+  from: assertThat(obj1.compareTo(obj2)).isNotZero();
+    to: assertThat(obj1).isNotEqualByComparingTo(obj2);
+
+  from: assertThat(obj1.compareTo(obj2)).isNotEqualTo(-1);
+  from: assertThat(obj1.compareTo(obj2)).isGreaterThanOrEqualTo(0);
+  from: assertThat(obj1.compareTo(obj2)).isGreaterThan(-1);
+  from: assertThat(obj1.compareTo(obj2)).isNotNegative();
+    to: assertThat(obj1).isGreaterThanOrEqualTo(obj2);
+
+  from: assertThat(obj1.compareTo(obj2)).isOne();
+    to: assertThat(obj1).isGreaterThan(obj2);
+
+  from: assertThat(obj1.compareTo(obj2)).isNotPositive();
+    to: assertThat(obj1).isLessThanOrEqualTo(obj2);
+  
+  from: assertThat(obj1.compareTo(obj2)).isLessThan(0);
+    to: assertThat(obj1).isLessThan(obj2);
+  ```
+
+  Several more combinations omitted...
+
 - AssertThatCollectionOrMapExpression
 
-  Moves collection and map operations inside ```assertThat()``` out.
+  Moves ```Collection``` and ```Map``` operations inside ```assertThat()``` out.
 
   ```
   from: assertThat(collection.isEmpty()).isTrue();
@@ -232,7 +324,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
   Analogously with ```isFalse()``` (except for ```containsAll()```).
 
-  Additional transformations for maps:
+  Additional transformations for ```Map``` instances:
 
   ```
   from: assertThat(map.get(key)).isEqualTo(value);
@@ -248,19 +340,128 @@ 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 upon the map
+  being a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
+  but ```containsKey(key)``` is ```true```.
+  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```),
+  choosing between both fixes (does not work well for batch processing), or ignore this edge case
+  altogether (just to be sure to not break any code).
+
+- AssertThatFileExpression
+
+  Moves ```File``` method calls inside ```assertThat()``` out.
+
+  ```
+  from: assertThat(file.canRead()).isTrue();
+    to: assertThat(file).canRead();
+
+  from: assertThat(file.canWrite()).isTrue();
+    to: assertThat(file).canWrite();
+
+  from: assertThat(file.exists()).isTrue();
+    to: assertThat(file).exists();
+
+  from: assertThat(file.exists()).isFalse();
+    to: assertThat(file).doesNotExist();
+
+  from: assertThat(file.isAbsolute()).isTrue();
+    to: assertThat(file).isAbsolute();
+
+  from: assertThat(file.isAbsolute()).isFalse();
+    to: assertThat(file).isRelative();
+
+  from: assertThat(file.isDirectory()).isTrue();
+    to: assertThat(file).isDirectory();
+
+  from: assertThat(file.isFile()).isTrue();
+    to: assertThat(file).isFile();
+
+  from: assertThat(file.getName()).isEqualTo(filename);
+    to: assertThat(file).hasName(filename);
+
+  from: assertThat(file.getParent()).isEqualTo(pathname);
+    to: assertThat(file).hasParent(pathname);
+
+  from: assertThat(file.getParent()).isNull();
+  from: assertThat(file.getParentFile()).isNull();
+    to: assertThat(file).hasNoParent();
+
+  from: assertThat(file.list()).isEmpty();
+  from: assertThat(file.listFiles()).isEmpty();
+    to: assertThat(file).isEmptyDirectory();
+
+  from: assertThat(file.list()).isNotEmpty();
+  from: assertThat(file.listFiles()).isNotEmpty();
+    to: assertThat(file).isNotEmptyDirectory();
+  ```
+
+  and additionally with AssertJ 3.14.0 or later
+
+  ```
+  from: assertThat(file.length()).isEqualTo(0);
+  from: assertThat(file.length()).isZero();
+    to: assertThat(file).isEmpty();
+
+  from: assertThat(file.length()).isNotEqualTo(0);
+  from: assertThat(file.length()).isNotZero();
+    to: assertThat(file).isNotEmpty();
+
+  from: assertThat(file.length()).isEqualTo(len);
+    to: assertThat(file).hasSize(len);
+  ```
+
+- AssertThatPathExpression
+
+  Moves ```Path``` method calls inside ```assertThat()``` out.
+  Note: Uses hasParentRaw() instead of hasParent() for quickfixes, because it is semantically
+  equivalent. For most cases though, hasParent() will show identical behavior.
+
+  ```
+  from: assertThat(path.isAbsolute()).isTrue();
+    to: assertThat(path).isAbsolute();
+
+  from: assertThat(path.isAbsolute()).isFalse();
+    to: assertThat(path).isRelative();
+
+  from: assertThat(path.getParent()).isEqualTo(pathname);
+    to: assertThat(path).hasParentRaw(pathname);
+
+  from: assertThat(path.getParent()).isNull();
+    to: assertThat(path).hasNoParentRaw();
+
+  from: assertThat(path.startsWith(otherPath)).isTrue();
+    to: assertThat(path).startsWithRaw(otherPath);
+
+  from: assertThat(path.endsWith(otherPath)).isTrue();
+    to: assertThat(path).endsWithRaw(otherPath);
+  ```
+
 - 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
 
-  Makes assertions on sizes of arrays, collections, maps, strings, 
-  or ```CharSequence```s more concise.
+  Makes assertions on sizes on ```Array```, ```Collection```,
+  ```Map```, ```String```, or ```CharSequence``` instances more concise.
 
   ```
   from: assertThat(array.length).isEqualTo(0);
@@ -296,14 +497,15 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat(array.length).isGreaterThanOrEqualTo(expression);
     to: assertThat(array).hasSizeGreaterThanOrEqualTo(expression);
   ```
-  and analogously for collections, maps, strings and CharSequences, e.g:
+  and analogously for ```Collection```, ```Map```, ```String``` and
+  ```CharSequence``` objects, e.g:
 
   ```
   from: assertThat("string".length()).isLessThan(1);
     to: assertThat("string").isEmpty();
 
-  from: assertThat("string".length()).isEqualTo(map.size())
-    to: assertThat("string").hasSameSizeAs(map);
+  from: assertThat(map.size()).isEqualTo(anotherMap.size())
+    to: assertThat(map).hasSameSizeAs(anotherMap);
     
   from: assertThat("string".length()).hasSize("strong".length())
     to: assertThat("string").hasSameSizeAs("strong");
@@ -328,6 +530,84 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
   ...and many, many more combinations (more than 150).
 
+- TwistedAssertion
+
+  Examines the actual expression for common mistakes such as mixing expected and actual expression.
+  For simple cases, a quick fix is offered to swap them. Otherwise, only a warning is issued.
+
+  ```
+  from: assertThat(5).isEqualTo(variable);
+    to: assertThat(variable).isEqualTo(5);
+
+  from: assertThat(8.0).isGreaterThan(variable);
+    to: assertThat(variable).isLessOrEqualTo(8.0);
+  ```
+
+  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
+  that will never fail due to the same actual and expected assertions.
+  This inspection will warn about obvious cases such as the following ones.
+
+  ```
+  assertThat(object).isEqualTo(object);
+  assertThat(object).isSameAs(object);
+  assertThat(object).hasSameClassAs(object);
+  assertThat(object).hasSameHashCodeAs(object);
+
+  assertThat(array).hasSameSizeAs(array);
+  assertThat(array).contains(array);
+  assertThat(array).containsAnyOf(array);
+  assertThat(array).containsExactly(array);
+  assertThat(array).containsExactlyInAnyOrder(array);
+  assertThat(array).containsExactlyInAnyOrder(array);
+  assertThat(array).containsOnly(array);
+  assertThat(array).containsSequence(array);
+  assertThat(array).containsSubsequence(array);
+  assertThat(array).startsWith(array);
+  assertThat(array).endsWith(array);
+  
+  assertThat(enumerable).hasSameSizeAs(enumerable);
+
+  assertThat(iterable).hasSameElementsAs(iterable);
+  assertThat(iterable).containsAll(iterable);
+  assertThat(iterable).containsAnyElementOf(iterable);
+  assertThat(iterable).containsOnlyElementsOf(iterable);
+  assertThat(iterable).containsExactlyElementsOf(iterable);
+  assertThat(iterable).containsSequence(iterable);
+  assertThat(iterable).containsSubsequence(iterable);
+
+  assertThat(charSeq).isEqualToIgnoringCase(charSeq);
+  assertThat(charSeq).startsWith(charSeq);
+  assertThat(charSeq).endsWith(charSeq);
+  assertThat(charSeq).containsSequence(charSeq);
+  assertThat(charSeq).containsSubsequence(charSeq);
+
+  assertThat(map).containsAllEntriesOf(map);
+  assertThat(map).containsExactlyEntriesOf(map);
+  assertThat(map).containsExactlyInAnyOrderEntriesOf(map);
+  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
@@ -349,9 +629,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatJava8Optional
 
   Examines the statement for Java 8 ```Optional``` type and whether the statement
-  effectively tries to assert the presence, absence or content and then 
+  effectively tries to assert the presence, absence or content and then
   replaces the statement by better assertions.
-  
+
   ```
   from: assertThat(opt.isPresent()).isEqualTo(true);
   from: assertThat(opt.isPresent()).isNotEqualTo(false);
@@ -389,7 +669,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatGuavaOptional
 
   Examines the statement for Google Guava ```Optional``` type and whether the statement
-  effectively tries to assert the presence, absence or content and then 
+  effectively tries to assert the presence, absence or content and then
   replaces the statement by better assertions.
 
   ```
@@ -423,31 +703,31 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(opt).isPresent();
   ```
 
-  AssertJ for Guava needs to be available in the classpath.
+  AssertJ for Guava needs to be available in the classpath for this inspection to work.
 
 - AssumeThatInsteadOfReturn
 
   Tries to detect bogus uses of return statements in test methods and replaces them by ```assumeThat()``` calls.
-  
+
   Novices will use these to skip test execution by bailing out early on some preconditions not met.
   However, this suggests that the test has actually been run and passed instead of showing the test
   as being skipped.
 
-  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or 
+  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or
   Jupiter ```@Test``` annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
   Method calls within the same class will be examined for ```assertThat()``` statements, too.
   However, at most 50 statements and down to five recursions will be tolerated before giving up.
-  
+
   Currently, the quickfix may lose some comments during operation. The other branch of the ```if``` statement
   will be inlined (blocks with declarations will remain a code block due to variable scope).
   The quickfix will only work with AssertJ >= 2.9.0 (for 2.x releases) or >= 3.9.0 (for 3.x releases).
-  
+
   The generated ```assumeThat()``` statement could be optimized further (similar to ```assertThat()```), but
   there is currently no support in Cajon for this (you could rename the method to ```assertThat()``` optimize it
   and turn it back into ```assumeThat()``` in the end).
 
   Example:
-  
+
   ```
       @Test
       public void check_fuel_emission() {
@@ -471,14 +751,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - JUnitAssertToAssertJ
 
   Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
-  Sometimes the expected and actual expressions are specified in wrong order -- 
+  Sometimes the expected and actual expressions are specified in wrong order --
   Cajon tries to swap these when it detects the supposed actual expression to be a
   constant while the expected one is not.
 
   Does not support Hamcrest-Matchers.
   If you need that kind of conversion, you might want to check out the
   [Assertions2AssertJ plugin](https://plugins.jetbrains.com/plugin/10345-assertions2assertj) by Ric Emery.
-  
+
   ```
   assertTrue(condition);
   assertTrue(message, condition);
@@ -516,6 +796,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ### Implemented referencing
 
+You can ctrl-click on references inside .extracting() method parameters to go the
+referencing method definition.
+
   ```
   .extracting("field")
   .extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
@@ -529,49 +812,142 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   .flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
   .flatExtracting(Extractors.resultOf("bareMethod")
   ```
-  Works on both POJOs and ```Iterable```s/```Array```s. 
-  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
-  If there's demand, I could add it.
+
+This works on both POJOs and ```Iterable```s/```Array```s.
+Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+If there's demand, I could add it.
 
 ## Development notice
 
-Cajon is written in Kotlin 1.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 ;) ).
-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.
+Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one I'm aware of ;) ).
+The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to make it work with JUnit 5.
 Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
 
 ## Planned features
-- More Optional fixes such as opt1.get() == opt2.get() etc.
-- More moving out of methods for File, Path, LocalDate/Time etc.
-- Converting ```foo.compareTo(bar) == 0``` to ```isEqualTo()``` (yes, I've *really* seen code like that)
-- Extraction with property names to lambda with Java 8
+
+- 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).
+- Added AssertThatComparableExpression for funny ```compareTo()``` uses.
+- 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
+  that would not correctly invert the condition on transformation.
+- Added new AssertThatFileExpression to move out many common methods from inside the
+  ```assertThat()``` expression (```exists(), getName(), getParent()```, and many more).
+- Added several transformations to AssertThatStringExpression inspection.
+  Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
+
+#### V1.5 (24-Sep-19)
+
+- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out-of-bounds exception.
+- AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
+  for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
+- 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 Stefan H.
+- 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.
 - AssertThatJava8Optional and AssertThatGuavaOptional inspections do not longer try to fix
   ```assertThat(optional).isEqualTo(Optional.fromNullable(expression))``` to ```contains()```
   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.
@@ -582,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.
@@ -598,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.
@@ -605,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.
@@ -613,28 +995,36 @@ 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
   getter renaming does not work that perfect, but I'm giving up for now as the IntelliJ SDK docs are seriously lacking).
-- Fixed an exception in batch mode if the description string was the same but for different fixes. 
+- Fixed an exception in batch mode if the description string was the same but for different fixes.
   Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
 
 #### 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.
+
+- Initial release.

build.gradle

@@ -1,76 +0,0 @@
-plugins {
-    id 'java'
-    id 'org.jetbrains.intellij' version '0.4.10'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.50'
-    id 'jacoco'
-    id 'com.github.kt3k.coveralls' version '2.8.4'
-}
-
-group 'de.platon42'
-version '1.4'
-
-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.13.2"
-    testCompile "org.assertj:assertj-guava:3.2.1"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.1'
-    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.2.1'
-//    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
-    updateSinceUntilBuild false
-    plugins = ['java']
-}
-
-patchPluginXml {
-    changeNotes """
-  <h4>V1.4 (25-Aug-19)</h4>
-    <ul>
-      <li>Minor fix for highlighting of JoinVarArgsContains inspection.
-      <li>Extended AssertThatSize inspection to Maps, too.
-      <li>Extended AssertThatCollectionOrMap inspection for several assertThat(map.get()) cases as suggested by Stefan H.
-    </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.4'
-}
-
-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
+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
-if $cygwin ; then
+# For Cygwin or MSYS, switch paths to Windows format before running java
+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 -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        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,47 +12,101 @@ 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

@@ -1,6 +1,5 @@
 package de.platon42.intellij.plugins.cajon
 
-import com.intellij.lang.jvm.JvmModifier
 import com.intellij.psi.*
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.codeStyle.JavaCodeStyleManager
@@ -33,7 +32,7 @@ fun PsiElement.findOutmostMethodCall(): PsiMethodCallExpression? {
 fun PsiElement.findStaticMethodCall(): PsiMethodCallExpression? {
     var elem: PsiElement? = this
     while (elem != null) {
-        if ((elem is PsiMethodCallExpression) && (elem.resolveMethod()?.hasModifier(JvmModifier.STATIC) == true)) {
+        if ((elem is PsiMethodCallExpression) && (elem.resolveMethod()?.hasModifierProperty(PsiModifier.STATIC) == true)) {
             return elem
         }
         elem = elem.firstChild
@@ -44,7 +43,7 @@ fun PsiElement.findStaticMethodCall(): PsiMethodCallExpression? {
 fun PsiElement.gatherAssertionCalls(): List<PsiMethodCallExpression> {
     val assertThatMethodCall = findStaticMethodCall() ?: return emptyList()
     return assertThatMethodCall.collectMethodCallsUpToStatement()
-        .filterNot { NOT_ACTUAL_ASSERTIONS.test(it) }
+        .filterNot(NOT_ACTUAL_ASSERTIONS::test)
         .toList()
 }
 
@@ -116,8 +115,7 @@ fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
 }
 
 fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
-    if (argIndex >= argumentList.expressions.size) return null
-    return getArg(argIndex).calculateConstantValue()
+    return getArgOrNull(argIndex)?.calculateConstantValue()
 }
 
 fun PsiExpression.calculateConstantValue(): Any? {
@@ -182,4 +180,4 @@ fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
         }
     }
     return lockedResult
-}
+}

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,85 +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
@@ -25,7 +26,7 @@ import de.platon42.intellij.plugins.cajon.MethodNames
 import de.platon42.intellij.plugins.cajon.qualifierExpression
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
 
-open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
+abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
         const val SIMPLIFY_MESSAGE_TEMPLATE = "%s() can be simplified to %s()"
@@ -72,6 +73,8 @@ open 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 @@ open 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 @@ open 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)
@@ -120,10 +127,20 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val IS_NOT_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_NULL)
             .parameterCount(0)!!
 
+        val IS_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_EMPTY)
+            .parameterCount(0)!!
         val IS_NOT_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_NOT_EMPTY)
             .parameterCount(0)!!
         val HAS_SIZE = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE)
             .parameterTypes("int")!!
+        val HAS_SIZE_GREATER_THAN_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_GREATER_THAN)
+            .parameterTypes("int")!!
+        val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO)
+            .parameterTypes("int")!!
+        val HAS_SIZE_LESS_THAN_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_LESS_THAN)
+            .parameterTypes("int")!!
+        val HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_LESS_THAN_OR_EQUAL_TO)
+            .parameterTypes("int")!!
 
         val IS_GREATER_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN)
             .parameterTypes("int")!!
@@ -135,9 +152,23 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val IS_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN_OR_EQUAL_TO)
             .parameterTypes("int")!!
 
-        val IS_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
+        val IS_ZERO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
             .parameterCount(0)!!
-        val IS_NOT_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
+        val IS_NOT_ZERO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
+            .parameterCount(0)!!
+        val IS_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
+            .parameterCount(0)!!
+        val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
+            .parameterCount(0)!!
+        val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
+            .parameterCount(0)!!
+        val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
+            .parameterCount(0)!!
+        val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
+            .parameterCount(0)!!
+        val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
+            .parameterCount(0)!!
+        val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
             .parameterCount(0)!!
 
         val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)
@@ -151,12 +182,12 @@ open 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)!!
@@ -170,7 +201,7 @@ open 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)!!
@@ -227,6 +258,20 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         holder.registerProblem(expression, message, quickfix)
     }
 
+    protected fun registerMoveOutMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldActualExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String) -> List<LocalQuickFix>
+    ) {
+        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
+        val description = MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
+        val quickfixes = quickFixSupplier(description)
+        holder.registerProblem(expression, message, *quickfixes.toTypedArray())
+    }
+
     protected fun registerReplaceMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
@@ -262,4 +307,4 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
     ) {
         registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
-}
+}

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

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

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

@@ -38,7 +38,13 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
 
                 if (isLeftNull && isRightNull) return
                 if (isLeftNull || isRightNull) {
-                    val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
+                    val expectedResultOnOp =
+                        when (binaryExpression.operationTokenType) {
+                            JavaTokenType.EQEQ -> expectedResult
+                            JavaTokenType.NE -> !expectedResult
+                            else -> return
+                        }
+                    val replacementMethod = expectedResultOnOp.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
                     registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
                         SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
                     }

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(
-                    IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_BOOLEAN,
-                    IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_BOOLEAN
-                ).map { it.test(expression) }
-                if (matchingCalls.none { it }) return
+                val isEqualToObject = IS_EQUAL_TO_OBJECT.test(expression)
+                val isEqualToPrimitive = IS_EQUAL_TO_BOOLEAN.test(expression)
+                val isNotEqualToObject = IS_NOT_EQUAL_TO_OBJECT.test(expression)
+                val isNotEqualToPrimitive = IS_NOT_EQUAL_TO_BOOLEAN.test(expression)
+
+                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/AssertThatCollectionOrMapExpressionInspection.kt

@@ -1,15 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.openapi.ui.ComboBox
 import com.intellij.psi.*
+import com.intellij.util.ui.FormBuilder
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import java.awt.BorderLayout
+import javax.swing.JComponent
+import javax.swing.JPanel
 
-class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection() {
+
+class AssertThatCollectionOrMapExpressionInspection : AbstractMoveOutInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a collection or map specific expression"
+        private const val DEFAULT_MAP_VALUES_NEVER_NULL = 2
 
         private val MAP_GET_MATCHER = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "get").parameterCount(1)
 
@@ -32,34 +39,37 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
         )
 
         private val MAPPINGS = listOf(
-            Mapping(
+            MoveOutMapping(
                 CallMatcher.anyOf(
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "isEmpty").parameterCount(0),
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "isEmpty").parameterCount(0)
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.IS_EMPTY).parameterCount(0),
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.IS_EMPTY).parameterCount(0)
                 ),
-                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
+                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "contains").parameterCount(1),
-                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS).parameterCount(1),
+                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "containsAll").parameterCount(1),
-                MethodNames.CONTAINS_ALL, null
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS_ALL).parameterCount(1),
+                MethodNames.CONTAINS_ALL, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "containsKey").parameterCount(1),
-                MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_KEY).parameterCount(1),
+                MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "containsValue").parameterCount(1),
-                MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_VALUE).parameterCount(1),
+                MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE, expectBoolean = true
             )
         )
     }
 
     override fun getDisplayName() = DISPLAY_NAME
 
+    @JvmField
+    var behaviorForMapValueEqualsNull: Int = DEFAULT_MAP_VALUES_NEVER_NULL
+
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
@@ -67,44 +77,82 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
                 if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
 
-                val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
-                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
                 if (MAP_GET_MATCHER.test(assertThatArgument)) {
+                    val expectedCallExpression = statement.findOutmostMethodCall() ?: return
                     val nullOrNotNull = expectedCallExpression.getAllTheSameNullNotNullConstants()
-                    if (nullOrNotNull != null) {
-                        val replacementMethod = nullOrNotNull.map("containsKey", "doesNotContainKey")
-                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                    if (nullOrNotNull == true) {
+                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_KEY) { desc, method ->
                             MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
                         }
+                    } else if (nullOrNotNull == false) {
+                        when (behaviorForMapValueEqualsNull) {
+                            1 -> // warning only
+                                registerMoveOutMethod(
+                                    holder,
+                                    expectedCallExpression,
+                                    assertThatArgument,
+                                    ""
+                                ) { _ -> emptyList() }
+                            2 -> // as doesNotContainKey(key)
+                                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.DOES_NOT_CONTAIN_KEY) { desc, method ->
+                                    MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
+                                }
+                            3 -> // as containsEntry(key, null)
+                                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_ENTRY) { desc, method ->
+                                    MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true, useNullNonNull = true)
+                                }
+                            4 -> // both
+                                registerMoveOutMethod(
+                                    holder,
+                                    expectedCallExpression,
+                                    assertThatArgument,
+                                    MethodNames.DOES_NOT_CONTAIN_KEY + "/" + MethodNames.CONTAINS_ENTRY
+                                ) { _ ->
+                                    listOf(
+                                        MoveOutMethodCallExpressionQuickFix(
+                                            "Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)",
+                                            MethodNames.DOES_NOT_CONTAIN_KEY,
+                                            useNullNonNull = true
+                                        ),
+                                        MoveOutMethodCallExpressionQuickFix(
+                                            "Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)",
+                                            MethodNames.CONTAINS_ENTRY,
+                                            keepExpectedAsSecondArgument = true,
+                                            useNullNonNull = true
+                                        )
+                                    )
+                                }
+                        }
                     } else {
                         if (ANY_IS_EQUAL_TO_MATCHER.test(expectedCallExpression)) {
-                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, "containsEntry") { desc, method ->
+                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_ENTRY) { desc, method ->
                                 MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true)
                             }
                         } else if (ANY_IS_NOT_EQUAL_TO_MATCHER.test(expectedCallExpression)) {
-                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, "doesNotContainEntry") { desc, method ->
+                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.DOES_NOT_CONTAIN_ENTRY) { desc, method ->
                                 MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true)
                             }
                         }
                     }
                 } else {
-                    if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
-                    val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
-
-                    val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
-
-                    val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse ?: return
-                    registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
-                        MoveOutMethodCallExpressionQuickFix(desc, method)
-                    }
+                    createInspectionsForMappings(statement, holder, MAPPINGS)
                 }
             }
         }
     }
 
-    private class Mapping(
-        val callMatcher: CallMatcher,
-        val replacementForTrue: String,
-        val replacementForFalse: String?
-    )
+    override fun createOptionsPanel(): JComponent {
+        val comboBox = ComboBox(
+            arrayOf("ignore", "warning only, no fixes", "as doesNotContainKey(key)", "as containsEntry(key, null)", "both choices")
+        )
+        comboBox.selectedIndex = behaviorForMapValueEqualsNull
+        comboBox.addActionListener { behaviorForMapValueEqualsNull = comboBox.selectedIndex }
+        val panel = JPanel(BorderLayout())
+        panel.add(
+            FormBuilder.createFormBuilder().addLabeledComponent("Fix get() on maps expecting null values:", comboBox).panel,
+            BorderLayout.NORTH
+        )
+        return panel
+    }
 }

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

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

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

@@ -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

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

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

@@ -29,6 +29,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
                 val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val outmostMethodCall = statement.findOutmostMethodCall() ?: return
                 if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
+                    if (actualExpression.type is PsiArrayType) return
                     val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
                     if (CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expectedCallExpression)) {
                         registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
@@ -91,9 +92,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
             }
 
             private fun checkPreconditions(staticMethodCall: PsiMethodCallExpression): Boolean {
-                val assertThatGuava = GUAVA_ASSERT_THAT_ANY.test(staticMethodCall)
-
-                if (ASSERT_THAT_ANY.test(staticMethodCall) || assertThatGuava) {
+                if (CallMatcher.anyOf(ASSERT_THAT_ANY, GUAVA_ASSERT_THAT_ANY).test(staticMethodCall)) {
                     JavaPsiFacade.getInstance(staticMethodCall.project)
                         .findClass(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(staticMethodCall.project)) ?: return false
                     return true

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
-                expression.getExpectedBooleanResult() ?: return
+                if (expression.getExpectedBooleanResult() != null) {
+                    if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
+                    val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
+                    if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
+                        val outmostMethodCall = expression.findOutmostMethodCall() ?: return
+                        holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
+                    }
+                } else {
+                    if (!CallMatcher.anyOf(ASSERT_THAT_BOOLEAN, ASSERT_THAT_BOOLEAN_OBJ).test(staticMethodCall)) return
+                    val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_BOOLEAN, IS_EQUAL_TO_OBJECT).test(expression)
+                    val isNotEqualTo = CallMatcher.anyOf(IS_NOT_EQUAL_TO_BOOLEAN, IS_NOT_EQUAL_TO_OBJECT).test(expression)
+                    if (!(isEqualTo || isNotEqualTo)) return
+                    val prefixExpression = expression.firstArg as? PsiPrefixExpression ?: return
+                    val operand = PsiUtil.skipParenthesizedExprDown(prefixExpression.operand) ?: return
+                    if (!TypeConversionUtil.isPrimitiveAndNotNull(operand.type)) return
+                    val originalMethod = getOriginalMethodName(expression) ?: return
 
-                val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
-                if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
-                    val outmostMethodCall = expression.findOutmostMethodCall() ?: return
-                    holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
+                    val replacementMethod = isEqualTo.map(MethodNames.IS_NOT_EQUAL_TO, MethodNames.IS_EQUAL_TO)
+                    val description = REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+                    val textRange = TextRange(staticMethodCall.textLength, expression.textLength)
+                    holder.registerProblem(expression, textRange, INVERT_OUTSIDE_CONDITION_MESSAGE, InvertUnaryExpressionQuickFix(description, replacementMethod))
                 }
             }
         }

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

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

@@ -76,4 +76,4 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
+}

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

@@ -5,10 +5,8 @@ import com.intellij.psi.*
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.HasHashCodeQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
 
-class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
+class AssertThatObjectExpressionInspection : AbstractMoveOutInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting equals(), toString(), or hashCode()"
@@ -16,6 +14,17 @@ class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
 
         private val OBJECT_TO_STRING = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "toString").parameterCount(0)
         private val OBJECT_HASHCODE = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "hashCode").parameterCount(0)
+
+        private val MAPPINGS = listOf(
+            MoveOutMapping(
+                OBJECT_EQUALS,
+                MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
+            ),
+            MoveOutMapping(
+                OBJECT_TO_STRING,
+                MethodNames.HAS_TO_STRING, expectedMatcher = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING)
+            )
+        )
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -25,31 +34,18 @@ class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
                 if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
 
-                val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
-                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-                when {
-                    OBJECT_EQUALS.test(assertThatArgument) -> {
-                        val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
-                        val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
-                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
-                            MoveOutMethodCallExpressionQuickFix(desc, method)
-                        }
-                    }
-                    OBJECT_TO_STRING.test(assertThatArgument) -> {
-                        staticMethodCall.findFluentCallTo(IS_EQUAL_TO_OBJECT) ?: staticMethodCall.findFluentCallTo(IS_EQUAL_TO_STRING) ?: return
-                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.HAS_TO_STRING) { desc, method ->
-                            RemoveActualOutmostMethodCallQuickFix(desc, method)
-                        }
-                    }
-                    OBJECT_HASHCODE.test(assertThatArgument) -> {
-                        val isEqualTo = staticMethodCall.findFluentCallTo(IS_EQUAL_TO_INT) ?: return
-                        val expectedExpression = isEqualTo.firstArg as? PsiMethodCallExpression ?: return
-                        if (OBJECT_HASHCODE.test(expectedExpression)) {
-                            holder.registerProblem(expectedCallExpression, HASHCODE_MESSAGE_TEMPLATE, HasHashCodeQuickFix())
-                        }
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+                val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
+                if (OBJECT_HASHCODE.test(assertThatArgument)) {
+                    val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                    val isEqualTo = staticMethodCall.findFluentCallTo(IS_EQUAL_TO_INT) ?: return
+                    val expectedExpression = isEqualTo.firstArg as? PsiMethodCallExpression ?: return
+                    if (OBJECT_HASHCODE.test(expectedExpression)) {
+                        holder.registerProblem(expectedCallExpression, HASHCODE_MESSAGE_TEMPLATE, HasHashCodeQuickFix())
                     }
+                } else {
+                    createInspectionsForMappings(statement, holder, MAPPINGS)
                 }
             }
         }

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

@@ -32,4 +32,4 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
             }
         }
     }
-}
+}

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

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

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

@@ -5,6 +5,7 @@ import com.intellij.psi.*
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ITERABLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_MAP_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceHasSizeMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickFix
 
@@ -34,7 +35,7 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                     && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
         }
 
-        fun getMatch(expression: PsiMethodCallExpression, isForArrayCollectionOrMap: Boolean, isForString: Boolean): Match? {
+        fun getMatch(expression: PsiMethodCallExpression, isForArrayOrCollection: Boolean, isForMap: Boolean, isForString: Boolean): Match? {
             val isLastExpression = expression.parent is PsiStatement
             val constValue = expression.calculateConstantParameterValue(0)
             if (IS_EQUAL_TO_INT.test(expression)) {
@@ -42,10 +43,11 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                     Match(expression, MethodNames.IS_EMPTY, noExpectedExpression = true)
                 } else {
                     val equalToExpression = expression.firstArg
-                    val equalsArrayCollectionOrMapSize = isArrayLength(equalToExpression) ||
-                            isCollectionSize(equalToExpression) || isMapSize(equalToExpression)
-                    if (isForArrayCollectionOrMap && equalsArrayCollectionOrMapSize ||
-                        isForString && (equalsArrayCollectionOrMapSize || isCharSequenceLength(equalToExpression))
+                    val equalsArrayOrCollectionSize = isArrayLength(equalToExpression) ||
+                            isCollectionSize(equalToExpression)
+                    if ((isForArrayOrCollection && equalsArrayOrCollectionSize)
+                        || (isForMap && (equalsArrayOrCollectionSize || isMapSize(equalToExpression)))
+                        || (isForString && (equalsArrayOrCollectionSize || isCharSequenceLength(equalToExpression)))
                     ) {
                         Match(expression, MethodNames.HAS_SAME_SIZE_AS, expectedIsCollection = true)
                     } else {
@@ -55,10 +57,10 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
             } else {
                 val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 0))
                         || (IS_LESS_THAN_INT.test(expression) && (constValue == 1))
-                        || IS_ZERO.test(expression))
+                        || IS_ZERO_INT.test(expression))
                 val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expression) && (constValue == 0))
                         || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 1))
-                        || IS_NOT_ZERO.test(expression))
+                        || IS_NOT_ZERO_INT.test(expression))
                 if ((isTestForEmpty && isLastExpression) || isTestForNotEmpty) {
                     val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
                     return Match(expression, replacementMethod, noExpectedExpression = true)
@@ -83,12 +85,13 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!ASSERT_THAT_INT.test(staticMethodCall)) return
 
                 val actualExpression = staticMethodCall.firstArg
-                val isForArrayCollectionOrMap = isArrayLength(actualExpression) || isCollectionSize(actualExpression) || isMapSize(actualExpression)
+                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForMap = isMapSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (!(isForArrayCollectionOrMap || isForString)) return
+                if (!(isForArrayOrCollection || isForMap || isForString)) return
 
                 val matches = staticMethodCall.collectMethodCallsUpToStatement()
-                    .mapNotNull { getMatch(it, isForArrayCollectionOrMap, isForString) }
+                    .mapNotNull { getMatch(it, isForArrayOrCollection, isForMap, isForString) }
                     .toList()
                 if (matches.isNotEmpty()) {
                     if (matches.size == 1) {
@@ -116,9 +119,11 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!HAS_SIZE.test(expression)) return
                 val actualExpression = expression.firstArg
 
-                val isForArrayCollectionOrMap = isArrayLength(actualExpression) || isCollectionSize(actualExpression) || isMapSize(actualExpression)
+                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForMap = isMapSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (!(isForArrayCollectionOrMap
+                if (!(isForArrayOrCollection
+                            || (isForMap && checkAssertedType(expression, ABSTRACT_MAP_ASSERT_CLASSNAME))
                             || (isForString && checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)))
                 ) return
 

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

@@ -3,41 +3,138 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
 import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.calculateConstantValue
+import de.platon42.intellij.plugins.cajon.firstArg
 
-class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
+class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a string specific expression"
 
+        private val ARG_IS_ZERO_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == 0 }
+        private val ARG_IS_MINUS_ONE_CONST: (PsiExpressionStatement, PsiMethodCallExpression) -> Boolean = { _, call -> call.firstArg.calculateConstantValue() == -1 }
+
+        private val STRING_COMPARE_TO_IGNORE_CASE =
+            CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "compareToIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING)
+        private val STRING_INDEX_OF = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "indexOf").parameterTypes(CommonClassNames.JAVA_LANG_STRING)
+        private val STRING_TRIM = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "trim").parameterCount(0)
+
         private val MAPPINGS = listOf(
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0),
-                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.IS_EMPTY).parameterCount(0),
+                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
             ),
-            Mapping(
+            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
+                MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
             ),
-            Mapping(
+            MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equalsIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC
+                MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contains").parameterCount(1),
-                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.CONTAINS).parameterCount(1),
+                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "startsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.STARTS_WITH).parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH, expectBoolean = true
             ),
-            Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "endsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
-                MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.ENDS_WITH).parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH, expectBoolean = true
+            ),
+            MoveOutMapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "matches").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                "matches", "doesNotMatch", expectBoolean = true
+            ),
+
+            MoveOutMapping(
+                STRING_COMPARE_TO_IGNORE_CASE,
+                MethodNames.IS_EQUAL_TO_IC, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_ZERO_CONST
+            ),
+            MoveOutMapping(
+                STRING_COMPARE_TO_IGNORE_CASE,
+                MethodNames.IS_EQUAL_TO_IC, expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
+            ),
+            MoveOutMapping(
+                STRING_COMPARE_TO_IGNORE_CASE,
+                MethodNames.IS_NOT_EQUAL_TO_IC, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_ZERO_CONST
+            ),
+            MoveOutMapping(
+                STRING_COMPARE_TO_IGNORE_CASE,
+                MethodNames.IS_NOT_EQUAL_TO_IC, expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
+            ),
+
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.STARTS_WITH, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_ZERO_CONST
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.STARTS_WITH, expectedMatcher = IS_ZERO_INT, replaceFromOriginalMethod = true
+            ),
+
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.DOES_NOT_START_WITH, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_ZERO_CONST
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.DOES_NOT_START_WITH, expectedMatcher = IS_NOT_ZERO_INT, replaceFromOriginalMethod = true
+            ),
+
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.CONTAINS, expectedMatcher = IS_NOT_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_MINUS_ONE_CONST
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.CONTAINS, expectedMatcher = IS_GREATER_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_ZERO_CONST
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.CONTAINS, expectedMatcher = IS_GREATER_THAN_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_MINUS_ONE_CONST
+            ),
+
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_MINUS_ONE_CONST
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_LESS_THAN_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_ZERO_CONST
+            ),
+            MoveOutMapping(
+                STRING_INDEX_OF,
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_LESS_THAN_OR_EQUAL_TO_INT, replaceFromOriginalMethod = true,
+                additionalCondition = ARG_IS_MINUS_ONE_CONST
+            ),
+
+            MoveOutMapping(
+                STRING_TRIM,
+                "isNotBlank", expectedMatcher = IS_NOT_EMPTY
             )
         )
     }
@@ -48,27 +145,8 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) return
-                val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
-
-                val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
-                val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
-
-                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
-                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
-
-                val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse
-                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
-                    MoveOutMethodCallExpressionQuickFix(desc, method)
-                }
+                createInspectionsForMappings(statement, holder, MAPPINGS)
             }
         }
     }
-
-    private class Mapping(
-        val callMatcher: CallMatcher,
-        val replacementForTrue: String,
-        val replacementForFalse: String
-    )
 }

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

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

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

@@ -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",
-            "containsAll", "containsAnyOf",
+            MethodNames.CONTAINS_EXACTLY, "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
+            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",
-            "isNotInstanceOf", "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
+            MethodNames.IS_INSTANCE_OF, "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
+            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/JoinVarArgsContainsInspection.kt

@@ -26,7 +26,7 @@ class JoinVarArgsContainsInspection : AbstractAssertJInspection() {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-                super.visitStatement(statement)
+                super.visitExpressionStatement(statement)
                 if (!statement.hasAssertThat()) return
                 val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) } ?: return
 
@@ -35,7 +35,7 @@ class JoinVarArgsContainsInspection : AbstractAssertJInspection() {
                 if (allCalls.find(COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY::test) != null) return
 
                 val onlyAssertionCalls = allCalls
-                    .filterNot { NOT_ACTUAL_ASSERTIONS.test(it) }
+                    .filterNot(NOT_ACTUAL_ASSERTIONS::test)
                     .toList()
 
                 for (methodMatcher in MATCHERS) {

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

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

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/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 =
-            PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
-
+        // was PsiParserFacade.getInstance(project).createWhiteSpaceFromText("\n\t"), changed due to breaking API changes
+        val newLineNode = project.getService(PsiParserFacade::class.java).createWhiteSpaceFromText("\n\t")
         lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
     }
 

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

@@ -2,7 +2,10 @@ package de.platon42.intellij.plugins.cajon.quickfixes
 
 import com.intellij.codeInspection.ProblemDescriptor
 import com.intellij.openapi.project.Project
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiExpression
 import com.intellij.psi.PsiMethodCallExpression
+import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
 
 class MoveOutMethodCallExpressionQuickFix(
@@ -10,7 +13,9 @@ class MoveOutMethodCallExpressionQuickFix(
     private val replacementMethod: String,
     private val useNullNonNull: Boolean = false,
     private val noExpectedExpression: Boolean = false,
-    private val keepExpectedAsSecondArgument: Boolean = false
+    private val keepExpectedAsSecondArgument: Boolean = false,
+    private val replaceOnlyThisMethod: CallMatcher? = null,
+    private val replaceFromOriginalMethod: Boolean = false
 ) :
     AbstractCommonQuickFix(description) {
 
@@ -26,30 +31,52 @@ class MoveOutMethodCallExpressionQuickFix(
         val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
         val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
         val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
-        val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy()
+        val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy() as PsiExpression?
 
-        if (keepExpectedAsSecondArgument) {
-            assertExpressionArg ?: return
-            val secondArg = outmostCallExpression.getArgOrNull(0)?.copy() ?: return
+        when {
+            replaceOnlyThisMethod != null -> {
+                val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
+                    .filter(replaceOnlyThisMethod::test)
+                    .toList()
 
-            assertExpression.replace(assertExpression.qualifierExpression)
+                assertExpression.replace(assertExpression.qualifierExpression)
 
-            val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, assertExpressionArg, secondArg)
-            expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression)
-            outmostCallExpression.replace(expectedExpression)
-        } else {
-            val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-                .filter { (if (useNullNonNull) it.getExpectedNullNonNullResult() else it.getExpectedBooleanResult()) != null }
-                .toList()
+                methodsToFix
+                    .forEach {
+                        val expectedExpression = createExpectedMethodCall(
+                            it,
+                            replacementMethod,
+                            *if (replaceFromOriginalMethod || noExpectedExpression) listOfNotNull(assertExpressionArg).toTypedArray() else it.argumentList.expressions
+                        )
+                        expectedExpression.replaceQualifierFromMethodCall(it)
+                        it.replace(expectedExpression)
+                    }
+            }
+            keepExpectedAsSecondArgument -> {
+                assertExpressionArg ?: return
+                val secondArg =
+                    if (useNullNonNull) JavaPsiFacade.getElementFactory(project).createExpressionFromText("null", null) else outmostCallExpression.getArgOrNull(0)?.copy() ?: return
 
-            assertExpression.replace(assertExpression.qualifierExpression)
+                assertExpression.replace(assertExpression.qualifierExpression)
 
-            methodsToFix
-                .forEach {
-                    val expectedExpression = createExpectedMethodCall(it, replacementMethod, *listOfNotNull(assertExpressionArg).toTypedArray())
-                    expectedExpression.replaceQualifierFromMethodCall(it)
-                    it.replace(expectedExpression)
-                }
+                val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, assertExpressionArg, secondArg)
+                expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression)
+                outmostCallExpression.replace(expectedExpression)
+            }
+            else -> {
+                val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
+                    .filter { (if (useNullNonNull) it.getExpectedNullNonNullResult() else it.getExpectedBooleanResult()) != null }
+                    .toList()
+
+                assertExpression.replace(assertExpression.qualifierExpression)
+
+                methodsToFix
+                    .forEach {
+                        val expectedExpression = createExpectedMethodCall(it, replacementMethod, *listOfNotNull(assertExpressionArg).toTypedArray())
+                        expectedExpression.replaceQualifierFromMethodCall(it)
+                        it.replace(expectedExpression)
+                    }
+            }
         }
     }
 }

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

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

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

@@ -1,6 +1,5 @@
 package de.platon42.intellij.plugins.cajon.references
 
-import com.intellij.lang.jvm.JvmModifier
 import com.intellij.openapi.util.TextRange
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.psi.*
@@ -30,7 +29,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
             val matchedGetter = PropertyUtilBase.findPropertyGetter(containingClass, partName, false, true)
             val fieldResult = PropertyUtilBase.findPropertyField(containingClass, partName, false)
             val textRange = TextRange(startOffset + 1, nextOffset)
-            val matchedBareMethod = containingClass.allMethods.find { (it.name == partName) && !it.hasModifier(JvmModifier.STATIC) }
+            val matchedBareMethod = containingClass.allMethods.find { (it.name == partName) && !it.hasModifierProperty(PsiModifier.STATIC) }
             val targets = listOfNotNull<PsiElement>(fieldResult, matchedGetter, matchedBareMethod)
             if (targets.isNotEmpty()) {
                 val results = listOf(textRange to targets)
@@ -44,7 +43,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
         }
 
         private fun lookupMethod(containingClass: PsiClass, methodName: String): List<Pair<TextRange, List<PsiElement>>>? {
-            val matchedMethod = containingClass.allMethods.find { (it.name == methodName) && !it.hasModifier(JvmModifier.STATIC) } ?: return null
+            val matchedMethod = containingClass.allMethods.find { (it.name == methodName) && !it.hasModifierProperty(PsiModifier.STATIC) } ?: return null
             val textRange = TextRange(1, methodName.length + 1)
             return listOf(textRange to listOf(matchedMethod))
         }
@@ -71,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
         }
@@ -125,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,20 +1,19 @@
 <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.
-    It adds several inspections and quick fixes to fully use the fluent assertion methods
+    It adds several <b>inspections and quick fixes</b> to fully use the fluent assertion methods
     and thus makes the intention clear and concise, also generating better messages on test failures.
-    It can also be used to convert JUnit 4 assertions and assumptions to AssertJ.
-    It supports referencing inside extracting()-methods with strings, adding refactoring safety.
+    It can also be used to <b>convert JUnit 4 assertions and assumptions to AssertJ</b>.
+    It supports <b>referencing inside extracting</b>()-methods with strings, adding refactoring safety.
+    <b>Bogus or twisted assertions</b> are also reported.
     <p>
     <a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
     ]]></description>
 
-    <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>
@@ -27,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"
@@ -41,10 +42,16 @@
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatObjectExpression" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectExpressionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatComparable" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatComparableInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatStringExpression" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringExpressionInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatCollectionOrMapExpression" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatCollectionOrMapExpressionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatFileExpression" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatFileExpressionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatPathExpression" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatPathExpressionInspection"/>
 
         <localInspection groupPath="Java" shortName="JoinAssertThatStatements" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinAssertThatStatementsInspection"/>
@@ -61,10 +68,15 @@
         <localInspection groupPath="Java" shortName="ImplicitAssertion" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.ImplicitAssertionInspection"/>
 
+        <localInspection groupPath="Java" shortName="TwistedAssertion" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.TwistedAssertionInspection"/>
+        <localInspection groupPath="Java" shortName="BogusAssertion" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.BogusAssertionInspection"/>
+
         <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.JUnitAssertToAssertJInspection"/>
     </extensions>
 
     <actions>
     </actions>
-</idea-plugin>
+</idea-plugin>

src/main/resources/inspectionDescriptions/AssertThatCollectionOrMapExpression.html

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

src/main/resources/inspectionDescriptions/AssertThatComparable.html

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

src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html

@@ -1,6 +1,6 @@
 <html>
 <body>
-Turns assertThat(enumerable).hasSize(0) 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/AssertThatFileExpression.html

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

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

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

src/main/resources/inspectionDescriptions/AssertThatStringExpression.html

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

src/main/resources/inspectionDescriptions/BogusAssertion.html

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

src/main/resources/inspectionDescriptions/TwistedAssertion.html

@@ -0,0 +1,7 @@
+<html>
+<body>
+Finds assertion method calls that have the expected and actual expressions twisted, such as assertThat(5).isEqualTo(foo).
+<!-- tooltip end -->
+For some obvious cases, a quickfix to swap the actual and expected expressions is provided.
+</body>
+</html>

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

@@ -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.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,203 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
-import com.intellij.openapi.roots.ContentEntry;
-import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.testFramework.*;
-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.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.logging.Logger;
-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 methodOrClassAnnotation = getMethodOrClassAnnotation(AddLocalJarToModule.class);
-                    if (methodOrClassAnnotation != null) {
-                        Stream.of(methodOrClassAnnotation.value()).forEach(it -> addJarContaining(model, it));
-                    }
-                }
-            };
-        }
-
-        void addJarContaining(ModifiableRootModel model, Class clazz) {
-            try {
-                Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
-
-                VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
-                myFixture.allowTreeAccessForFile(jarFile);
-                PsiTestUtil.addLibrary(
-                        model,
-                        jarPath.getFileName().toString().replace(".jar", ""),
-                        jarPath.getParent().toString(),
-                        jarPath.getFileName().toString()
-                );
-            } catch (URISyntaxException e) {
-                throw new IllegalArgumentException("Class URL malformed", e);
-            }
-        }
-
-        @Override
-        protected String getTestDataPath() {
-            TestDataPath testDataPath = getMethodOrClassAnnotation(TestDataPath.class);
-            if (testDataPath == null) {
-                return super.getTestDataPath();
-            }
-            TestDataSubPath testDataSubPath = getMethodOrClassAnnotation(TestDataSubPath.class);
-            if (testDataSubPath == null) {
-                return testDataPath.value();
-            }
-            return Paths.get(testDataPath.value(), testDataSubPath.value()).toString();
-        }
-
-        public JavaCodeInsightTestFixture getMyFixture() {
-            return myFixture;
-        }
-
-        private <T extends Annotation> T getMethodOrClassAnnotation(Class<T> clazz) {
-            T annotation = extensionContext.getRequiredTestMethod().getAnnotation(clazz);
-            if (annotation == null) {
-                annotation = extensionContext.getRequiredTestClass().getAnnotation(clazz);
-            }
-            return annotation;
-        }
-    }
-}

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

@@ -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

@@ -1,30 +1,46 @@
 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.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)
+//@AddMavenDependencyToModule("org.assertj:assertj-core:3.25.3", includeTransitiveDependencies = false, DependencyScope.COMPILE)
 @DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
-abstract class AbstractCajonTest {
+abstract class AbstractCajonTest : AbstractJUnit5TestCase() {
 
-    protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
-        val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
-        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
-        quickfixes.forEach { it.familyName }
-        quickfixes.forEach(myFixture::launchAction)
+    protected fun executeQuickFixes(regex: Regex, expectedFixes: Int) {
+        val quickfixes = getQuickFixes(regex, expectedFixes)
+        assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
+        quickfixes.forEach(fixture::launchAction)
+    }
+
+    protected fun executeQuickFixesNoFamilyNameCheck(regex: Regex, expectedFixes: Int) {
+        val quickfixes = getQuickFixes(regex, expectedFixes)
+        quickfixes.forEach(fixture::launchAction)
+    }
+
+    protected fun getQuickFixes(regex: Regex, expectedFixes: Int): List<IntentionAction> {
+        val allFixes = fixture.getAllQuickFixes()
+        val quickfixes = allFixes.filter { it.text.matches(regex) }
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${allFixes.map { it.text }}").hasSize(expectedFixes)
+        return quickfixes
+    }
+
+    protected fun assertHighlightings(count: Int, snippet: String) {
+        assertThat(fixture.doHighlighting())
+            .areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
     }
 
     class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {
@@ -33,4 +49,4 @@ abstract class AbstractCajonTest {
             return nameForMethod.substringBefore("$")
         }
     }
-}
+}

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

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
-        myFixture.configureByFile("BooleanConditionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
-        myFixture.checkResultByFile("BooleanConditionAfter.java")
+    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse() {
+        fixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
+        fixture.configureByFile("BooleanConditionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
+        fixture.checkResultByFile("BooleanConditionAfter.java")
     }
-}
+}

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

@@ -1,31 +1,102 @@
 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.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/CollectionMapExpression")
 internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/CollectionMapExpression")
-    internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
-        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
-        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
+    internal fun assertThat_with_certain_Collection_and_Map_methods() {
+        fixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
+        fixture.checkResultByFile("CollectionMapExpressionAfter.java")
     }
-}
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values() {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 3
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        fixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
+    }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null() {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 0
+
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+    }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null() {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 1
+
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        val highlights = fixture.doHighlighting()
+            .asSequence()
+            .filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
+            .filter {
+                it.quickFixActionRanges?.any { innerit -> innerit.first.action.text.contains("Inspection 'Asserting a collection or map specific expression") } ?: true
+            }
+            .toList()
+        assertThat(highlights).hasSize(4)
+
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+    }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null() {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 4
+
+        fixture.enableInspections(inspection)
+        fixture.configureByFile("CollectionMapExpressionBefore.java")
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+    }
+}

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

@@ -0,0 +1,22 @@
+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/Comparable")
+internal class AssertThatComparableInspectionTest : AbstractCajonTest() {
+
+    @Test
+    internal fun assertThat_with_compareTo_method() {
+        fixture.enableInspections(AssertThatComparableInspection::class.java)
+        fixture.configureByFile("ComparableBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isEqualByComparingTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isNotEqualByComparingTo() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThanOrEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isGreaterThan() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThanOrEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove compareTo() of actual expression and use assertThat().isLessThan() instead"), 4)
+        fixture.checkResultByFile("ComparableAfter.java")
+    }
+}

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_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
-        myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
-        myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
+    internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty() {
+        fixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
+        fixture.configureByFile("EnumerableIsEmptyBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
+        executeQuickFixes(Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
+        fixture.checkResultByFile("EnumerableIsEmptyAfter.java")
     }
-}
+}

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

@@ -0,0 +1,36 @@
+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/FileExpression")
+internal class AssertThatFileExpressionInspectionTest : AbstractCajonTest() {
+
+    @Test
+    internal fun assertThat_with_certain_File_methods() {
+        fixture.enableInspections(AssertThatFileExpressionInspection::class.java)
+        fixture.configureByFile("FileExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove canRead() of actual expression and use assertThat().canRead() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove canWrite() of actual expression and use assertThat().canWrite() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().exists() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove exists() of actual expression and use assertThat().doesNotExist() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isDirectory() of actual expression and use assertThat().isDirectory() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isFile() of actual expression and use assertThat().isFile() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getName() of actual expression and use assertThat().hasName() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasNoParent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove getParentFile() of actual expression and use assertThat().hasParent() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove listFiles() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove list() of actual expression and use assertThat().isNotEmptyDirectory() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isEmpty() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove length() of actual expression and use assertThat().hasSize() instead"), 1)
+        fixture.checkResultByFile("FileExpressionAfter.java")
+    }
+}

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

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
-        myFixture.configureByFile("InstanceOfBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
-        myFixture.checkResultByFile("InstanceOfAfter.java")
+    internal fun assertThat_with_instanceof_can_be_moved_out() {
+        fixture.enableInspections(AssertThatInstanceOfInspection::class.java)
+        fixture.configureByFile("InstanceOfBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
+        fixture.checkResultByFile("InstanceOfAfter.java")
     }
-}
+}

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
-        myFixture.configureByFile("InvertedBooleanConditionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
-        myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
+    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted() {
+        fixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
+        fixture.configureByFile("InvertedBooleanConditionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Invert condition in assertThat()"), 25)
+        executeQuickFixes(Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
+        fixture.checkResultByFile("InvertedBooleanConditionAfter.java")
     }
-}
+}

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
-        myFixture.configureByFile("Java8OptionalBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
-        myFixture.checkResultByFile("Java8OptionalAfter.java")
+    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified() {
+        fixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
+        fixture.configureByFile("Java8OptionalBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        executeQuickFixes(Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+        fixture.checkResultByFile("Java8OptionalAfter.java")
     }
-}
+}

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
-        myFixture.configureByFile("ObjectExpressionBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
-        myFixture.checkResultByFile("ObjectExpressionAfter.java")
+    internal fun assertThat_with_certain_Object_methods() {
+        fixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
+        fixture.configureByFile("ObjectExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
+        executeQuickFixes(Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
+        fixture.checkResultByFile("ObjectExpressionAfter.java")
     }
-}
+}

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
-        myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
-        myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
+    internal fun assertThat_with_isEqualTo_null_can_use_isNull() {
+        fixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+        fixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
+        fixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
     }
-}
+}

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

@@ -0,0 +1,22 @@
+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/PathExpression")
+internal class AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
+
+    @Test
+    internal fun assertThat_with_certain_Path_methods() {
+        fixture.enableInspections(AssertThatPathExpressionInspection::class.java)
+        fixture.configureByFile("PathExpressionBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
+        executeQuickFixes(Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
+        fixture.checkResultByFile("PathExpressionAfter.java")
+    }
+}

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

@@ -1,36 +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.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.extrakting
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/Size")
 internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/Size")
-    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(AssertThatSizeInspection::class.java)
-        myFixture.configureByFile("SizeBefore.java")
-        assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
+    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified() {
+        fixture.enableInspections(AssertThatSizeInspection::class.java)
+        fixture.configureByFile("SizeBefore.java")
+        assertHighlightings(1, "Try to operate on the iterable itself rather than its size")
 
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 19)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 11)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 21)
-        myFixture.checkResultByFile("SizeAfter.java")
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
+        executeQuickFixes(Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
+        executeQuickFixes(Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
+        fixture.checkResultByFile("SizeAfter.java")
     }
-}
+}

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

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

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

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

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

@@ -0,0 +1,17 @@
+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/BogusAssertion")
+internal class BogusAssertionInspectionTest : AbstractCajonTest() {
+
+    @Test
+    internal fun reports_bogus_assertions() {
+        fixture.enableInspections(BogusAssertionInspection::class.java)
+        fixture.configureByFile("BogusAssertionBefore.java")
+        assertHighlightings(14 * 9 + 10 + 12 + 8, "Actual expression in assertThat() is the same as expected")
+        assertHighlightings(3, "Same actual and expected expression, but may be testing equals() or hashCode()")
+    }
+}

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

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

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
-        myFixture.configureByFile("JoinStatementsBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
-        myFixture.checkResultByFile("JoinStatementsAfter.java")
+    internal fun assertThat_statements_can_be_joined_together() {
+        fixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
+        fixture.configureByFile("JoinStatementsBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Join assertThat() statements"), 5)
+        fixture.checkResultByFile("JoinStatementsAfter.java")
     }
-}
+}

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(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(JoinVarArgsContainsInspection::class.java)
-        myFixture.configureByFile("JoinVarArgsContainsBefore.java")
-        executeQuickFixes(myFixture, Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
-        myFixture.checkResultByFile("JoinVarArgsContainsAfter.java")
+    internal fun join_contains_and_doesNotContain_together_where_possible() {
+        fixture.enableInspections(JoinVarArgsContainsInspection::class.java)
+        fixture.configureByFile("JoinVarArgsContainsBefore.java")
+        executeQuickFixes(Regex.fromLiteral("Join multiple arguments to variadic argument method calls"), 3)
+        fixture.checkResultByFile("JoinVarArgsContainsAfter.java")
     }
-}
+}

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

@@ -0,0 +1,21 @@
+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/TwistedAssertion")
+internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
+
+    @Test
+    internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible() {
+        fixture.enableInspections(TwistedAssertionInspection::class.java)
+        fixture.configureByFile("TwistedAssertionBefore.java")
+        assertHighlightings(9, "Actual expression in assertThat() is a constant")
+        assertHighlightings(10, "Twisted actual and expected expressions")
+
+        executeQuickFixes(Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)
+        executeQuickFixesNoFamilyNameCheck(Regex("Replace .* by .* and swap actual and expected expressions"), 4)
+        fixture.checkResultByFile("TwistedAssertionAfter.java")
+    }
+}

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) {
-        myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+    internal fun extractor_is_able_to_find_reference_for_field_extracting() {
+        fixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
+    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path() {
+        fixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("protected Address address;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
+    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field() {
+        fixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
+    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call() {
+        fixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
+    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part() {
+        fixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_byName_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+    internal fun extractor_is_able_to_find_reference_using_byName_extractor() {
+        fixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
+    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor() {
+        fixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
+    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list() {
+        fixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).isEqualTo("private String name;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
+    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list() {
+        fixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("private String street;")
     }
 
     @Test
-    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
-        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
+    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method() {
+        fixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
+        assertThat(fixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
 
     @Test
-    internal fun extractor_is_unable_to_find_reference(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
-        assertThatThrownBy { myFixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
+    internal fun extractor_is_unable_to_find_reference() {
+        fixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
+        assertThatThrownBy { fixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
     }
-}
+}

src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java

@@ -189,6 +189,20 @@ public class BinaryExpression {
         assertThat(stringAct).isNotNull();
         assertThat(stringAct).isNotNull();
 
+        assertThat(stringAct).as("doh!").isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+
+        assertThat(stringAct).as("doh!").isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+
         assertThat(null == null).isTrue();
         assertThat(!false).isTrue();
 

src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java

@@ -189,6 +189,20 @@ public class BinaryExpression {
         assertThat(null == stringAct).isEqualTo(false);
         assertThat(null == stringAct).isNotEqualTo(true);
 
+        assertThat(stringAct != null).as("doh!").isTrue();
+        assertThat(stringAct != null).isEqualTo(true);
+        assertThat(stringAct != null).isNotEqualTo(false);
+        assertThat(stringAct != null).isFalse();
+        assertThat(stringAct != null).isEqualTo(false);
+        assertThat(stringAct != null).isNotEqualTo(true);
+
+        assertThat(null != stringAct).as("doh!").isTrue();
+        assertThat(null != stringAct).isEqualTo(true);
+        assertThat(null != stringAct).isNotEqualTo(false);
+        assertThat(null != stringAct).isFalse();
+        assertThat(null != stringAct).isEqualTo(false);
+        assertThat(null != stringAct).isNotEqualTo(true);
+
         assertThat(null == null).isTrue();
         assertThat(!false).isTrue();
 

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

@@ -0,0 +1,218 @@
+import java.io.File;
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class BogusAssertions {
+
+    private void bogusAssertions() {
+        boolean[] boolarray = new boolean[10];
+        byte[] bytearray = new byte[10];
+        short[] shortarray = new short[10];
+        int[] intarray = new int[10];
+        long[] longarray = new long[10];
+        float[] floatarray = new float[10];
+        double[] doublearray = new double[10];
+        char[] chararray = new char[10];
+        Object[] objarray = new Object[10];
+        String string = "foo";
+        List<String> list = new ArrayList<>();
+        Map<String, Integer> map = new HashMap<>();
+        String bar = "bar";
+
+        assertThat(boolarray).isEqualTo(boolarray);
+        assertThat(boolarray).isSameAs(boolarray);
+        assertThat(boolarray).hasSameClassAs(boolarray);
+        assertThat(boolarray).hasSameHashCodeAs(boolarray);
+        assertThat(boolarray).hasSameSizeAs(boolarray);
+        assertThat(boolarray).contains(boolarray);
+        assertThat(boolarray).containsAnyOf(boolarray);
+        assertThat(boolarray).containsExactly(boolarray);
+        assertThat(boolarray).containsExactlyInAnyOrder(boolarray);
+        assertThat(boolarray).containsOnly(boolarray);
+        assertThat(boolarray).containsSequence(boolarray);
+        assertThat(boolarray).containsSubsequence(boolarray);
+        assertThat(boolarray).startsWith(boolarray);
+        assertThat(boolarray).endsWith(boolarray);
+
+        assertThat(bytearray).isEqualTo(bytearray);
+        assertThat(bytearray).isSameAs(bytearray);
+        assertThat(bytearray).hasSameClassAs(bytearray);
+        assertThat(bytearray).hasSameHashCodeAs(bytearray);
+        assertThat(bytearray).hasSameSizeAs(bytearray);
+        assertThat(bytearray).contains(bytearray);
+        assertThat(bytearray).containsAnyOf(bytearray);
+        assertThat(bytearray).containsExactly(bytearray);
+        assertThat(bytearray).containsExactlyInAnyOrder(bytearray);
+        assertThat(bytearray).containsOnly(bytearray);
+        assertThat(bytearray).containsSequence(bytearray);
+        assertThat(bytearray).containsSubsequence(bytearray);
+        assertThat(bytearray).startsWith(bytearray);
+        assertThat(bytearray).endsWith(bytearray);
+
+        assertThat(shortarray).isEqualTo(shortarray);
+        assertThat(shortarray).isSameAs(shortarray);
+        assertThat(shortarray).hasSameClassAs(shortarray);
+        assertThat(shortarray).hasSameHashCodeAs(shortarray);
+        assertThat(shortarray).hasSameSizeAs(shortarray);
+        assertThat(shortarray).contains(shortarray);
+        assertThat(shortarray).containsAnyOf(shortarray);
+        assertThat(shortarray).containsExactly(shortarray);
+        assertThat(shortarray).containsExactlyInAnyOrder(shortarray);
+        assertThat(shortarray).containsOnly(shortarray);
+        assertThat(shortarray).containsSequence(shortarray);
+        assertThat(shortarray).containsSubsequence(shortarray);
+        assertThat(shortarray).startsWith(shortarray);
+        assertThat(shortarray).endsWith(shortarray);
+
+        assertThat(intarray).isEqualTo(intarray);
+        assertThat(intarray).isSameAs(intarray);
+        assertThat(intarray).hasSameClassAs(intarray);
+        assertThat(intarray).hasSameHashCodeAs(intarray);
+        assertThat(intarray).hasSameSizeAs(intarray);
+        assertThat(intarray).contains(intarray);
+        assertThat(intarray).containsAnyOf(intarray);
+        assertThat(intarray).containsExactly(intarray);
+        assertThat(intarray).containsExactlyInAnyOrder(intarray);
+        assertThat(intarray).containsOnly(intarray);
+        assertThat(intarray).containsSequence(intarray);
+        assertThat(intarray).containsSubsequence(intarray);
+        assertThat(intarray).startsWith(intarray);
+        assertThat(intarray).endsWith(intarray);
+
+        assertThat(longarray).isEqualTo(longarray);
+        assertThat(longarray).isSameAs(longarray);
+        assertThat(longarray).hasSameClassAs(longarray);
+        assertThat(longarray).hasSameHashCodeAs(longarray);
+        assertThat(longarray).hasSameSizeAs(longarray);
+        assertThat(longarray).contains(longarray);
+        assertThat(longarray).containsAnyOf(longarray);
+        assertThat(longarray).containsExactly(longarray);
+        assertThat(longarray).containsExactlyInAnyOrder(longarray);
+        assertThat(longarray).containsOnly(longarray);
+        assertThat(longarray).containsSequence(longarray);
+        assertThat(longarray).containsSubsequence(longarray);
+        assertThat(longarray).startsWith(longarray);
+        assertThat(longarray).endsWith(longarray);
+
+        assertThat(floatarray).isEqualTo(floatarray);
+        assertThat(floatarray).isSameAs(floatarray);
+        assertThat(floatarray).hasSameClassAs(floatarray);
+        assertThat(floatarray).hasSameHashCodeAs(floatarray);
+        assertThat(floatarray).hasSameSizeAs(floatarray);
+        assertThat(floatarray).contains(floatarray);
+        assertThat(floatarray).containsAnyOf(floatarray);
+        assertThat(floatarray).containsExactly(floatarray);
+        assertThat(floatarray).containsExactlyInAnyOrder(floatarray);
+        assertThat(floatarray).containsOnly(floatarray);
+        assertThat(floatarray).containsSequence(floatarray);
+        assertThat(floatarray).containsSubsequence(floatarray);
+        assertThat(floatarray).startsWith(floatarray);
+        assertThat(floatarray).endsWith(floatarray);
+
+        assertThat(doublearray).isEqualTo(doublearray);
+        assertThat(doublearray).isSameAs(doublearray);
+        assertThat(doublearray).hasSameClassAs(doublearray);
+        assertThat(doublearray).hasSameHashCodeAs(doublearray);
+        assertThat(doublearray).hasSameSizeAs(doublearray);
+        assertThat(doublearray).contains(doublearray);
+        assertThat(doublearray).containsAnyOf(doublearray);
+        assertThat(doublearray).containsExactly(doublearray);
+        assertThat(doublearray).containsExactlyInAnyOrder(doublearray);
+        assertThat(doublearray).containsOnly(doublearray);
+        assertThat(doublearray).containsSequence(doublearray);
+        assertThat(doublearray).containsSubsequence(doublearray);
+        assertThat(doublearray).startsWith(doublearray);
+        assertThat(doublearray).endsWith(doublearray);
+
+        assertThat(chararray).isEqualTo(chararray);
+        assertThat(chararray).isSameAs(chararray);
+        assertThat(chararray).hasSameClassAs(chararray);
+        assertThat(chararray).hasSameHashCodeAs(chararray);
+        assertThat(chararray).hasSameSizeAs(chararray);
+        assertThat(chararray).contains(chararray);
+        assertThat(chararray).containsAnyOf(chararray);
+        assertThat(chararray).containsExactly(chararray);
+        assertThat(chararray).containsExactlyInAnyOrder(chararray);
+        assertThat(chararray).containsOnly(chararray);
+        assertThat(chararray).containsSequence(chararray);
+        assertThat(chararray).containsSubsequence(chararray);
+        assertThat(chararray).startsWith(chararray);
+        assertThat(chararray).endsWith(chararray);
+
+        assertThat(objarray).isEqualTo(objarray);
+        assertThat(objarray).isSameAs(objarray);
+        assertThat(objarray).hasSameClassAs(objarray);
+        assertThat(objarray).hasSameHashCodeAs(objarray);
+        assertThat(objarray).hasSameSizeAs(objarray);
+        assertThat(objarray).contains(objarray);
+        assertThat(objarray).containsAnyOf(objarray);
+        assertThat(objarray).containsExactly(objarray);
+        assertThat(objarray).containsExactlyInAnyOrder(objarray);
+        assertThat(objarray).containsOnly(objarray);
+        assertThat(objarray).containsSequence(objarray);
+        assertThat(objarray).containsSubsequence(objarray);
+        assertThat(objarray).startsWith(objarray);
+        assertThat(objarray).endsWith(objarray);
+
+        assertThat(string).as("foo").isEqualTo(string);
+        assertThat(string).as("foo").isSameAs(string);
+        assertThat(string).as("foo").hasSameClassAs(string);
+        assertThat(string).as("foo").hasSameHashCodeAs(string);
+        assertThat(string).as("foo").hasSameSizeAs(string);
+        assertThat(string).as("foo").isEqualToIgnoringCase(string);
+        assertThat(string).as("foo").containsSequence(string);
+        assertThat(string).as("foo").containsSubsequence(string);
+        assertThat(string).as("foo").startsWith(string);
+        assertThat(string).as("foo").endsWith(string);
+
+        assertThat(list).as("foo").isEqualTo(list);
+        assertThat(list).as("foo").isSameAs(list);
+        assertThat(list).as("foo").hasSameClassAs(list);
+        assertThat(list).as("foo").hasSameHashCodeAs(list);
+        assertThat(list).as("foo").hasSameSizeAs(list);
+        assertThat(list).as("foo").containsAll(list);
+        assertThat(list).as("foo").containsAnyElementsOf(list);
+        assertThat(list).as("foo").containsOnlyElementsOf(list);
+        assertThat(list).as("foo").containsExactlyElementsOf(list);
+        assertThat(list).as("foo").hasSameElementsAs(list);
+        assertThat(list).as("foo").containsSequence(list);
+        assertThat(list).as("foo").containsSubsequence(list);
+
+        assertThat(map).as("foo").isEqualTo(map);
+        assertThat(map).as("foo").isSameAs(map);
+        assertThat(map).as("foo").hasSameClassAs(map);
+        assertThat(map).as("foo").hasSameHashCodeAs(map);
+        assertThat(map).as("foo").hasSameSizeAs(map);
+        assertThat(map).as("foo").containsAllEntriesOf(map);
+        assertThat(map).as("foo").containsExactlyEntriesOf(map);
+        assertThat(map).as("foo").containsExactlyInAnyOrderEntriesOf(map);
+
+        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/CollectionMapExpression/CollectionMapExpressionWithNullValuesAfter.java

@@ -0,0 +1,63 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+import java.util.*;
+
+public class CollectionMapExpression {
+
+    private void collectionMapExpression() {
+        List<String> stringList = new ArrayList<>();
+        List<String> anotherList = new ArrayList<>();
+        Map<String, Integer> keyValueMap = new HashMap<>();
+
+        assertThat(stringList).as("foo").isEmpty();
+        assertThat(stringList).isEmpty();
+        assertThat(stringList).contains("foo");
+        assertThat(stringList).contains("foo");
+        assertThat(stringList).containsAll(anotherList);
+        assertThat(stringList).containsAll(anotherList);
+
+        assertThat(stringList).as("foo").isNotEmpty();
+        assertThat(stringList).isNotEmpty();
+        assertThat(stringList).doesNotContain("foo");
+        assertThat(stringList).doesNotContain("foo");
+        assertThat(stringList.containsAll(anotherList)).isEqualTo(false);
+        assertThat(stringList.containsAll(anotherList)).isFalse();
+
+        assertThat(keyValueMap).as("foo").isEmpty();
+        assertThat(keyValueMap).isEmpty();
+        assertThat(keyValueMap).containsKey("foo");
+        assertThat(keyValueMap).containsKey("foo");
+        assertThat(keyValueMap).containsValue(2);
+        assertThat(keyValueMap).containsValue(2);
+
+        assertThat(keyValueMap).as("foo").isNotEmpty();
+        assertThat(keyValueMap).isNotEmpty();
+        assertThat(keyValueMap).doesNotContainKey("foo");
+        assertThat(keyValueMap).doesNotContainKey("foo");
+        assertThat(keyValueMap).doesNotContainValue(2);
+        assertThat(keyValueMap).doesNotContainValue(2);
+
+        assertThat(keyValueMap).containsEntry("foo", 2);
+        assertThat(keyValueMap).doesNotContainEntry("foo", 3);
+        assertThat(keyValueMap).containsEntry("foo", null);
+        assertThat(keyValueMap).containsEntry("foo", null);
+        assertThat(keyValueMap).containsKey("foo");
+        assertThat(keyValueMap).containsKey("foo");
+
+        Map<String, String> stringStringMap = new HashMap<>();
+        assertThat(stringStringMap).containsEntry("foo", "bar");
+        assertThat(stringStringMap).doesNotContainEntry("foo", "bar");
+        assertThat(stringStringMap).containsEntry("foo", null);
+        assertThat(stringStringMap).containsEntry("foo", null);
+        assertThat(stringStringMap).containsKey("foo");
+        assertThat(stringStringMap).containsKey("foo");
+
+        assertThat(stringList).as("foo").isNotEmpty().as("bar").isNotEmpty();
+        assertThat(stringList.isEmpty()).as("foo").isEqualTo(false).as("bar").isTrue();
+        assertThat(stringList.isEmpty()).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
+
+        org.junit.Assert.assertThat(stringList, null);
+        fail("oh no!");
+    }
+}

src/test/resources/inspections/Comparable/ComparableAfter.java

@@ -0,0 +1,41 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class CompareTo {
+
+    private void comparable() {
+        String string = "string";
+        assertThat(string).isEqualByComparingTo("foo");
+        assertThat(string).isEqualByComparingTo("foo");
+
+        assertThat(string).isNotEqualByComparingTo("foo");
+        assertThat(string).isNotEqualByComparingTo("foo");
+
+        assertThat(string).isGreaterThanOrEqualTo("foo");
+        assertThat(string).isGreaterThanOrEqualTo("foo");
+        assertThat(string).isGreaterThanOrEqualTo("foo");
+        assertThat(string).isGreaterThanOrEqualTo("foo");
+
+        assertThat(string).isGreaterThan("foo");
+        assertThat(string).isGreaterThan("foo");
+        assertThat(string).isGreaterThan("foo");
+        assertThat(string).isGreaterThan("foo");
+        assertThat(string).isGreaterThan("foo");
+
+        assertThat(string).isLessThanOrEqualTo("foo");
+        assertThat(string).isLessThanOrEqualTo("foo");
+        assertThat(string).isLessThanOrEqualTo("foo");
+        assertThat(string).isLessThanOrEqualTo("foo");
+
+        assertThat(string).isLessThan("foo");
+        assertThat(string).isLessThan("foo");
+        assertThat(string).isLessThan("foo");
+        assertThat(string).isLessThan("foo");
+
+        assertThat(string.compareTo("foo")).isNotEqualTo(2);
+        assertThat(string.compareTo("foo")).isEqualTo(2);
+
+        org.junit.Assert.assertThat(string, null);
+        fail("oh no!");
+    }
+}

src/test/resources/inspections/Comparable/ComparableBefore.java

@@ -0,0 +1,41 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class CompareTo {
+
+    private void comparable() {
+        String string = "string";
+        assertThat(string.compareTo("foo")).isEqualTo(0);
+        assertThat(string.compareTo("foo")).isZero();
+
+        assertThat(string.compareTo("foo")).isNotEqualTo(0);
+        assertThat(string.compareTo("foo")).isNotZero();
+
+        assertThat(string.compareTo("foo")).isNotEqualTo(-1);
+        assertThat(string.compareTo("foo")).isGreaterThanOrEqualTo(0);
+        assertThat(string.compareTo("foo")).isGreaterThan(-1);
+        assertThat(string.compareTo("foo")).isNotNegative();
+
+        assertThat(string.compareTo("foo")).isEqualTo(1);
+        assertThat(string.compareTo("foo")).isOne();
+        assertThat(string.compareTo("foo")).isGreaterThan(0);
+        assertThat(string.compareTo("foo")).isPositive();
+        assertThat(string.compareTo("foo")).isGreaterThanOrEqualTo(1);
+
+        assertThat(string.compareTo("foo")).isNotEqualTo(1);
+        assertThat(string.compareTo("foo")).isLessThanOrEqualTo(0);
+        assertThat(string.compareTo("foo")).isLessThan(1);
+        assertThat(string.compareTo("foo")).isNotPositive();
+
+        assertThat(string.compareTo("foo")).isEqualTo(-1);
+        assertThat(string.compareTo("foo")).isLessThan(0);
+        assertThat(string.compareTo("foo")).isNegative();
+        assertThat(string.compareTo("foo")).isLessThanOrEqualTo(-1);
+
+        assertThat(string.compareTo("foo")).isNotEqualTo(2);
+        assertThat(string.compareTo("foo")).isEqualTo(2);
+
+        org.junit.Assert.assertThat(string, null);
+        fail("oh no!");
+    }
+}