New JoinVarArgsContains inspection that will detect multiple .contains(), .doesNotContain(), and .containsOnlyOnce() calls within the same statement that could be joined together using variadic arguments.

Unrelated: Upgraded Gradle to 5.4.1. Upgraded kotlin to 1.3.40. Upgraded jacoco to 0.8.4. Minor style change for immediate returns. Increased test/branch coverage.

.travis.yml

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

README.md

@@ -1,4 +1,4 @@
-# Cajon - Concise AssertJ Optimizing Nitpicker
+# 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 is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
@@ -73,19 +73,46 @@ 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.
+
   ```
   from: assertThat(expected).someCondition();
         assertThat(expected).anotherCondition();
-    to: assertThat(expected).someCondition().anotherCondition();
+    to: assertThat(expected).someCondition()
+                            .anotherCondition();
   ```
-  Joining will work on actual expressions inside assertThat() that are
-  - the same variable reference
-  - textually equal binary expressions
-  - the same method calls (except for known side-effect methods such as ```Iterator.next()``` -- please notify me about others)
+  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
+  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 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 
+  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");
+  ```
+  Will not be performed on more complex statements with ```.extracting()``` or ```.as()``` to avoid
+  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
+
+  Uses ```isNull()``` and ```isNotNull()``` instead.
+
   ```
   from: assertThat(object).isEqualTo(null);
     to: assertThat(object).isNull();
@@ -95,12 +122,18 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
 
 - AssertThatBooleanCondition
+
+  Uses ```isTrue()``` and ```isFalse()``` instead.
+
   ```
   from: assertThat(booleanValue).isEqualTo(true/false/Boolean.TRUE/Boolean.FALSE);  
     to: assertThat(booleanValue).isTrue()/isFalse();
   ```
 
 - AssertThatInvertedBooleanCondition
+
+  Inverts the boolean condition to make it more readable.
+  
   ```
   from: assertThat(!booleanValue).isEqualTo(true/false/Boolean.TRUE/Boolean.FALSE);  
   from: assertThat(!booleanValue).isTrue()/isFalse();  
@@ -108,6 +141,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
 
 - AssertThatInstanceOf
+
+  Moves ```instanceof``` expressions out of ```assertThat()```.
+  
   ```
   from: assertThat(object instanceof classname).isEqualTo(true);
   from: assertThat(object instanceof classname).isTrue();
@@ -119,13 +155,21 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
 
 - AssertThatStringIsEmpty
+
+  Uses ```isEmpty()``` for empty string assertions.
+
   ```
   from: assertThat(charSequence/string).isEqualTo("");
   from: assertThat(charSequence/string).hasSize(0);
     to: assertThat(charSequence/string).isEmpty();
   ```
 
+  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();
@@ -148,13 +192,60 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
   Analogously with ```isFalse()```.
 
+- AssertThatObjectExpression
+
+  Handles equals(), toString() and hashCode() inside an expected expression.
+  
+  ```
+  from: assertThat(objActual.equals(objExpected)).isTrue();
+    to: assertThat(objActual).isEqualTo(objExpected);
+
+  from: assertThat(objActual.toString()).isEqualTo(stringExpected);
+    to: assertThat(objActual).hasToString(stringExpected);
+
+  from: assertThat(objActual.hashCode()).isEqualTo(objExpected.hashCode());
+    to: assertThat(objActual).hasSameHashCodeAs(objExpected);
+  ```
+
+- AssertThatCollectionOrMapExpression
+
+  Moves collection and map operations inside ```assertThat()``` out.
+
+  ```
+  from: assertThat(collection.isEmpty()).isTrue();
+    to: assertThat(collection).isEmpty();
+
+  from: assertThat(collection.contains("foobar")).isTrue();
+    to: assertThat(collection).contains("foobar");
+    
+  from: assertThat(collection.containsAll(otherCollection)).isTrue();
+    to: assertThat(collection).containsAll(otherCollection);
+
+  from: assertThat(map.isEmpty()).isTrue();
+    to: assertThat(map).isEmpty();
+
+  from: assertThat(map.containsKey(key)).isTrue();
+    to: assertThat(map).containsKey(key);
+    
+  from: assertThat(map.containsValue(value)).isTrue();
+    to: assertThat(map).containsValue(value);
+  ```
+  Analogously with ```isFalse()``` (except for ```containsAll()```).
+
 - AssertThatEnumerableIsEmpty
+
+  Uses ```isEmpty()``` for ```hasSize(0)``` iterable assertions instead.
+  
   ```
   from: assertThat(enumerable).hasSize(0);
     to: assertThat(enumerable).isEmpty();
   ```
 
 - AssertThatSize
+
+  Makes assertions on sizes of arrays, collections, strings, 
+  or ```CharSequence```s more concise.
+
   ```
   from: assertThat(array.length).isEqualTo(0);
   from: assertThat(array.length).isLessThanOrEqualTo(0);
@@ -203,25 +294,48 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
 
 - AssertThatBinaryExpression
+
+  Splits a boolean condition represented by binary expression out of ```assertThat()```.
+
   ```
   from: assertThat(primActual == primExpected).isTrue();
     to: assertThat(primActual).isEqualTo(primExpected);
 
   from: assertThat(10 < primActual).isNotEqualTo(false);
-    to: assertThat(primActual).isGreaterThan(primExpected);
+    to: assertThat(primActual).isGreaterThan(10);
 
   from: assertThat(objActual != objExpected).isEqualTo(true);
     to: assertThat(objActual).isNotSameAs(objExpected);
 
   from: assertThat(null == objActual).isFalse();
     to: assertThat(objActual).isNotNull();
-
-  from: assertThat(objActual.equals(objExpected).isTrue();
-    to: assertThat(objActual).isEqualTo(objExpected);
   ```
   ...and many, many more combinations (more than 150).
 
+- ImplicitAssertion
+
+  Detects and removes implicit use of ```isNotNull()```, ```isNotEmpty()``` and
+  ```isPresent()``` when followed by an assertion that will implicitly cover this
+  check.
+
+  ```
+  from: assertThat(string).isNotNull().startsWith("foo");
+    to: assertThat(string).startsWith("foo");
+
+  from: assertThat(list).isNotEmpty().hasSize(10);
+    to: assertThat(list).hasSize(10);
+
+  from: assertThat(optional).isPresent().contains("foo");
+    to: assertThat(optional).contains("foo");
+  ```
+  ...and many more combinations (more than 100).
+
 - AssertThatJava8Optional
+
+  Examines the statement for Java 8 ```Optional``` type and whether the statement
+  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);
@@ -239,8 +353,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat(opt.get()).isSameAs("foo");
     to: assertThat(opt).containsSame("foo"); 
 
+  from: assertThat(opt.orElse(null)).isEqualTo(null);
+    to: assertThat(opt).isNotPresent();
+     
+  from: assertThat(opt.orElse(null)).isNotEqualTo(null);
+    to: assertThat(opt).isPresent();
+     
   from: assertThat(opt).isEqualTo(Optional.of("foo"));
-  from: assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
+  from: assertThat(opt).isEqualTo(Optional.ofNullable("foo")); // only for constant "foo"
     to: assertThat(opt).contains("foo"); 
 
   from: assertThat(opt).isEqualTo(Optional.empty());
@@ -251,6 +371,11 @@ 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 
+  replaces the statement by better assertions.
+
   ```
   from: assertThat(opt.isPresent()).isEqualTo(true);
   from: assertThat(opt.isPresent()).isNotEqualTo(false);
@@ -265,8 +390,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat(opt.get()).isEqualTo("foo");
     to: assertThat(opt).contains("foo");
      
+  from: assertThat(opt.orNull()).isEqualTo(null);
+    to: assertThat(opt).isAbsent();
+     
+  from: assertThat(opt.orNull()).isNotEqualTo(null);
+    to: assertThat(opt).isPresent();
+     
   from: assertThat(opt).isEqualTo(Optional.of("foo"));
-  from: assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
+  from: assertThat(opt).isEqualTo(Optional.fromNullable("foo")); // only for constant "foo"
     to: assertThat(opt).contains("foo"); 
 
   from: assertThat(opt).isEqualTo(Optional.absent());
@@ -278,7 +409,60 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   AssertJ for Guava needs to be available in the classpath.
 
+- 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 
+  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() {
+          if (System.getProperty("manufacturer").equals("Volkswagen")) {
+              return;
+          }
+          double nitroxppm = doWltpDrivingCycle();
+          assertThat(nitroxppm).isLessThan(500.0);
+      }
+  ```
+  will be transformed to
+  ```
+      @Test
+      public void check_fuel_emission() {
+          assumeThat(System.getProperty("manufacturer").equals("Volkswagen")).isFalse();
+          double nitroxppm = doWltpDrivingCycle();
+          assertThat(nitroxppm).isLessThan(500.0);
+      }
+  ```
+
 - 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 -- 
+  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);
@@ -286,8 +470,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   assertFalse(message, condition);
   assertNull(object);
   assertNull(message, object);
-  assertNonNull(object);
-  assertNonNull(message, object);
+  assertNotNull(object);
+  assertNotNull(message, object);
   assertEquals(expected, actual);
   assertEquals(message, expected, actual);
   assertEquals(expectedDoubleOrFloat, actualDoubleOrFloat, delta);
@@ -304,6 +488,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   assertArrayEquals(message, expectedArray, actualArray);
   assertArrayEquals(expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
   assertArrayEquals(message, expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
+  
+  assumeTrue(condition);
+  assumeTrue(message, condition);
+  assumeFalse(condition);
+  assumeFalse(message, condition);
+  assumeNotNull(object); // single argument only!
+  assumeNoException(throwable);
+  assumeNoException(message, throwable);
   ```
 
 ### Implemented referencing
@@ -322,8 +514,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   .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 will add it.
+  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+  If there's demand, I could add it.
 
 ## Development notice
 
@@ -331,20 +523,58 @@ Cajon is written in Kotlin 1.3.
 
 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.
-Feel free to use the code (in package de.platon42.intellij.jupiter) for your projects (with attribution).
+Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
 
 ## Planned features
-- AssumeThatInsteadOfReturn
+- More Optional fixes such as opt1.get() == opt2.get() 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
+
   ```
   from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
     to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
   ```
 
-- Kotlin support (right now, however, with less than 100 downloads after a month, this is unlikely to happen)
-
 ## Changelog
 
+#### 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.
+- Extended JUnitAssertToAssertJ inspection to convert JUnit ```assume``` statements, too.
+- Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.
+- New ImplicitAssertion inspection for implicit ```isNotNull()```, ```isNotEmpty()``` and ```isPresent()``` assertions that will be covered by chained assertions.
+- Fix for multiple JUnit Conversions in batch mode with and without delta creating an exception.
+- 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.
+
+#### 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.
+- 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.
+- Fixed family names for inspections in batch mode.
+- Reworded many inspection messages for better understanding.
+- 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).

build.gradle

@@ -1,11 +1,13 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '0.4.8'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.31'
+    id 'org.jetbrains.intellij' version '0.4.9'
+    id 'org.jetbrains.kotlin.jvm' version '1.3.41'
+    id 'jacoco'
+    id 'com.github.kt3k.coveralls' version '2.8.4'
 }
 
 group 'de.platon42'
-version '0.7'
+version '1.3'
 
 repositories {
     mavenCentral()
@@ -18,10 +20,10 @@ repositories {
 
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testCompile "org.assertj:assertj-core:3.12.2"
+    testCompile "org.assertj:assertj-core:3.13.0"
     testCompile "org.assertj:assertj-guava:3.2.1"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
+    testImplementation 'org.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"
 }
@@ -33,29 +35,22 @@ compileTestKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2019.1.1'
+    version '2019.2'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
     updateSinceUntilBuild false
+    plugins = ['java']
 }
 
 patchPluginXml {
     changeNotes """
-  <h4>V0.7 (28-Apr-19)</h4>
+  <h4>V1.3 (03-Aug-19)</h4>
     <ul>
-      <li>Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
-          (really, Jetbrains, this sucks for no reason).
-      <li>Extended AssertThatSize inspection to transform hasSize() into hasSameSizeAs(), if possible.
-      <li>Implemented first version of JoinAssertThatStatements inspection that will try to merge assertThat() statements with the same
-          actual object together, preserving comments.
-    </ul>
-  <h4>V0.6 (22-Apr-19)</h4>
-    <ul>
-      <li>New AssertThatStringExpression inspection that will move isEmpty(), equals(), equalsIgnoreCase(), contains(),
-          startsWith(), and endsWith() out of actual expression.
-      <li>Extended AssertThatSize inspection to take strings and CharSequences into account, too.
-      <li>New AssertThatInvertedBooleanCondition inspection that will remove inverted boolean expressions inside assertThat().
-      <li>Renamed a few inspections to better/shorter names.
-      <li>New AssertThatInstanceOf inspection that moves instanceof expressions out of assertThat().
+      <li>New JoinVarArgsContains inspection that will detect multiple .contains(), .doesNotContain(), and .containsOnlyOnce()
+          calls within the same statement that could be joined together using variadic arguments.
+      <li>AssertJ 3.13.0 broke some inspections due to new AbstractStringAssert::isEqualTo() method.
+      <li>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.
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """
@@ -63,9 +58,20 @@ patchPluginXml {
 
 test {
     useJUnitPlatform()
-//    testLogging {
-//        events "passed", "skipped", "failed"
-//    }
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+}
+
+jacoco {
+    toolVersion = '0.8.4'
+}
+
+jacocoTestReport {
+    reports {
+        xml.enabled true
+        csv.enabled false
+    }
 }
 
 publishPlugin {

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip

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

@@ -7,6 +7,20 @@ class AssertJClassNames {
         @NonNls
         const val ASSERTIONS_CLASSNAME = "org.assertj.core.api.Assertions"
 
+        @NonNls
+        const val ASSUMPTIONS_CLASSNAME = "org.assertj.core.api.Assumptions"
+
+        @NonNls
+        const val DESCRIPTABLE_INTERFACE = "org.assertj.core.api.Descriptable"
+        @NonNls
+        const val EXTENSION_POINTS_INTERFACE = "org.assertj.core.api.ExtensionPoints"
+        @NonNls
+        const val ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.EnumerableAssert"
+        @NonNls
+        const val OBJECT_ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.ObjectEnumerableAssert"
+
+        @NonNls
+        const val ASSERT_INTERFACE = "org.assertj.core.api.Assert"
         @NonNls
         const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
         @NonNls
@@ -24,7 +38,7 @@ class AssertJClassNames {
         @NonNls
         const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
         @NonNls
-        const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
+        const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"
         @NonNls
         const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"
 
@@ -33,6 +47,6 @@ class AssertJClassNames {
         @NonNls
         const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
         @NonNls
-        const val GUAVA_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
+        const val GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
     }
 }

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

@@ -6,6 +6,7 @@ import com.siyeh.ig.callMatcher.CallMatcher
 val CORE_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
 val GUAVA_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
 val ALL_ASSERT_THAT_MATCHERS = CallMatcher.anyOf(CORE_ASSERT_THAT_MATCHER, GUAVA_ASSERT_THAT_MATCHER)!!
+
 val EXTRACTING_FROM_OBJECT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME, "extracting")!!
 val EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extracting")!!
 val FLAT_EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "flatExtracting")!!
@@ -18,6 +19,35 @@ val EXTRACTING_CALL_MATCHERS = CallMatcher.anyOf(
     EXTRACTING_RESULT_OF_FROM_ITERABLE
 )!!
 
+val DESCRIBED_AS = CallMatcher.instanceCall(AssertJClassNames.DESCRIPTABLE_INTERFACE, MethodNames.DESCRIBED_AS, MethodNames.AS)!!
+val WITH_REPRESENTATION_AND_SUCH = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "withRepresentation", "withThreadDumpOnError")!!
+val USING_COMPARATOR = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "usingComparator", "usingDefaultComparator")!!
+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"
+)!!
+
+val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
+    DESCRIBED_AS,
+    WITH_REPRESENTATION_AND_SUCH,
+    USING_COMPARATOR,
+    IN_HEXADECIMAL_OR_BINARY
+)!!
+
+val NOT_ACTUAL_ASSERTIONS = CallMatcher.anyOf(
+    ALL_ASSERT_THAT_MATCHERS,
+    COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY
+)!!
+
 val KNOWN_METHODS_WITH_SIDE_EFFECTS = CallMatcher.anyOf(
     CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_ITERATOR, "next")
 )!!

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

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

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

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

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

@@ -11,8 +11,19 @@ class MethodNames {
 
         @NonNls
         const val ASSERT_THAT = "assertThat"
+
+        @NonNls
+        const val ASSUME_THAT = "assumeThat"
+
         @NonNls
         const val AS = "as"
+        @NonNls
+        const val DESCRIBED_AS = "describedAs"
+        @NonNls
+        const val IN_HEXADECIMAL = "inHexadecimal"
+        @NonNls
+        const val IN_BINARY = "inBinary"
+
         @NonNls
         const val IS_EQUAL_TO = "isEqualTo"
         @NonNls
@@ -21,6 +32,10 @@ class MethodNames {
         const val IS_SAME_AS = "isSameAs"
         @NonNls
         const val IS_NOT_SAME_AS = "isNotSameAs"
+
+        @NonNls
+        const val HAS_TO_STRING = "hasToString"
+
         @NonNls
         const val IS_GREATER_THAN = "isGreaterThan"
         @NonNls
@@ -38,7 +53,7 @@ class MethodNames {
         @NonNls
         const val IS_FALSE = "isFalse"
         @NonNls
-        const val IS_NULL = "isNull"
+        const val IS_NULL = "isNull" // terminal, returns void
         @NonNls
         const val IS_NOT_NULL = "isNotNull"
         @NonNls
@@ -51,7 +66,9 @@ class MethodNames {
         const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"
 
         @NonNls
-        const val IS_EMPTY = "isEmpty"
+        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
@@ -69,10 +86,22 @@ class MethodNames {
         @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 IS_EQUAL_TO_IC = "isEqualToIgnoringCase"
         @NonNls
         const val IS_NOT_EQUAL_TO_IC = "isNotEqualToIgnoringCase"

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

@@ -3,6 +3,7 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.tree.IElementType
@@ -11,13 +12,14 @@ import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_STRING_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ENUMERABLE_ASSERT_INTERFACE
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_OPTIONAL_CLASSNAME
 import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.getArg
 import de.platon42.intellij.plugins.cajon.qualifierExpression
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
 
@@ -28,8 +30,9 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         const val MORE_CONCISE_MESSAGE_TEMPLATE = "%s() would be more concise than %s()"
 
         const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with %s()"
-        const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE = "Remove unwrapping of expected expression and replace %s() with %s()"
-        const val UNWRAP_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap actual expression and replace %s() with %s()"
+        const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap expected expression and replace %s() with %s()"
+        const val MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE = "Remove %s() of actual expression and use assertThat().%s() instead"
+        const val MOVING_OUT_MESSAGE_TEMPLATE = "Moving %s() expression out of assertThat() would be more concise"
 
         val TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP = mapOf<IElementType, String>(
             JavaTokenType.EQEQ to MethodNames.IS_EQUAL_TO,
@@ -74,24 +77,33 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val ASSERT_THAT_JAVA8_OPTIONAL = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
             .parameterTypes(CommonClassNames.JAVA_UTIL_OPTIONAL)!!
 
-        val ASSERT_THAT_GUAVA_OPTIONAL = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
-            .parameterTypes(GUAVA_OPTIONAL_CLASSNAME)!!
+        val GUAVA_ASSERT_THAT_ANY = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterCount(1)!!
 
-        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
+        val IS_EQUAL_TO_STRING = CallMatcher.instanceCall(ABSTRACT_STRING_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+            .parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
+        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("boolean")!!
         val IS_NOT_EQUAL_TO_BOOLEAN =
             CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
                 .parameterTypes("boolean")!!
-        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_SAME_AS)
+        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_SAME_AS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_SAME_AS)
+        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_SAME_AS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
 
-        val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)
+        val IS_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NULL)
+            .parameterCount(0)!!
+        val IS_NOT_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_NULL)
+            .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 IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
@@ -127,6 +139,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
             .parameterCount(0)!!
         val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "isPresent")
             .parameterCount(0)!!
+        val OPTIONAL_OR_ELSE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "orElse")
+            .parameterCount(1)!!
 
         val OPTIONAL_OF = CallMatcher.staticCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "of")
             .parameterCount(1)!!
@@ -139,6 +153,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
             .parameterCount(0)!!
         val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "isPresent")
             .parameterCount(0)!!
+        val GUAVA_OPTIONAL_OR_NULL = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "orNull")
+            .parameterCount(0)!!
 
         val GUAVA_OPTIONAL_OF = CallMatcher.staticCall(GUAVA_OPTIONAL_CLASSNAME, "of")
             .parameterCount(1)!!
@@ -174,7 +190,22 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
         val quickFix = ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
-        holder.registerProblem(expression, message, quickFix)
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickFix)
+    }
+
+    protected fun registerMoveOutMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldActualExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
+        val description = MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, message, quickfix)
     }
 
     protected fun registerReplaceMethod(
@@ -199,7 +230,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val description = descriptionTemplate.format(originalMethod, replacementMethod)
         val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickfix)
     }
 
     protected fun registerRemoveExpectedOutmostMethod(
@@ -211,55 +243,4 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
     ) {
         registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
-
-    protected fun registerRemoveActualOutmostMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldExpectedCallExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        registerConciseMethod(UNWRAP_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
-    }
-
-    protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
-        if (argIndex >= expression.argumentList.expressions.size) return null
-        val valueExpression = expression.getArg(argIndex)
-        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
-        val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
-        if (value == null) {
-            val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
-            if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
-                return when (field.name) {
-                    "TRUE" -> true
-                    "FALSE" -> false
-                    else -> null
-                }
-            }
-        }
-        return value
-    }
-
-    protected fun getExpectedBooleanResult(expectedCallExpression: PsiMethodCallExpression): Boolean? {
-        val isTrue = IS_TRUE.test(expectedCallExpression)
-        val isFalse = IS_FALSE.test(expectedCallExpression)
-        if (isTrue || isFalse) {
-            return isTrue
-        } else {
-            val isEqualTo = IS_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
-            val isNotEqualTo = IS_NOT_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
-            if (isEqualTo || isNotEqualTo) {
-                val constValue = calculateConstantParameterValue(expectedCallExpression, 0) as? Boolean ?: return null
-                return isNotEqualTo xor constValue
-            }
-        }
-        return null
-    }
-
-    protected fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
-        val findClass =
-            JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
-                ?: return false
-        return findClass.allMethods.any { it.name == methodname }
-    }
 }

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

@@ -7,12 +7,10 @@ import org.jetbrains.annotations.NonNls
 open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
-        const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
-
-        const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with assertThat().%s()"
-
         @NonNls
         const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
+        @NonNls
+        const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
 
         @NonNls
         const val ASSERT_TRUE_METHOD = "assertTrue"
@@ -32,6 +30,16 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
         const val ASSERT_NOT_SAME_METHOD = "assertNotSame"
         @NonNls
         const val ASSERT_ARRAY_EQUALS_METHOD = "assertArrayEquals"
+
+        @NonNls
+        const val ASSUME_TRUE_METHOD = "assumeTrue"
+        @NonNls
+        const val ASSUME_FALSE_METHOD = "assumeFalse"
+        @NonNls
+        const val ASSUME_NOT_NULL_METHOD = "assumeNotNull"
+        @NonNls
+        const val ASSUME_NO_EXCEPTION = "assumeNoException"
+
     }
 
     override fun getGroupDisplayName(): String {

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

@@ -4,53 +4,42 @@ import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
 import com.intellij.psi.util.TypeConversionUtil
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.map
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveActualOuterExpressionMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix
 
 class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a binary expression"
-        private const val SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split %s expression out of assertThat()"
-        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving %s expression out of assertThat() would be more meaningful"
+        private const val SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split binary expression out of assertThat()"
+        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving binary expression out of assertThat() would be more meaningful"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
-                    return
-                }
+            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+                super.visitExpressionStatement(statement)
+                if (!statement.hasAssertThat()) return
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
 
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
 
-                val assertThatArgument = expression.firstArg
-                if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
-                    val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
-                    registerSplitMethod(holder, expression, "${MethodNames.EQUALS}()", replacementMethod, ::MoveActualOuterExpressionMethodCallQuickFix)
-                    return
-                }
-
-                val binaryExpression = assertThatArgument as? PsiBinaryExpression ?: return
+                val binaryExpression = staticMethodCall.firstArg as? PsiBinaryExpression ?: return
 
                 val leftType = binaryExpression.lOperand.type ?: return
                 val rightType = binaryExpression.rOperand?.type ?: return
 
                 val bothTypes = listOf(leftType, rightType)
                 val (isLeftNull, isRightNull) = bothTypes.map(TypeConversionUtil::isNullType)
-                if (isLeftNull && isRightNull) {
-                    return
-                } else if (isLeftNull || isRightNull) {
+
+                if (isLeftNull && isRightNull) return
+                if (isLeftNull || isRightNull) {
                     val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
-                    registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                    registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
                         SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
                     }
                     return
@@ -58,7 +47,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
 
                 val isPrimitive = bothTypes.all(TypeConversionUtil::isPrimitiveAndNotNull)
                 val isNumericType = bothTypes.all(TypeConversionUtil::isNumericType)
-                val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+                val constantEvaluationHelper = JavaPsiFacade.getInstance(statement.project).constantEvaluationHelper
                 val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
 
                 val tokenType = binaryExpression.operationTokenType
@@ -72,7 +61,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                     (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
                 val replacementMethod = mappingToUse[tokenType] ?: return
 
-                registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
                     SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
                 }
             }
@@ -82,13 +71,10 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
     private fun registerSplitMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
-        type: String,
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        val description = SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE.format(type)
-        val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
+        val quickfix = quickFixSupplier(SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE, replacementMethod)
+        holder.registerProblem(expression, MORE_MEANINGFUL_MESSAGE_TEMPLATE, quickfix)
     }
 }

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

@@ -5,10 +5,8 @@ import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.util.TypeConversionUtil
+import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.map
 
 class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
 
@@ -22,22 +20,18 @@ class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             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
-                }
-                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) {
-                    return
-                }
+                if (matchingCalls.none { it }) return
+                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) return
 
                 val expectedExpression = expression.firstArg
-                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) {
-                    return
-                }
-                val expectedResult = calculateConstantParameterValue(expression, 0) as? Boolean ?: return
+                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) return
+
+                val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
                 val flippedBooleanTest = matchingCalls.drop(2).any { it }
 
                 val replacementMethod = (expectedResult xor flippedBooleanTest).map(MethodNames.IS_TRUE, MethodNames.IS_FALSE)

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

@@ -0,0 +1,70 @@
+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
+
+class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting a collection or map specific expression"
+
+        private val MAPPINGS = listOf(
+            Mapping(
+                CallMatcher.anyOf(
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "isEmpty").parameterCount(0),
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "isEmpty").parameterCount(0)
+                ),
+                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
+            ),
+            Mapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "contains").parameterCount(1),
+                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
+            ),
+            Mapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "containsAll").parameterCount(1),
+                MethodNames.CONTAINS_ALL, null
+            ),
+            Mapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "containsKey").parameterCount(1),
+                MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY
+            ),
+            Mapping(
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "containsValue").parameterCount(1),
+                MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE
+            )
+        )
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+                super.visitExpressionStatement(statement)
+                if (!statement.hasAssertThat()) return
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
+
+                val 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 ?: return
+                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                    MoveOutMethodCallExpressionQuickFix(desc, method)
+                }
+            }
+        }
+    }
+
+    private class Mapping(
+        val callMatcher: CallMatcher,
+        val replacementForTrue: String,
+        val replacementForFalse: String?
+    )
+}

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

@@ -4,7 +4,10 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiStatement
 import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.calculateConstantParameterValue
+import de.platon42.intellij.plugins.cajon.hasAssertThat
 
 class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
 
@@ -18,11 +21,11 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!HAS_SIZE.test(expression)) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
+                val isLastExpression = expression.parent is PsiStatement
+                if (!(HAS_SIZE.test(expression) && isLastExpression)) return
 
-                val value = calculateConstantParameterValue(expression, 0) ?: return
+                val value = expression.calculateConstantParameterValue(0) ?: return
                 if (value == 0) {
                     registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                 }

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

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

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

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

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

@@ -1,19 +1,14 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.map
-import de.platon42.intellij.plugins.cajon.quickfixes.RemoveUnaryExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryStatementQuickFix
 
 class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting an inverted boolean condition"
-        private const val INVERT_CONDITION_DESCRIPTION = "Invert condition in assertThat()"
         private const val INVERT_CONDITION_MESSAGE = "Condition inside assertThat() could be inverted"
     }
 
@@ -23,29 +18,17 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
+                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
+                expression.getExpectedBooleanResult() ?: return
 
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
-
-                val prefixExpression = expression.firstArg as? PsiPrefixExpression ?: return
+                val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
                 if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
-                    val replacementMethod = expectedResult.map(MethodNames.IS_FALSE, MethodNames.IS_TRUE)
-                    registerInvertMethod(holder, expression, replacementMethod, ::RemoveUnaryExpressionQuickFix)
+                    val outmostMethodCall = expression.findOutmostMethodCall() ?: return
+                    holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
                 }
             }
         }
     }
-
-    private fun registerInvertMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val quickfix = quickFixSupplier(INVERT_CONDITION_DESCRIPTION, replacementMethod)
-        holder.registerProblem(expression, INVERT_CONDITION_MESSAGE, quickfix)
-    }
 }

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

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

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

@@ -0,0 +1,57 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.HasHashCodeQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
+
+class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting equals(), toString(), or hashCode()"
+        private const val HASHCODE_MESSAGE_TEMPLATE = "Replacing hashCode() expressions by hasSameHashCode() would be more concise"
+
+        private val OBJECT_TO_STRING = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "toString").parameterCount(0)
+        private val OBJECT_HASHCODE = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "hashCode").parameterCount(0)
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+                super.visitExpressionStatement(statement)
+                if (!statement.hasAssertThat()) return
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+
+                val assertThatArgument = staticMethodCall.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())
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

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

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

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

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

@@ -1,51 +1,42 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.CommonClassNames
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.*
 import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveActualOuterExpressionMethodCallQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
 
 class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a string specific expression"
-        private const val MOVE_EXPECTED_EXPRESSION_DESCRIPTION_TEMPLATE = "Remove %s() of expected expression and use assertThat().%s() instead"
-        private const val MOVING_OUT_MESSAGE_TEMPLATE = "Moving %s() expression out of assertThat() would be more concise"
 
         private val MAPPINGS = listOf(
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0)!!,
-                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, hasExpected = false
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0),
+                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
             ),
             Mapping(
                 CallMatcher.anyOf(
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equals").parameterCount(1)!!,
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contentEquals").parameterCount(1)!!
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equals").parameterCount(1),
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contentEquals").parameterCount(1)
                 ),
                 MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equalsIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!,
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equalsIgnoreCase").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
                 MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contains").parameterCount(1)!!,
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contains").parameterCount(1),
                 MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "startsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!,
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "startsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
                 MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "endsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!,
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "endsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
                 MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH
             )
         )
@@ -55,48 +46,29 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
-                    return
-                }
-                val assertThatArgument = expression.firstArg as? PsiMethodCallExpression ?: return
+            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 = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
 
                 val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse
-                if (mapping.hasExpected) {
-                    registerMoveOutMethod(holder, expression, assertThatArgument, replacementMethod, ::MoveActualOuterExpressionMethodCallQuickFix)
-                } else {
-                    registerMoveOutMethod(holder, expression, assertThatArgument, replacementMethod) { desc, method ->
-                        RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression = true)
+                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                    MoveOutMethodCallExpressionQuickFix(desc, method)
                 }
             }
         }
     }
-    }
-
-    private fun registerMoveOutMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldActualExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
-        val description = MOVE_EXPECTED_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
-    }
 
     private class Mapping(
         val callMatcher: CallMatcher,
         val replacementForTrue: String,
-        val replacementForFalse: String,
-        val hasExpected: Boolean = true
+        val replacementForFalse: String
     )
 }

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

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

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

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

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

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

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

@@ -10,41 +10,44 @@ import com.siyeh.ig.callMatcher.CallMatcher.staticCall
 import de.platon42.intellij.plugins.cajon.AssertJClassNames
 import de.platon42.intellij.plugins.cajon.MethodNames
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssertMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssumeMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitDeltaAssertMethodCallQuickFix
 
 class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Convert JUnit assertions to AssertJ"
+        private const val DISPLAY_NAME = "Convert JUnit assertions/assumptions to AssertJ"
+        private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
+        private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"
 
-        private val MAPPINGS = listOf(
+        private val ASSERT_MAPPINGS = listOf(
             Mapping(
                 anyOf(
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
                 ),
-                MethodNames.IS_TRUE, false
+                MethodNames.IS_TRUE, hasExpected = false
             ),
             Mapping(
                 anyOf(
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
                 ),
-                MethodNames.IS_FALSE, false
+                MethodNames.IS_FALSE, hasExpected = false
             ),
             Mapping(
                 anyOf(
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                 ),
-                MethodNames.IS_NULL, false
+                MethodNames.IS_NULL, hasExpected = false
             ),
             Mapping(
                 anyOf(
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
                     staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                 ),
-                MethodNames.IS_NOT_NULL, false
+                MethodNames.IS_NOT_NULL, hasExpected = false
             ),
             Mapping(
                 anyOf(
@@ -109,6 +112,34 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
                 MethodNames.CONTAINS_EXACTLY
             )
         )
+
+        private val ASSUME_MAPPINGS = listOf(
+            Mapping(
+                anyOf(
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes("boolean")
+                ),
+                MethodNames.IS_TRUE, hasExpected = false
+            ),
+            Mapping(
+                anyOf(
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes("boolean")
+                ),
+                MethodNames.IS_FALSE, hasExpected = false
+            ),
+            Mapping(
+                staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
+                MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
+            ),
+            Mapping(
+                anyOf(
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_THROWABLE),
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_THROWABLE)
+                ),
+                "doesNotThrowAnyException", hasExpected = false
+            )
+        )
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -117,21 +148,31 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                val isJUnitAssertCall = expression.resolveMethod()?.containingClass?.qualifiedName == JUNIT_ASSERT_CLASSNAME
-                if (!isJUnitAssertCall) {
-                    return // early exit
-                }
+                when (expression.resolveMethod()?.containingClass?.qualifiedName) {
+                    JUNIT_ASSERT_CLASSNAME -> {
                         JavaPsiFacade.getInstance(expression.project)
                             .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
                         if (mapping.hasDelta) {
-                    registerConvertMethod(holder, expression, mapping.replacement, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
                         } else {
-                    registerConvertMethod(holder, expression, mapping.replacement) { desc, method ->
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
                                 ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
                             }
                         }
                     }
+                    JUNIT_ASSUME_CLASSNAME -> {
+                        JavaPsiFacade.getInstance(expression.project)
+                            .findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                        val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                        if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
+                                ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 
@@ -139,10 +180,11 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
         replacementMethod: String,
+        staticMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
         val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, staticMethod, replacementMethod)
         val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
         holder.registerProblem(expression, message, quickfix)
@@ -152,6 +194,7 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         val callMatcher: CallMatcher,
         val replacement: String,
         val hasExpected: Boolean = true,
-        val hasDelta: Boolean = false
+        val hasDelta: Boolean = false,
+        val singleArgument: Boolean = false
     )
 }

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

@@ -2,30 +2,38 @@ package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.codeInspection.ui.SingleIntegerFieldOptionsPanel
 import com.intellij.psi.*
 import com.intellij.psi.util.PsiTreeUtil
+import com.siyeh.ig.psiutils.EquivalenceChecker
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.JoinStatementsQuickFix
+import javax.swing.JComponent
 
 class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Joining multiple assertThat() statements with same actual expression"
+        private const val DISPLAY_NAME = "Join multiple assertThat() statements with same actual expression"
         private const val CAN_BE_JOINED_DESCRIPTION = "Multiple assertThat() statements can be joined together"
+        private const val DEFAULT_SEPARATE_LINE_LIMIT = 1
     }
 
+    @JvmField
+    var separateLineLimit: Int = DEFAULT_SEPARATE_LINE_LIMIT
+
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitCodeBlock(block: PsiCodeBlock?) {
+            override fun visitCodeBlock(block: PsiCodeBlock) {
                 super.visitCodeBlock(block)
-                val statements = block?.statements ?: return
                 var lastActualExpression: PsiExpression? = null
                 var sameCount = 0
                 var firstStatement: PsiStatement? = null
                 var lastStatement: PsiStatement? = null
-                for (statement in statements) {
+                // Note: replace with TrackingEquivalenceChecker() for IDEA >= 2019.1
+                val equivalenceChecker = EquivalenceChecker.getCanonicalPsiEquivalence()!!
+                for (statement in block.statements) {
                     val assertThatCall = isLegitAssertThatCall(statement)
                     var reset = true
                     var actualExpression: PsiExpression? = null
@@ -33,13 +41,9 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                         reset = (lastActualExpression == null)
                         actualExpression = assertThatCall.firstArg
                         if (!reset) {
-                            val isSame = when (actualExpression) {
-                                is PsiReferenceExpression -> (actualExpression.qualifierExpression == (lastActualExpression as? PsiReferenceExpression)?.qualifierExpression)
-                                is PsiMethodCallExpression -> (actualExpression.text == (lastActualExpression as? PsiMethodCallExpression)?.text)
-                                        && !KNOWN_METHODS_WITH_SIDE_EFFECTS.test(actualExpression)
-                                is PsiPolyadicExpression -> (actualExpression.text == (lastActualExpression as? PsiPolyadicExpression)?.text)
-                                else -> false
-                            }
+                            val isSame = equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
+                                    && !hasExpressionWithSideEffects(actualExpression)
+
                             if (isSame) {
                                 sameCount++
                                 lastStatement = statement
@@ -50,7 +54,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                     }
                     if (reset) {
                         if (sameCount > 1) {
-                            registerProblem(firstStatement, lastStatement)
+                            registerProblem(holder, isOnTheFly, firstStatement!!, lastStatement!!)
                         }
                         firstStatement = statement
                         lastStatement = null
@@ -59,29 +63,54 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                     }
                 }
                 if (sameCount > 1) {
-                    registerProblem(firstStatement, lastStatement)
+                    registerProblem(holder, isOnTheFly, firstStatement!!, lastStatement!!)
                 }
             }
 
-            private fun registerProblem(firstStatement: PsiStatement?, lastStatement: PsiStatement?) {
-                val problemDescriptor = holder.manager.createProblemDescriptor(
-                    firstStatement!!,
-                    lastStatement!!,
-                    CAN_BE_JOINED_DESCRIPTION,
-                    ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                    isOnTheFly,
-                    JoinStatementsQuickFix()
-                )
-                holder.registerProblem(problemDescriptor)
-            }
-
             private fun isLegitAssertThatCall(statement: PsiStatement?): PsiMethodCallExpression? {
                 if ((statement is PsiExpressionStatement) && (statement.expression is PsiMethodCallExpression)) {
+                    if (!statement.hasAssertThat()) return null
+
                     val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
                     return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
                 }
                 return null
             }
+
+            private fun hasExpressionWithSideEffects(actualExpression: PsiExpression): Boolean {
+                var result = false
+                PsiTreeUtil.processElements(actualExpression) { element ->
+                    val matched = when (element) {
+                        is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
+                                || (element.operationTokenType == JavaTokenType.MINUSMINUS)
+                        is PsiMethodCallExpression -> KNOWN_METHODS_WITH_SIDE_EFFECTS.test(element)
+                        else -> false
                     }
+                    if (matched) {
+                        result = true
+                        false
+                    } else {
+                        true
+                    }
+                }
+                return result
+            }
+        }
+    }
+
+    override fun createOptionsPanel(): JComponent {
+        return SingleIntegerFieldOptionsPanel("Limit for joins before adding line breaks:", this, "separateLineLimit")
+    }
+
+    private fun registerProblem(holder: ProblemsHolder, isOnTheFly: Boolean, firstStatement: PsiStatement, lastStatement: PsiStatement) {
+        val problemDescriptor = holder.manager.createProblemDescriptor(
+            firstStatement,
+            lastStatement,
+            CAN_BE_JOINED_DESCRIPTION,
+            ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+            isOnTheFly,
+            JoinStatementsQuickFix(separateLineLimit)
+        )
+        holder.registerProblem(problemDescriptor)
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -3,11 +3,12 @@ package de.platon42.intellij.plugins.cajon.quickfixes
 import com.intellij.codeInspection.ProblemDescriptor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.*
-import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.util.PsiTreeUtil
-import de.platon42.intellij.plugins.cajon.ALL_ASSERT_THAT_MATCHERS
+import de.platon42.intellij.plugins.cajon.findStaticMethodCall
+import de.platon42.intellij.plugins.cajon.shortenAndReformat
+
+class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
 
-class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
     companion object {
         private const val JOIN_STATEMENTS_MESSAGE = "Join assertThat() statements"
     }
@@ -15,33 +16,35 @@ class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val firstStatement = descriptor.startElement as PsiExpressionStatement
         val lastStatement = descriptor.endElement as PsiExpressionStatement
+
+        val expressionCount = countExpressions(firstStatement, lastStatement)
+        val addLineBreaks = (expressionCount > separateLineLimit)
+
         do {
             val commentsToKeep = ArrayList<PsiComment>()
             val stuffToDelete = ArrayList<PsiElement>()
-            var previousStatement = lastStatement.prevSibling ?: throw IllegalStateException("Internal error")
+            var previousStatement = lastStatement.prevSibling!!
             while (previousStatement !is PsiExpressionStatement) {
                 if (previousStatement is PsiComment) {
                     commentsToKeep.add(previousStatement.copy() as PsiComment)
                 }
                 stuffToDelete.add(previousStatement)
-                previousStatement = previousStatement.prevSibling ?: throw IllegalStateException("Internal error")
+                previousStatement = previousStatement.prevSibling!!
             }
             stuffToDelete.forEach { if (it.isValid) it.delete() }
 
             val statementComments = PsiTreeUtil.getChildrenOfAnyType(previousStatement, PsiComment::class.java)
             commentsToKeep.addAll(statementComments)
 
-            val assertThatCallOfCursorStatement =
-                PsiTreeUtil.findChildrenOfType(lastStatement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
-                    ?: throw IllegalStateException("Internal error")
+            val assertThatCallOfCursorStatement = lastStatement.findStaticMethodCall()!!
 
             val lastElementBeforeConcat = assertThatCallOfCursorStatement.parent
             commentsToKeep.forEach {
                 lastElementBeforeConcat.addAfter(it, lastElementBeforeConcat.firstChild)
-                val newLineNode =
-                    PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
-
-                lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
+                addLineBreak(project, lastElementBeforeConcat)
+            }
+            if (commentsToKeep.isEmpty() && addLineBreaks) {
+                addLineBreak(project, lastElementBeforeConcat)
             }
 
             val newLeaf = previousStatement.firstChild
@@ -49,6 +52,29 @@ class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
             previousStatement.delete()
         } while (previousStatement !== firstStatement)
         val codeBlock = PsiTreeUtil.getParentOfType(lastStatement, PsiCodeBlock::class.java) ?: return
-        CodeStyleManager.getInstance(project).reformat(codeBlock)
+        codeBlock.shortenAndReformat()
+    }
+
+    private fun addLineBreak(project: Project, lastElementBeforeConcat: PsiElement) {
+        val newLineNode =
+            PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
+
+        lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
+    }
+
+    private fun countExpressions(firstStatement: PsiElement, lastStatement: PsiElement): Int {
+        var count = 0
+        var currentStatement = firstStatement
+        do {
+            while (currentStatement !is PsiExpressionStatement) {
+                currentStatement = currentStatement.nextSibling!!
+            }
+            count++
+            if (currentStatement === lastStatement) {
+                break
+            }
+            currentStatement = currentStatement.nextSibling!!
+        } while (true)
+        return count
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,32 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiInstanceOfExpression
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
-
-class RemoveInstanceOfExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCallExpression.firstArg as? PsiInstanceOfExpression ?: return
-        val expectedClass = assertExpression.checkType ?: return
-        val factory = JavaPsiFacade.getElementFactory(project)
-        val classObjectAccess = factory.createExpressionFromText("${expectedClass.type.canonicalText}.class", null)
-
-        val operand = PsiUtil.deparenthesizeExpression(assertExpression.operand) ?: return
-        assertExpression.replace(operand)
-
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod, classObjectAccess)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
-    }
-}

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

@@ -1,27 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiUnaryExpression
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
-
-class RemoveUnaryExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCallExpression.firstArg as? PsiUnaryExpression ?: return
-        val operand = PsiUtil.skipParenthesizedExprDown(assertExpression.operand) ?: return
-        assertExpression.replace(operand)
-
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
-    }
-}

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

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.*
+
+class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
+    AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val CONVERT_DESCRIPTION = "Convert JUnit assumptions to assertJ"
+    }
+
+    override fun getFamilyName(): String {
+        return CONVERT_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val args = methodCallExpression.argumentList
+        val count = args.expressions.size
+        val actualExpression = args.expressions[count - 1] ?: return
+        val messageExpression = args.expressions.getOrNull(count - 2)
+
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
+        val newMethodCall = createAssumeThat(element, actualExpression)
+
+        if (messageExpression != null) {
+            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
+            asExpression.replaceQualifier(newMethodCall)
+            expectedMethodCall.replaceQualifier(asExpression)
+        } else {
+            expectedMethodCall.replaceQualifier(newMethodCall)
+        }
+
+        newMethodCall.resolveMethod()?.addAsStaticImport(element)
+        element.replace(expectedMethodCall).shortenAndReformat()
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -50,19 +50,16 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
         }
 
         private fun findActualType(element: PsiElement): PsiClassType? {
-            val assertThatCall = PsiTreeUtil.findChildrenOfType(element, PsiMethodCallExpression::class.java)
-                .find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return null
-            return assertThatCall.firstArg.type as? PsiClassType
+            val assertThatCall = element.findStaticMethodCall()
+            return assertThatCall?.firstArg?.type as? PsiClassType
         }
 
         private fun findAndCreateReferences(element: PsiElement, finder: (PsiLiteralExpression) -> List<Pair<TextRange, List<PsiElement>>>?): Array<PsiReference> {
             val literal = element as PsiLiteralExpression
-            val results = finder(literal)
-            if (results != null) {
+            val results = finder(literal) ?: return PsiReference.EMPTY_ARRAY
+
             return results.map { ExtractorReference(literal, it.first, it.second) }.toTypedArray()
         }
-            return PsiReference.EMPTY_ARRAY
-        }
     }
 
     override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
@@ -74,6 +71,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
         override fun getVariants(): Array<Any> {
             return ArrayUtil.EMPTY_OBJECT_ARRAY
         }
@@ -89,9 +87,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class PropertyOrFieldReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-            return findAndCreateReferences(element, ::findReferences)
-        }
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
@@ -113,9 +109,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class IterablePropertyOrFieldReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-            return findAndCreateReferences(element, ::findReferences)
-        }
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
@@ -128,9 +122,8 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
                 isResultOf = true
             }
 
-            if (!CallMatcher.anyOf(EXTRACTING_FROM_ITERABLE, FLAT_EXTRACTING_FROM_ITERABLE).test(methodCallExpression)) {
-                return null
-            }
+            if (!CallMatcher.anyOf(EXTRACTING_FROM_ITERABLE, FLAT_EXTRACTING_FROM_ITERABLE).test(methodCallExpression)) return null
+
             val iterableType = findActualType(methodCallExpression) ?: return null
             val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
             val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null
@@ -140,16 +133,13 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class IterableResultOfReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-            return findAndCreateReferences(element, ::findReferences)
-        }
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
             val methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression::class.java) ?: return null
-            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) {
-                return null
-            }
+            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) return null
+
             val iterableType = findActualType(methodCallExpression) ?: return null
             val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
             val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null

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

@@ -1,21 +1,20 @@
 <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">Platon42</vendor>
+    <vendor email="chrisly@platon42.de" url="https://github.com/chrisly42/cajon-plugin">Chris 'platon42' Hodges</vendor>
 
     <description><![CDATA[
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
     It adds several inspections and quick fixes 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 to AssertJ.
+    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.
+    <p>
+    <a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
     ]]></description>
 
-    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
     <idea-version since-build="173.2696.26"/>
 
-    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
-         on how to target different products -->
     <depends>com.intellij.modules.lang</depends>
     <depends>com.intellij.modules.platform</depends>
     <depends>com.intellij.modules.java</depends>
@@ -40,17 +39,28 @@
 
         <localInspection groupPath="Java" shortName="AssertThatBinaryExpression" enabledByDefault="true" level="WARNING"
                          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="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="JoinAssertThatStatements" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinAssertThatStatementsInspection"/>
+        <localInspection groupPath="Java" shortName="JoinVarArgsContains" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinVarArgsContainsInspection"/>
+        <localInspection groupPath="Java" shortName="AssumeThatInsteadOfReturn" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssumeThatInsteadOfReturnInspection"/>
 
         <localInspection groupPath="Java" shortName="AssertThatJava8Optional" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatJava8OptionalInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatGuavaOptional" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatGuavaOptionalInspection"/>
 
+        <localInspection groupPath="Java" shortName="ImplicitAssertion" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.ImplicitAssertionInspection"/>
+
         <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.JUnitAssertToAssertJInspection"/>
     </extensions>

src/main/resources/inspectionDescriptions/AssertThatBinaryExpression.html

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

src/main/resources/inspectionDescriptions/AssertThatBooleanCondition.html

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

src/main/resources/inspectionDescriptions/AssertThatCollectionOrMapExpression.html

@@ -0,0 +1,8 @@
+<html>
+<body>
+Turns assertThat(collectionOrMap.someMethod(arg)).isTrue/isFalse() into assertThat(collectionOrMap).someMethod(arg).
+<!-- tooltip end -->
+<br>someMethod() can be isEmpty(), contains(), and containsAll() for collections and
+isEmpty(), containsKey(), and containsValue() for maps.
+</body>
+</html>

src/main/resources/inspectionDescriptions/AssertThatGuavaOptional.html

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

src/main/resources/inspectionDescriptions/AssertThatInstanceOf.html

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

src/main/resources/inspectionDescriptions/AssertThatInvertedBooleanCondition.html

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

src/main/resources/inspectionDescriptions/AssertThatObjectExpression.html

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

src/main/resources/inspectionDescriptions/AssertThatSize.html

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

src/main/resources/inspectionDescriptions/AssertThatStringExpression.html

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

src/main/resources/inspectionDescriptions/AssumeThatInsteadOfReturn.html

@@ -0,0 +1,18 @@
+<html>
+<body>
+Tries to detect bogus uses of return statements in test methods and replaces them by assumeThat() calls.
+<!-- tooltip end -->
+<br>
+Novices will use these to skip test execution by bailing out early on some preconditions not met.
+However, this suggests that the test has actually been run and passed instead of showing the test
+as being skipped.
+<p>Return statements in if statements in main test methods
+    (must be annotated with JUnit 4 or Jupiter @Test annotations)
+    will be verified to have at least one assertThat() statement in the code flow.
+    Method calls within the same class will be examined for assertThat() statements, too.
+    However, at most 50 statements and down to five recursions will be tolerated before giving up.
+</p>
+<p>Currently, the quickfix may lose some comments during operation. The other branch of the if statement
+    will be inlined (blocks with declarations will remain a code block due to variable scope).</p>
+</body>
+</html>

src/main/resources/inspectionDescriptions/ImplicitAssertion.html

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

src/main/resources/inspectionDescriptions/JUnitAssertToAssertJ.html

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

src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html

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

src/main/resources/inspectionDescriptions/JoinVarArgsContains.html

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

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

@@ -8,17 +8,17 @@ import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.PsiTestUtil;
-import com.intellij.testFramework.UsefulTestCase;
+import com.intellij.testFramework.*;
+import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
+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;
@@ -26,7 +26,7 @@ import java.nio.file.Paths;
 import java.util.logging.Logger;
 import java.util.stream.Stream;
 
-public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback {
+public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback, InvocationInterceptor {
 
     private static final Logger LOG = Logger.getLogger(LightCodeInsightExtension.class.getName());
 
@@ -77,7 +77,41 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
         return context.getStore(Namespace.create(LightCodeInsightExtension.class, context.getRequiredTestMethod()));
     }
 
-    private static class LightCodeInsightFixtureTestCaseWrapper extends LightCodeInsightFixtureTestCase {
+    @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) {
@@ -124,7 +158,7 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
             };
         }
 
-        protected void addJarContaining(ModifiableRootModel model, Class clazz) {
+        void addJarContaining(ModifiableRootModel model, Class clazz) {
             try {
                 Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
 

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

@@ -1,44 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import com.intellij.testFramework.EdtTestUtilKt;
-import com.intellij.testFramework.TestLoggerFactory;
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
-import org.jetbrains.annotations.NotNull;
-
-// See https://github.com/junit-team/junit5/issues/157
-public class WorkaroundUntilJupiterGetsExecutorProvider {
-
-    protected static void runTest(Runnable test) throws Throwable {
-        Throwable[] throwables = new Throwable[1];
-
-        Runnable runnable = () -> {
-            try {
-                TestLoggerFactory.onTestStarted();
-                test.run();
-                TestLoggerFactory.onTestFinished(true);
-            } catch (Throwable e) {
-                TestLoggerFactory.onTestFinished(false);
-                e.fillInStackTrace();
-                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;
-            });
-        }
-    }
-}

src/test/java/de/platon42/intellij/playground/Playground.java

@@ -1,448 +0,0 @@
-package de.platon42.intellij.playground;
-
-import org.assertj.core.api.ListAssert;
-import org.assertj.core.data.Offset;
-import org.assertj.core.extractor.Extractors;
-
-import java.util.*;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.data.Offset.offset;
-import static org.assertj.guava.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-
-public class Playground {
-
-    private void sizeOfList() {
-        assertThat("string").as("foo").hasSize(0);
-        assertThat(new StringBuilder()).as("bar").hasSize(0);
-        ListAssert<String> etc = assertThat(new ArrayList<String>()).as("etc");
-        etc.hasSize(0);
-        assertThat(new Long[1]).as("etc").hasSize(0);
-
-        assertThat("string").as("foo").isEmpty();
-        assertThat(new StringBuilder()).as("bar").isEmpty();
-        assertThat(new ArrayList<Long>()).as("etc").isEmpty();
-        assertThat(new Long[1]).as("etc").isEmpty();
-
-        assertThat(new ArrayList<>().size()).isEqualTo(1);
-        assertThat(new ArrayList<String>().size()).isEqualTo(1);
-        assertThat(new ArrayList<String>().size()).isGreaterThanOrEqualTo(1);
-        assertThat(new ArrayList<String>().size()).isZero();
-        assertThat(new ArrayList<String>()).hasSizeGreaterThan(1);
-        assertThat(new ArrayList<String>()).hasSameSizeAs(new ArrayList<>());
-        assertThat(new Long[1]).as("etc").hasSameSizeAs(new Long[2]);
-        assertThat(new Long[1]).as("etc").hasSameSizeAs(new Long[2]);
-    }
-
-    private void joinStatements() {
-        List<String> list = new ArrayList<>();
-        assertThat(list).as("foo").hasSize(2);
-        assertThat(list).as("bar").contains("barbar"); // comment to keep
-        assertThat(list).as("etc").contains("etcetc");
-
-        // moar!
-        assertThat(list).doesNotContain("foobar");
-
-        assertThat("narf").isNotEqualTo("puit");
-        assertThat(list).as("bar").contains("barbar");
-        assertThat(list).as("foo").hasSize(2);
-        assertThat(list).as("evil").extracting(String::length).contains(2);
-
-        assertThat(list).as("bar").contains("barbar");
-        assertThat("narf").isNotEqualTo("puit");
-        assertThat(list).as("foo").hasSize(2);
-        if (true) {
-            assertThat(list).doesNotContain("narf");
-            assertThat(list).as("bar").contains("barbar");
-        }
-        assertThat(list.get(0)).isNotEmpty();
-        assertThat(list.get(0)).hasSize(3);
-        assertThat(list.get(0)).isEqualTo("bar");
-
-        assertThat(list.get(0) + "foo").isEqualTo("bar");
-        assertThat(list.get(0) + "foo").doesNotStartWith("foo");
-
-        Iterator<String> iterator = list.iterator();
-        assertThat(iterator.next()).isEqualTo("foo");
-        assertThat(iterator.next()).isEqualTo("bar");
-    }
-
-    private void sizeOfArray() {
-        assertThat(new String[1].length).isLessThanOrEqualTo(1);
-        assertThat(new String[1]).hasSameSizeAs(new Object());
-        assertThat("").isEqualTo(null);
-        assertThat(true).isTrue();
-        assertThat(true).isEqualTo(true);
-        assertThat(Boolean.TRUE).isEqualTo(Boolean.FALSE);
-        assertThat(Boolean.TRUE).isEqualTo(true);
-    }
-
-    private void booleanIsTrueOrFalse() {
-        boolean primitive = false;
-        Boolean object = java.lang.Boolean.TRUE;
-
-        assertThat(primitive).isEqualTo(Boolean.TRUE);
-        assertThat(primitive).isEqualTo(Boolean.FALSE);
-        assertThat(object).isEqualTo(Boolean.TRUE);
-        assertThat(object).isEqualTo(Boolean.FALSE);
-        assertThat(primitive).isEqualTo(true);
-        assertThat(primitive).isEqualTo(false);
-        assertThat(object).isEqualTo(true);
-        assertThat(object).isEqualTo(false);
-
-        assertThat(primitive).isNotEqualTo(Boolean.TRUE);
-        assertThat(primitive).isNotEqualTo(Boolean.FALSE);
-        assertThat(object).isNotEqualTo(Boolean.TRUE);
-        assertThat(object).isNotEqualTo(Boolean.FALSE);
-        assertThat(primitive).isNotEqualTo(true);
-        assertThat(primitive).isNotEqualTo(false);
-        assertThat(object).isNotEqualTo(true);
-        assertThat(object).isNotEqualTo(false);
-
-        assertThat(primitive).as("nah").isEqualTo(true && !true);
-        assertThat(object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
-
-        assertThat("").isEqualTo(Boolean.TRUE);
-    }
-
-    private void binaryExpression() {
-        int primExp = 42;
-        int primAct = 1337;
-        Double numberObjExp = 42.0;
-        Double numberObjAct = 1337.0;
-        String stringExp = "foo";
-        String stringAct = "bar";
-
-        assertThat(primAct == primExp).isTrue();
-        assertThat(primAct == 1).isTrue();
-        assertThat(primAct == primExp).isEqualTo(false);
-        assertThat(primAct != primExp).isEqualTo(true);
-        assertThat(1 != primAct).isTrue();
-        assertThat(primAct != primExp).isNotEqualTo(true);
-        assertThat(primAct > primExp).isNotEqualTo(false);
-        assertThat(primAct > primExp).isFalse();
-        assertThat(primAct > 1).isFalse();
-        assertThat(primAct >= 1).isTrue();
-        assertThat(primAct >= primExp).isEqualTo(false);
-        assertThat(1 <= primAct).isFalse();
-        assertThat(1 > primAct).isTrue();
-        assertThat(primAct < primExp).isNotEqualTo(true);
-        assertThat(primAct <= primExp).isNotEqualTo(false);
-        assertThat(primAct <= primExp).isFalse();
-        assertThat(primAct <= 1).isFalse();
-        assertThat(numberObjAct == 1).isTrue();
-        assertThat(numberObjAct == numberObjExp).isEqualTo(false);
-        assertThat(numberObjAct != numberObjExp).isEqualTo(true);
-        assertThat(1 != numberObjAct).isTrue();
-        assertThat(numberObjAct != numberObjExp).isNotEqualTo(true);
-        assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
-        assertThat(numberObjAct > 1).isFalse();
-        assertThat(numberObjAct >= numberObjExp).isTrue();
-        assertThat(numberObjAct >= numberObjExp).isEqualTo(false);
-        assertThat(1 <= numberObjAct).isFalse();
-        assertThat(numberObjAct < numberObjExp).isEqualTo(true);
-        assertThat(numberObjAct < numberObjExp).isNotEqualTo(true);
-        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
-        assertThat(numberObjAct <= 1).isFalse();
-        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
-        assertThat(stringAct == stringExp).isNotEqualTo(false);
-        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
-        assertThat(stringAct != stringExp).isFalse();
-        assertThat(stringAct == null).isNotEqualTo(true);
-        assertThat(null == stringAct).isEqualTo(false);
-
-        assertThat(null == null).isTrue();
-        assertThat(!false).isTrue();
-    }
-
-    private void stringStuff() {
-        String foo = "bar";
-        assertThat(foo).isEqualTo("");
-        assertThat(foo).hasSize(0);
-        assertThat(foo.contains("foobar")).isTrue();
-        assertThat(foo).contains("foobar");
-        assertThat(foo.startsWith("foobar")).isTrue();
-        assertThat(foo).startsWith("foobar");
-        assertThat(foo.endsWith("foobar")).isTrue();
-        assertThat(foo).endsWith("foobar");
-        assertThat(foo.equalsIgnoreCase("foo")).isTrue();
-        assertThat(foo).isEqualToIgnoringCase("foo");
-
-        assertThat(foo.contains("foobar")).isFalse();
-        assertThat(foo).doesNotContain("foobar");
-        assertThat(foo.startsWith("foobar")).isFalse();
-        assertThat(foo).doesNotStartWith("foobar");
-        assertThat(foo.endsWith("foobar")).isFalse();
-        assertThat(foo).doesNotEndWith("foobar");
-        assertThat(foo.equalsIgnoreCase("foo")).isFalse();
-        assertThat(foo).isNotEqualToIgnoringCase("foo");
-
-        ArrayList<String> list = new ArrayList<>();
-        long[] otherArray = new long[4];
-
-        String string = "string";
-        assertThat(string.length()).isEqualTo(0);
-        assertThat(string.length()).isZero();
-        assertThat(string.length()).isNotZero();
-        assertThat(string.length()).as("hi").isGreaterThan(0);
-        assertThat(string.length()).isGreaterThanOrEqualTo(1);
-        assertThat(string.length()).isLessThan(1);
-        assertThat(string.length()).isLessThanOrEqualTo(0);
-        assertThat(string.length()).isEqualTo(list.size());
-        assertThat(string.length()).isEqualTo(otherArray.length);
-        assertThat(string.length()).isEqualTo(1);
-        assertThat(string.length()).isGreaterThan(otherArray.length - 1);
-        assertThat(string.length()).isGreaterThanOrEqualTo(otherArray.length + 1);
-        assertThat(string.length()).isLessThan(otherArray.length - 3);
-        assertThat(string.length()).isLessThanOrEqualTo(1 - otherArray.length);
-
-        StringBuilder stringBuilder = new StringBuilder();
-        assertThat(stringBuilder.length()).isEqualTo(0);
-        assertThat(stringBuilder.length()).isZero();
-        assertThat(stringBuilder.length()).isNotZero();
-        assertThat(stringBuilder.length()).as("hi").isGreaterThan(0);
-        assertThat(stringBuilder.length()).isGreaterThanOrEqualTo(1);
-        assertThat(stringBuilder.length()).isLessThan(1);
-        assertThat(stringBuilder.length()).isLessThanOrEqualTo(0);
-        assertThat(stringBuilder.length()).isEqualTo(list.size());
-        assertThat(stringBuilder.length()).isEqualTo(otherArray.length);
-        assertThat(stringBuilder.length()).isEqualTo(1);
-        assertThat(stringBuilder.length()).isGreaterThan(otherArray.length - 1);
-        assertThat(stringBuilder.length()).isGreaterThanOrEqualTo(otherArray.length + 1);
-        assertThat(stringBuilder.length()).isLessThan(otherArray.length - 3);
-        assertThat(stringBuilder.length()).isLessThanOrEqualTo(1 - otherArray.length);
-    }
-
-    private void java8Optional() {
-        Optional<String> opt = Optional.empty();
-
-        assertThat(opt.isPresent()).isEqualTo(true);
-        assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
-        assertThat(opt.isPresent()).isNotEqualTo(false);
-        assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
-        assertThat(opt.isPresent()).isTrue();
-
-        assertThat(opt.isPresent()).isEqualTo(false);
-        assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
-        assertThat(opt.isPresent()).isNotEqualTo(true);
-        assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
-        assertThat(opt.isPresent()).isFalse();
-
-        assertThat(opt.get()).isEqualTo("foo");
-        assertThat(opt.get()).isSameAs("foo");
-
-        assertThat(opt).isEqualTo(Optional.of("foo"));
-        assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
-        assertThat(opt).isNotEqualTo(Optional.of("foo"));
-        assertThat(opt).isNotEqualTo(Optional.ofNullable("foo"));
-
-        assertThat(opt).isEqualTo(Optional.empty());
-        assertThat(opt).isNotEqualTo(Optional.empty());
-        assertThat(opt).isPresent();
-    }
-
-    private void assertThatGuavaOptional() {
-        com.google.common.base.Optional<String> opt = com.google.common.base.Optional.absent();
-
-        assertThat(opt.isPresent()).isEqualTo(true);
-        assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
-        assertThat(opt.isPresent()).isNotEqualTo(false);
-        assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
-        assertThat(opt.isPresent()).isTrue();
-
-        assertThat(opt.isPresent()).isEqualTo(false);
-        assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
-        assertThat(opt.isPresent()).isNotEqualTo(true);
-        assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
-        assertThat(opt.isPresent()).isFalse();
-
-        assertThat(opt.get()).isEqualTo("foo");
-        assertThat(opt.get()).isSameAs("foo");
-        assertThat(opt.get()).isNotEqualTo("foo");
-        assertThat(opt.get()).isNotSameAs("foo");
-
-        assertThat(opt).isEqualTo(com.google.common.base.Optional.of("foo"));
-        assertThat(opt).isEqualTo(com.google.common.base.Optional.fromNullable("foo"));
-        assertThat(opt).isNotEqualTo(com.google.common.base.Optional.of("foo"));
-        assertThat(opt).isNotEqualTo(com.google.common.base.Optional.fromNullable("foo"));
-
-        assertThat(opt).isEqualTo(com.google.common.base.Optional.absent());
-        assertThat(opt).isNotEqualTo(com.google.common.base.Optional.absent());
-        assertThat(opt).isAbsent();
-    }
-
-    private void assertThatInstance() {
-        String foo = "foo";
-        assertThat(foo instanceof String).isTrue();
-        assertThat(foo).isInstanceOf(String.class);
-        assertThat(foo).isNotInstanceOf(String.class);
-    }
-
-    private void junitAssertions() {
-        assertFalse(!(new int[3].length == new ArrayList<Integer>().size()));
-        assertThat(!(new int[3].length == new ArrayList<Integer>().size())).isFalse();
-        assertThat((new int[3].length == new ArrayList<Integer>().size())).isTrue();
-        assertThat(new int[3].length).isEqualTo(new ArrayList<Integer>().size());
-        assertThat(new int[3]).hasSameSizeAs(new ArrayList<Integer>());
-
-        assertTrue(true);
-        assertTrue("message", true);
-        assertFalse(true);
-        assertFalse("message", true);
-        assertEquals(1L, 2L);
-        assertEquals("message", 1L, 2L);
-        assertNotEquals(1L, 2L);
-        assertNotEquals("message", 1L, 2L);
-        assertEquals(4.0, 4.4, 3.3);
-        assertThat(3.0).isCloseTo(4.0, Offset.offset(2.3));
-        assertThat(new int[1]).isEqualTo(new int[2]);
-
-        String foo = "foo";
-        String bar = "bar";
-
-        assertTrue(foo == "foo");
-        assertTrue("oh no!", foo == "foo");
-        assertFalse(foo == "bar");
-        assertFalse("boom!", foo == "bar");
-
-        assertNull(foo);
-        assertNull("oh no!", foo);
-        assertNotNull(foo);
-        assertNotNull("oh no!", foo);
-
-        assertEquals(bar, foo);
-        assertEquals("equals", bar, foo);
-        assertNotEquals(bar, foo);
-        assertNotEquals("equals", bar, foo);
-
-        assertSame(bar, foo);
-        assertSame("same", bar, foo);
-        assertNotSame(bar, foo);
-        assertNotSame("same", bar, foo);
-
-        assertEquals(1.0, 2.0, 0.1);
-        assertEquals("equals", 1.0, 2.0, 0.1);
-        assertEquals(1.0f, 2.0f, 0.1f);
-        assertEquals("equals", 1.0f, 2.0f, 0.1f);
-
-        assertNotEquals(1.0, 2.0);
-        assertNotEquals(1.0, 2.0, 0.1);
-        assertNotEquals("equals", 1.0, 2.0);
-        assertNotEquals("equals", 1.0, 2.0, 0.1);
-        assertNotEquals(1.0f, 2.0f);
-        assertNotEquals(1.0f, 2.0f, 0.1f);
-        assertNotEquals("equals", 1.0f, 2.0f);
-        assertNotEquals("equals", 1.0f, 2.0f, 0.1f);
-
-        assertArrayEquals(new int[2], new int[1]);
-        assertArrayEquals("array equals", new int[2], new int[1]);
-
-        assertArrayEquals(new double[2], new double[1], 1.0);
-        assertArrayEquals("array equals", new double[2], new double[1], 1.0);
-        assertArrayEquals(new float[2], new float[1], 1.0f);
-        assertArrayEquals("array equals", new float[2], new float[1], 1.0f);
-
-
-        assertThat(foo == "foo").isTrue();
-        assertThat(foo == "foo").as("oh no!").isTrue();
-        assertThat(foo == "bar").isFalse();
-        assertThat(foo == "bar").as("boom!").isFalse();
-
-        assertThat(foo).isNull();
-        assertThat(foo).as("oh no!").isNull();
-        assertThat(foo).isNotNull();
-        assertThat(foo).as("oh no!").isNotNull();
-
-        assertThat(foo).isEqualTo(bar);
-        assertThat(foo).as("equals").isEqualTo(bar);
-        assertThat(foo).isNotEqualTo(bar);
-        assertThat(foo).as("equals").isNotEqualTo(bar);
-
-        assertThat(foo).isSameAs(bar);
-        assertThat(foo).as("same").isSameAs(bar);
-        assertThat(foo).isNotSameAs(bar);
-        assertThat(foo).as("same").isNotSameAs(bar);
-
-        assertThat(2.0).isEqualTo(1.0);
-        assertThat(2.0).isCloseTo(1.0, offset(0.1));
-        assertThat(2.0).as("equals").isEqualTo(1.0);
-        assertThat(2.0).as("equals").isCloseTo(1.0, offset(0.1));
-        assertThat(2.0f).isEqualTo(1.0f);
-        assertThat(2.0f).isCloseTo(1.0f, offset(0.1f));
-        assertThat(2.0f).as("equals").isEqualTo(1.0f);
-        assertThat(2.0f).as("equals").isCloseTo(1.0f, offset(0.1f));
-
-        assertThat(2.0).isNotEqualTo(1.0);
-        assertThat(2.0).isNotCloseTo(1.0, offset(0.1));
-        assertThat(2.0).as("equals").isNotEqualTo(1.0);
-        assertThat(2.0).as("equals").isNotCloseTo(1.0, offset(0.1));
-        assertThat(2.0f).isNotEqualTo(1.0f);
-        assertThat(2.0f).isNotCloseTo(1.0f, offset(0.1f));
-        assertThat(2.0f).as("equals").isNotEqualTo(1.0f);
-        assertThat(2.0f).as("equals").isNotCloseTo(1.0f, offset(0.1f));
-
-        assertThat(new int[1]).isEqualTo(new int[2]);
-        assertThat(new int[1]).as("array equals").isEqualTo(new int[2]);
-
-        assertThat(new double[1]).containsExactly(new double[2], offset(1.0));
-        assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
-        assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
-        assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
-
-        assertThat(new Object()).extracting("toString");
-        assertThat(new Object()).extracting(Object::toString, Object::hashCode);
-    }
-
-    private void findReferences() {
-        Contact contact = new Contact();
-        List<Contact> contactList = Collections.emptyList();
-
-        assertThat(contact).extracting("name").isEqualTo("foo");
-        assertThat(contact).extracting("age", "country", "address.street", "street", "address.noMailings", "address.REALLYnoMAILINGS").containsExactly(1, "Elmst. 42");
-        assertThat(contact).extracting(Extractors.byName("name")).isEqualTo("foo");
-        assertThat(contact).extracting(Extractors.resultOf("getStreet")).isEqualTo("foo");
-        assertThat(contact).extracting(Extractors.resultOf("getStreet"), Extractors.byName("narf")).isEqualTo("foo");
-
-        assertThat(contactList).extracting("name").isEqualTo("foo");
-        assertThat(contactList).extracting("name", "moar").isEqualTo("foo");
-        assertThat(contactList).extracting("name", String.class).isEqualTo("foo");
-        assertThat(contactList).extracting(Extractors.byName("name")).isEqualTo("foo");
-        assertThat(contactList).extracting(Extractors.resultOf("getStreet"), Extractors.byName("narf")).isEqualTo("foo");
-        assertThat(contactList).extractingResultOf("getStreet").isEqualTo("foo");
-        assertThat(contactList).extractingResultOf("getStreet", String.class).isEqualTo("foo");
-        assertThat(contactList).flatExtracting("age", "address.street", "street").containsExactly(1, "Elmst. 42");
-        assertThat(contactList).flatExtracting("age").containsExactly(1, "Elmst. 42");
-    }
-
-    public class Contact {
-        private String name;
-        private Integer age;
-        private Address address;
-
-        public String getStreet() {
-            return address.getStreet();
-        }
-    }
-
-    public class Address {
-        private String street;
-        private String country;
-
-        public String getStreet() {
-            return street;
-        }
-
-        public String getCountry() {
-            return country;
-        }
-
-        public boolean isNoMailings() {
-            return true;
-        }
-
-        public Boolean getREALLYnoMAILINGS() {
-            return true;
-        }
-    }
-}

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

@@ -1,67 +1,36 @@
 package de.platon42.intellij.plugins.cajon
 
 import com.intellij.pom.java.LanguageLevel
-import com.intellij.testFramework.TestLoggerFactory
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import com.intellij.testFramework.runInEdtAndWait
 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.junit.jupiter.api.DisplayNameGeneration
+import org.junit.jupiter.api.DisplayNameGenerator
 import org.junit.jupiter.api.extension.ExtendWith
-import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
 
 @ExtendWith(LightCodeInsightExtension::class)
 @TestDataPath("src/test/resources")
 @TestJdk(LanguageLevel.JDK_1_8, annotations = true, useInternal = true)
 @AddLocalJarToModule(Assertions::class)
+@DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
 abstract class AbstractCajonTest {
 
-    // See https://github.com/junit-team/junit5/issues/157, should be resolved with junit5 5.5 M2
-    protected fun runTest(body: () -> Unit) {
-        val throwables = arrayOfNulls<Throwable>(1)
-
-        invokeTestRunnable {
-            try {
-                TestLoggerFactory.onTestStarted()
-                body()
-                TestLoggerFactory.onTestFinished(true)
-            } catch (e: InvocationTargetException) {
-                TestLoggerFactory.onTestFinished(false)
-                e.fillInStackTrace()
-                throwables[0] = e.targetException
-            } catch (e: IllegalAccessException) {
-                TestLoggerFactory.onTestFinished(false)
-                e.fillInStackTrace()
-                throwables[0] = e
-            } catch (e: Throwable) {
-                TestLoggerFactory.onTestFinished(false)
-                throwables[0] = e
-            }
-        }
-
-        if (throwables[0] != null) {
-            throw throwables[0]!!
-        }
-    }
-
-    private fun invokeTestRunnable(runnable: () -> Unit) {
-        val policy = IdeaTestExecutionPolicy.current()
-        if (policy != null && !policy.runInDispatchThread()) {
-            runnable()
-        } else {
-            runInEdtAndWait {
-                runnable()
-            }
-        }
-    }
-
     protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
-        val quickfixes = myFixture.getAllQuickFixes().filter { it.familyName.matches(regex) }
-        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.familyName }}").hasSize(expectedFixes)
+        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)
     }
+
+    class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {
+        override fun generateDisplayNameForMethod(testClass: Class<*>?, testMethod: Method?): String {
+            val nameForMethod = super.generateDisplayNameForMethod(testClass, testMethod)
+            return nameForMethod.substringBefore("$")
+        }
+    }
 }

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

@@ -11,12 +11,9 @@ internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/BinaryExpression")
     internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
         myFixture.configureByFile("BinaryExpressionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 148)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 12)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 149)
         myFixture.checkResultByFile("BinaryExpressionAfter.java")
     }
-    }
 }

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

@@ -11,14 +11,12 @@ internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/BooleanCondition")
     internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
         myFixture.configureByFile("BooleanConditionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
         myFixture.checkResultByFile("BooleanConditionAfter.java")
     }
-    }
 }

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

@@ -0,0 +1,27 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.junit.jupiter.api.Test
+
+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)
+        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
+    }
+}

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

@@ -11,11 +11,9 @@ internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/EnumerableIsEmpty")
     internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
         myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
         myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
     }
-    }
 }

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

@@ -14,44 +14,35 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
 
     @Test
     internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
         myFixture.configureByFile("GuavaOptionalBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with Guava assertThat().isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with Guava assertThat().isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with Guava assertThat().isPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with Guava assertThat().isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().contains()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with contains()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with Guava assertThat().contains()"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
         myFixture.checkResultByFile("GuavaOptionalAfter.java")
     }
-    }
 
     @Test
     internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
         myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 7)
+        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 4)
+        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
         myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
-    }
 
     @Test
     internal fun adds_missing_Guava_import_isAbsent_first(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         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 .*"), 6)
+        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 3)
+        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
         myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
-    }
 }

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

@@ -11,12 +11,10 @@ internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/InstanceOf")
     internal fun assertThat_with_instanceof_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
         myFixture.configureByFile("InstanceOfBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace instanceof expression by assertThat().isInstanceOf()"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace instanceof expression by assertThat().isNotInstanceOf()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
         myFixture.checkResultByFile("InstanceOfAfter.java")
     }
-    }
 }

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

@@ -11,11 +11,9 @@ internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonT
     @Test
     @TestDataSubPath("inspections/InvertedBooleanCondition")
     internal fun assertThat_with_inverted_boolean_condition_can_be_inverted(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
         myFixture.configureByFile("InvertedBooleanConditionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 21)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
         myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
     }
-    }
 }

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

@@ -11,21 +11,17 @@ internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/Java8Optional")
     internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
         myFixture.configureByFile("Java8OptionalBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isNotPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isNotPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with isPresent()"), 1)
+        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 actual expression and replace isFalse() with isNotPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with contains()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with contains()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isSameAs() with containsSame()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
         myFixture.checkResultByFile("Java8OptionalAfter.java")
     }
-    }
 }

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

@@ -0,0 +1,22 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.junit.jupiter.api.Test
+
+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")
+    }
+}

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

@@ -11,12 +11,10 @@ internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest
     @Test
     @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
     internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
         myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
         myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
     }
-    }
 }

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

@@ -4,6 +4,8 @@ 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
 
 internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
@@ -11,9 +13,10 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/Size")
     internal fun assertThat_size_of_array_or_collection_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         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")
+
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 4)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 4)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 4)
@@ -27,8 +30,7 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 4)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 4)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 12)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14)
         myFixture.checkResultByFile("SizeAfter.java")
     }
-    }
 }

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

@@ -11,24 +11,22 @@ internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/StringExpression")
     internal fun assertThat_with_certain_String_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
         myFixture.configureByFile("StringExpressionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of expected expression and use assertThat().isEmpty() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of expected expression and use assertThat().isEqualTo() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of expected expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of expected expression and use assertThat().isEqualTo() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of expected expression and use assertThat().contains() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of expected expression and use assertThat().startsWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of expected expression and use assertThat().endsWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of expected expression and use assertThat().isNotEmpty() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of expected expression and use assertThat().isNotEqualTo() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of expected expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of expected expression and use assertThat().isNotEqualTo() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of expected expression and use assertThat().doesNotContain() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of expected expression and use assertThat().doesNotStartWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of expected expression and use assertThat().doesNotEndWith() instead"), 2)
+        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")
     }
-    }
 }

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

@@ -4,6 +4,8 @@ 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
 
 internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
@@ -11,12 +13,15 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/StringIsEmpty")
     internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
         myFixture.configureByFile("StringIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 2)
+        val highlights = myFixture.doHighlighting()
+            .asSequence()
+            .filter { it.description?.contains(" can be simplified to") ?: false }
+            .toList()
+        assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
         myFixture.checkResultByFile("StringIsEmptyAfter.java")
     }
-    }
 }

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

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

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

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

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

@@ -15,11 +15,10 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
     @Test
     @TestDataSubPath("inspections/JUnitAssertToAssertJ")
     internal fun junit_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
         myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
         myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 38)
+        executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+        executeQuickFixes(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
         myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
     }
-    }
 }

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

@@ -10,12 +10,10 @@ internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
 
     @Test
     @TestDataSubPath("inspections/JoinStatements")
-    internal fun assertThat_size_of_array_or_collection_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
+    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"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
         myFixture.checkResultByFile("JoinStatementsAfter.java")
     }
-    }
 }

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

@@ -0,0 +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
+
+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")
+    }
+}

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

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

src/test/java/org/assertj/core/api/AssertJExtensions.kt

@@ -0,0 +1,19 @@
+package org.assertj.core.api
+
+import org.assertj.core.groups.FieldsOrPropertiesExtractor
+import java.util.*
+
+// Workaround for ambiguous method signature of .extracting() see https://github.com/joel-costigliola/assertj-core/issues/1499
+fun <SELF : AbstractIterableAssert<SELF, ACTUAL, ELEMENT, ELEMENT_ASSERT>,
+        ACTUAL : Iterable<ELEMENT>,
+        ELEMENT,
+        ELEMENT_ASSERT : AbstractAssert<ELEMENT_ASSERT, ELEMENT>,
+        V>
+        AbstractIterableAssert<SELF, ACTUAL, ELEMENT, ELEMENT_ASSERT>.extrakting(extractor: (ELEMENT) -> V): AbstractListAssert<*, List<V>, V, ObjectAssert<V>> {
+    val values = FieldsOrPropertiesExtractor.extract(actual, extractor)
+    if (actual is SortedSet<*>) {
+        usingDefaultElementComparator()
+    }
+    @Suppress("UNCHECKED_CAST")
+    return newListAssertInstance(values).withAssertionState(myself) as AbstractListAssert<*, List<V>, V, ObjectAssert<V>>
+}

src/test/resources/inspections/AssumeThat/AssumeThatAfter.java

@@ -0,0 +1,158 @@
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assumptions.assumeThat;
+
+public class AssumeThat {
+
+    @Test
+    public void junit4_return_very_early() {
+        assumeThat(new Random().nextBoolean()).isFalse();
+        System.out.println("sweet!"); // single else statement
+        String foobar = System.getProperty("foobar");
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @Test
+    public void junit4_return_in_else_branch_with_declaration_in_code_block_and_lots_of_comments() {
+        // primary comments
+        assumeThat(new Random().nextBoolean()).isTrue();
+        {
+            // Block start comment will be retained
+            String anotherString = "narf"; // This one is likely to be kept
+            assertThat(foobar).isNotEmpty();
+            assertThat(foobar).isEqualTo(anotherString);
+            // Block end comment is also going to be retained
+        } /* weird places */
+        // well, well, let's do some checks
+        String foobar = System.getProperty("foobar");
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @org.junit.jupiter.api.Test
+    public void junit5_return_after_call_without_else_branch() {
+        String foobar = System.getProperty("car_manufacturer");
+        assumeThat(foobar.equals("Volkswagen")).isFalse();
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @org.junit.jupiter.api.Test
+    public void junit5_return_with_empty_else_block() {
+        String foobar = System.getProperty("car_manufacturer");
+        assumeThat(foobar.equals("Volkswagen")).isFalse();
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @org.junit.jupiter.api.TestTemplate
+    public void junit5_return_inside_recursion_with_comments() {
+        String foobar = System.getProperty("car_manufacturer");
+        if (foobar != null) {
+            assumeThat(!foobar.equals("Volkswagen")).isTrue();
+            // I doubted this comment will be retained -- but surprise!
+            assertThat(foobar).isNotEmpty();
+            // we might keep this one alright.
+            foobar = "narf";
+            // And the final one? Again what learned.
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+        if(foobar.length() == 0)
+        {
+            return;
+        }
+        assertThat(foobar).endsWith("!!!");
+    }
+
+    @Test
+    public void junit4_return_after_assertion() {
+        String foobar = System.getProperty("car_manufacturer");
+        assertThat(foobar).isNotNull();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_return_after_assertions_in_subroutine() {
+        String foobar = System.getProperty("car_manufacturer");
+        assertStuff(foobar);
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_return_after_assertions_in_deep_subroutine() {
+        String foobar = System.getProperty("car_manufacturer");
+        firstMethod();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_return_after_assertions_in_deep_subroutine_with_recursion() {
+        String foobar = System.getProperty("car_manufacturer");
+        firstMethodWithPotentialRecursion();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_no_harm_with_infinite_recursion() {
+        String foobar = System.getProperty("car_manufacturer");
+        infiniteRecursion();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    private void assertStuff(String foobar) {
+        if (new Random().nextBoolean()) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            assertThat(foobar).isNull();
+        }
+    }
+
+    private void firstMethod() {
+        if (new Random().nextBoolean()) {
+            assertStuff("narf");
+        }
+    }
+
+    private void firstMethodWithPotentialRecursion() {
+        if (new Random().nextBoolean()) {
+            assertStuff("narf");
+        } else {
+            infiniteRecursion();
+        }
+    }
+
+    private void infiniteRecursion() {
+        secondaryRecursion();
+        secondaryRecursion();
+    }
+
+    private void secondaryRecursion() {
+        infiniteRecursion();
+        infiniteRecursion();
+    }
+}

src/test/resources/inspections/AssumeThat/AssumeThatBefore.java

@@ -0,0 +1,163 @@
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AssumeThat {
+
+    @Test
+    public void junit4_return_very_early() {
+        if (new Random().nextBoolean()) {
+            return;
+        } else System.out.println("sweet!"); // single else statement
+        String foobar = System.getProperty("foobar");
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @Test
+    public void junit4_return_in_else_branch_with_declaration_in_code_block_and_lots_of_comments() {
+        // primary comments
+        if (new Random().nextBoolean()) /* strange place for a comment */ {
+            // Block start comment will be retained
+            String anotherString = "narf"; // This one is likely to be kept
+            assertThat(foobar).isNotEmpty();
+            assertThat(foobar).isEqualTo(anotherString);
+            // Block end comment is also going to be retained
+        } /* weird places */ else /* more weird places */ { // this one is lost
+            return; // Would be sweet to keep this comment, too.
+        } // another comment lost
+        // well, well, let's do some checks
+        String foobar = System.getProperty("foobar");
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @org.junit.jupiter.api.Test
+    public void junit5_return_after_call_without_else_branch() {
+        String foobar = System.getProperty("car_manufacturer");
+        if (foobar.equals("Volkswagen")) return; // no need for Volkswagen to perform tests
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @org.junit.jupiter.api.Test
+    public void junit5_return_with_empty_else_block() {
+        String foobar = System.getProperty("car_manufacturer");
+        if (foobar.equals("Volkswagen")) return; else {}
+        assertThat(foobar).isNotEmpty();
+    }
+
+    @org.junit.jupiter.api.TestTemplate
+    public void junit5_return_inside_recursion_with_comments() {
+        String foobar = System.getProperty("car_manufacturer");
+        if (foobar != null) {
+            if (!foobar.equals("Volkswagen")) {
+                // I doubted this comment will be retained -- but surprise!
+                assertThat(foobar).isNotEmpty();
+                // we might keep this one alright.
+                foobar = "narf";
+                // And the final one? Again what learned.
+            } else {
+                // ooops, how did that happen?
+                return;
+            }
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+        if(foobar.length() == 0)
+        {
+            return;
+        }
+        assertThat(foobar).endsWith("!!!");
+    }
+
+    @Test
+    public void junit4_return_after_assertion() {
+        String foobar = System.getProperty("car_manufacturer");
+        assertThat(foobar).isNotNull();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_return_after_assertions_in_subroutine() {
+        String foobar = System.getProperty("car_manufacturer");
+        assertStuff(foobar);
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_return_after_assertions_in_deep_subroutine() {
+        String foobar = System.getProperty("car_manufacturer");
+        firstMethod();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_return_after_assertions_in_deep_subroutine_with_recursion() {
+        String foobar = System.getProperty("car_manufacturer");
+        firstMethodWithPotentialRecursion();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    @Test
+    public void junit4_no_harm_with_infinite_recursion() {
+        String foobar = System.getProperty("car_manufacturer");
+        infiniteRecursion();
+        if (!foobar.equals("Volkswagen")) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            return;
+        }
+        assertThat(foobar).startsWith("another ecology rapist");
+    }
+
+    private void assertStuff(String foobar) {
+        if (new Random().nextBoolean()) {
+            assertThat(foobar).isNotEmpty();
+        } else {
+            assertThat(foobar).isNull();
+        }
+    }
+
+    private void firstMethod() {
+        if (new Random().nextBoolean()) {
+            assertStuff("narf");
+        }
+    }
+
+    private void firstMethodWithPotentialRecursion() {
+        if (new Random().nextBoolean()) {
+            assertStuff("narf");
+        } else {
+            infiniteRecursion();
+        }
+    }
+
+    private void infiniteRecursion() {
+        secondaryRecursion();
+        secondaryRecursion();
+    }
+
+    private void secondaryRecursion() {
+        infiniteRecursion();
+        infiniteRecursion();
+    }
+}

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

@@ -1,4 +1,5 @@
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 public class BinaryExpression {
 
@@ -10,7 +11,7 @@ public class BinaryExpression {
         String stringExp = "foo";
         String stringAct = "bar";
 
-        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).as("doh!").isEqualTo(primExp);
         assertThat(primAct).isEqualTo(primExp);
         assertThat(primAct).isEqualTo(primExp);
         assertThat(primAct).isEqualTo(primExp);
@@ -25,7 +26,7 @@ public class BinaryExpression {
         assertThat(primAct).isNotEqualTo(1);
         assertThat(primAct).isNotEqualTo(1);
 
-        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).as("doh!").isNotEqualTo(primExp);
         assertThat(primAct).isNotEqualTo(primExp);
         assertThat(primAct).isNotEqualTo(primExp);
         assertThat(primAct).isNotEqualTo(1);
@@ -36,7 +37,7 @@ public class BinaryExpression {
         assertThat(primAct).isEqualTo(1);
         assertThat(primAct).isEqualTo(1);
 
-        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).as("doh!").isGreaterThan(primExp);
         assertThat(primAct).isGreaterThan(primExp);
         assertThat(primAct).isGreaterThan(primExp);
         assertThat(primAct).isGreaterThan(1);
@@ -47,7 +48,7 @@ public class BinaryExpression {
         assertThat(primAct).isLessThanOrEqualTo(1);
         assertThat(primAct).isLessThanOrEqualTo(1);
 
-        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).as("doh!").isGreaterThanOrEqualTo(primExp);
         assertThat(primAct).isGreaterThanOrEqualTo(primExp);
         assertThat(primAct).isGreaterThanOrEqualTo(primExp);
         assertThat(primAct).isGreaterThanOrEqualTo(1);
@@ -58,7 +59,7 @@ public class BinaryExpression {
         assertThat(primAct).isLessThan(1);
         assertThat(primAct).isLessThan(1);
 
-        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).as("doh!").isLessThan(primExp);
         assertThat(primAct).isLessThan(primExp);
         assertThat(primAct).isLessThan(primExp);
         assertThat(primAct).isLessThan(1);
@@ -69,7 +70,7 @@ public class BinaryExpression {
         assertThat(primAct).isGreaterThanOrEqualTo(1);
         assertThat(primAct).isGreaterThanOrEqualTo(1);
 
-        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).as("doh!").isLessThanOrEqualTo(primExp);
         assertThat(primAct).isLessThanOrEqualTo(primExp);
         assertThat(primAct).isLessThanOrEqualTo(primExp);
         assertThat(primAct).isLessThanOrEqualTo(1);
@@ -80,7 +81,7 @@ public class BinaryExpression {
         assertThat(primAct).isGreaterThan(1);
         assertThat(primAct).isGreaterThan(1);
 
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(1);
@@ -91,7 +92,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isNotEqualTo(1);
         assertThat(numberObjAct).isNotEqualTo(1);
 
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(1);
@@ -102,7 +103,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isEqualTo(1);
         assertThat(numberObjAct).isEqualTo(1);
 
-        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isGreaterThan(numberObjExp);
         assertThat(numberObjAct).isGreaterThan(numberObjExp);
         assertThat(numberObjAct).isGreaterThan(numberObjExp);
         assertThat(numberObjAct).isGreaterThan(1);
@@ -113,7 +114,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isLessThanOrEqualTo(1);
         assertThat(numberObjAct).isLessThanOrEqualTo(1);
 
-        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isGreaterThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
@@ -124,7 +125,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isLessThan(1);
         assertThat(numberObjAct).isLessThan(1);
 
-        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isLessThan(numberObjExp);
         assertThat(numberObjAct).isLessThan(numberObjExp);
         assertThat(numberObjAct).isLessThan(numberObjExp);
         assertThat(numberObjAct).isLessThan(1);
@@ -135,7 +136,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
 
-        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isLessThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isLessThanOrEqualTo(1);
@@ -146,42 +147,42 @@ public class BinaryExpression {
         assertThat(numberObjAct).isGreaterThan(1);
         assertThat(numberObjAct).isGreaterThan(1);
 
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(true);
 
-        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).as("doh!").isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
 
-        assertThat(stringAct).isEqualTo(stringExp);
-        assertThat(stringAct).isEqualTo(stringExp);
-        assertThat(stringAct).isEqualTo(stringExp);
-        assertThat(stringAct).isNotEqualTo(stringExp);
-        assertThat(stringAct).isNotEqualTo(stringExp);
-        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct.equals(stringExp)).as("doh!").isTrue();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isFalse();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(true);
 
-        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).as("doh!").isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
 
-        assertThat(stringAct).isNull();
+        assertThat(stringAct).as("doh!").isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNotNull();
         assertThat(stringAct).isNotNull();
         assertThat(stringAct).isNotNull();
 
-        assertThat(stringAct).isNull();
+        assertThat(stringAct).as("doh!").isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNotNull();
@@ -190,5 +191,13 @@ public class BinaryExpression {
 
         assertThat(null == null).isTrue();
         assertThat(!false).isTrue();
+
+        assertThat(primAct).as("doh!").isEqualTo(primExp).isEqualTo(primExp);
+        assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);
+
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue().isEqualTo(true);
+
+        org.junit.Assert.assertThat(stringAct, null);
+        fail("oh no!");
     }
 }

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

@@ -1,4 +1,5 @@
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 public class BinaryExpression {
 
@@ -10,7 +11,7 @@ public class BinaryExpression {
         String stringExp = "foo";
         String stringAct = "bar";
 
-        assertThat(primAct == primExp).isTrue();
+        assertThat(primAct == primExp).as("doh!").isTrue();
         assertThat(primAct == primExp).isEqualTo(true);
         assertThat(primAct == primExp).isEqualTo(Boolean.TRUE);
         assertThat(primAct == primExp).isNotEqualTo(false);
@@ -25,7 +26,7 @@ public class BinaryExpression {
         assertThat(primAct == 1).isFalse();
         assertThat(1 == primAct).isFalse();
 
-        assertThat(primAct != primExp).isTrue();
+        assertThat(primAct != primExp).as("doh!").isTrue();
         assertThat(primAct != primExp).isEqualTo(true);
         assertThat(primAct != primExp).isNotEqualTo(false);
         assertThat(primAct != 1).isTrue();
@@ -36,7 +37,7 @@ public class BinaryExpression {
         assertThat(primAct != 1).isFalse();
         assertThat(1 != primAct).isFalse();
 
-        assertThat(primAct > primExp).isTrue();
+        assertThat(primAct > primExp).as("doh!").isTrue();
         assertThat(primAct > primExp).isEqualTo(true);
         assertThat(primAct > primExp).isNotEqualTo(false);
         assertThat(primAct > 1).isTrue();
@@ -47,7 +48,7 @@ public class BinaryExpression {
         assertThat(primAct > 1).isFalse();
         assertThat(1 < primAct).isFalse();
 
-        assertThat(primAct >= primExp).isTrue();
+        assertThat(primAct >= primExp).as("doh!").isTrue();
         assertThat(primAct >= primExp).isEqualTo(true);
         assertThat(primAct >= primExp).isNotEqualTo(false);
         assertThat(primAct >= 1).isTrue();
@@ -58,7 +59,7 @@ public class BinaryExpression {
         assertThat(primAct >= 1).isFalse();
         assertThat(1 <= primAct).isFalse();
 
-        assertThat(primAct < primExp).isTrue();
+        assertThat(primAct < primExp).as("doh!").isTrue();
         assertThat(primAct < primExp).isEqualTo(true);
         assertThat(primAct < primExp).isNotEqualTo(false);
         assertThat(primAct < 1).isTrue();
@@ -69,7 +70,7 @@ public class BinaryExpression {
         assertThat(primAct < 1).isFalse();
         assertThat(1 > primAct).isFalse();
 
-        assertThat(primAct <= primExp).isTrue();
+        assertThat(primAct <= primExp).as("doh!").isTrue();
         assertThat(primAct <= primExp).isEqualTo(true);
         assertThat(primAct <= primExp).isNotEqualTo(false);
         assertThat(primAct <= 1).isTrue();
@@ -80,7 +81,7 @@ public class BinaryExpression {
         assertThat(primAct <= 1).isFalse();
         assertThat(1 >= primAct).isFalse();
 
-        assertThat(numberObjAct == numberObjExp).isTrue();
+        assertThat(numberObjAct == numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct == numberObjExp).isEqualTo(true);
         assertThat(numberObjAct == numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct == 1).isTrue();
@@ -91,7 +92,7 @@ public class BinaryExpression {
         assertThat(numberObjAct == 1).isFalse();
         assertThat(1 == numberObjAct).isFalse();
 
-        assertThat(numberObjAct != numberObjExp).isTrue();
+        assertThat(numberObjAct != numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct != numberObjExp).isEqualTo(true);
         assertThat(numberObjAct != numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct != 1).isTrue();
@@ -102,7 +103,7 @@ public class BinaryExpression {
         assertThat(numberObjAct != 1).isFalse();
         assertThat(1 != numberObjAct).isFalse();
 
-        assertThat(numberObjAct > numberObjExp).isTrue();
+        assertThat(numberObjAct > numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct > numberObjExp).isEqualTo(true);
         assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct > 1).isTrue();
@@ -113,7 +114,7 @@ public class BinaryExpression {
         assertThat(numberObjAct > 1).isFalse();
         assertThat(1 < numberObjAct).isFalse();
 
-        assertThat(numberObjAct >= numberObjExp).isTrue();
+        assertThat(numberObjAct >= numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct >= numberObjExp).isEqualTo(true);
         assertThat(numberObjAct >= numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct >= 1).isTrue();
@@ -124,7 +125,7 @@ public class BinaryExpression {
         assertThat(numberObjAct >= 1).isFalse();
         assertThat(1 <= numberObjAct).isFalse();
 
-        assertThat(numberObjAct < numberObjExp).isTrue();
+        assertThat(numberObjAct < numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct < numberObjExp).isEqualTo(true);
         assertThat(numberObjAct < numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct < 1).isTrue();
@@ -135,7 +136,7 @@ public class BinaryExpression {
         assertThat(numberObjAct < 1).isFalse();
         assertThat(1 > numberObjAct).isFalse();
 
-        assertThat(numberObjAct <= numberObjExp).isTrue();
+        assertThat(numberObjAct <= numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct <= numberObjExp).isEqualTo(true);
         assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct <= 1).isTrue();
@@ -146,42 +147,42 @@ public class BinaryExpression {
         assertThat(numberObjAct <= 1).isFalse();
         assertThat(1 >= numberObjAct).isFalse();
 
-        assertThat(numberObjAct.equals(numberObjExp)).isTrue();
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue();
         assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
         assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
         assertThat(numberObjAct.equals(numberObjExp)).isFalse();
         assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
         assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(true);
 
-        assertThat(stringAct == stringExp).isTrue();
+        assertThat(stringAct == stringExp).as("doh!").isTrue();
         assertThat(stringAct == stringExp).isEqualTo(true);
         assertThat(stringAct == stringExp).isNotEqualTo(false);
         assertThat(stringAct == stringExp).isFalse();
         assertThat(stringAct == stringExp).isEqualTo(false);
         assertThat(stringAct == stringExp).isNotEqualTo(true);
 
-        assertThat(stringAct.equals(stringExp)).isTrue();
+        assertThat(stringAct.equals(stringExp)).as("doh!").isTrue();
         assertThat(stringAct.equals(stringExp)).isEqualTo(true);
         assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
         assertThat(stringAct.equals(stringExp)).isFalse();
         assertThat(stringAct.equals(stringExp)).isEqualTo(false);
         assertThat(stringAct.equals(stringExp)).isNotEqualTo(true);
 
-        assertThat(stringAct != stringExp).isTrue();
+        assertThat(stringAct != stringExp).as("doh!").isTrue();
         assertThat(stringAct != stringExp).isEqualTo(true);
         assertThat(stringAct != stringExp).isNotEqualTo(false);
         assertThat(stringAct != stringExp).isFalse();
         assertThat(stringAct != stringExp).isEqualTo(false);
         assertThat(stringAct != stringExp).isNotEqualTo(true);
 
-        assertThat(stringAct == null).isTrue();
+        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).isTrue();
+        assertThat(null == stringAct).as("doh!").isTrue();
         assertThat(null == stringAct).isEqualTo(true);
         assertThat(null == stringAct).isNotEqualTo(false);
         assertThat(null == stringAct).isFalse();
@@ -190,5 +191,13 @@ public class BinaryExpression {
 
         assertThat(null == null).isTrue();
         assertThat(!false).isTrue();
+
+        assertThat(primAct == primExp).as("doh!").isTrue().isEqualTo(true);
+        assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);
+
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue().isEqualTo(true);
+
+        org.junit.Assert.assertThat(stringAct, null);
+        fail("oh no!");
     }
 }

src/test/resources/inspections/BooleanCondition/BooleanConditionAfter.java

@@ -1,4 +1,5 @@
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 public class BooleanCondition {
 
@@ -6,7 +7,7 @@ public class BooleanCondition {
         boolean primitive = false;
         Boolean object = Boolean.TRUE;
 
-        assertThat(primitive).isTrue();
+        assertThat(primitive).as("foo").isTrue();
         assertThat(primitive).isFalse();
         assertThat(object).isTrue();
         assertThat(object).isFalse();
@@ -15,7 +16,7 @@ public class BooleanCondition {
         assertThat(object).isTrue();
         assertThat(object).isFalse();
 
-        assertThat(primitive).isFalse();
+        assertThat(primitive).as("foo").isFalse();
         assertThat(primitive).isTrue();
         assertThat(object).isFalse();
         assertThat(object).isTrue();
@@ -28,5 +29,11 @@ public class BooleanCondition {
         assertThat(object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
 
         assertThat("").isEqualTo(Boolean.TRUE);
+
+        assertThat(primitive).isTrue().as("foo").isTrue().as("bar").isTrue().isFalse();
+
+        assertThat(object).isEqualTo(Boolean.TYPE);
+        org.junit.Assert.assertThat(object, null);
+        fail("oh no!");
     }
 }

src/test/resources/inspections/BooleanCondition/BooleanConditionBefore.java

@@ -1,4 +1,5 @@
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 public class BooleanCondition {
 
@@ -6,7 +7,7 @@ public class BooleanCondition {
         boolean primitive = false;
         Boolean object = Boolean.TRUE;
 
-        assertThat(primitive).isEqualTo(Boolean.TRUE);
+        assertThat(primitive).as("foo").isEqualTo(Boolean.TRUE);
         assertThat(primitive).isEqualTo(Boolean.FALSE);
         assertThat(object).isEqualTo(Boolean.TRUE);
         assertThat(object).isEqualTo(Boolean.FALSE);
@@ -15,7 +16,7 @@ public class BooleanCondition {
         assertThat(object).isEqualTo(true);
         assertThat(object).isEqualTo(false);
 
-        assertThat(primitive).isNotEqualTo(Boolean.TRUE);
+        assertThat(primitive).as("foo").isNotEqualTo(Boolean.TRUE);
         assertThat(primitive).isNotEqualTo(Boolean.FALSE);
         assertThat(object).isNotEqualTo(Boolean.TRUE);
         assertThat(object).isNotEqualTo(Boolean.FALSE);
@@ -28,5 +29,11 @@ public class BooleanCondition {
         assertThat(object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
 
         assertThat("").isEqualTo(Boolean.TRUE);
+
+        assertThat(primitive).isEqualTo(Boolean.TRUE).as("foo").isEqualTo(true).as("bar").isTrue().isFalse();
+
+        assertThat(object).isEqualTo(Boolean.TYPE);
+        org.junit.Assert.assertThat(object, null);
+        fail("oh no!");
     }
 }

src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionAfter.java

@@ -0,0 +1,48 @@
+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(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/CollectionMapExpression/CollectionMapExpressionBefore.java

@@ -0,0 +1,48 @@
+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.isEmpty()).as("foo").isEqualTo(true);
+        assertThat(stringList.isEmpty()).isTrue();
+        assertThat(stringList.contains("foo")).isEqualTo(true);
+        assertThat(stringList.contains("foo")).isTrue();
+        assertThat(stringList.containsAll(anotherList)).isEqualTo(true);
+        assertThat(stringList.containsAll(anotherList)).isTrue();
+
+        assertThat(stringList.isEmpty()).as("foo").isEqualTo(false);
+        assertThat(stringList.isEmpty()).isFalse();
+        assertThat(stringList.contains("foo")).isEqualTo(false);
+        assertThat(stringList.contains("foo")).isFalse();
+        assertThat(stringList.containsAll(anotherList)).isEqualTo(false);
+        assertThat(stringList.containsAll(anotherList)).isFalse();
+
+        assertThat(keyValueMap.isEmpty()).as("foo").isEqualTo(true);
+        assertThat(keyValueMap.isEmpty()).isTrue();
+        assertThat(keyValueMap.containsKey("foo")).isEqualTo(true);
+        assertThat(keyValueMap.containsKey("foo")).isTrue();
+        assertThat(keyValueMap.containsValue(2)).isEqualTo(true);
+        assertThat(keyValueMap.containsValue(2)).isTrue();
+
+        assertThat(keyValueMap.isEmpty()).as("foo").isEqualTo(false);
+        assertThat(keyValueMap.isEmpty()).isFalse();
+        assertThat(keyValueMap.containsKey("foo")).isEqualTo(false);
+        assertThat(keyValueMap.containsKey("foo")).isFalse();
+        assertThat(keyValueMap.containsValue(2)).isEqualTo(false);
+        assertThat(keyValueMap.containsValue(2)).isFalse();
+
+        assertThat(stringList.isEmpty()).as("foo").isEqualTo(false).as("bar").isFalse();
+        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!");
+    }
+}