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. Removed oraclejdk8 from travis-ci. Added custom Jupiter DisplayNameGenerator for user friendly test names in report. Extended documentation. Removed Playground.

Renamed a few inspections to better/shorter names (and fixed file and directory names accordingly).

.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,15 +1,17 @@
-# 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 assertions.
+Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
-## Why?
+## Purpose
 
 First, code is easier to read, when it is concise and reflects the intention clearly.
 AssertJ has plenty of different convenience methods that describing various intentions precisely.
 Why write longer, more complex code that can be expressed in brevity?
 
-Second, AssertJ is able to output more meaningful descriptions when an assertion fails.
+Second, when using the available special assertion methods of AssertJ, a failure of a condition
+can be expressed in better detail and with more meaningful descriptions.
 This makes finding bugs and fixing failed tests more efficient.
+Nobody likes to read failures of the kind "failed because true is not false".
 
 For example:
 
@@ -17,7 +19,7 @@ For example:
 assertThat(collection.size()).isEqualTo(5);
 ```
 
-If the collection has more or less than 5 elements, the assertion will fail, but will not
+If the collection has more or less than five elements, the assertion will fail, but will not
 tell you about the contents, making it hard to guess what went wrong.
 
 Instead, if you wrote the same assertion the following way:
@@ -26,41 +28,161 @@ Instead, if you wrote the same assertion the following way:
 assertThat(collection).hasSize(5);
 ```
 
-Then AssertJ would tell you the contents of the collection on failure.
+Then AssertJ would tell you the _actual contents_ of the collection on failure.
 
 ## Conversion of JUnit assertions to AssertJ
 
 The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
 
-## Implemented inspections
+## Lookup and refactoring of string-based extracting()
+
+AssertJ allows [extracting POJO fields/properties on iterables/arrays](http://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#extracted-properties-assertion).
+
+Using strings is not safe for refactoring (and before Java 8 Lambdas were available,
+creating extractor functions just for testing purpose was a bit too tedious).
+
+This plugin adds support for referencing these fields (so you can ctrl(/cmd)-click on the 
+string to go to the definition) and also allows safe refactoring on the 
+fields (refactoring a getter method without a corresponding field will not work 
+correctly right now).
+
+## Usage
+
+The plugin will report inspections in your opened editor file as warnings.
+You can then quick-fix these with your quick-fix hotkey (usually Alt-Return or Opt-Return).
+
+Or, you can use the "Run Inspection by Name..." action to run one inspection on a bigger scope (e.g. the whole project).
+Applying a quick fix might result in further optimization possibilities, so 
+you might need to perform a couple of fixes before you get to the final result.
+
+Check out this example where every line represents the result after a Cajon quickfix:
+```
+assertFalse(!(array.length == collection.size()));
+
+assertThat(!(array.length == collection.size())).isFalse();
+
+assertThat(array.length == collection.size()).isTrue();
+
+assertThat(array.length).isEqualTo(collection.size());
+
+assertThat(array).hasSameSizeAs(collection);
+```
+
+You can toggle the various inspections in the Settings/Editor/Inspections in the AssertJ group.
+
+## 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();
+  ```
+  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()``` -- please notify me about others.
+
+  The comments of the statements will be preserved. When using ```.extracting()``` or similar, the statements will not be merged.
+
+- AssertThatObjectIsNullOrNotNull
+
+  Uses ```isNull()``` and ```isNotNull()``` instead.
 
-- AssertThatObjectIsNull
   ```
   from: assertThat(object).isEqualTo(null);
     to: assertThat(object).isNull();
-  ```
+
-- AssertThatObjectIsNotNull
-  ```
   from: assertThat(object).isNotEqualTo(null);  
     to: assertThat(object).isNotNull();
   ```
-- AssertThatBooleanIsTrueOrFalse
+
+- 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();  
+    to: assertThat(booleanValue).isFalse()/isTrue();
+  ```
+
+- AssertThatInstanceOf
+
+  Moves ```instanceof``` expressions out of ```assertThat()```.
+  
+  ```
+  from: assertThat(object instanceof classname).isEqualTo(true);
+  from: assertThat(object instanceof classname).isTrue();
+    to: assertThat(object).isInstanceOf(classname.class);
+
+  from: assertThat(object instanceof classname).isEqualTo(false);
+  from: assertThat(object instanceof classname).isFalse();
+    to: assertThat(object).isNotInstanceOf(classname.class);
+  ```
+
 - 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();
+
+  from: assertThat(stringActual.equals(stringExpected)).isTrue();
+  from: assertThat(stringActual.contentEquals(charSeqExpected)).isTrue();
+    to: assertThat(stringActual).isEqualTo(stringExpected);
+
+  from: assertThat(stringActual.equalsIgnoreCase(stringExpected)).isTrue();
+    to: assertThat(stringActual).isEqualToIgnoringCase(stringExpected);
+
+  from: assertThat(stringActual.contains(stringExpected)).isTrue();
+    to: assertThat(stringActual).contains(stringExpected);
+
+  from: assertThat(stringActual.startsWith(stringExpected)).isTrue();
+    to: assertThat(stringActual).startsWith(stringExpected);
+
+  from: assertThat(stringActual.endsWith(stringExpected)).isTrue();
+    to: assertThat(stringActual).endsWith(stringExpected);
+  ```
+  Analogously with ```isFalse()```.
+
 - 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);
@@ -75,11 +197,176 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to
 
   from: assertThat(array.length).isEqualTo(anotherArray.length);
     to: assertThat(array).hasSameSizeAs(anotherArray);
+    
+  from: assertThat(array).hasSize(anotherArray.length);
+    to: assertThat(array).hasSameSizeAs(anotherArray);
   ```
 
-  and analogously for collections...
+  and additionally with AssertJ 13.2.0 or later
+
+  ```
+  from: assertThat(array.length).isLessThanOrEqualTo(expression);
+    to: assertThat(array).hasSizeLessThanOrEqualTo(expression);
+    
+  from: assertThat(array.length).isLessThan(expression);
+    to: assertThat(array).hasSizeLessThan(expression);
+
+  from: assertThat(array.length).isGreaterThan(expression);
+    to: assertThat(array).hasSizeGreaterThan(expression);
+
+  from: assertThat(array.length).isGreaterThanOrEqualTo(expression);
+    to: assertThat(array).hasSizeGreaterThanOrEqualTo(expression);
+  ```
+  and analogously for collections, strings and CharSequences, e.g:
+
+  ```
+  from: assertThat("string".length()).isLessThan(1);
+    to: assertThat("string").isEmpty();
+
+  from: assertThat("string".length()).isEqualTo(collection.size())
+    to: assertThat("string").hasSameSizeAs(collection);
+    
+  from: assertThat("string".length()).hasSize("strong".length())
+    to: assertThat("string").hasSameSizeAs("strong");
+  ```
+
+- 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);
+
+  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).
+
+- 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);
+  from: assertThat(opt.isPresent()).isTrue();
+    to: assertThat(opt).isPresent();
+
+  from: assertThat(opt.isPresent()).isEqualTo(false);
+  from: assertThat(opt.isPresent()).isNotEqualTo(true);
+  from: assertThat(opt.isPresent()).isFalse();
+    to: assertThat(opt).isNotPresent();
+    
+  from: assertThat(opt.get()).isEqualTo("foo");
+    to: assertThat(opt).contains("foo");
+     
+  from: assertThat(opt.get()).isSameAs("foo");
+    to: assertThat(opt).containsSame("foo"); 
+
+  from: assertThat(opt).isEqualTo(Optional.of("foo"));
+  from: assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
+    to: assertThat(opt).contains("foo"); 
+
+  from: assertThat(opt).isEqualTo(Optional.empty());
+    to: assertThat(opt).isNotPresent();
+
+  from: assertThat(opt).isNotEqualTo(Optional.empty());
+    to: assertThat(opt).isPresent();
+  ```
+
+- 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);
+  from: assertThat(opt.isPresent()).isTrue();
+    to: assertThat(opt).isPresent();
+
+  from: assertThat(opt.isPresent()).isEqualTo(false);
+  from: assertThat(opt.isPresent()).isNotEqualTo(true);
+  from: assertThat(opt.isPresent()).isFalse();
+    to: assertThat(opt).isAbsent();
+    
+  from: assertThat(opt.get()).isEqualTo("foo");
+    to: assertThat(opt).contains("foo");
+     
+  from: assertThat(opt).isEqualTo(Optional.of("foo"));
+  from: assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
+    to: assertThat(opt).contains("foo"); 
+
+  from: assertThat(opt).isEqualTo(Optional.absent());
+    to: assertThat(opt).isAbsent();
+
+  from: assertThat(opt).isNotEqualTo(Optional.absent());
+    to: assertThat(opt).isPresent();
+  ```
+
+  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 generated ```assumeThat()``` statement could be optimized further (similar to ```assertThat()```).
+
+  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 to AssertJ format.
+
+  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);
@@ -107,6 +394,92 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to
   assertArrayEquals(message, expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
   ```
 
-## TODO
+### Implemented referencing
-- AssertThatGuavaOptionalContains
+
-- extraction with property names to lambda with Java 8
+  ```
+  .extracting("field")
+  .extracting("outerField.fieldInsideObjectTypeOfOuterField.andSoOn")
+  .extracting("property") // where the class has a getProperty() (or isProperty() for boolean) method
+  .extracting("bareMethod") // supported with AssertJ 13.12.0
+  .extracting(Extractors.byName("fieldOrPropertyOrBareMethod")
+  .extracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
+  .extracting(Extractors.resultOf("bareMethod")
+  .extractingResultOf("bareMethod")
+  .flatExtracting("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
+  .flatExtracting(Extractors.byName("fieldOrPropertyOrBareMethod.orAPathLikeAbove")
+  .flatExtracting(Extractors.resultOf("bareMethod")
+  ```
+  Works on both POJOs and ```Iterable```s/```Array```s. 
+  Implementation is very basic though and does not work with fancy cascaded .extracting() sequences.
+  If there's demand, I will add it.
+
+## Development notice
+
+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).
+
+## Planned features
+- 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
+
+#### 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).
+- Extended AssertThatSize inspection to transform ```hasSize()``` into ```hasSameSizeAs()```, if possible.
+- Implemented first version of JoinAssertThatStatements inspection that will try to merge ```assertThat()``` statements with the same
+  actual object together, preserving comments.
+
+#### V0.6 (22-Apr-19)
+- New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
+  ```startsWith()```, and ```endsWith()``` out of actual expression.
+- Extended AssertThatSize inspection to take ```String```s and ```CharSequences``` into account, too.
+- New AssertThatInvertedBooleanCondition inspection that will remove inverted boolean expressions inside ```assertThat()```.
+- Renamed a few inspections to better/shorter names.
+- New AssertThatInstanceOf inspection that moves instanceof expressions out of ```assertThat()```.
+
+#### V0.5 (18-Apr-19)
+- Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
+- Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
+- Added support for referencing and refactoring inside ```.extracting()``` methods with fields, properties and methods (though
+  getter renaming does not work that perfect, but I'm giving up for now as the IntelliJ SDK docs are seriously lacking).
+- Fixed an exception in batch mode if the description string was the same but for different fixes. 
+  Now descriptions are different for quick fixes triggered by AssertThatJava8OptionalInspection and AssertThatGuavaOptionalInspection.
+
+#### V0.4 (11-Apr-19)
+- Reduced minimal supported IDEA version from 2018.2 to 2017.2.
+- New inspection AssertThatJava8Optional that operates on Java 8 ```Optional``` objects and tries to use ```contains()```, ```containsSame()```, ```isPresent()```, and ```isNotPresent()``` instead.
+- New inspection AssertThatGuavaOptional that operates on Guava ```Optional``` objects and tries to use ```contains()```, ```isPresent()```, and ```isAbsent()``` instead.
+- Added support in AssertThatBinaryExpressionIsTrueOrFalse for ```is(Not)EqualTo(Boolean.TRUE/FALSE)```.
+
+#### V0.3 (07-Apr-19)
+- New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and ```equals()``` statements (more than 150 combinations) inside ```assertThat()```.
+- Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
+- Support for ```hasSizeLessThan()```, ```hasSizeLessThanOrEqualTo()```, ```hasSizeGreaterThanOrEqualTo()```, and ```hasSizeGreaterThan()``` for AssertThatSizeInspection (with AssertJ >=13.2.0).
+- Really fixed highlighting for JUnit conversion. Sorry.
+
+#### V0.2 (01-Apr-19)
+- Fixed descriptions and quick fix texts.
+- Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.
+
+#### V0.1 (31-Mar-19)
+- Initial release.

build.gradle

@@ -1,11 +1,13 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '0.4.3'
+    id 'org.jetbrains.intellij' version '0.4.8'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.21'
+    id 'org.jetbrains.kotlin.jvm' version '1.3.31'
+    id 'jacoco'
+    id 'com.github.kt3k.coveralls' version '2.8.2'
 }
 
 group 'de.platon42'
-version '0.2'
+version '0.8'
 
 repositories {
     mavenCentral()
@@ -18,12 +20,12 @@ repositories {
 
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testCompile "org.assertj:assertj-core:3.11.1"
+    testCompile "org.assertj:assertj-core:3.12.2"
+    testCompile "org.assertj:assertj-guava:3.2.1"
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
-    testRuntimeOnly 'org.junit.vintage:junit-vintage-engine:5.4.0'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
-    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
+//    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
 }
 
 compileKotlin {
@@ -33,30 +35,52 @@ compileTestKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2018.3.4'
+    version '2019.1.1'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
     updateSinceUntilBuild false
 }
 
 patchPluginXml {
     changeNotes """
-      <h4>V0.2 (01-Apr-19)</h4>
+  <h4>V0.8 (05-May-19)</h4>
     <ul>
-      <li>Fixed descriptions and quick fix texts.
+      <li>Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
-      <li>Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.
+      <li>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.
+      <li>Heavily reworked inspections for edge cases, such as multiple isEqualTo() calls inside a single statement.
+      <li>Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
+      <li>Corrected highlighting for many inspections.
+      <li>Fixed family names for inspections in batch mode.
+      <li>Reworded many inspection messages for better understanding.
+      <li>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.
     </ul>
-      <h4>V0.1 (31-Mar-19)</h4>
+  <h4>V0.7 (28-Apr-19)</h4>
     <ul>
-      <li>Initial release.
+      <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>
+  <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """
 }
 
 test {
     useJUnitPlatform()
-//    testLogging {
+    testLogging {
-//        events "passed", "skipped", "failed"
+        events "passed", "skipped", "failed"
-//    }
+    }
+}
+
+jacoco {
+    toolVersion = '0.8.3'
+}
+
+jacocoTestReport {
+    reports {
+        xml.enabled true
+        csv.enabled false
+    }
 }
 
 publishPlugin {

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

@@ -0,0 +1,46 @@
+package de.platon42.intellij.plugins.cajon
+
+import org.jetbrains.annotations.NonNls
+
+class AssertJClassNames {
+    companion object {
+        @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 ASSERT_INTERFACE = "org.assertj.core.api.Assert"
+        @NonNls
+        const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
+        @NonNls
+        const val ABSTRACT_OBJECT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectAssert"
+        @NonNls
+        const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
+        @NonNls
+        const val ABSTRACT_INTEGER_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntegerAssert"
+        @NonNls
+        const val ABSTRACT_COMPARABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractComparableAssert"
+        @NonNls
+        const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
+        @NonNls
+        const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
+        @NonNls
+        const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
+        @NonNls
+        const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
+        @NonNls
+        const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"
+
+        @NonNls
+        const val GUAVA_OPTIONAL_CLASSNAME = "com.google.common.base.Optional"
+        @NonNls
+        const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
+    }
+}

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

@@ -0,0 +1,38 @@
+package de.platon42.intellij.plugins.cajon
+
+import com.intellij.psi.CommonClassNames
+import com.siyeh.ig.callMatcher.CallMatcher
+
+val CORE_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
+val GUAVA_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
+val ALL_ASSERT_THAT_MATCHERS = CallMatcher.anyOf(CORE_ASSERT_THAT_MATCHER, GUAVA_ASSERT_THAT_MATCHER)!!
+
+val EXTRACTING_FROM_OBJECT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME, "extracting")!!
+val EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extracting")!!
+val FLAT_EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "flatExtracting")!!
+val EXTRACTING_RESULT_OF_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extractingResultOf")!!
+
+val EXTRACTING_CALL_MATCHERS = CallMatcher.anyOf(
+    EXTRACTING_FROM_OBJECT,
+    EXTRACTING_FROM_ITERABLE,
+    FLAT_EXTRACTING_FROM_ITERABLE,
+    EXTRACTING_RESULT_OF_FROM_ITERABLE
+)!!
+
+val DESCRIBED_AS = CallMatcher.instanceCall(AssertJClassNames.DESCRIPTABLE_INTERFACE, MethodNames.DESCRIBED_AS, MethodNames.AS)!!
+val WITH_REPRESENTATION_AND_SUCH = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "withRepresentation", "withThreadDumpOnError")!!
+val USING_COMPARATOR = CallMatcher.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 NOT_ACTUAL_ASSERTIONS = CallMatcher.anyOf(
+    ALL_ASSERT_THAT_MATCHERS,
+    DESCRIBED_AS,
+    WITH_REPRESENTATION_AND_SUCH,
+    USING_COMPARATOR,
+    IN_HEXADECIMAL_OR_BINARY
+)!!
+
+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

@@ -0,0 +1,147 @@
+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() = 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) {
+    qualifierExpression.replace(qualifier)
+}
+
+fun PsiMethodCallExpression.replaceQualifierFromMethodCall(oldMethodCall: PsiMethodCallExpression) {
+    qualifierExpression.replace(oldMethodCall.qualifierExpression)
+}
+
+fun PsiElement.findOutmostMethodCall(): PsiMethodCallExpression? {
+    val statement = PsiTreeUtil.getParentOfType(this, PsiStatement::class.java, false) ?: return null
+    return PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java)
+}
+
+fun PsiElement.findStaticMethodCall(): PsiMethodCallExpression? {
+    var elem: PsiElement? = this
+    while (elem != null) {
+        if ((elem is PsiMethodCallExpression) && (elem.resolveMethod()?.hasModifier(JvmModifier.STATIC) == true)) {
+            return elem
+        }
+        elem = elem.firstChild
+    }
+    return null
+}
+
+fun PsiElement.gatherAssertionCalls(): List<PsiMethodCallExpression> {
+    val assertThatMethodCall = findStaticMethodCall() ?: return emptyList()
+    return assertThatMethodCall.collectMethodCallsUpToStatement()
+        .filterNot { NOT_ACTUAL_ASSERTIONS.test(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 = 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 == containingClass))
+    }
+    if (notImportedStatically) {
+        importList.add(factory.createImportStaticStatement(containingClass, methodName))
+    }
+}
+
+fun PsiElement.shortenAndReformat() {
+    val codeStyleManager = JavaCodeStyleManager.getInstance(project)
+    codeStyleManager.shortenClassReferences(this)
+    CodeStyleManager.getInstance(project).reformat(this)
+}
+
+fun PsiMethodCallExpression.getExpectedBooleanResult(): Boolean? {
+    val isTrue = AbstractAssertJInspection.IS_TRUE.test(this)
+    val isFalse = AbstractAssertJInspection.IS_FALSE.test(this)
+    if (isTrue || isFalse) {
+        return isTrue
+    } else {
+        val isEqualTo = AbstractAssertJInspection.IS_EQUAL_TO_BOOLEAN.test(this) || AbstractAssertJInspection.IS_EQUAL_TO_OBJECT.test(this)
+        val isNotEqualTo =
+            AbstractAssertJInspection.IS_NOT_EQUAL_TO_BOOLEAN.test(this) || AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT.test(this)
+        if (isEqualTo || isNotEqualTo) {
+            val constValue = calculateConstantParameterValue(0) as? Boolean ?: return null
+            return isNotEqualTo xor constValue
+        }
+    }
+    return null
+}
+
+fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
+    if (argIndex >= argumentList.expressions.size) return null
+    val valueExpression = getArg(argIndex)
+    val constantEvaluationHelper = JavaPsiFacade.getInstance(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
+}
+
+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,
+                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
+}

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

@@ -0,0 +1,40 @@
+package de.platon42.intellij.plugins.cajon
+
+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)
+}
+
+fun createGuavaAssertThat(context: PsiElement, actualExpression: PsiExpression): PsiMethodCallExpression {
+    return createAssertThat(context, AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, actualExpression)
+}
+
+fun createAssertThat(context: PsiElement, baseclass: String, actualExpression: PsiExpression): PsiMethodCallExpression {
+    return createMethodCall(context, "$baseclass.${MethodNames.ASSERT_THAT}", actualExpression)
+}
+
+fun createExpectedMethodCall(context: PsiElement, methodName: String, vararg arguments: PsiElement): PsiMethodCallExpression {
+    return createMethodCall(context, "a.$methodName", *arguments)
+}
+
+fun createMethodCall(context: PsiElement, fullQualifiedMethodName: String, vararg arguments: PsiElement): PsiMethodCallExpression {
+    val factory = JavaPsiFacade.getElementFactory(context.project)
+    val argString = generateSequence('b') { it + 1 }.take(arguments.size).joinToString(", ")
+    val expectedExpression = factory.createExpressionFromText(
+        "$fullQualifiedMethodName($argString)", context
+    ) as PsiMethodCallExpression
+    arguments.forEachIndexed { index, newArg -> expectedExpression.getArg(index).replace(newArg) }
+    return expectedExpression
+}
+
+fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
+    val findClass =
+        JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
+            ?: return false
+    return findClass.allMethods.any { it.name == methodname }
+}

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

@@ -0,0 +1,108 @@
+package de.platon42.intellij.plugins.cajon
+
+import org.jetbrains.annotations.NonNls
+
+class MethodNames {
+
+    companion object {
+
+        @NonNls
+        const val EQUALS = "equals"
+
+        @NonNls
+        const val ASSERT_THAT = "assertThat"
+
+        @NonNls
+        const val ASSUME_THAT = "assumeThat"
+
+        @NonNls
+        const val AS = "as"
+        @NonNls
+        const val DESCRIBED_AS = "describedAs"
+        @NonNls
+        const val IN_HEXADECIMAL = "inHexadecimal"
+        @NonNls
+        const val IN_BINARY = "inBinary"
+
+        @NonNls
+        const val IS_EQUAL_TO = "isEqualTo"
+        @NonNls
+        const val IS_NOT_EQUAL_TO = "isNotEqualTo"
+        @NonNls
+        const val IS_SAME_AS = "isSameAs"
+        @NonNls
+        const val IS_NOT_SAME_AS = "isNotSameAs"
+        @NonNls
+        const val IS_GREATER_THAN = "isGreaterThan"
+        @NonNls
+        const val IS_GREATER_THAN_OR_EQUAL_TO = "isGreaterThanOrEqualTo"
+        @NonNls
+        const val IS_LESS_THAN = "isLessThan"
+        @NonNls
+        const val IS_LESS_THAN_OR_EQUAL_TO = "isLessThanOrEqualTo"
+        @NonNls
+        const val IS_ZERO = "isZero"
+        @NonNls
+        const val IS_NOT_ZERO = "isNotZero"
+        @NonNls
+        const val IS_TRUE = "isTrue"
+        @NonNls
+        const val IS_FALSE = "isFalse"
+        @NonNls
+        const val IS_NULL = "isNull" // terminal, returns void
+        @NonNls
+        const val IS_NOT_NULL = "isNotNull"
+        @NonNls
+        const val IS_CLOSE_TO = "isCloseTo"
+        @NonNls
+        const val IS_NOT_CLOSE_TO = "isNotCloseTo"
+        @NonNls
+        const val IS_INSTANCE_OF = "isInstanceOf"
+        @NonNls
+        const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"
+
+        @NonNls
+        const val IS_EMPTY = "isEmpty" // terminal, returns void
+        @NonNls
+        const val IS_NOT_EMPTY = "isNotEmpty"
+        @NonNls
+        const val HAS_SIZE = "hasSize"
+        @NonNls
+        const val HAS_SIZE_LESS_THAN = "hasSizeLessThan"
+        @NonNls
+        const val HAS_SIZE_LESS_THAN_OR_EQUAL_TO = "hasSizeLessThanOrEqualTo"
+        @NonNls
+        const val HAS_SIZE_GREATER_THAN = "hasSizeGreaterThan"
+        @NonNls
+        const val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO = "hasSizeGreaterThanOrEqualTo"
+        @NonNls
+        const val HAS_SAME_SIZE_AS = "hasSameSizeAs"
+        @NonNls
+        const val CONTAINS = "contains"
+        @NonNls
+        const val DOES_NOT_CONTAIN = "doesNotContain"
+        @NonNls
+        const val CONTAINS_EXACTLY = "containsExactly"
+        @NonNls
+        const val IS_EQUAL_TO_IC = "isEqualToIgnoringCase"
+        @NonNls
+        const val IS_NOT_EQUAL_TO_IC = "isNotEqualToIgnoringCase"
+        @NonNls
+        const val STARTS_WITH = "startsWith"
+        @NonNls
+        const val ENDS_WITH = "endsWith"
+        @NonNls
+        const val DOES_NOT_START_WITH = "doesNotStartWith"
+        @NonNls
+        const val DOES_NOT_END_WITH = "doesNotEndWith"
+        @NonNls
+        const val CONTAINS_SAME = "containsSame"
+        @NonNls
+        const val IS_PRESENT = "isPresent"
+        @NonNls
+        const val IS_NOT_PRESENT = "isNotPresent"
+
+        @NonNls
+        const val IS_ABSENT = "isAbsent"
+    }
+}

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

@@ -1,97 +1,153 @@
 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.psi.CommonClassNames
+import com.intellij.openapi.util.TextRange
-import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.*
-import com.intellij.psi.PsiCapturedWildcardType
-import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.tree.IElementType
 import com.intellij.psi.util.PsiTypesUtil
 import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_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.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.qualifierExpression
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
-import org.jetbrains.annotations.NonNls
 
 open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
-        const val SIMPLIFY_MESSAGE_TEMPLATE = "%s can be simplified to %s"
+        const val SIMPLIFY_MESSAGE_TEMPLATE = "%s() can be simplified to %s()"
+        const val MORE_CONCISE_MESSAGE_TEMPLATE = "%s() would be more concise than %s()"
 
-        const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s with %s"
+        const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with %s()"
+        const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap expected expression and replace %s() with %s()"
+        const val MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE = "Remove %s() of actual expression and use assertThat().%s() instead"
+        const val MOVING_OUT_MESSAGE_TEMPLATE = "Moving %s() expression out of assertThat() would be more concise"
 
-        @NonNls
+        val TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP = mapOf<IElementType, String>(
-        const val ASSERTIONS_CLASSNAME = "org.assertj.core.api.Assertions"
+            JavaTokenType.EQEQ to MethodNames.IS_EQUAL_TO,
+            JavaTokenType.NE to MethodNames.IS_NOT_EQUAL_TO,
+            JavaTokenType.GT to MethodNames.IS_GREATER_THAN,
+            JavaTokenType.GE to MethodNames.IS_GREATER_THAN_OR_EQUAL_TO,
+            JavaTokenType.LT to MethodNames.IS_LESS_THAN,
+            JavaTokenType.LE to MethodNames.IS_LESS_THAN_OR_EQUAL_TO
+        )
 
-        @NonNls
+        val TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS = mapOf<IElementType, String>(
-        const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
+            JavaTokenType.EQEQ to MethodNames.IS_SAME_AS,
-        @NonNls
+            JavaTokenType.NE to MethodNames.IS_NOT_SAME_AS
-        const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
+        )
-        @NonNls
-        const val ABSTRACT_INTEGER_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntegerAssert"
-        @NonNls
-        const val ABSTRACT_COMPARABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractComparableAssert"
-        @NonNls
-        const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
-        @NonNls
-        const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
-        @NonNls
-        const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
 
-        @NonNls
+        val SWAP_SIDE_OF_BINARY_OPERATOR = mapOf<IElementType, IElementType>(
-        const val ASSERT_THAT_METHOD = "assertThat"
+            JavaTokenType.GT to JavaTokenType.LT,
-        @NonNls
+            JavaTokenType.GE to JavaTokenType.LE,
-        const val IS_EQUAL_TO_METHOD = "isEqualTo"
+            JavaTokenType.LT to JavaTokenType.GT,
-        @NonNls
+            JavaTokenType.LE to JavaTokenType.GE
-        const val IS_NOT_EQUAL_TO_METHOD = "isNotEqualTo"
+        )
-        @NonNls
-        const val IS_GREATER_THAN_METHOD = "isGreaterThan"
-        @NonNls
-        const val IS_GREATER_THAN_OR_EQUAL_TO_METHOD = "isGreaterThanOrEqualTo"
-        @NonNls
-        const val IS_LESS_THAN_METHOD = "isLessThan"
-        @NonNls
-        const val IS_LESS_THAN_OR_EQUAL_TO_METHOD = "isLessThanOrEqualTo"
-        @NonNls
-        const val IS_ZERO_METHOD = "isZero"
-        @NonNls
-        const val IS_NOT_ZERO_METHOD = "isNotZero"
-        @NonNls
-        const val HAS_SIZE_METHOD = "hasSize"
 
-        val ASSERT_THAT_INT = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, ASSERT_THAT_METHOD)
+        val INVERT_BINARY_OPERATOR = mapOf<IElementType, IElementType>(
+            JavaTokenType.EQEQ to JavaTokenType.NE,
+            JavaTokenType.NE to JavaTokenType.EQEQ,
+            JavaTokenType.GT to JavaTokenType.LE,
+            JavaTokenType.GE to JavaTokenType.LT,
+            JavaTokenType.LT to JavaTokenType.GE,
+            JavaTokenType.LE to JavaTokenType.GT
+        )
+
+
+        val ASSERT_THAT_INT = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
             .parameterTypes("int")!!
 
-        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
+        val ASSERT_THAT_BOOLEAN = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterTypes("boolean")!!
+
+        val ASSERT_THAT_ANY = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterCount(1)!!
+
+        val ASSERT_THAT_JAVA8_OPTIONAL = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterTypes(CommonClassNames.JAVA_UTIL_OPTIONAL)!!
+
+        val GUAVA_ASSERT_THAT_ANY = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterCount(1)!!
+
+        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, IS_NOT_EQUAL_TO_METHOD)
+        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, IS_EQUAL_TO_METHOD)
+        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, IS_NOT_EQUAL_TO_METHOD)
+            CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
                 .parameterTypes("boolean")!!
-        val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, HAS_SIZE_METHOD)
+        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_SAME_AS)
+            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
+        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_SAME_AS)
+            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
+
+        val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)
             .parameterTypes("int")!!
 
-        val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
+        val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("int")!!
-        val IS_GREATER_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, IS_GREATER_THAN_METHOD)
+        val IS_GREATER_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN)
             .parameterTypes("int")!!
-        val IS_GREATER_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, IS_GREATER_THAN_OR_EQUAL_TO_METHOD)
+        val IS_GREATER_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN_OR_EQUAL_TO)
             .parameterTypes("int")!!
 
-        val IS_LESS_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, IS_LESS_THAN_METHOD)
+        val IS_LESS_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN)
             .parameterTypes("int")!!
-        val IS_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, IS_LESS_THAN_OR_EQUAL_TO_METHOD)
+        val IS_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_LESS_THAN_OR_EQUAL_TO)
             .parameterTypes("int")!!
 
-        val IS_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, IS_ZERO_METHOD)
+        val IS_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_ZERO)
             .parameterCount(0)!!
-        val IS_NOT_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, IS_NOT_ZERO_METHOD)
+        val IS_NOT_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
+            .parameterCount(0)!!
+
+        val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)
+            .parameterCount(0)!!
+        val IS_FALSE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_FALSE)
             .parameterCount(0)!!
 
         val COLLECTION_SIZE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "size")
             .parameterCount(0)!!
+        val CHAR_SEQUENCE_LENGTH = CallMatcher.instanceCall("java.lang.CharSequence", "length")
+            .parameterCount(0)!!
+        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "equals")
+            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
+
+        val OPTIONAL_GET = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "get")
+            .parameterCount(0)!!
+        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "isPresent")
+            .parameterCount(0)!!
+
+        val OPTIONAL_OF = CallMatcher.staticCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "of")
+            .parameterCount(1)!!
+        val OPTIONAL_OF_NULLABLE = CallMatcher.staticCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "ofNullable")
+            .parameterCount(1)!!
+        val OPTIONAL_EMPTY = CallMatcher.staticCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "empty")
+            .parameterCount(0)!!
+
+        val GUAVA_OPTIONAL_GET = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "get")
+            .parameterCount(0)!!
+        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "isPresent")
+            .parameterCount(0)!!
+
+        val GUAVA_OPTIONAL_OF = CallMatcher.staticCall(GUAVA_OPTIONAL_CLASSNAME, "of")
+            .parameterCount(1)!!
+        val GUAVA_OPTIONAL_FROM_NULLABLE = CallMatcher.staticCall(GUAVA_OPTIONAL_CLASSNAME, "fromNullable")
+            .parameterCount(1)!!
+        val GUAVA_OPTIONAL_ABSENT = CallMatcher.staticCall(GUAVA_OPTIONAL_CLASSNAME, "absent")
+            .parameterCount(0)!!
     }
 
     override fun getGroupDisplayName(): String {
@@ -99,8 +155,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
     }
 
     protected fun checkAssertedType(expression: PsiMethodCallExpression, classname: String): Boolean {
-        var assertedType = expression.methodExpression.qualifierExpression?.type ?: return false
+        var assertedType = expression.qualifierExpression.type ?: return false
-        if (assertedType is PsiCapturedWildcardType) {
+        while (assertedType is PsiCapturedWildcardType) {
             assertedType = assertedType.upperBound
         }
         val assertedClass = PsiTypesUtil.getPsiClass(assertedType) ?: return false
@@ -109,8 +165,7 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         return assertedClass.isEquivalentTo(expectedClass) || assertedClass.isInheritor(expectedClass, true)
     }
 
-    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) =
+    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) = expression.resolveMethod()?.name
-        expression.resolveMethod()?.name?.plus("()")
 
     protected fun registerSimplifyMethod(
         holder: ProblemsHolder,
@@ -120,17 +175,58 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val originalMethod = getOriginalMethodName(expression) ?: return
         val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
-        holder.registerProblem(
+        val quickFix = ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
-            expression,
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
-            message,
+        holder.registerProblem(expression, textRange, message, quickFix)
-            ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
-        )
     }
 
-    protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
+    protected fun registerMoveOutMethod(
-        if (argIndex >= expression.argumentList.expressionCount) return null
+        holder: ProblemsHolder,
-        val valueExpression = expression.argumentList.expressions[argIndex] ?: return null
+        expression: PsiMethodCallExpression,
-        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+        oldActualExpression: PsiMethodCallExpression,
-        return constantEvaluationHelper.computeConstantExpression(valueExpression)
+        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(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        registerConciseMethod(REPLACE_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
+    }
+
+    protected fun registerConciseMethod(
+        descriptionTemplate: String,
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val originalMethod = getOriginalMethodName(oldExpectedCallExpression) ?: return
+        val description = descriptionTemplate.format(originalMethod, replacementMethod)
+        val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickfix)
+    }
+
+    protected fun registerRemoveExpectedOutmostMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
 }

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

@@ -7,10 +7,6 @@ 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"
 
@@ -38,6 +34,5 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
         return "AssertJ"
     }
 
-    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) =
+    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) = expression.resolveMethod()?.name
-        expression.resolveMethod()?.name?.plus("()")
 }

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

@@ -0,0 +1,95 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.LocalQuickFix
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+import com.intellij.psi.util.TypeConversionUtil
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+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"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+                super.visitExpressionStatement(statement)
+                if (!statement.hasAssertThat()) {
+                    return
+                }
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
+                    return
+                }
+
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
+
+                val assertThatArgument = staticMethodCall.firstArg
+                if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
+                    val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
+                    registerSplitMethod(holder, expectedCallExpression, "${MethodNames.EQUALS}()", replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
+                    return
+                }
+
+                val binaryExpression = assertThatArgument as? PsiBinaryExpression ?: return
+
+                val leftType = binaryExpression.lOperand.type ?: return
+                val rightType = binaryExpression.rOperand?.type ?: return
+
+                val bothTypes = listOf(leftType, rightType)
+                val (isLeftNull, isRightNull) = bothTypes.map(TypeConversionUtil::isNullType)
+                if (isLeftNull && isRightNull) {
+                    return
+                } else if (isLeftNull || isRightNull) {
+                    val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
+                    registerSplitMethod(holder, expectedCallExpression, "binary", replacementMethod) { desc, method ->
+                        SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
+                    }
+                    return
+                }
+
+                val isPrimitive = bothTypes.all(TypeConversionUtil::isPrimitiveAndNotNull)
+                val isNumericType = bothTypes.all(TypeConversionUtil::isNumericType)
+                val constantEvaluationHelper = JavaPsiFacade.getInstance(statement.project).constantEvaluationHelper
+                val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
+
+                val tokenType = binaryExpression.operationTokenType
+                    .let {
+                        if (swapExpectedAndActual) SWAP_SIDE_OF_BINARY_OPERATOR.getOrDefault(it, it) else it
+                    }
+                    .let {
+                        if (expectedResult) it else INVERT_BINARY_OPERATOR.getOrDefault(it, it)
+                    }
+                val mappingToUse =
+                    (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
+                val replacementMethod = mappingToUse[tokenType] ?: return
+
+                registerSplitMethod(holder, expectedCallExpression, "binary", replacementMethod) { desc, method ->
+                    SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
+                }
+            }
+        }
+    }
+
+    private fun registerSplitMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        type: String,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val description = SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE.format(type)
+        val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, message, quickfix)
+    }
+}

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

@@ -0,0 +1,49 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.util.TypeConversionUtil
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
+
+class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting a boolean condition"
+    }
+
+    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 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
+                }
+
+                val expectedExpression = expression.firstArg
+                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) {
+                    return
+                }
+                val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
+                val flippedBooleanTest = matchingCalls.drop(2).any { it }
+
+                val replacementMethod = (expectedResult xor flippedBooleanTest).map(MethodNames.IS_TRUE, MethodNames.IS_FALSE)
+                registerSimplifyMethod(holder, expression, replacementMethod)
+            }
+        }
+    }
+}

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

@@ -1,53 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
-import com.intellij.psi.util.TypeConversionUtil
-
-class AssertThatBooleanIsTrueOrFalseInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting true or false"
-    }
-
-    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 isEqualToObject = IS_EQUAL_TO_OBJECT.test(expression)
-                val isEqualToBoolean = IS_EQUAL_TO_BOOLEAN.test(expression)
-                val isNotEqualToObject = IS_NOT_EQUAL_TO_OBJECT.test(expression)
-                val isNotEqualToBoolean = IS_NOT_EQUAL_TO_BOOLEAN.test(expression)
-                val normalBooleanTest = isEqualToObject || isEqualToBoolean
-                val flippedBooleanTest = isNotEqualToObject || isNotEqualToBoolean
-                if (!(normalBooleanTest || flippedBooleanTest)) {
-                    return
-                }
-                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) {
-                    return
-                }
-
-                val equalToExpression = expression.argumentList.expressions[0] ?: return
-                if (!TypeConversionUtil.isBooleanType(equalToExpression.type)) {
-                    return
-                }
-                var value = calculateConstantParameterValue(expression, 0)
-                if (value == null) {
-                    val field = (equalToExpression as? PsiReferenceExpression)?.resolve() as? PsiField
-                    if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
-                        when {
-                            field.name == "TRUE" -> value = true
-                            field.name == "FALSE" -> value = false
-                        }
-                    }
-                }
-                val expectedResult = value as? Boolean ?: return
-
-                val replacementMethod = if (expectedResult xor flippedBooleanTest) "isTrue()" else "isFalse()"
-                registerSimplifyMethod(holder, expression, replacementMethod)
-            }
-        }
-    }
-}

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

@@ -4,6 +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() {
 
@@ -17,14 +21,17 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                val hasSize = HAS_SIZE.test(expression)
+                if (!expression.hasAssertThat()) {
-                if (!hasSize) {
+                    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, "isEmpty()")
+                    registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                 }
             }
         }

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

@@ -0,0 +1,112 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.*
+import com.intellij.psi.search.GlobalSearchScope
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.*
+
+class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting an Optional (Guava)"
+        private const val REPLACE_GUAVA_DESCRIPTION_TEMPLATE = "Replace %s() with Guava assertThat().%s()"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+                super.visitExpressionStatement(statement)
+                if (!statement.hasAssertThat()) {
+                    return
+                }
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+
+                if (!checkPreconditions(staticMethodCall)) {
+                    return
+                }
+                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
+
+                val outmostMethodCall = statement.findOutmostMethodCall() ?: return
+                if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
+                    val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
+                    if (IS_EQUAL_TO_OBJECT.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
+                        )
+                    }
+                }
+            }
+
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                if (!expression.hasAssertThat()) {
+                    return
+                }
+                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                if (!checkPreconditions(staticMethodCall)) {
+                    return
+                }
+                // 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.
+                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)) {
+                        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 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
+            }
+        }
+    }
+
+    private fun registerSimplifyForGuavaMethod(holder: ProblemsHolder, expression: PsiMethodCallExpression, replacementMethod: String) {
+        val originalMethod = getOriginalMethodName(expression) ?: return
+        val description = REPLACE_GUAVA_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
+        val quickFix = QuickFixWithPostfixDelegate(
+            ReplaceSimpleMethodCallQuickFix(description, replacementMethod),
+            ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+        )
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickFix)
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryStatementQuickFix
+
+class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting an inverted boolean condition"
+        private const val INVERT_CONDITION_MESSAGE = "Condition inside assertThat() could be inverted"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                if (!expression.hasAssertThat()) {
+                    return
+                }
+                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
+                    return
+                }
+                expression.getExpectedBooleanResult() ?: return
+
+                val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
+                if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
+                    val outmostMethodCall = expression.findOutmostMethodCall() ?: return
+                    holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,81 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiExpressionStatement
+import com.intellij.psi.PsiMethodCallExpression
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.UnwrapExpectedStaticMethodCallQuickFix
+
+class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting an Optional (Java 8)"
+    }
+
+    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_ANY.test(staticMethodCall)) {
+                    return
+                }
+                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
+
+                val outmostMethodCall = statement.findOutmostMethodCall() ?: return
+                if (OPTIONAL_GET.test(actualExpression)) {
+                    val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
+                    if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method)
+                        }
+                    } else if (IS_SAME_AS_OBJECT.test(expectedCallExpression)) {
+                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS_SAME) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method)
+                        }
+                    }
+                } else if (OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                    val expectedPresence = outmostMethodCall.getAllTheSameExpectedBooleanConstants() ?: return
+                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
+                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
+                        MoveOutMethodCallExpressionQuickFix(desc, method)
+                    }
+                }
+            }
+
+            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)) {
+                        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/AssertThatObjectIsNotNullInspection.kt

@@ -1,31 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiType
-
-class AssertThatObjectIsNotNullInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting non-null"
-    }
-
-    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 (!IS_NOT_EQUAL_TO_OBJECT.test(expression)) {
-                    return
-                }
-
-                if (expression.argumentList.expressions[0].type == PsiType.NULL) {
-                    registerSimplifyMethod(holder, expression, "isNotNull()")
-                }
-            }
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiType
-
-class AssertThatObjectIsNullInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting null"
-    }
-
-    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 (!IS_EQUAL_TO_OBJECT.test(expression)) {
-                    return
-                }
-
-                if (expression.argumentList.expressions[0].type == PsiType.NULL) {
-                    registerSimplifyMethod(holder, expression, "isNull()")
-                }
-            }
-        }
-    }
-}

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

@@ -0,0 +1,38 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+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() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting null or not-null"
+    }
+
+    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 isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expression)
+                val isEqualTo = IS_EQUAL_TO_OBJECT.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,60 +2,27 @@ 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() {
 
     companion object {
-        private const val DISPLAY_NAME = "Asserting the size of an collection or array"
+        private const val DISPLAY_NAME = "Asserting the size of an collection, array or string"
-        private const val MORE_CONCISE_MESSAGE_TEMPLATE = "%s would be more concise than %s"
+        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"
 
-    override fun getDisplayName() = DISPLAY_NAME
+        private val BONUS_EXPRESSIONS_CALL_MATCHER_MAP = listOf(
+            IS_LESS_THAN_INT to MethodNames.HAS_SIZE_LESS_THAN,
+            IS_LESS_THAN_OR_EQUAL_TO_INT to MethodNames.HAS_SIZE_LESS_THAN_OR_EQUAL_TO,
+            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 buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        private fun isCharSequenceLength(expression: PsiExpression) = (expression is PsiMethodCallExpression) && CHAR_SEQUENCE_LENGTH.test(expression)
-        return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_INT.test(expression)) {
-                    return
-                }
-                val actualExpression = expression.argumentList.expressions[0] ?: return
-
-                if (isArrayLength(actualExpression) || isCollectionSize(actualExpression)) {
-                    val statement = PsiTreeUtil.getParentOfType(expression, PsiStatement::class.java) ?: return
-                    val expectedCallExpression = PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java) ?: return
-                    val constValue = calculateConstantParameterValue(expectedCallExpression, 0)
-                    if (IS_EQUAL_TO_INT.test(expectedCallExpression)) {
-                        if (constValue == 0) {
-                            registerSizeMethod(holder, expression, expectedCallExpression, "isEmpty()", noExpectedExpression = true)
-                            return
-                        }
-                        val equalToExpression = expectedCallExpression.argumentList.expressions[0]
-                        if (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) {
-                            registerSizeMethod(holder, expression, expectedCallExpression, "hasSameSizeAs()", expectedIsCollection = true)
-                            return
-                        }
-                        registerSizeMethod(holder, expression, expectedCallExpression, "hasSize()")
-                    } else {
-                        if ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 0))
-                            || (IS_LESS_THAN_INT.test(expectedCallExpression) && (constValue == 1))
-                            || IS_ZERO.test(expectedCallExpression)
-                        ) {
-                            registerSizeMethod(holder, expression, expectedCallExpression, "isEmpty()", noExpectedExpression = true)
-                            return
-                        }
-                        if ((IS_GREATER_THAN_INT.test(expectedCallExpression) && (constValue == 0))
-                            || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 1))
-                            || IS_NOT_ZERO.test(expectedCallExpression)
-                        ) {
-                            registerSizeMethod(holder, expression, expectedCallExpression, "isNotEmpty()", noExpectedExpression = true)
-                            return
-                        }
-                    }
-                }
-            }
 
         private fun isCollectionSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && COLLECTION_SIZE.test(expression)
 
@@ -65,23 +32,118 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                     && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
         }
 
-            private fun registerSizeMethod(
+        fun getMatch(expression: PsiMethodCallExpression, isForArrayOrCollection: Boolean, isForString: Boolean): Match? {
-                holder: ProblemsHolder,
+            val isLastExpression = expression.parent is PsiStatement
-                expression: PsiMethodCallExpression,
+            val constValue = expression.calculateConstantParameterValue(0)
-                expectedCallExpression: PsiMethodCallExpression,
+            if (IS_EQUAL_TO_INT.test(expression)) {
-                replacementMethod: String,
+                return if ((constValue == 0) && isLastExpression) {
-                noExpectedExpression: Boolean = false,
+                    Match(expression, MethodNames.IS_EMPTY, noExpectedExpression = true)
-                expectedIsCollection: Boolean = false
+                } else {
+                    val equalToExpression = expression.firstArg
+                    if (isForArrayOrCollection && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) ||
+                        isForString && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression) || isCharSequenceLength(equalToExpression))
                     ) {
-                val originalMethod = getOriginalMethodName(expectedCallExpression) ?: return
+                        Match(expression, MethodNames.HAS_SAME_SIZE_AS, expectedIsCollection = true)
-                val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+                    } else {
-                val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
+                        Match(expression, MethodNames.HAS_SIZE)
-                holder.registerProblem(
+                    }
+                }
+            } 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,
-                    message,
+                            expression,
-                    ReplaceSizeMethodCallQuickFix(description, replacementMethod, noExpectedExpression, expectedIsCollection)
+                            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
+                }
+                val isHasSize = HAS_SIZE.test(expression)
+                if (!(isHasSize)) {
+                    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

@@ -0,0 +1,75 @@
+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 AssertThatStringExpressionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting a string specific expression"
+
+        private val MAPPINGS = listOf(
+            Mapping(
+                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)!!
+                ),
+                MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO
+            ),
+            Mapping(
+                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)!!,
+                MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
+            ),
+            Mapping(
+                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)!!,
+                MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH
+            )
+        )
+    }
+
+    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
+                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
+            }
+        }
+    }
+
+    private class Mapping(
+        val callMatcher: CallMatcher,
+        val replacementForTrue: String,
+        val replacementForFalse: String
+    )
+}

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

@@ -4,6 +4,11 @@ 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.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() {
 
@@ -17,9 +22,13 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
+                if (!expression.hasAssertThat()) {
+                    return
+                }
                 val isEqual = IS_EQUAL_TO_OBJECT.test(expression)
                 val hasSize = HAS_SIZE.test(expression)
-                if (!(isEqual || hasSize)) {
+                val isLastExpression = expression.parent is PsiStatement
+                if (!((isEqual || hasSize) && isLastExpression)) {
                     return
                 }
 
@@ -27,9 +36,9 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
                     return
                 }
 
-                val value = calculateConstantParameterValue(expression, 0) ?: return
+                val value = expression.calculateConstantParameterValue(0) ?: return
                 if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
-                    registerSimplifyMethod(holder, expression, "isEmpty()")
+                    registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                 }
             }
         }

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

@@ -0,0 +1,146 @@
+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 = listOf(
+            "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)
+                if (TEST_ANNOTATIONS.none(method::hasAnnotation)) {
+                    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/JUnitAssertToAssertJInspection.kt

@@ -1,14 +1,14 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
+import com.intellij.psi.*
-import com.intellij.psi.CommonClassNames
+import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
 import com.siyeh.ig.callMatcher.CallMatcher
 import com.siyeh.ig.callMatcher.CallMatcher.anyOf
+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.ReplaceJUnitDeltaAssertMethodCallQuickFix
 
@@ -16,97 +16,99 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Convert JUnit assertions to AssertJ"
+        private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
+        private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to assertThat().%s()"
 
         private val MAPPINGS = listOf(
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
                 ),
-                "isTrue()", false
+                MethodNames.IS_TRUE, false
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
                 ),
-                "isFalse()", false
+                MethodNames.IS_FALSE, false
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.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_STRING, CommonClassNames.JAVA_LANG_OBJECT),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                 ),
-                "isNull()", false
+                MethodNames.IS_NULL, false
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.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_STRING, CommonClassNames.JAVA_LANG_OBJECT),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                 ),
-                "isNotNull()", false
+                MethodNames.IS_NOT_NULL, false
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
                 ),
-                "isCloseTo()", hasDelta = true
+                MethodNames.IS_CLOSE_TO, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
                 ),
-                "isEqualTo()"
+                MethodNames.IS_EQUAL_TO
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
                 ),
-                "isNotCloseTo()", hasDelta = true
+                MethodNames.IS_NOT_CLOSE_TO, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
                 ),
-                "isNotEqualTo()"
+                MethodNames.IS_NOT_EQUAL_TO
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
                 ),
-                "isSameAs()"
+                MethodNames.IS_SAME_AS
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
                 ),
-                "isNotSameAs()"
+                MethodNames.IS_NOT_SAME_AS
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double[]", "double[]", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double[]", "double[]", "double"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("double[]", "double[]", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("double[]", "double[]", "double"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float[]", "float[]", "float"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float[]", "float[]", "float"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
                 ),
-                "containsExactly()", hasDelta = true
+                MethodNames.CONTAINS_EXACTLY, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
                 ),
-                "containsExactly()"
+                MethodNames.CONTAINS_EXACTLY
             )
         )
     }
@@ -121,53 +123,31 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
                 if (!isJUnitAssertCall) {
                     return // early exit
                 }
-                for (mapping in MAPPINGS) {
+                JavaPsiFacade.getInstance(expression.project)
-                    if (mapping.callMatcher.test(expression)) {
+                    .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
                 if (mapping.hasDelta) {
-                            registerDeltaReplacementMethod(holder, expression, mapping.replacement)
+                    registerConvertMethod(holder, expression, mapping.replacement, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
                 } else {
-                            registerSimpleReplacementMethod(holder, expression, mapping.hasExpected, mapping.replacement)
+                    registerConvertMethod(holder, expression, mapping.replacement) { desc, method ->
-                        }
+                        ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
-                        return
                     }
                 }
             }
         }
     }
 
-    private fun registerSimpleReplacementMethod(
+    private fun registerConvertMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
-        hasExpected: Boolean,
+        replacementMethod: String,
-        replacementMethod: 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, replacementMethod)
         val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
-        holder.registerProblem(
+        val quickfix = quickFixSupplier(description, replacementMethod)
-            expression,
+        holder.registerProblem(expression, message, quickfix)
-            message,
-            ProblemHighlightType.INFORMATION,
-            null as TextRange?,
-            ReplaceJUnitAssertMethodCallQuickFix(description, hasExpected, replacementMethod)
-        )
-    }
-
-    private fun registerDeltaReplacementMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        replacementMethod: String
-    ) {
-        val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-        val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
-        holder.registerProblem(
-            expression,
-            message,
-            ProblemHighlightType.INFORMATION,
-            null as TextRange?,
-            ReplaceJUnitDeltaAssertMethodCallQuickFix(description, replacementMethod)
-        )
     }
 
     private class Mapping(

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

@@ -0,0 +1,93 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+import com.intellij.psi.util.PsiTreeUtil
+import com.siyeh.ig.psiutils.TrackingEquivalenceChecker
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.JoinStatementsQuickFix
+
+class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Join multiple assertThat() statements with same actual expression"
+        private const val CAN_BE_JOINED_DESCRIPTION = "Multiple assertThat() statements can be joined together"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitCodeBlock(block: PsiCodeBlock) {
+                super.visitCodeBlock(block)
+                var lastActualExpression: PsiExpression? = null
+                var sameCount = 0
+                var firstStatement: PsiStatement? = null
+                var lastStatement: PsiStatement? = null
+                val equivalenceChecker = TrackingEquivalenceChecker()
+                for (statement in block.statements) {
+                    val assertThatCall = isLegitAssertThatCall(statement)
+                    var reset = true
+                    var actualExpression: PsiExpression? = null
+                    if (assertThatCall != null) {
+                        reset = (lastActualExpression == null)
+                        actualExpression = assertThatCall.firstArg
+                        if (!reset) {
+                            val isSame = when (actualExpression) {
+                                is PsiMethodCallExpression -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
+                                        && PsiTreeUtil.findChildrenOfAnyType(
+                                    actualExpression,
+                                    false,
+                                    PsiMethodCallExpression::class.java
+                                ).none { KNOWN_METHODS_WITH_SIDE_EFFECTS.test(it) }
+                                else -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
+                            }
+                            if (isSame) {
+                                sameCount++
+                                lastStatement = statement
+                            } else {
+                                reset = true
+                            }
+                        }
+                    }
+                    if (reset) {
+                        if (sameCount > 1) {
+                            registerProblem(holder, isOnTheFly, firstStatement!!, lastStatement!!)
+                        }
+                        firstStatement = statement
+                        lastStatement = null
+                        lastActualExpression = actualExpression
+                        sameCount = 1
+                    }
+                }
+                if (sameCount > 1) {
+                    registerProblem(holder, isOnTheFly, firstStatement!!, lastStatement!!)
+                }
+            }
+
+            private fun isLegitAssertThatCall(statement: PsiStatement?): PsiMethodCallExpression? {
+                if ((statement is PsiExpressionStatement) && (statement.expression is PsiMethodCallExpression)) {
+                    if (!statement.hasAssertThat()) {
+                        return null
+                    }
+                    val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
+                    return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
+                }
+                return null
+            }
+        }
+    }
+
+    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()
+        )
+        holder.registerProblem(problemDescriptor)
+    }
+}

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

@@ -1,32 +1,10 @@
 package de.platon42.intellij.plugins.cajon.quickfixes
 
 import com.intellij.codeInspection.LocalQuickFix
-import com.intellij.psi.PsiElementFactory
-import com.intellij.psi.PsiJavaFile
-import com.intellij.psi.PsiMethod
-import com.intellij.psi.PsiMethodCallExpression
-import org.jetbrains.annotations.NonNls
 
 abstract class AbstractCommonQuickFix(private val description: String) : LocalQuickFix {
 
+    override fun getName() = description
+
     override fun getFamilyName() = description
-
-    companion object {
-        @NonNls
-        const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
-    }
-
-    protected fun addStaticImport(method: PsiMethod, element: PsiMethodCallExpression, factory: PsiElementFactory, vararg allowedClashes: String) {
-        val methodName = method.name
-        val containingClass = method.containingClass ?: return
-        val importList = (element.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 == method.containingClass))
-        }
-        if (notImportedStatically) {
-            importList.add(factory.createImportStaticStatement(containingClass, methodName))
-        }
-    }
 }

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

@@ -0,0 +1,26 @@
+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.PsiStatement
+import com.intellij.psi.util.PsiTreeUtil
+import de.platon42.intellij.plugins.cajon.*
+
+class ForGuavaPostFix {
+
+    companion object {
+        val REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT: (Project, ProblemDescriptor) -> Unit = exit@
+        { _, descriptor ->
+            val element = descriptor.startElement
+            val statement = PsiTreeUtil.getParentOfType(element, PsiStatement::class.java) ?: return@exit
+            val assertThatCall = statement.findStaticMethodCall() ?: return@exit
+
+            val newMethodCall = createGuavaAssertThat(element, assertThatCall.firstArg)
+            newMethodCall.resolveMethod()?.addAsStaticImport(element, AssertJClassNames.ASSERTIONS_CLASSNAME)
+            val parentCall = PsiTreeUtil.getParentOfType(assertThatCall, PsiMethodCallExpression::class.java) ?: return@exit
+            parentCall.replaceQualifier(newMethodCall)
+            parentCall.shortenAndReformat()
+        }
+    }
+}

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

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

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,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 MoveOutMethodCallExpressionQuickFix(description: String, private val replacementMethod: String) : 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 = assertExpression.getArgOrNull(0)?.copy()
+
+        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
+            .filter { 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

@@ -0,0 +1,20 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.LocalQuickFix
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+
+class QuickFixWithPostfixDelegate(
+    private val mainFix: LocalQuickFix,
+    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

@@ -0,0 +1,39 @@
+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 RemoveActualOutmostMethodCallQuickFix(
+    description: String,
+    private val replacementMethod: String,
+    private val noExpectedExpression: Boolean = false
+) : AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val REMOVE_ACTUAL_EXPRESSION_DESCRIPTION = "Remove method calls in actual expressions and use better assertion"
+    }
+
+    override fun getFamilyName(): String {
+        return REMOVE_ACTUAL_EXPRESSION_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
+
+        val methodsToFix = assertThatMethodCall.gatherAssertionCalls()
+
+        assertExpression.replace(assertExpression.qualifierExpression)
+
+        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/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,49 @@
+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
+                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

@@ -2,57 +2,49 @@ package de.platon42.intellij.plugins.cajon.quickfixes
 
 import com.intellij.codeInspection.ProblemDescriptor
 import com.intellij.openapi.project.Project
-import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiExpression
 import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.codeStyle.CodeStyleManager
+import de.platon42.intellij.plugins.cajon.*
-import com.intellij.psi.codeStyle.JavaCodeStyleManager
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 
-class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val hasExpected: Boolean, private val replacementMethod: String) :
+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 factory = JavaPsiFacade.getElementFactory(element.project)
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
-        val count = args.expressionCount
+        val count = args.expressions.size
         val actualExpression = args.expressions[count - 1] ?: return
-        val (expectedExpression, messageExpression) = if (hasExpected) {
+        val (expectedExpression, messageExpression) = if (noExpectedExpression) {
-            val expected = args.expressions[count - 2] ?: return
+            val message = args.expressions.getOrNull(count - 2)
-            val message = if (count > 2) args.expressions[0] else null
+            emptyArray<PsiExpression>() to message
-            Pair(expected, message)
         } else {
-            val message = if (count > 1) args.expressions[0] else null
+            val expected = args.expressions[count - 2] ?: return
-            Pair(null, message)
+            val message = args.expressions.getOrNull(count - 3)
+            arrayOf(expected) to message
         }
 
-        val expectedMethodCall = factory.createExpressionFromText(
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, *expectedExpression)
-            "a.${if (hasExpected) replacementMethod.replace("()", "(e)") else replacementMethod}", element
+        val newMethodCall = createAssertThat(element, actualExpression)
-        ) as PsiMethodCallExpression
-        if (hasExpected) {
-            expectedMethodCall.argumentList.expressions[0].replace(expectedExpression!!)
-        }
-
-        val newMethodCall = factory.createExpressionFromText(
-            "org.assertj.core.api.Assertions.assertThat(a)", element
-        ) as PsiMethodCallExpression
-        newMethodCall.argumentList.expressions[0].replace(actualExpression)
 
         if (messageExpression != null) {
-            val asExpression = factory.createExpressionFromText("a.as(desc)", element) as PsiMethodCallExpression
+            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
-            asExpression.argumentList.expressions[0].replace(messageExpression)
+            asExpression.replaceQualifier(newMethodCall)
-            asExpression.methodExpression.qualifierExpression!!.replace(newMethodCall)
+            expectedMethodCall.replaceQualifier(asExpression)
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(asExpression)
         } else {
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(newMethodCall)
+            expectedMethodCall.replaceQualifier(newMethodCall)
         }
 
-        val assertThatMethod = newMethodCall.resolveMethod() ?: return
+        newMethodCall.resolveMethod()?.addAsStaticImport(element, GUAVA_ASSERTIONS_CLASSNAME)
-        addStaticImport(assertThatMethod, element, factory, GUAVA_ASSERTIONS_CLASSNAME)
+        element.replace(expectedMethodCall).shortenAndReformat()
-
-        val codeStyleManager = JavaCodeStyleManager.getInstance(element.project)
-        val newElement = element.replace(expectedMethodCall)
-        val shortened = codeStyleManager.shortenClassReferences(newElement)
-        CodeStyleManager.getInstance(element.project).reformat(shortened)
     }
 }

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

@@ -2,59 +2,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.PsiMethodCallExpression
-import com.intellij.psi.codeStyle.CodeStyleManager
+import de.platon42.intellij.plugins.cajon.*
-import com.intellij.psi.codeStyle.JavaCodeStyleManager
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 
 class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : 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 factory = JavaPsiFacade.getElementFactory(element.project)
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
-        val count = args.expressionCount
+        val count = args.expressions.size
-        val actualExpression = args.expressions[count - 2] ?: return
+        val messageExpression = args.expressions.getOrNull(count - 4)
-        val messageExpression = if (count > 3) args.expressions[0] else null
         val expectedExpression = args.expressions[count - 3] ?: return
+        val actualExpression = args.expressions[count - 2] ?: return
         val deltaExpression = args.expressions[count - 1] ?: return
 
-        val offsetMethodCall = factory.createExpressionFromText(
+        val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
-            "org.assertj.core.data.Offset.offset(c)", element
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall)
-        ) as PsiMethodCallExpression
+        val newMethodCall = createAssertThat(element, actualExpression)
-
-        offsetMethodCall.argumentList.expressions[0].replace(deltaExpression)
-
-        val expectedMethodCall = factory.createExpressionFromText(
-            "a.${replacementMethod.removeSuffix("()")}(e, offs)", element
-        ) as PsiMethodCallExpression
-
-        expectedMethodCall.argumentList.expressions[0].replace(expectedExpression)
-        expectedMethodCall.argumentList.expressions[1].replace(offsetMethodCall)
-
-        val newMethodCall = factory.createExpressionFromText(
-            "org.assertj.core.api.Assertions.assertThat(a)", element
-        ) as PsiMethodCallExpression
-        newMethodCall.argumentList.expressions[0].replace(actualExpression)
 
         if (messageExpression != null) {
-            val asExpression = factory.createExpressionFromText("a.as(desc)", element) as PsiMethodCallExpression
+            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
-            asExpression.argumentList.expressions[0].replace(messageExpression)
+            asExpression.replaceQualifier(newMethodCall)
-            asExpression.methodExpression.qualifierExpression!!.replace(newMethodCall)
+            expectedMethodCall.replaceQualifier(asExpression)
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(asExpression)
         } else {
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(newMethodCall)
+            expectedMethodCall.replaceQualifier(newMethodCall)
         }
 
-        val assertThatMethod = newMethodCall.resolveMethod() ?: return
+        newMethodCall.resolveMethod()?.addAsStaticImport(element, GUAVA_ASSERTIONS_CLASSNAME)
-        addStaticImport(assertThatMethod, element, factory, GUAVA_ASSERTIONS_CLASSNAME)
+        offsetMethodCall.resolveMethod()?.addAsStaticImport(element)
-        val offsetMethod = offsetMethodCall.resolveMethod() ?: return
+        element.replace(expectedMethodCall).shortenAndReformat()
-        addStaticImport(offsetMethod, element, factory)
-
-        val codeStyleManager = JavaCodeStyleManager.getInstance(element.project)
-        val newElement = element.replace(expectedMethodCall)
-        val shortened = codeStyleManager.shortenClassReferences(newElement)
-        CodeStyleManager.getInstance(element.project).reformat(shortened)
     }
 }

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

@@ -2,19 +2,25 @@ 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.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
+import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
 
 class ReplaceSimpleMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
 
+    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 factory = JavaPsiFacade.getElementFactory(element.project)
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val oldQualifier = methodCallExpression.methodExpression.qualifierExpression ?: return
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod)
-        val expectedExpression =
+        expectedExpression.replaceQualifierFromMethodCall(methodCallExpression)
-            factory.createExpressionFromText("a.$replacementMethod", element) as PsiMethodCallExpression
-        expectedExpression.methodExpression.qualifierExpression!!.replace(oldQualifier)
         element.replace(expectedExpression)
     }
 }

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

@@ -2,41 +2,48 @@ 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.PsiExpression
-import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiReferenceExpression
+import de.platon42.intellij.plugins.cajon.*
 
 class ReplaceSizeMethodCallQuickFix(
     description: String,
     private val replacementMethod: String,
-    private val noExpectedExpression: Boolean,
+    private val noExpectedExpression: Boolean = false,
-    private val expectedIsCollection: Boolean
+    private val expectedIsCollection: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val REPLACE_DESCRIPTION = "Replace methods by better ones"
+    }
+
+    override fun getFamilyName(): String {
+        return REPLACE_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
-        val factory = JavaPsiFacade.getElementFactory(element.project)
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val assertExpression = assertThatMethodCall.firstArg
-        val assertExpression = methodCallExpression.argumentList.expressions[0] ?: return
         replaceCollectionSizeOrArrayLength(assertExpression)
-        val statement = PsiTreeUtil.getParentOfType(element, PsiStatement::class.java) ?: return
+
-        val oldExpectedExpression = PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java) ?: return
-        val expectedExpression =
-            factory.createExpressionFromText("a.${if (noExpectedExpression) replacementMethod else replacementMethod.replace("()", "(e)")}", element) as PsiMethodCallExpression
-        if (!noExpectedExpression) {
         if (expectedIsCollection) {
-                replaceCollectionSizeOrArrayLength(oldExpectedExpression.argumentList.expressions[0])
+            replaceCollectionSizeOrArrayLength(outmostCallExpression.firstArg)
         }
-            expectedExpression.argumentList.expressions[0].replace(oldExpectedExpression.argumentList.expressions[0])
+
-        }
+        val args = if (noExpectedExpression) emptyArray() else arrayOf(outmostCallExpression.firstArg)
-        expectedExpression.methodExpression.qualifierExpression!!.replace(oldExpectedExpression.methodExpression.qualifierExpression!!)
+        val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, *args)
-        oldExpectedExpression.replace(expectedExpression)
+
+        expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression)
+        outmostCallExpression.replace(expectedExpression)
     }
 
     private fun replaceCollectionSizeOrArrayLength(assertExpression: PsiExpression) {
         assertExpression.replace(
             when (assertExpression) {
                 is PsiReferenceExpression -> assertExpression.qualifierExpression!!
-                is PsiMethodCallExpression -> assertExpression.methodExpression.qualifierExpression!!
+                is PsiMethodCallExpression -> assertExpression.qualifierExpression
                 else -> return
             }
         )

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

@@ -0,0 +1,45 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+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.*
+
+class SplitBinaryExpressionMethodCallQuickFix(
+    description: String,
+    private val replacementMethod: String,
+    private val pickRightOperand: Boolean = false,
+    private val noExpectedExpression: Boolean = false
+) : AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val SPLIT_EXPRESSION_DESCRIPTION = "Split binary expressions out of assertThat()"
+    }
+
+    override fun getFamilyName(): String {
+        return SPLIT_EXPRESSION_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val 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 args = if (noExpectedExpression) emptyArray() else arrayOf(expectedArgument)
+
+        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

@@ -0,0 +1,29 @@
+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.createExpectedMethodCall
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
+
+class UnwrapExpectedStaticMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    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
+        val expectedMethodCallExpression = oldExpectedExpression.firstArg as? PsiMethodCallExpression ?: return
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, expectedMethodCallExpression.firstArg)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}

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

@@ -0,0 +1,158 @@
+package de.platon42.intellij.plugins.cajon.references
+
+import com.intellij.lang.jvm.JvmModifier
+import com.intellij.openapi.util.TextRange
+import com.intellij.patterns.PlatformPatterns
+import com.intellij.psi.*
+import com.intellij.psi.util.PropertyUtilBase
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.util.PsiTypesUtil
+import com.intellij.util.ArrayUtil
+import com.intellij.util.ProcessingContext
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+
+class ExtractorReferenceContributor : PsiReferenceContributor() {
+
+    companion object {
+        private val BY_NAME = CallMatcher.staticCall(AssertJClassNames.EXTRACTORS_CLASSNAME, "byName")
+        private val RESULT_OF = CallMatcher.staticCall(AssertJClassNames.EXTRACTORS_CLASSNAME, "resultOf")
+            .parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
+
+        private val propertyOrFieldReferenceProvider = PropertyOrFieldReferenceProvider()
+        private val iterablePropertyOrFieldReferenceProvider = IterablePropertyOrFieldReferenceProvider()
+        private val iterableResultOfReferenceProvider = IterableResultOfReferenceProvider()
+
+        private fun lookupFieldOrProperty(containingClass: PsiClass, path: String, startOffset: Int): List<Pair<TextRange, List<PsiElement>>> {
+            val partName = path.substring(startOffset).substringBefore(".")
+            val nextOffset = startOffset + partName.length + 1
+
+            val matchedGetter = PropertyUtilBase.findPropertyGetter(containingClass, partName, false, true)
+            val fieldResult = PropertyUtilBase.findPropertyField(containingClass, partName, false)
+            val textRange = TextRange(startOffset + 1, nextOffset)
+            val matchedBareMethod = containingClass.allMethods.find { (it.name == partName) && !it.hasModifier(JvmModifier.STATIC) }
+            val targets = listOfNotNull<PsiElement>(fieldResult, matchedGetter, matchedBareMethod)
+            if (targets.isNotEmpty()) {
+                val results = listOf(textRange to targets)
+                if (nextOffset >= path.length) {
+                    return results
+                }
+                val nextClass = PsiTypesUtil.getPsiClass(matchedGetter?.returnType ?: fieldResult?.type) ?: return results
+                return listOf(results, lookupFieldOrProperty(nextClass, path, nextOffset)).flatten()
+            }
+            return emptyList()
+        }
+
+        private fun lookupMethod(containingClass: PsiClass, methodName: String): List<Pair<TextRange, List<PsiElement>>>? {
+            val matchedMethod = containingClass.allMethods.find { (it.name == methodName) && !it.hasModifier(JvmModifier.STATIC) } ?: return null
+            val textRange = TextRange(1, methodName.length + 1)
+            return listOf(textRange to listOf(matchedMethod))
+        }
+
+        private fun findActualType(element: PsiElement): 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) {
+                return results.map { ExtractorReference(literal, it.first, it.second) }.toTypedArray()
+            }
+            return PsiReference.EMPTY_ARRAY
+        }
+    }
+
+    override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
+        registrar.registerReferenceProvider(PlatformPatterns.psiElement(PsiLiteralExpression::class.java), propertyOrFieldReferenceProvider)
+        registrar.registerReferenceProvider(PlatformPatterns.psiElement(PsiLiteralExpression::class.java), iterablePropertyOrFieldReferenceProvider)
+        registrar.registerReferenceProvider(PlatformPatterns.psiElement(PsiLiteralExpression::class.java), iterableResultOfReferenceProvider)
+    }
+
+    class ExtractorReference(literal: PsiLiteralExpression, range: TextRange, private val targets: List<PsiElement>) :
+        PsiPolyVariantReferenceBase<PsiLiteralExpression>(literal, range, true) {
+
+        override fun getVariants(): Array<Any> {
+            return ArrayUtil.EMPTY_OBJECT_ARRAY
+        }
+
+        override fun resolve(): PsiElement? {
+            return multiResolve(false).map(ResolveResult::getElement).firstOrNull()
+        }
+
+        override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
+            return PsiElementResolveResult.createResults(targets)
+        }
+    }
+
+    class PropertyOrFieldReferenceProvider : PsiReferenceProvider() {
+
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            return findAndCreateReferences(element, ::findReferences)
+        }
+
+        fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
+            val literal = element.value as? String ?: return null
+            var methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression::class.java) ?: return null
+            var isResultOf = false
+            if (BY_NAME.test(methodCallExpression)) {
+                methodCallExpression = PsiTreeUtil.getParentOfType(methodCallExpression, PsiMethodCallExpression::class.java) ?: return null
+            } else if (RESULT_OF.test(methodCallExpression)) {
+                methodCallExpression = PsiTreeUtil.getParentOfType(methodCallExpression, PsiMethodCallExpression::class.java) ?: return null
+                isResultOf = true
+            }
+            if (!EXTRACTING_FROM_OBJECT.test(methodCallExpression)) {
+                return emptyList()
+            }
+            val containingClass = PsiTypesUtil.getPsiClass(findActualType(methodCallExpression)) ?: return null
+            return if (isResultOf) lookupMethod(containingClass, literal) else lookupFieldOrProperty(containingClass, literal, 0)
+        }
+    }
+
+    class IterablePropertyOrFieldReferenceProvider : PsiReferenceProvider() {
+
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            return findAndCreateReferences(element, ::findReferences)
+        }
+
+        fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
+            val literal = element.value as? String ?: return null
+            var methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression::class.java) ?: return null
+            var isResultOf = false
+            if (BY_NAME.test(methodCallExpression)) {
+                methodCallExpression = PsiTreeUtil.getParentOfType(methodCallExpression, PsiMethodCallExpression::class.java) ?: return null
+            } else if (RESULT_OF.test(methodCallExpression)) {
+                methodCallExpression = PsiTreeUtil.getParentOfType(methodCallExpression, PsiMethodCallExpression::class.java) ?: return null
+                isResultOf = true
+            }
+
+            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
+            return if (isResultOf) lookupMethod(containingClass, literal) else lookupFieldOrProperty(containingClass, literal, 0)
+        }
+    }
+
+    class IterableResultOfReferenceProvider : PsiReferenceProvider() {
+
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            return findAndCreateReferences(element, ::findReferences)
+        }
+
+        fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
+            val literal = element.value as? String ?: return null
+            val methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression::class.java) ?: return null
+            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) {
+                return null
+            }
+            val iterableType = findActualType(methodCallExpression) ?: return null
+            val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
+            val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null
+            return lookupMethod(containingClass, literal)
+        }
+    }
+}

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

@@ -5,12 +5,14 @@
 
     <description><![CDATA[
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
-    It adds inspections and quick fixes to fully make use of the AssertJ methods
+    It adds several inspections and quick fixes to fully use the fluent assertion methods
-    to make the intention clear and concise. It can also convert JUnit 4 assertions to AssertJ.
+    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 supports referencing inside extracting()-methods with strings, adding refactoring safety.
     ]]></description>
 
     <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
-    <idea-version since-build="182.0"/>
+    <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 -->
@@ -19,25 +21,39 @@
     <depends>com.intellij.modules.java</depends>
 
     <extensions defaultExtensionNs="com.intellij">
-        <localInspection groupPath="Java" shortName="AssertThatObjectIsNull" enabledByDefault="true" level="WARNING"
+        <psi.referenceContributor implementation="de.platon42.intellij.plugins.cajon.references.ExtractorReferenceContributor"/>
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNullInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatObjectIsNullOrNotNull" enabledByDefault="true" level="WARNING"
-        <localInspection groupPath="Java" shortName="AssertThatObjectIsNotNull" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNullOrNotNullInspection"/>
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNotNullInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatBooleanCondition" enabledByDefault="true" level="WARNING"
-        <localInspection groupPath="Java" shortName="AssertThatBooleanIsTrueOrFalse" enabledByDefault="true"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanConditionInspection"/>
-                         level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatInvertedBooleanCondition" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanIsTrueOrFalseInspection"/>
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInvertedBooleanConditionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatInstanceOf" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInstanceOfInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringIsEmptyInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true"
+        <localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true" level="WARNING"
-                         level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatEnumerableIsEmptyInspection"/>
 
-        <localInspection groupPath="Java" shortName="AssertThatSize" enabledByDefault="true"
+        <localInspection groupPath="Java" shortName="AssertThatSize" enabledByDefault="true" level="WARNING"
-                         level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatSizeInspection"/>
 
-        <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true"
+        <localInspection groupPath="Java" shortName="AssertThatBinaryExpression" enabledByDefault="true" level="WARNING"
-                         level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatStringExpression" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringExpressionInspection"/>
+
+        <localInspection groupPath="Java" shortName="JoinAssertThatStatements" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinAssertThatStatementsInspection"/>
+        <localInspection groupPath="Java" shortName="AssumeThatInsteadOfReturnInspection" 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="JUnitAssertToAssertJ" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.JUnitAssertToAssertJInspection"/>
     </extensions>
 

src/main/resources/META-INF/pluginIcon.svg

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Foo" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px"
+     width="226.77px" height="226.77px" viewBox="0 0 226.77 226.77" enable-background="new 0 0 226.77 226.77" xml:space="preserve">
+<g>
+	<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="44.1792" y1="72.1201" x2="184.0214" y2="-8.6178">
+		<stop offset="0.2408" style="stop-color:#FFFFFF"/>
+        <stop offset="1" style="stop-color:#000000"/>
+	</linearGradient>
+    <path fill="url(#SVGID_1_)" stroke="#231F20" stroke-miterlimit="10" d="M210.1,36.551L122.5,7.75
+		C18.101,26.951,18.101,26.951,18.101,26.951L94.3,55.75L210.1,36.551"/>
+    <linearGradient id="SVGID_2_" gradientUnits="userSpaceOnUse" x1="-12.9795" y1="80.7827" x2="127.5331" y2="161.9077">
+		<stop offset="0.1763" style="stop-color:#FFFFFF"/>
+        <stop offset="0.2617" style="stop-color:#F9F9F9"/>
+        <stop offset="0.3726" style="stop-color:#E9E9E9"/>
+        <stop offset="0.4976" style="stop-color:#CFCECE"/>
+        <stop offset="0.6329" style="stop-color:#AAA9A9"/>
+        <stop offset="0.7765" style="stop-color:#7B7979"/>
+        <stop offset="0.9248" style="stop-color:#433F40"/>
+        <stop offset="1" style="stop-color:#231F20"/>
+	</linearGradient>
+    <polygon fill="url(#SVGID_2_)" stroke="#231F20" stroke-miterlimit="10" points="17.5,185.35 94.6,218.95 94.3,55.75
+		18.101,26.951 	"/>
+    <linearGradient id="SVGID_3_" gradientUnits="userSpaceOnUse" x1="88.6709" y1="122.3887" x2="214.4668" y2="133.3944">
+		<stop offset="0.1216" style="stop-color:#FFFFFF"/>
+        <stop offset="1" style="stop-color:#2B2728"/>
+        <stop offset="1" style="stop-color:#231F20"/>
+	</linearGradient>
+    <polygon fill="url(#SVGID_3_)" stroke="#231F20" stroke-miterlimit="10" points="94.5,55.75 94.5,56.35 94.5,55.75 95,219.25
+		209.5,190.15 209.5,36.65 	"/>
+</g>
+    <linearGradient id="SVGID_4_" gradientUnits="userSpaceOnUse" x1="51.6982" y1="79.75" x2="51.6982" y2="79.75">
+	<stop offset="0.1763" style="stop-color:#FFFFFF"/>
+        <stop offset="0.2617" style="stop-color:#F9F9F9"/>
+        <stop offset="0.3726" style="stop-color:#E9E9E9"/>
+        <stop offset="0.4976" style="stop-color:#CFCECE"/>
+        <stop offset="0.6329" style="stop-color:#AAA9A9"/>
+        <stop offset="0.7765" style="stop-color:#7B7979"/>
+        <stop offset="0.9248" style="stop-color:#433F40"/>
+        <stop offset="1" style="stop-color:#231F20"/>
+</linearGradient>
+    <path fill="url(#SVGID_4_)" stroke="#231F20" stroke-miterlimit="10" d="M51.699,79.75"/>
+    <path fill="#231F20" stroke="#231F20" stroke-miterlimit="10" d="M171.307,117.313c0.267,13.237-6.324,27.028-14.723,30.805
+	s-15.423-3.893-15.69-17.132c-0.267-13.236,6.323-27.029,14.723-30.805C164.015,96.405,171.039,104.076,171.307,117.313z"/>
+    <polygon fill="#39B54A" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" points="175.6,143.05 176.2,99.7 183.55,97
+	191.95,132.25 193.3,92.95 198.1,91.45 196.3,136.6 188.95,138.85 180.85,103.45 180.7,141.55 "/>
+    <path fill="#009444" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" d="M109.9,113.65c1.8,0,25.35-5.25,25.35-5.25
+	l1.2,38.7l-6.9,7.5l-11.25,3.15l-5.55-5.25l-1.5-6.75l5.1-1.35l1.95,6.6l3.45,1.05l5.25-1.95l4.5-4.35l-0.6-30.9l-19.2,4.051
+	L109.9,113.65z"/>
+    <path fill="#00A79D" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" d="M46.15,102.4c0-0.45-2.85-6.45-2.85-6.45
+	l-6.75-3l-5.7,0.15l-1.916,1.667L26.2,97.15l-2.4,5.1l-0.9,8.55l-0.75,12.15l0.3,12.3l2.85,8.25l8.85,4.95l7.2,0.45l5.55-5.551
+	l1.8-3.6l-3.15-4.05l-2.85,2.25l-3,3.6l-5.4,1.351l-4.2-1.95l-2.4-5.7l-1.05-5.85l0.6-10.051L28,110.8l0.9-6.75l1.95-3.75l6-0.75
+	l3.45,1.95l2.25,2.7l1.95,1.5L46.15,102.4z"/>
+    <polygon fill="#2BB673" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" points="52.9,151.9 70.4,101.549
+	76.1,104.249 85.2,164.05 79.1,160.85 73.1,111.05 71.4,110.149 67,127.15 73.7,129.749 74.5,136.351 65.5,132.7 58.1,154.049 "/>
+</svg>

src/main/resources/inspectionDescriptions/AssertThatBinaryExpression.html

@@ -0,0 +1,11 @@
+<html>
+<body>
+Turns a binary expression in the kind of assertThat(actual &lt;operator&gt; expected) with .isTrue()/isFalse()/isEqualTo()/isNotEqualTo()
+into assertThat(actual).is&lt;operator&gt;(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>
+</html>

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/AssertThatGuavaOptional.html

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

src/main/resources/inspectionDescriptions/AssertThatInstanceOf.html

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

src/main/resources/inspectionDescriptions/AssertThatInvertedBooleanCondition.html

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

src/main/resources/inspectionDescriptions/AssertThatJava8Optional.html

@@ -0,0 +1,7 @@
+<html>
+<body>
+Looks at expected and actual expression being of Java 8 Optional type and whether the statement effectively tries to assert the
+presence, absence or content and then replaces the statement by isPresent(), isNotPresent(), contains(), or containsSame().
+<!-- tooltip end -->
+</body>
+</html>

src/main/resources/inspectionDescriptions/AssertThatObjectIsNotNull.html

@@ -1,6 +0,0 @@
-<html>
-<body>
-Turns assertThat(object).isNotEqualTo(null) into assertThat(object).isNotNull().
-<!-- tooltip end -->
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatObjectIsNull.html

@@ -1,6 +0,0 @@
-<html>
-<body>
-Turns assertThat(object).isEqualTo(null) into assertThat(object).isNull().
-<!-- tooltip end -->
-</body>
-</html>

src/main/resources/inspectionDescriptions/AssertThatObjectIsNullOrNotNull.html

@@ -0,0 +1,6 @@
+<html>
+<body>
+Turns assertThat(object).is(Not)EqualTo(null) into assertThat(object).is(Not)Null().
+<!-- tooltip end -->
+</body>
+</html>

src/main/resources/inspectionDescriptions/AssertThatSize.html

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

src/main/resources/inspectionDescriptions/AssertThatStringExpression.html

@@ -0,0 +1,7 @@
+<html>
+<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().
+</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/JUnitAssertToAssertJ.html

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

src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html

@@ -0,0 +1,7 @@
+<html>
+<body>
+Joins consecutive assertThat() statements with the same actual expression together.
+<!-- tooltip end -->
+<br>Retains comments during operation. If the AssertThat()-Statement contains .extracting() methods, they will not be joined.
+</body>
+</html>

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

@@ -131,7 +131,6 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
                 VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
                 myFixture.allowTreeAccessForFile(jarFile);
                 PsiTestUtil.addLibrary(
-                        myFixture.getModule(),
                         model,
                         jarPath.getFileName().toString().replace(".jar", ""),
                         jarPath.getParent().toString(),

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

@@ -1,188 +0,0 @@
-package de.platon42.intellij.playground;
-
-import org.assertj.core.api.ListAssert;
-import org.assertj.core.data.Offset;
-
-import java.util.ArrayList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.data.Offset.offset;
-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>()).hasSameSizeAs(new ArrayList<>());
-        assertThat(new Long[1]).as("etc").hasSameSizeAs(new Long[2]);
-    }
-
-    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 stringIsEmpty() {
-        String foo = "bar";
-        assertThat(foo).isEqualTo("");
-        assertThat(foo).hasSize(0);
-    }
-
-    private void junitAssertions() {
-        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);
-        assertEquals(1.0, 2.0, 0.1);
-        assertEquals("equals", 1.0, 2.0);
-        assertEquals("equals", 1.0, 2.0, 0.1);
-        assertEquals(1.0f, 2.0f);
-        assertEquals(1.0f, 2.0f, 0.1f);
-        assertEquals("equals", 1.0f, 2.0f);
-        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));
-    }
-
-}

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

@@ -11,16 +11,20 @@ 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
+    // 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)
 
@@ -60,8 +64,15 @@ abstract class AbstractCajonTest {
     }
 
     protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
-        val quickfixes = myFixture.getAllQuickFixes().filter { it.familyName.matches(regex) }
+        val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
-        assertThat(quickfixes).hasSize(expectedFixes)
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
         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

@@ -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 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()"), 149)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 13)
+            myFixture.checkResultByFile("BinaryExpressionAfter.java")
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+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 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()"), 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/AssertThatBooleanIsTrueOrFalseInspectionTest.kt

@@ -1,21 +0,0 @@
-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 AssertThatBooleanIsTrueOrFalseInspectionTest : AbstractCajonTest() {
-
-    @Test
-    @TestDataSubPath("inspections/BooleanIsTrueOrFalse")
-    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
-            myFixture.enableInspections(AssertThatBooleanIsTrueOrFalseInspection::class.java)
-            myFixture.configureByFile("BooleanIsTrueOrFalseBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace is.*"), 17)
-            myFixture.checkResultByFile("BooleanIsTrueOrFalseAfter.java")
-        }
-    }
-}

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

@@ -14,7 +14,7 @@ internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
             myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace hasSize.*"), 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

@@ -0,0 +1,52 @@
+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)
+@TestDataSubPath("inspections/GuavaOptional")
+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("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 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 .*"), 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 .*"), 3)
+            executeQuickFixes(myFixture, Regex("Remove .*"), 3)
+            myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
+        }
+    }
+}

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.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 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("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

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

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.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 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("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 get() of actual expression and use assertThat().contains() instead"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+            myFixture.checkResultByFile("Java8OptionalAfter.java")
+        }
+    }
+}

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

@@ -1,21 +0,0 @@
-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 AssertThatObjectIsNotNullInspectionTest : AbstractCajonTest() {
-
-    @Test
-    @TestDataSubPath("inspections/ObjectIsNotNull")
-    internal fun assertThat_with_isNotEqualTo_null_can_use_isNotNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
-            myFixture.enableInspections(AssertThatObjectIsNotNullInspection::class.java)
-            myFixture.configureByFile("ObjectIsNotNullBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 3)
-            myFixture.checkResultByFile("ObjectIsNotNullAfter.java")
-        }
-    }
-}

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

@@ -6,16 +6,17 @@ import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test
 
-internal class AssertThatObjectIsNullInspectionTest : AbstractCajonTest() {
+internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/ObjectIsNull")
+    @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
     internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         runTest {
-            myFixture.enableInspections(AssertThatObjectIsNullInspection::class.java)
+            myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
-            myFixture.configureByFile("ObjectIsNullBefore.java")
+            myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 3)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
-            myFixture.checkResultByFile("ObjectIsNullAfter.java")
+            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,18 +4,35 @@ 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() {
 
     @Test
-    @TestDataSubPath("inspections/AssertThatSize")
+    @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("AssertThatSizeBefore.java")
+            myFixture.configureByFile("SizeBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 20)
+            assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
-            myFixture.checkResultByFile("AssertThatSizeAfter.java")
+
+            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)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 12)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 8)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 4)
+            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()"), 14)
+            myFixture.checkResultByFile("SizeAfter.java")
         }
     }
 }

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

@@ -0,0 +1,34 @@
+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 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 actual expression and use assertThat().isEmpty() instead"), 2)
+            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"), 2)
+            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() {
@@ -14,7 +16,13 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
             myFixture.configureByFile("StringIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 4)
+            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,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(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) {
+        runTest {
+            myFixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
+            myFixture.configureByFile("AssumeThatBefore.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 4)
+            myFixture.checkResultByFile("AssumeThatAfter.java")
+        }
+    }
+}

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

@@ -18,7 +18,7 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
             myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 38)
+            executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 38)
             myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
         }
     }

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

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

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

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

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/AssertThatSize/AssertThatSizeAfter.java

@@ -1,35 +0,0 @@
-import java.util.ArrayList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class assertThatSize {
-
-    private void assertThatSize() {
-        ArrayList<String> list = new ArrayList<>();
-        ArrayList<String> otherList = new ArrayList<>();
-        long[] array = new long[5];
-        long[] otherArray = new long[4];
-
-        assertThat(list).isEmpty();
-        assertThat(list).isEmpty();
-        assertThat(list).isNotEmpty();
-        assertThat(list).as("hi").isNotEmpty();
-        assertThat(list).isNotEmpty();
-        assertThat(list).isEmpty();
-        assertThat(list).isEmpty();
-        assertThat(list).hasSameSizeAs(otherList);
-        assertThat(list).hasSameSizeAs(array);
-        assertThat(list).hasSize(1);
-
-        assertThat(array).isEmpty();
-        assertThat(array).isEmpty();
-        assertThat(array).isNotEmpty();
-        assertThat(array).as("hi").isNotEmpty();
-        assertThat(array).isNotEmpty();
-        assertThat(array).isEmpty();
-        assertThat(array).isEmpty();
-        assertThat(array).hasSameSizeAs(list);
-        assertThat(array).hasSameSizeAs(otherArray);
-        assertThat(array).hasSize(1);
-    }
-}

src/test/resources/inspections/AssertThatSize/AssertThatSizeBefore.java

@@ -1,35 +0,0 @@
-import java.util.ArrayList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class assertThatSize {
-
-    private void assertThatSize() {
-        ArrayList<String> list = new ArrayList<>();
-        ArrayList<String> otherList = new ArrayList<>();
-        long[] array = new long[5];
-        long[] otherArray = new long[4];
-
-        assertThat(list.size()).isEqualTo(0);
-        assertThat(list.size()).isZero();
-        assertThat(list.size()).isNotZero();
-        assertThat(list.size()).as("hi").isGreaterThan(0);
-        assertThat(list.size()).isGreaterThanOrEqualTo(1);
-        assertThat(list.size()).isLessThan(1);
-        assertThat(list.size()).isLessThanOrEqualTo(0);
-        assertThat(list.size()).isEqualTo(otherList.size());
-        assertThat(list.size()).isEqualTo(array.length);
-        assertThat(list.size()).isEqualTo(1);
-
-        assertThat(array.length).isEqualTo(0);
-        assertThat(array.length).isZero();
-        assertThat(array.length).isNotZero();
-        assertThat(array.length).as("hi").isGreaterThan(0);
-        assertThat(array.length).isGreaterThanOrEqualTo(1);
-        assertThat(array.length).isLessThan(1);
-        assertThat(array.length).isLessThanOrEqualTo(0);
-        assertThat(array.length).isEqualTo(list.size());
-        assertThat(array.length).isEqualTo(otherArray.length);
-        assertThat(array.length).isEqualTo(1);
-    }
-}

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

@@ -0,0 +1,151 @@
+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.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,156 @@
+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.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

@@ -0,0 +1,199 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BinaryExpression {
+
+    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).as("doh!").isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(1);
+        assertThat(primAct).isEqualTo(1);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(1);
+        assertThat(primAct).isNotEqualTo(1);
+
+        assertThat(primAct).as("doh!").isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(1);
+        assertThat(primAct).isNotEqualTo(1);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(1);
+        assertThat(primAct).isEqualTo(1);
+
+        assertThat(primAct).as("doh!").isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(1);
+        assertThat(primAct).isGreaterThan(1);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+
+        assertThat(primAct).as("doh!").isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(1);
+        assertThat(primAct).isLessThan(1);
+
+        assertThat(primAct).as("doh!").isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(1);
+        assertThat(primAct).isLessThan(1);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+
+        assertThat(primAct).as("doh!").isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(1);
+        assertThat(primAct).isGreaterThan(1);
+
+        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(1);
+        assertThat(numberObjAct).isEqualTo(1);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(1);
+        assertThat(numberObjAct).isNotEqualTo(1);
+
+        assertThat(numberObjAct).as("doh!").isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(1);
+        assertThat(numberObjAct).isNotEqualTo(1);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(1);
+        assertThat(numberObjAct).isEqualTo(1);
+
+        assertThat(numberObjAct).as("doh!").isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(1);
+        assertThat(numberObjAct).isGreaterThan(1);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+
+        assertThat(numberObjAct).as("doh!").isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(1);
+        assertThat(numberObjAct).isLessThan(1);
+
+        assertThat(numberObjAct).as("doh!").isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(1);
+        assertThat(numberObjAct).isLessThan(1);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+
+        assertThat(numberObjAct).as("doh!").isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(1);
+        assertThat(numberObjAct).isGreaterThan(1);
+
+        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+
+        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).as("doh!").isEqualTo(stringExp);
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(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).as("doh!").isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+
+        assertThat(stringAct).as("doh!").isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+
+        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).as("doh!").isEqualTo(numberObjExp).isEqualTo(numberObjExp);
+    }
+}

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

@@ -0,0 +1,199 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BinaryExpression {
+
+    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).as("doh!").isTrue();
+        assertThat(primAct == primExp).isEqualTo(true);
+        assertThat(primAct == primExp).isEqualTo(Boolean.TRUE);
+        assertThat(primAct == primExp).isNotEqualTo(false);
+        assertThat(primAct == primExp).isNotEqualTo(Boolean.FALSE);
+        assertThat(primAct == 1).isTrue();
+        assertThat(1 == primAct).isTrue();
+        assertThat(primAct == primExp).isFalse();
+        assertThat(primAct == primExp).isEqualTo(false);
+        assertThat(primAct == primExp).isEqualTo(Boolean.FALSE);
+        assertThat(primAct == primExp).isNotEqualTo(true);
+        assertThat(primAct == primExp).isNotEqualTo(Boolean.TRUE);
+        assertThat(primAct == 1).isFalse();
+        assertThat(1 == primAct).isFalse();
+
+        assertThat(primAct != primExp).as("doh!").isTrue();
+        assertThat(primAct != primExp).isEqualTo(true);
+        assertThat(primAct != primExp).isNotEqualTo(false);
+        assertThat(primAct != 1).isTrue();
+        assertThat(1 != primAct).isTrue();
+        assertThat(primAct != primExp).isFalse();
+        assertThat(primAct != primExp).isEqualTo(false);
+        assertThat(primAct != primExp).isNotEqualTo(true);
+        assertThat(primAct != 1).isFalse();
+        assertThat(1 != primAct).isFalse();
+
+        assertThat(primAct > primExp).as("doh!").isTrue();
+        assertThat(primAct > primExp).isEqualTo(true);
+        assertThat(primAct > primExp).isNotEqualTo(false);
+        assertThat(primAct > 1).isTrue();
+        assertThat(1 < primAct).isTrue();
+        assertThat(primAct > primExp).isFalse();
+        assertThat(primAct > primExp).isEqualTo(false);
+        assertThat(primAct > primExp).isNotEqualTo(true);
+        assertThat(primAct > 1).isFalse();
+        assertThat(1 < primAct).isFalse();
+
+        assertThat(primAct >= primExp).as("doh!").isTrue();
+        assertThat(primAct >= primExp).isEqualTo(true);
+        assertThat(primAct >= primExp).isNotEqualTo(false);
+        assertThat(primAct >= 1).isTrue();
+        assertThat(1 <= primAct).isTrue();
+        assertThat(primAct >= primExp).isFalse();
+        assertThat(primAct >= primExp).isEqualTo(false);
+        assertThat(primAct >= primExp).isNotEqualTo(true);
+        assertThat(primAct >= 1).isFalse();
+        assertThat(1 <= primAct).isFalse();
+
+        assertThat(primAct < primExp).as("doh!").isTrue();
+        assertThat(primAct < primExp).isEqualTo(true);
+        assertThat(primAct < primExp).isNotEqualTo(false);
+        assertThat(primAct < 1).isTrue();
+        assertThat(1 > primAct).isTrue();
+        assertThat(primAct < primExp).isFalse();
+        assertThat(primAct < primExp).isEqualTo(false);
+        assertThat(primAct < primExp).isNotEqualTo(true);
+        assertThat(primAct < 1).isFalse();
+        assertThat(1 > primAct).isFalse();
+
+        assertThat(primAct <= primExp).as("doh!").isTrue();
+        assertThat(primAct <= primExp).isEqualTo(true);
+        assertThat(primAct <= primExp).isNotEqualTo(false);
+        assertThat(primAct <= 1).isTrue();
+        assertThat(1 >= primAct).isTrue();
+        assertThat(primAct <= primExp).isFalse();
+        assertThat(primAct <= primExp).isEqualTo(false);
+        assertThat(primAct <= primExp).isNotEqualTo(true);
+        assertThat(primAct <= 1).isFalse();
+        assertThat(1 >= primAct).isFalse();
+
+        assertThat(numberObjAct == numberObjExp).as("doh!").isTrue();
+        assertThat(numberObjAct == numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct == numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct == 1).isTrue();
+        assertThat(1 == numberObjAct).isTrue();
+        assertThat(numberObjAct == numberObjExp).isFalse();
+        assertThat(numberObjAct == numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct == numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct == 1).isFalse();
+        assertThat(1 == numberObjAct).isFalse();
+
+        assertThat(numberObjAct != numberObjExp).as("doh!").isTrue();
+        assertThat(numberObjAct != numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct != numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct != 1).isTrue();
+        assertThat(1 != numberObjAct).isTrue();
+        assertThat(numberObjAct != numberObjExp).isFalse();
+        assertThat(numberObjAct != numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct != numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct != 1).isFalse();
+        assertThat(1 != numberObjAct).isFalse();
+
+        assertThat(numberObjAct > numberObjExp).as("doh!").isTrue();
+        assertThat(numberObjAct > numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct > 1).isTrue();
+        assertThat(1 < numberObjAct).isTrue();
+        assertThat(numberObjAct > numberObjExp).isFalse();
+        assertThat(numberObjAct > numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct > numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct > 1).isFalse();
+        assertThat(1 < numberObjAct).isFalse();
+
+        assertThat(numberObjAct >= numberObjExp).as("doh!").isTrue();
+        assertThat(numberObjAct >= numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct >= numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct >= 1).isTrue();
+        assertThat(1 <= numberObjAct).isTrue();
+        assertThat(numberObjAct >= numberObjExp).isFalse();
+        assertThat(numberObjAct >= numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct >= numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct >= 1).isFalse();
+        assertThat(1 <= numberObjAct).isFalse();
+
+        assertThat(numberObjAct < numberObjExp).as("doh!").isTrue();
+        assertThat(numberObjAct < numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct < numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct < 1).isTrue();
+        assertThat(1 > numberObjAct).isTrue();
+        assertThat(numberObjAct < numberObjExp).isFalse();
+        assertThat(numberObjAct < numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct < numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct < 1).isFalse();
+        assertThat(1 > numberObjAct).isFalse();
+
+        assertThat(numberObjAct <= numberObjExp).as("doh!").isTrue();
+        assertThat(numberObjAct <= numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct <= 1).isTrue();
+        assertThat(1 >= numberObjAct).isTrue();
+        assertThat(numberObjAct <= numberObjExp).isFalse();
+        assertThat(numberObjAct <= numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct <= 1).isFalse();
+        assertThat(1 >= numberObjAct).isFalse();
+
+        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).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)).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).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).as("doh!").isTrue();
+        assertThat(stringAct == null).isEqualTo(true);
+        assertThat(stringAct == null).isNotEqualTo(false);
+        assertThat(stringAct == null).isFalse();
+        assertThat(stringAct == null).isEqualTo(false);
+        assertThat(stringAct == null).isNotEqualTo(true);
+
+        assertThat(null == stringAct).as("doh!").isTrue();
+        assertThat(null == stringAct).isEqualTo(true);
+        assertThat(null == stringAct).isNotEqualTo(false);
+        assertThat(null == stringAct).isFalse();
+        assertThat(null == stringAct).isEqualTo(false);
+        assertThat(null == stringAct).isNotEqualTo(true);
+
+        assertThat(null == null).isTrue();
+        assertThat(!false).isTrue();
+
+        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);
+    }
+}

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

@@ -1,12 +1,12 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class BooleanIsTrueOrFalse {
+public class BooleanCondition {
 
-    private void booleanIsTrueOrFalse() {
+    private void 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 +15,7 @@ public class BooleanIsTrueOrFalse {
         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 +28,7 @@ public class BooleanIsTrueOrFalse {
         assertThat(object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
 
         assertThat("").isEqualTo(Boolean.TRUE);
+
+        assertThat(primitive).isTrue().as("foo").isTrue().as("bar").isTrue().isFalse();
     }
 }

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

@@ -1,12 +1,12 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class BooleanIsTrueOrFalse {
+public class BooleanCondition {
 
-    private void booleanIsTrueOrFalse() {
+    private void 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 +15,7 @@ public class BooleanIsTrueOrFalse {
         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 +28,7 @@ public class BooleanIsTrueOrFalse {
         assertThat(object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
 
         assertThat("").isEqualTo(Boolean.TRUE);
+
+        assertThat(primitive).isEqualTo(Boolean.TRUE).as("foo").isEqualTo(true).as("bar").isTrue().isFalse();
     }
 }

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

@@ -14,5 +14,7 @@ public class EnumerableIsEmpty {
         assertThat(new StringBuilder()).as("bar").hasSize(1);
         assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
         assertThat(new Long[1]).as("etc").hasSize(1);
+
+        assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").isEmpty();
     }
 }

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

@@ -14,5 +14,7 @@ public class EnumerableIsEmpty {
         assertThat(new StringBuilder()).as("bar").hasSize(1);
         assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
         assertThat(new Long[1]).as("etc").hasSize(1);
+
+        assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").hasSize(0);
     }
 }

src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java

@@ -0,0 +1,55 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class GuavaOptional {
+
+    private void guavaOptional() {
+        Optional<String> opt = Optional.absent();
+
+        assertThat(opt).as("foo").isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt).contains("foo");
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt).isAbsent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt).contains("foo");
+        org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt).as("foo").isAbsent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt).contains("foo");
+        org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt).as("foo").isAbsent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").isPresent().as("bar").isPresent();
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.FALSE);
+    }
+}

src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java

@@ -0,0 +1,55 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class GuavaOptional {
+
+    private void guavaOptional() {
+        Optional<String> opt = Optional.absent();
+
+        assertThat(opt.isPresent()).as("foo").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()).as("foo").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()).as("foo").isEqualTo("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).as("foo").isEqualTo(Optional.of("foo"));
+        assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt).isEqualTo(Optional.absent());
+        assertThat(opt).isNotEqualTo(Optional.absent());
+
+        org.assertj.guava.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.of("foo"));
+        org.assertj.guava.api.Assertions.assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
+        org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        org.assertj.guava.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.absent());
+        org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.absent());
+
+        org.assertj.core.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.of("foo"));
+        org.assertj.core.api.Assertions.assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
+        org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        org.assertj.core.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.absent());
+        org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.absent());
+
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.FALSE);
+    }
+}

src/test/resources/inspections/GuavaOptional/WithoutPriorGuavaImportAfter.java

@@ -0,0 +1,27 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class GuavaOptional {
+
+    private void guavaOptional() {
+        Optional<String> opt = Optional.absent();
+
+        assertThat(opt).contains("foo");
+        assertThat(opt).contains("foo");
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt).isPresent();
+        assertThat(opt).isAbsent();
+
+        assertThat(opt).contains("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).isAbsent();
+        assertThat(opt).isPresent();
+    }
+}

src/test/resources/inspections/GuavaOptional/WithoutPriorGuavaImportBefore.java

@@ -0,0 +1,26 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class GuavaOptional {
+
+    private void guavaOptional() {
+        Optional<String> opt = Optional.absent();
+
+        assertThat(opt).isEqualTo(Optional.of("foo"));
+        assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt.isPresent()).isTrue();
+        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(Optional.absent());
+        assertThat(opt).isNotEqualTo(Optional.absent());
+    }
+}

src/test/resources/inspections/InstanceOf/InstanceOfAfter.java

@@ -0,0 +1,25 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class InstanceOf {
+
+    private void instanceOf() {
+        Boolean object = Boolean.TRUE;
+
+        assertThat(object).as("foo").isInstanceOf(Boolean.class);
+        assertThat(object).isInstanceOf(Boolean.class);
+        assertThat(object).isInstanceOf(Boolean.class);
+        assertThat(object).isInstanceOf(Boolean.class);
+        assertThat(object).isInstanceOf(Boolean.class);
+
+        assertThat(object).as("foo").isNotInstanceOf(Boolean.class);
+        assertThat(object).isNotInstanceOf(Boolean.class);
+        assertThat(object).isNotInstanceOf(Boolean.class);
+        assertThat(object).isNotInstanceOf(Boolean.class);
+        assertThat(object).isNotInstanceOf(Boolean.class);
+
+        assertThat(object).as("nah").isNotInstanceOf(Boolean.class);
+
+        assertThat(object).as("foo").isInstanceOf(Boolean.class).as("bar").isInstanceOf(Boolean.class);
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE).as("bar").isEqualTo(false);
+    }
+}

src/test/resources/inspections/InstanceOf/InstanceOfBefore.java

@@ -0,0 +1,25 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class InstanceOf {
+
+    private void instanceOf() {
+        Boolean object = Boolean.TRUE;
+
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE);
+        assertThat(object instanceof Boolean).isEqualTo(true);
+        assertThat(object instanceof Boolean).isNotEqualTo(Boolean.FALSE);
+        assertThat(object instanceof Boolean).isNotEqualTo(false);
+        assertThat(object instanceof Boolean).isTrue();
+
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.FALSE);
+        assertThat(object instanceof Boolean).isEqualTo(false);
+        assertThat(object instanceof Boolean).isNotEqualTo(Boolean.TRUE);
+        assertThat(object instanceof Boolean).isNotEqualTo(true);
+        assertThat(object instanceof Boolean).isFalse();
+
+        assertThat(((object)) instanceof Boolean).as("nah").isEqualTo(true && !true);
+
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE).as("bar").isEqualTo(true);
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE).as("bar").isEqualTo(false);
+    }
+}

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

@@ -0,0 +1,39 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class InvertedBooleanCondition {
+
+    private void invertedBooleanCondition() {
+        boolean primitive = false;
+        Boolean object = Boolean.TRUE;
+
+        assertThat(primitive).as("foo").isFalse();
+        assertThat(primitive).isFalse();
+        assertThat(primitive).isFalse();
+        assertThat(primitive).isFalse();
+        assertThat(primitive).isFalse();
+
+        assertThat(object).as("foo").isFalse();
+        assertThat(object).isFalse();
+        assertThat(object).isFalse();
+        assertThat(object).isFalse();
+        assertThat(object).isFalse();
+
+        assertThat(primitive).as("foo").isTrue();
+        assertThat(primitive).isTrue();
+        assertThat(primitive).isTrue();
+        assertThat(primitive).isTrue();
+        assertThat(primitive).isTrue();
+
+        assertThat(object).as("foo").isTrue();
+        assertThat(object).isTrue();
+        assertThat(object).isTrue();
+        assertThat(object).isTrue();
+        assertThat(object).isTrue();
+
+        assertThat(!((primitive))).as("nah").isTrue();
+        assertThat(!object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
+
+        assertThat(primitive).as("foo").isFalse().as("bar").isFalse();
+        assertThat(primitive).as("foo").isFalse().as("bar").isTrue();
+    }
+}

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

@@ -0,0 +1,39 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class InvertedBooleanCondition {
+
+    private void invertedBooleanCondition() {
+        boolean primitive = false;
+        Boolean object = Boolean.TRUE;
+
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE);
+        assertThat(!primitive).isEqualTo(true);
+        assertThat(!primitive).isNotEqualTo(Boolean.FALSE);
+        assertThat(!primitive).isNotEqualTo(false);
+        assertThat(!primitive).isTrue();
+
+        assertThat(!object).as("foo").isEqualTo(Boolean.TRUE);
+        assertThat(!object).isEqualTo(true);
+        assertThat(!object).isNotEqualTo(Boolean.FALSE);
+        assertThat(!object).isNotEqualTo(false);
+        assertThat(!object).isTrue();
+
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.FALSE);
+        assertThat(!primitive).isEqualTo(false);
+        assertThat(!primitive).isNotEqualTo(Boolean.TRUE);
+        assertThat(!primitive).isNotEqualTo(true);
+        assertThat(!primitive).isFalse();
+
+        assertThat(!object).as("foo").isEqualTo(Boolean.FALSE);
+        assertThat(!object).isEqualTo(false);
+        assertThat(!object).isNotEqualTo(Boolean.TRUE);
+        assertThat(!object).isNotEqualTo(true);
+        assertThat(!object).isFalse();
+
+        assertThat(!(((!((primitive)))))).as("nah").isEqualTo(true && !true);
+        assertThat(!object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
+
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(false);
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(true);
+    }
+}

src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java

@@ -0,0 +1,40 @@
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class Java8Optional {
+
+    private void java8Optional() {
+        Optional<String> opt = Optional.empty();
+
+        assertThat(opt).as("foo").isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).isNotPresent();
+        assertThat(opt).isNotPresent();
+        assertThat(opt).isNotPresent();
+        assertThat(opt).isNotPresent();
+        assertThat(opt).isNotPresent();
+
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt).containsSame("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt).contains("foo");
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.ofNullable("foo"));
+
+        assertThat(opt).as("foo").isNotPresent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").isPresent().as("bar").isPresent();
+        assertThat(opt.isPresent()).as("foo").isEqualTo(false).as("bar").isTrue();
+
+        assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
+    }
+}