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. Minor refactorings. Extended documentation.
Fix for incompatible method call regarding IDEA <2018.2.
2019-04-18 22:12:48 +02:00 · 2019-04-13 18:35:49 +02:00 · 2019-04-11 23:55:35 +02:00 · 2019-04-11 21:09:10 +02:00 · 2019-04-11 16:26:11 +02:00 · 2019-04-08 11:56:13 +02:00
77 changed files with 2740 additions and 492 deletions
@@ -17,7 +17,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,40 +26,63 @@ 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.

+## 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).
+
+You can toggle the various inspections in the Settings/Editor/Inspections in the AssertJ group.
+
 ## Implemented inspections

- AssertThatObjectIsNull
+- AssertThatObjectIsNullOrNotNull
  ```
  from: assertThat(object).isEqualTo(null);
    to: assertThat(object).isNull();
-  ```
- AssertThatObjectIsNotNull
-  ```
+
  from: assertThat(object).isNotEqualTo(null);  
    to: assertThat(object).isNotNull();
  ```
+  
 - AssertThatBooleanIsTrueOrFalse
  ```
  from: assertThat(booleanValue).isEqualTo(true/false/Boolean.TRUE/Boolean.FALSE);  
    to: assertThat(booleanValue).isTrue()/isFalse();
  ```
+  
 - AssertThatStringIsEmpty
  ```
  from: assertThat(charSequence/string).isEqualTo("");
  from: assertThat(charSequence/string).hasSize(0);
    to: assertThat(charSequence/string).isEmpty();
  ```
+  
 - AssertThatEnumerableIsEmpty
  ```
  from: assertThat(enumerable).hasSize(0);
    to: assertThat(enumerable).isEmpty();
  ```
+  
 - AssertThatSize
  ```
  from: assertThat(array.length).isEqualTo(0);
@@ -77,8 +100,68 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to
    to: assertThat(array).hasSameSizeAs(anotherArray);
  ```

+  with AssertJ 13.2.0 or higher
+
+  ```
+  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...

+- AssertThatBinaryExpressionIsTrueOrFalse
+  ```
+  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();
+  ```
+  ...and many, many more combinations (more than 150).
+
+- AssertThatJava8Optional
+  ```
+  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();
+  ```
+
 - JUnitAssertToAssertJ
  ```
  assertTrue(condition);
@@ -107,6 +190,108 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to
  assertArrayEquals(message, expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
  ```
  
+- AssertThatGuavaOptional
+  ```
+  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.
+
+### Implemented referencing
+
+  ```
+  .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.
+
+## 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 I 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).
+
 ## TODO
- AssertThatGuavaOptionalContains
- extraction with property names to lambda with Java 8
+- AssertThatNegatedBooleanExpression
+- AssertThatInstanceOf
+- AssertThatStringOps
+  ```
+  from: assertThat(string.contains(foobar)).isTrue();
+    to: assertThat(string).contains(foobar);
+  from: assertThat(string.startsWith(foobar)).isTrue();
+    to: assertThat(string).startsWith(foobar);
+  from: assertThat(string.endsWith(foobar)).isTrue();
+    to: assertThat(string).endsWith(foobar);
+  from: assertThat(string.equalsIgnoreCase(foobar)).isTrue();
+    to: assertThat(string).isEqualToIgnoringCase(foobar);
+  ```
+  Analogously with ```isFalse()```.
+  
+- AssumeInsteadOfReturn
+- 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
+
+## Changelog
+
+#### V0.5 (13-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.
@@ -1,11 +1,11 @@
 plugins {
    id 'java'
    id 'org.jetbrains.intellij' version '0.4.3'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.21'
+    id 'org.jetbrains.kotlin.jvm' version '1.3.30'
 }

 group 'de.platon42'
-version '0.2'
+version '0.5'

 repositories {
    mavenCentral()
@@ -18,12 +18,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,23 +33,37 @@ compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2018.3.4'
+    version '2019.1'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
    updateSinceUntilBuild false
 }

 patchPluginXml {
    changeNotes """
-      <h4>V0.2 (01-Apr-19)</h4>
+  <h4>V0.5 (18-Apr-19)</h4>
    <ul>
-      <li>Fixed descriptions and quick fix texts.
-      <li>Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.
+      <li>Fixed incompatibility with IDEA versions < 2018.2 (affected AssertThatSizeInspection). Minimal version is now 2017.3.
+      <li>Fixed missing Guava imports (if not already present) for AssertThatGuavaInspection. This was a major PITA to get right.
+      <li>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).
+      <li>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.
    </ul>
-      <h4>V0.1 (31-Mar-19)</h4>
+  <h4>V0.4 (11-Apr-19)</h4>
    <ul>
-      <li>Initial release.
+      <li>Reduced minimal supported IDEA version from 2018.2 to 2017.2.
+      <li>New inspection AssertThatJava8Optional that operates on Java 8 Optional objects and tries to use contains(), containsSame(), isPresent(), and isNotPresent() instead.
+      <li>New inspection AssertThatGuavaOptional that operates on Guava Optional objects and tries to use contains(), isPresent(), and isAbsent() instead.
+      <li>Added support in AssertThatBinaryExpressionIsTrueOrFalse for is(Not)EqualTo(Boolean.TRUE/FALSE).
    </ul>
-      """
+  <h4>V0.3 (07-Apr-19)</h4>
+    <ul>
+      <li>New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and equals() statements (more than 150 combinations) inside assertThat().
+      <li>Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
+      <li>Support for hasSizeLessThan(), hasSizeLessThanOrEqualTo(), hasSizeGreaterThanOrEqualTo(), and hasSizeGreaterThan() for AssertThatSizeInspection (with AssertJ >=13.2.0).
+      <li>Really fixed highlighting for JUnit conversion. Sorry.
+    </ul>
+"""
 }

 test {
@@ -0,0 +1,38 @@
+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 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"
+        @NonNls
+        const val GUAVA_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
+    }
+}
@@ -0,0 +1,47 @@
+package de.platon42.intellij.plugins.cajon
+
+import com.intellij.psi.*
+import com.intellij.psi.codeStyle.CodeStyleManager
+import com.intellij.psi.codeStyle.JavaCodeStyleManager
+import com.intellij.psi.util.PsiTreeUtil
+
+val PsiMethodCallExpression.qualifierExpression: PsiExpression get() = this.methodExpression.qualifierExpression!!
+val PsiMethodCallExpression.firstArg: PsiExpression get() = this.argumentList.expressions[0]!!
+
+fun PsiMethodCallExpression.replaceQualifier(qualifier: PsiElement) {
+    this.qualifierExpression.replace(qualifier)
+}
+
+fun PsiMethodCallExpression.replaceQualifierFromMethodCall(oldMethodCall: PsiMethodCallExpression) {
+    this.qualifierExpression.replace(oldMethodCall.qualifierExpression)
+}
+
+fun PsiElement.findOutmostMethodCall(): PsiMethodCallExpression? {
+    val statement = PsiTreeUtil.getParentOfType(this, PsiStatement::class.java) ?: return null
+    return PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java)
+}
+
+fun PsiMethodCallExpression.getArg(n: Int): PsiExpression = this.argumentList.expressions[n]
+
+fun <T> Boolean.map(forTrue: T, forFalse: T) = if (this) forTrue else forFalse
+
+fun PsiMethod.addAsStaticImport(context: PsiElement, vararg allowedClashes: String) {
+    val factory = JavaPsiFacade.getElementFactory(context.project)
+    val methodName = this.name
+    val containingClass = this.containingClass ?: return
+    val importList = (context.containingFile as PsiJavaFile).importList ?: return
+    val notImportedStatically = importList.importStaticStatements.none {
+        val targetClass = it.resolveTargetClass() ?: return@none false
+        ((it.referenceName == methodName) && !allowedClashes.contains(targetClass.qualifiedName))
+                || (it.isOnDemand && (targetClass == this.containingClass))
+    }
+    if (notImportedStatically) {
+        importList.add(factory.createImportStaticStatement(containingClass, methodName))
+    }
+}
+
+fun PsiElement.shortenAndReformat() {
+    val codeStyleManager = JavaCodeStyleManager.getInstance(project)
+    codeStyleManager.shortenClassReferences(this)
+    CodeStyleManager.getInstance(project).reformat(this)
+}
@@ -0,0 +1,35 @@
+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.siyeh.ig.callMatcher.CallMatcher
+
+val CORE_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
+
+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
+}
@@ -0,0 +1,79 @@
+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 AS = "as"
+        @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"
+        @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_EMPTY = "isEmpty"
+        @NonNls
+        const val IS_NOT_EMPTY = "isNotEmpty"
+        @NonNls
+        const val HAS_SIZE = "hasSize"
+        @NonNls
+        const val HAS_SIZE_LESS_THAN = "hasSizeLessThan"
+        @NonNls
+        const val HAS_SIZE_LESS_THAN_OR_EQUAL_TO = "hasSizeLessThanOrEqualTo"
+        @NonNls
+        const val HAS_SIZE_GREATER_THAN = "hasSizeGreaterThan"
+        @NonNls
+        const val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO = "hasSizeGreaterThanOrEqualTo"
+        @NonNls
+        const val HAS_SAME_SIZE_AS = "hasSameSizeAs"
+        @NonNls
+        const val CONTAINS = "contains"
+        @NonNls
+        const val CONTAINS_EXACTLY = "containsExactly"
+        @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"
+    }
+}
@@ -1,97 +1,149 @@
 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.psi.JavaPsiFacade
-import com.intellij.psi.PsiCapturedWildcardType
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.*
 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.GUAVA_ASSERTIONS_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_OPTIONAL_CLASSNAME
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.getArg
+import de.platon42.intellij.plugins.cajon.qualifierExpression
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
-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 REMOVE_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap actual expression and replace %s() with %s()"

-        @NonNls
-        const val ASSERTIONS_CLASSNAME = "org.assertj.core.api.Assertions"
+        val TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP = mapOf<IElementType, String>(
+            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
-        const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
-        @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_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
+        val TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS = mapOf<IElementType, String>(
+            JavaTokenType.EQEQ to MethodNames.IS_SAME_AS,
+            JavaTokenType.NE to MethodNames.IS_NOT_SAME_AS
+        )

-        @NonNls
-        const val ASSERT_THAT_METHOD = "assertThat"
-        @NonNls
-        const val IS_EQUAL_TO_METHOD = "isEqualTo"
-        @NonNls
-        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 SWAP_SIDE_OF_BINARY_OPERATOR = mapOf<IElementType, IElementType>(
+            JavaTokenType.GT to JavaTokenType.LT,
+            JavaTokenType.GE to JavaTokenType.LE,
+            JavaTokenType.LT to JavaTokenType.GT,
+            JavaTokenType.LE to JavaTokenType.GE
+        )

-        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 ASSERT_THAT_GUAVA_OPTIONAL = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterTypes(GUAVA_OPTIONAL_CLASSNAME)!!
+
+        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, 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(ABSTRACT_ASSERT_CLASSNAME, 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(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_SAME_AS)
+            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
+        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_SAME_AS)
+            .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 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 +151,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
    }

    protected fun checkAssertedType(expression: PsiMethodCallExpression, classname: String): Boolean {
-        var assertedType = expression.methodExpression.qualifierExpression?.type ?: return false
-        if (assertedType is PsiCapturedWildcardType) {
+        var assertedType = expression.qualifierExpression.type ?: return false
+        while (assertedType is PsiCapturedWildcardType) {
            assertedType = assertedType.upperBound
        }
        val assertedClass = PsiTypesUtil.getPsiClass(assertedType) ?: return false
@@ -109,8 +161,7 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
        return assertedClass.isEquivalentTo(expectedClass) || assertedClass.isInheritor(expectedClass, true)
    }

-    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) =
-        expression.resolveMethod()?.name?.plus("()")
+    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) = expression.resolveMethod()?.name

    protected fun registerSimplifyMethod(
        holder: ProblemsHolder,
@@ -120,17 +171,93 @@ 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(
-            expression,
-            message,
-            ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
-        )
+        val quickFix = ReplaceSimpleMethodCallQuickFix(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, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
+    }
+
+    private fun registerConciseMethod(
+        descriptionTemplate: String,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix,
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression
+    ) {
+        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)
+        holder.registerProblem(expression, message, quickfix)
+    }
+
+    protected fun registerRemoveExpectedOutmostMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
+    }
+
+    protected fun registerRemoveActualOutmostMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        registerConciseMethod(REMOVE_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
    }

    protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
-        if (argIndex >= expression.argumentList.expressionCount) return null
-        val valueExpression = expression.argumentList.expressions[argIndex] ?: return null
+        if (argIndex >= expression.argumentList.expressions.size) return null
+        val valueExpression = expression.getArg(argIndex)
        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
-        return constantEvaluationHelper.computeConstantExpression(valueExpression)
+        val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
+        if (value == null) {
+            val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
+            if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
+                return when (field.name) {
+                    "TRUE" -> true
+                    "FALSE" -> false
+                    else -> null
+                }
+            }
+        }
+        return value
+    }
+
+    protected fun getExpectedBooleanResult(expectedCallExpression: PsiMethodCallExpression): Boolean? {
+        val isTrue = IS_TRUE.test(expectedCallExpression)
+        val isFalse = IS_FALSE.test(expectedCallExpression)
+        if (isTrue || isFalse) {
+            return isTrue
+        } else {
+            val isEqualTo = IS_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
+            val isNotEqualTo = IS_NOT_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
+            if (isEqualTo || isNotEqualTo) {
+                val constValue = calculateConstantParameterValue(expectedCallExpression, 0) as? Boolean ?: return null
+                return isNotEqualTo xor constValue
+            }
+        }
+        return null
+    }
+
+    protected fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
+        val findClass =
+            JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
+                ?: return false
+        return findClass.allMethods.any { it.name == methodname }
    }
 }
@@ -9,7 +9,7 @@ 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"
+        const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with assertThat().%s()"

        @NonNls
        const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
@@ -38,6 +38,5 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
        return "AssertJ"
    }

-    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) =
-        expression.resolveMethod()?.name?.plus("()")
+    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) = expression.resolveMethod()?.name
 }
@@ -0,0 +1,96 @@
+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.MethodNames
+import de.platon42.intellij.plugins.cajon.MethodNames.Companion.IS_NOT_NULL
+import de.platon42.intellij.plugins.cajon.MethodNames.Companion.IS_NULL
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
+import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.SplitEqualsExpressionMethodCallQuickFix
+
+class AssertThatBinaryExpressionIsTrueOrFalseInspection : 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 visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
+                    return
+                }
+
+                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
+                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+
+                val assertThatArgument = expression.firstArg
+                if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
+                    val replacementMethod = if (expectedResult) MethodNames.IS_EQUAL_TO else MethodNames.IS_NOT_EQUAL_TO
+                    registerSplitMethod(holder, expression, "${MethodNames.EQUALS}()", replacementMethod, ::SplitEqualsExpressionMethodCallQuickFix)
+                    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 = if (expectedResult) IS_NULL else IS_NOT_NULL
+                    registerSplitMethod(holder, expression, "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(expression.project).constantEvaluationHelper
+                val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
+
+                val tokenType = binaryExpression.operationSign.tokenType
+                    .let {
+                        if (swapExpectedAndActual) SWAP_SIDE_OF_BINARY_OPERATOR.getOrDefault(it, it) else it
+                    }
+                    .let {
+                        if (expectedResult) it else INVERT_BINARY_OPERATOR.getOrDefault(it, it)
+                    } ?: return
+                val mappingToUse =
+                    (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
+                val replacementMethod = mappingToUse[tokenType] ?: return
+
+                registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                    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)
+            }
+        }
+    }
+}
@@ -1,8 +1,14 @@
 package de.platon42.intellij.plugins.cajon.inspections

 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.*
+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.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map

 class AssertThatBooleanIsTrueOrFalseInspection : AbstractAssertJInspection() {

@@ -16,36 +22,25 @@ class AssertThatBooleanIsTrueOrFalseInspection : AbstractAssertJInspection() {
        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)) {
+                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 equalToExpression = expression.argumentList.expressions[0] ?: return
-                if (!TypeConversionUtil.isBooleanType(equalToExpression.type)) {
+                val expectedExpression = expression.firstArg
+                if (!TypeConversionUtil.isBooleanType(expectedExpression.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 expectedResult = calculateConstantParameterValue(expression, 0) as? Boolean ?: return
+                val flippedBooleanTest = matchingCalls.drop(2).any { it }

-                val replacementMethod = if (expectedResult xor flippedBooleanTest) "isTrue()" else "isFalse()"
+                val replacementMethod = (expectedResult xor flippedBooleanTest).map(MethodNames.IS_TRUE, MethodNames.IS_FALSE)
                registerSimplifyMethod(holder, expression, replacementMethod)
            }
        }
@@ -4,6 +4,7 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.MethodNames

 class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {

@@ -17,14 +18,13 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
        return object : JavaElementVisitor() {
            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                super.visitMethodCallExpression(expression)
-                val hasSize = HAS_SIZE.test(expression)
-                if (!hasSize) {
+                if (!HAS_SIZE.test(expression)) {
                    return
                }

                val value = calculateConstantParameterValue(expression, 0) ?: return
                if (value == 0) {
-                    registerSimplifyMethod(holder, expression, "isEmpty()")
+                    registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                }
            }
        }
@@ -0,0 +1,110 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.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)"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                JavaPsiFacade.getInstance(expression.project)
+                    .findClass(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                val assertThatGuava = ASSERT_THAT_GUAVA_OPTIONAL.test(expression)
+                if (!(ASSERT_THAT_ANY.test(expression) || assertThatGuava)) {
+                    return
+                }
+                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
+
+                val isEqualTo = IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
+                val isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
+                if (assertThatGuava) {
+                    if (isEqualTo) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
+                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS, ::RemoveExpectedOutmostMethodCallQuickFix)
+                        } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_ABSENT)
+                        }
+                    } else if (isNotEqualTo) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
+                        }
+                    }
+                } else {
+                    // we're not calling an assertThat() from Guava, but a core-AssertJ one!
+                    // We need to replace that by the Guava one, if we want to apply a formally correct fix.
+                    val actualExpression = expression.firstArg as? PsiMethodCallExpression
+                    if (actualExpression != null) {
+                        if (GUAVA_OPTIONAL_GET.test(actualExpression) && isEqualTo) {
+                            registerRemoveActualOutmostForGuavaMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS)
+                        } else if (GUAVA_OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                            val expectedPresence = getExpectedBooleanResult(expectedCallExpression) ?: return
+                            val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_ABSENT)
+                            registerRemoveActualOutmostForGuavaMethod(holder, expression, expectedCallExpression, replacementMethod, noExpectedExpression = true)
+                        }
+                    }
+                    if (isEqualTo) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
+                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS) { desc, method ->
+                                QuickFixWithPostfixDelegate(
+                                    RemoveExpectedOutmostMethodCallQuickFix(desc, method),
+                                    ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                                )
+                            }
+                        } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyForGuavaMethod(holder, expectedCallExpression, MethodNames.IS_ABSENT)
+                        }
+                    } else if (isNotEqualTo) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                            registerSimplifyForGuavaMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun registerRemoveActualOutmostForGuavaMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        noExpectedExpression: Boolean = false
+    ) {
+        registerRemoveActualOutmostMethod(holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
+            QuickFixWithPostfixDelegate(
+                RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression),
+                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+            )
+        }
+    }
+
+    private fun registerSimplifyForGuavaMethod(holder: ProblemsHolder, expression: PsiMethodCallExpression, replacementMethod: String) {
+        val originalMethod = getOriginalMethodName(expression) ?: return
+        val description = REPLACE_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
+        )
+        holder.registerProblem(expression, message, quickFix)
+    }
+}
@@ -0,0 +1,70 @@
+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.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
+import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.RemoveExpectedOutmostMethodCallQuickFix
+
+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 visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                if (!ASSERT_THAT_ANY.test(expression)) {
+                    return
+                }
+                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
+
+                if (ASSERT_THAT_JAVA8_OPTIONAL.test(expression)) {
+                    if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (CallMatcher.anyOf(OPTIONAL_OF, OPTIONAL_OF_NULLABLE).test(innerExpectedCall)) {
+                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS, ::RemoveExpectedOutmostMethodCallQuickFix)
+                        } else if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_NOT_PRESENT)
+                        }
+                    } else if (IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
+                        if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
+                        }
+                    }
+                } else {
+                    val actualExpression = expression.firstArg as? PsiMethodCallExpression ?: return
+
+                    if (OPTIONAL_GET.test(actualExpression)) {
+                        if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                            registerRemoveActualOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS) { desc, method ->
+                                RemoveActualOutmostMethodCallQuickFix(desc, method)
+                            }
+                        } else if (IS_SAME_AS_OBJECT.test(expectedCallExpression)) {
+                            registerRemoveActualOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS_SAME) { desc, method ->
+                                RemoveActualOutmostMethodCallQuickFix(desc, method)
+                            }
+                        }
+                    } else if (OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                        val expectedPresence = getExpectedBooleanResult(expectedCallExpression) ?: return
+                        val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
+                        registerRemoveActualOutmostMethod(holder, expression, expectedCallExpression, replacementMethod) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression = true)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -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()")
-                }
-            }
-        }
-    }
-}
@@ -5,11 +5,14 @@ import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.PsiType
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map

-class AssertThatObjectIsNotNullInspection : AbstractAssertJInspection() {
+class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {

    companion object {
-        private const val DISPLAY_NAME = "Asserting non-null"
+        private const val DISPLAY_NAME = "Asserting null or not-null"
    }

    override fun getDisplayName() = DISPLAY_NAME
@@ -18,12 +21,14 @@ class AssertThatObjectIsNotNullInspection : AbstractAssertJInspection() {
        return object : JavaElementVisitor() {
            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                super.visitMethodCallExpression(expression)
-                if (!IS_NOT_EQUAL_TO_OBJECT.test(expression)) {
+                val isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expression)
+                val isEqualTo = IS_EQUAL_TO_OBJECT.test(expression)
+                if (!(isEqualTo || isNotEqualTo)) {
                    return
                }

-                if (expression.argumentList.expressions[0].type == PsiType.NULL) {
-                    registerSimplifyMethod(holder, expression, "isNotNull()")
+                if (expression.firstArg.type == PsiType.NULL) {
+                    registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL))
                }
            }
        }
@@ -2,14 +2,24 @@ 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.AssertJClassNames.Companion.ABSTRACT_ITERABLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.map
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickFix

 class AssertThatSizeInspection : AbstractAssertJInspection() {

    companion object {
        private const val DISPLAY_NAME = "Asserting the size of an collection or array"
-        private const val MORE_CONCISE_MESSAGE_TEMPLATE = "%s would be more concise than %s"
+
+        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 getDisplayName() = DISPLAY_NAME
@@ -21,37 +31,46 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                if (!ASSERT_THAT_INT.test(expression)) {
                    return
                }
-                val actualExpression = expression.argumentList.expressions[0] ?: return
+                val actualExpression = expression.firstArg

                if (isArrayLength(actualExpression) || isCollectionSize(actualExpression)) {
-                    val statement = PsiTreeUtil.getParentOfType(expression, PsiStatement::class.java) ?: return
-                    val expectedCallExpression = PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java) ?: return
+                    val expectedCallExpression = expression.findOutmostMethodCall() ?: return
                    val constValue = calculateConstantParameterValue(expectedCallExpression, 0)
                    if (IS_EQUAL_TO_INT.test(expectedCallExpression)) {
                        if (constValue == 0) {
-                            registerSizeMethod(holder, expression, expectedCallExpression, "isEmpty()", noExpectedExpression = true)
-                            return
+                            registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.IS_EMPTY) { desc, method ->
+                                ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = true)
                            }
-                        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
+                            val equalToExpression = expectedCallExpression.firstArg
+                            if (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) {
+                                registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.HAS_SAME_SIZE_AS) { desc, method ->
+                                    ReplaceSizeMethodCallQuickFix(desc, method, expectedIsCollection = true)
                                }
-                        if ((IS_GREATER_THAN_INT.test(expectedCallExpression) && (constValue == 0))
+                            } else {
+                                registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.HAS_SIZE) { desc, method ->
+                                    ReplaceSizeMethodCallQuickFix(desc, method)
+                                }
+                            }
+                        }
+                    } else {
+                        val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 0))
+                                || (IS_LESS_THAN_INT.test(expectedCallExpression) && (constValue == 1))
+                                || IS_ZERO.test(expectedCallExpression))
+                        val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expectedCallExpression) && (constValue == 0))
                                || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 1))
-                            || IS_NOT_ZERO.test(expectedCallExpression)
-                        ) {
-                            registerSizeMethod(holder, expression, expectedCallExpression, "isNotEmpty()", noExpectedExpression = true)
-                            return
+                                || IS_NOT_ZERO.test(expectedCallExpression))
+                        if (isTestForEmpty || isTestForNotEmpty) {
+                            val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
+                            registerReplaceMethod(holder, expression, expectedCallExpression, replacementMethod) { desc, method ->
+                                ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = true)
+                            }
+                        } else if (hasAssertJMethod(expression, ABSTRACT_ITERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE_LESS_THAN)) {
+                            // new stuff in AssertJ 13.2.0
+                            val matchedMethod = BONUS_EXPRESSIONS_CALL_MATCHER_MAP.find { it.first.test(expectedCallExpression) }?.second ?: return
+                            registerReplaceMethod(holder, expression, expectedCallExpression, matchedMethod) { desc, method ->
+                                ReplaceSizeMethodCallQuickFix(desc, method)
+                            }
                        }
                    }
                }
@@ -64,24 +83,6 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                return ((psiReferenceExpression.qualifierExpression?.type is PsiArrayType)
                        && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
            }
-
-            private fun registerSizeMethod(
-                holder: ProblemsHolder,
-                expression: PsiMethodCallExpression,
-                expectedCallExpression: PsiMethodCallExpression,
-                replacementMethod: String,
-                noExpectedExpression: Boolean = false,
-                expectedIsCollection: Boolean = false
-            ) {
-                val originalMethod = getOriginalMethodName(expectedCallExpression) ?: return
-                val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-                val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
-                holder.registerProblem(
-                    expression,
-                    message,
-                    ReplaceSizeMethodCallQuickFix(description, replacementMethod, noExpectedExpression, expectedIsCollection)
-                )
-            }
        }
    }
 }
@@ -4,6 +4,8 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.MethodNames

 class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {

@@ -29,7 +31,7 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {

                val value = calculateConstantParameterValue(expression, 0) ?: return
                if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
-                    registerSimplifyMethod(holder, expression, "isEmpty()")
+                    registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                }
            }
        }
@@ -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.CommonClassNames
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.*
+import com.intellij.psi.search.GlobalSearchScope
 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

@@ -20,93 +20,93 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
        private val MAPPINGS = listOf(
            Mapping(
                anyOf(
-                    CallMatcher.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(CommonClassNames.JAVA_LANG_STRING, "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"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "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),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                ),
-                "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),
-                    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_STRING, 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"),
-                    CallMatcher.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"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "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),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
+                    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"),
-                    CallMatcher.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"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
+                    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("double", "double", "double"),
+                    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("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),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
+                    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),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
+                    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),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
+                    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"),
-                    CallMatcher.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"),
-                    CallMatcher.staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
+                    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("double[]", "double[]", "double"),
+                    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("float[]", "float[]", "float")
                ),
-                "containsExactly()", hasDelta = true
+                MethodNames.CONTAINS_EXACTLY, hasDelta = true
            ),
            Mapping(
                anyOf(
-                    CallMatcher.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(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
                ),
-                "containsExactly()"
+                MethodNames.CONTAINS_EXACTLY
            )
        )
    }
@@ -121,53 +121,31 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
                if (!isJUnitAssertCall) {
                    return // early exit
                }
-                for (mapping in MAPPINGS) {
-                    if (mapping.callMatcher.test(expression)) {
+                JavaPsiFacade.getInstance(expression.project)
+                    .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)
-                        }
-                        return
+                    registerConvertMethod(holder, expression, mapping.replacement) { desc, method ->
+                        ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
                    }
                }
            }
        }
    }

-    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 message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
-        holder.registerProblem(
-            expression,
-            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)
-        )
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, message, quickfix)
    }

    private class Mapping(
@@ -1,32 +1,9 @@
 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 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))
-        }
-    }
 }
@@ -0,0 +1,25 @@
+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 = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: 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()
+        }
+    }
+}
@@ -0,0 +1,16 @@
+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 applyFix(project: Project, descriptor: ProblemDescriptor) {
+        mainFix.applyFix(project, descriptor)
+        postfix(project, descriptor)
+    }
+}
@@ -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 de.platon42.intellij.plugins.cajon.*
+
+class RemoveActualOutmostMethodCallQuickFix(
+    description: String,
+    private val replacementMethod: String,
+    private val noExpectedExpression: Boolean = false
+) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val assertExpression = methodCallExpression.firstArg as? PsiMethodCallExpression ?: return
+        assertExpression.replace(assertExpression.qualifierExpression)
+
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
+        val args = if (noExpectedExpression) emptyArray() else oldExpectedExpression.argumentList.expressions
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}
@@ -0,0 +1,21 @@
+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 RemoveExpectedOutmostMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(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)
+    }
+}
@@ -2,57 +2,41 @@ 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 com.intellij.psi.codeStyle.JavaCodeStyleManager
+import de.platon42.intellij.plugins.cajon.*
+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) {

    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 expected = args.expressions[count - 2] ?: return
-            val message = if (count > 2) args.expressions[0] else null
-            Pair(expected, message)
+        val (expectedExpression, messageExpression) = if (noExpectedExpression) {
+            val message = args.expressions.getOrNull(count - 2)
+            emptyArray<PsiExpression>() to message
        } else {
-            val message = if (count > 1) args.expressions[0] else null
-            Pair(null, message)
+            val expected = args.expressions[count - 2] ?: return
+            val message = args.expressions.getOrNull(count - 3)
+            arrayOf(expected) to message
        }

-        val expectedMethodCall = factory.createExpressionFromText(
-            "a.${if (hasExpected) replacementMethod.replace("()", "(e)") else replacementMethod}", element
-        ) 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)
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, *expectedExpression)
+        val newMethodCall = createAssertThat(element, actualExpression)

        if (messageExpression != null) {
-            val asExpression = factory.createExpressionFromText("a.as(desc)", element) as PsiMethodCallExpression
-            asExpression.argumentList.expressions[0].replace(messageExpression)
-            asExpression.methodExpression.qualifierExpression!!.replace(newMethodCall)
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(asExpression)
+            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
+            asExpression.replaceQualifier(newMethodCall)
+            expectedMethodCall.replaceQualifier(asExpression)
        } else {
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(newMethodCall)
+            expectedMethodCall.replaceQualifier(newMethodCall)
        }

-        val assertThatMethod = newMethodCall.resolveMethod() ?: return
-        addStaticImport(assertThatMethod, element, factory, GUAVA_ASSERTIONS_CLASSNAME)
-
-        val codeStyleManager = JavaCodeStyleManager.getInstance(element.project)
-        val newElement = element.replace(expectedMethodCall)
-        val shortened = codeStyleManager.shortenClassReferences(newElement)
-        CodeStyleManager.getInstance(element.project).reformat(shortened)
+        newMethodCall.resolveMethod()?.addAsStaticImport(element, GUAVA_ASSERTIONS_CLASSNAME)
+        element.replace(expectedMethodCall).shortenAndReformat()
    }
 }
@@ -2,59 +2,36 @@ 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 com.intellij.psi.codeStyle.JavaCodeStyleManager
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME

 class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {

    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 actualExpression = args.expressions[count - 2] ?: return
-        val messageExpression = if (count > 3) args.expressions[0] else null
+        val count = args.expressions.size
+        val messageExpression = args.expressions.getOrNull(count - 4)
        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(
-            "org.assertj.core.data.Offset.offset(c)", element
-        ) as PsiMethodCallExpression
-
-        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)
+        val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall)
+        val newMethodCall = createAssertThat(element, actualExpression)

        if (messageExpression != null) {
-            val asExpression = factory.createExpressionFromText("a.as(desc)", element) as PsiMethodCallExpression
-            asExpression.argumentList.expressions[0].replace(messageExpression)
-            asExpression.methodExpression.qualifierExpression!!.replace(newMethodCall)
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(asExpression)
+            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
+            asExpression.replaceQualifier(newMethodCall)
+            expectedMethodCall.replaceQualifier(asExpression)
        } else {
-            expectedMethodCall.methodExpression.qualifierExpression!!.replace(newMethodCall)
+            expectedMethodCall.replaceQualifier(newMethodCall)
        }

-        val assertThatMethod = newMethodCall.resolveMethod() ?: return
-        addStaticImport(assertThatMethod, element, factory, GUAVA_ASSERTIONS_CLASSNAME)
-        val offsetMethod = offsetMethodCall.resolveMethod() ?: return
-        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)
+        newMethodCall.resolveMethod()?.addAsStaticImport(element, GUAVA_ASSERTIONS_CLASSNAME)
+        offsetMethodCall.resolveMethod()?.addAsStaticImport(element)
+        element.replace(expectedMethodCall).shortenAndReformat()
    }
 }
@@ -2,19 +2,20 @@ 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) {
+class ReplaceSimpleMethodCallQuickFix(
+    description: String,
+    private val replacementMethod: String
+) : AbstractCommonQuickFix(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 =
-            factory.createExpressionFromText("a.$replacementMethod", element) as PsiMethodCallExpression
-        expectedExpression.methodExpression.qualifierExpression!!.replace(oldQualifier)
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod)
+        expectedExpression.replaceQualifierFromMethodCall(methodCallExpression)
        element.replace(expectedExpression)
    }
 }
@@ -2,33 +2,33 @@ 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 com.intellij.psi.PsiExpression
+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 expectedIsCollection: Boolean
+    private val noExpectedExpression: Boolean = false,
+    private val expectedIsCollection: Boolean = false
 ) : AbstractCommonQuickFix(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 assertExpression = methodCallExpression.argumentList.expressions[0] ?: return
+        val assertExpression = methodCallExpression.firstArg
        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) {
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
+
        if (expectedIsCollection) {
-                replaceCollectionSizeOrArrayLength(oldExpectedExpression.argumentList.expressions[0])
+            replaceCollectionSizeOrArrayLength(oldExpectedExpression.firstArg)
        }
-            expectedExpression.argumentList.expressions[0].replace(oldExpectedExpression.argumentList.expressions[0])
-        }
-        expectedExpression.methodExpression.qualifierExpression!!.replace(oldExpectedExpression.methodExpression.qualifierExpression!!)
+
+        val args = if (noExpectedExpression) emptyArray() else arrayOf(oldExpectedExpression.firstArg)
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
+
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
        oldExpectedExpression.replace(expectedExpression)
    }

@@ -36,7 +36,7 @@ class ReplaceSizeMethodCallQuickFix(
        assertExpression.replace(
            when (assertExpression) {
                is PsiReferenceExpression -> assertExpression.qualifierExpression!!
-                is PsiMethodCallExpression -> assertExpression.methodExpression.qualifierExpression!!
+                is PsiMethodCallExpression -> assertExpression.qualifierExpression
                else -> return
            }
        )
@@ -0,0 +1,32 @@
+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.createExpectedMethodCall
+import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
+
+class SplitBinaryExpressionMethodCallQuickFix(
+    description: String,
+    private val replacementMethod: String,
+    private val pickRightOperand: Boolean = false,
+    private val noExpectedExpression: Boolean = false
+) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val binaryExpression = methodCallExpression.firstArg as? PsiBinaryExpression ?: return
+        val expectedArgument = (if (pickRightOperand) binaryExpression.lOperand else binaryExpression.rOperand)?.copy() ?: return
+        binaryExpression.replace(if (pickRightOperand) binaryExpression.rOperand!! else binaryExpression.lOperand)
+
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
+        val args = if (noExpectedExpression) emptyArray() else arrayOf(expectedArgument)
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}
@@ -0,0 +1,22 @@
+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 SplitEqualsExpressionMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val equalsMethodCall = methodCallExpression.firstArg as? PsiMethodCallExpression ?: return
+        val expectedArgument = equalsMethodCall.firstArg.copy()
+        equalsMethodCall.replace(equalsMethodCall.qualifierExpression)
+
+        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
+        val expectedExpression = createExpectedMethodCall(element, replacementMethod, expectedArgument)
+        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}
@@ -0,0 +1,162 @@
+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.ProcessingContext
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.AssertJClassNames
+import de.platon42.intellij.plugins.cajon.CORE_ASSERT_THAT_MATCHER
+import de.platon42.intellij.plugins.cajon.firstArg
+
+class ExtractorReferenceContributor : PsiReferenceContributor() {
+
+    companion object {
+
+        private val EXTRACTING_FROM_OBJECT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME, "extracting")
+        private val EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extracting")
+        private val FLAT_EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "flatExtracting")
+        private val EXTRACTING_RESULT_OF_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extractingResultOf")
+
+        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 = PsiTreeUtil.findChildrenOfType(element, PsiMethodCallExpression::class.java)
+                .find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return null
+            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 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)
+        }
+    }
+}
@@ -7,10 +7,11 @@
    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
    to make the intention clear and concise. It can also 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.2290.1"/>

    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
         on how to target different products -->
@@ -19,25 +20,28 @@
    <depends>com.intellij.modules.java</depends>

    <extensions defaultExtensionNs="com.intellij">
-        <localInspection groupPath="Java" shortName="AssertThatObjectIsNull" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNullInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatObjectIsNotNull" enabledByDefault="true" level="WARNING"
-                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNotNullInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatBooleanIsTrueOrFalse" enabledByDefault="true"
-                         level="WARNING"
+        <psi.referenceContributor implementation="de.platon42.intellij.plugins.cajon.references.ExtractorReferenceContributor"/>
+        <localInspection groupPath="Java" shortName="AssertThatObjectIsNullOrNotNull" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectIsNullOrNotNullInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatBooleanIsTrueOrFalse" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanIsTrueOrFalseInspection"/>
        <localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringIsEmptyInspection"/>
-        <localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true"
-                         level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatEnumerableIsEmptyInspection"/>

-        <localInspection groupPath="Java" shortName="AssertThatSize" enabledByDefault="true"
-                         level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatSize" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatSizeInspection"/>

-        <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true"
-                         level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatBinaryExpressionIsTrueOrFalse" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionIsTrueOrFalseInspection"/>
+
+        <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>

@@ -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>
@@ -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>
@@ -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 -->
+Requires AssertJ-Guava to be in classpath.
+</body>
+</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>
@@ -1,6 +0,0 @@
-<html>
-<body>
-Turns assertThat(object).isNotEqualTo(null) into assertThat(object).isNotNull().
-<!-- tooltip end -->
-</body>
-</html>
@@ -1,6 +0,0 @@
-<html>
-<body>
-Turns assertThat(object).isEqualTo(null) into assertThat(object).isNull().
-<!-- tooltip end -->
-</body>
-</html>
@@ -0,0 +1,6 @@
+<html>
+<body>
+Turns assertThat(object).is(Not)EqualTo(null) into assertThat(object).is(Not)Null().
+<!-- tooltip end -->
+</body>
+</html>
@@ -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(),
@@ -2,11 +2,16 @@ package de.platon42.intellij.playground;

 import org.assertj.core.api.ListAssert;
 import org.assertj.core.data.Offset;
+import org.assertj.core.extractor.Extractors;

 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Offset.offset;
+import static org.assertj.guava.api.Assertions.assertThat;
 import static org.junit.Assert.*;

 public class Playground {
@@ -27,6 +32,7 @@ public class Playground {
        assertThat(new ArrayList<String>().size()).isEqualTo(1);
        assertThat(new ArrayList<String>().size()).isGreaterThanOrEqualTo(1);
        assertThat(new ArrayList<String>().size()).isZero();
+        assertThat(new ArrayList<String>()).hasSizeGreaterThan(1);
        assertThat(new ArrayList<String>()).hasSameSizeAs(new ArrayList<>());
        assertThat(new Long[1]).as("etc").hasSameSizeAs(new Long[2]);
    }
@@ -69,10 +75,135 @@ public class Playground {
        assertThat("").isEqualTo(Boolean.TRUE);
    }

-    private void stringIsEmpty() {
+    private void binaryExpression() {
+        int primExp = 42;
+        int primAct = 1337;
+        Double numberObjExp = 42.0;
+        Double numberObjAct = 1337.0;
+        String stringExp = "foo";
+        String stringAct = "bar";
+
+        assertThat(primAct == primExp).isTrue();
+        assertThat(primAct == 1).isTrue();
+        assertThat(primAct == primExp).isEqualTo(false);
+        assertThat(primAct != primExp).isEqualTo(true);
+        assertThat(1 != primAct).isTrue();
+        assertThat(primAct != primExp).isNotEqualTo(true);
+        assertThat(primAct > primExp).isNotEqualTo(false);
+        assertThat(primAct > primExp).isFalse();
+        assertThat(primAct > 1).isFalse();
+        assertThat(primAct >= 1).isTrue();
+        assertThat(primAct >= primExp).isEqualTo(false);
+        assertThat(1 <= primAct).isFalse();
+        assertThat(1 > primAct).isTrue();
+        assertThat(primAct < primExp).isNotEqualTo(true);
+        assertThat(primAct <= primExp).isNotEqualTo(false);
+        assertThat(primAct <= primExp).isFalse();
+        assertThat(primAct <= 1).isFalse();
+        assertThat(numberObjAct == 1).isTrue();
+        assertThat(numberObjAct == numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct != numberObjExp).isEqualTo(true);
+        assertThat(1 != numberObjAct).isTrue();
+        assertThat(numberObjAct != numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct > 1).isFalse();
+        assertThat(numberObjAct >= numberObjExp).isTrue();
+        assertThat(numberObjAct >= numberObjExp).isEqualTo(false);
+        assertThat(1 <= numberObjAct).isFalse();
+        assertThat(numberObjAct < numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct < numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct <= 1).isFalse();
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
+        assertThat(stringAct == stringExp).isNotEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
+        assertThat(stringAct != stringExp).isFalse();
+        assertThat(stringAct == null).isNotEqualTo(true);
+        assertThat(null == stringAct).isEqualTo(false);
+
+        assertThat(null == null).isTrue();
+        assertThat(!false).isTrue();
+    }
+
+    private void stringStuff() {
        String foo = "bar";
        assertThat(foo).isEqualTo("");
        assertThat(foo).hasSize(0);
+        assertThat(foo.contains("foobar")).isTrue();
+        assertThat(foo).contains("foobar");
+        assertThat(foo.startsWith("foobar")).isTrue();
+        assertThat(foo).startsWith("foobar");
+        assertThat(foo.endsWith("foobar")).isTrue();
+        assertThat(foo).endsWith("foobar");
+        assertThat(foo.equalsIgnoreCase("foo")).isTrue();
+        assertThat(foo).isEqualToIgnoringCase("foo");
+
+        assertThat(foo.contains("foobar")).isFalse();
+        assertThat(foo).doesNotContain("foobar");
+        assertThat(foo.startsWith("foobar")).isFalse();
+        assertThat(foo).doesNotStartWith("foobar");
+        assertThat(foo.endsWith("foobar")).isFalse();
+        assertThat(foo).doesNotEndWith("foobar");
+        assertThat(foo.equalsIgnoreCase("foo")).isFalse();
+        assertThat(foo).isNotEqualToIgnoringCase("foo");
+    }
+
+    private void java8Optional() {
+        Optional<String> opt = Optional.empty();
+
+        assertThat(opt.isPresent()).isEqualTo(true);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isNotEqualTo(false);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isTrue();
+
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isNotEqualTo(true);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isFalse();
+
+        assertThat(opt.get()).isEqualTo("foo");
+        assertThat(opt.get()).isSameAs("foo");
+
+        assertThat(opt).isEqualTo(Optional.of("foo"));
+        assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.ofNullable("foo"));
+
+        assertThat(opt).isEqualTo(Optional.empty());
+        assertThat(opt).isNotEqualTo(Optional.empty());
+        assertThat(opt).isPresent();
+    }
+
+    private void assertThatGuavaOptional() {
+        com.google.common.base.Optional<String> opt = com.google.common.base.Optional.absent();
+
+        assertThat(opt.isPresent()).isEqualTo(true);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isNotEqualTo(false);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isTrue();
+
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isNotEqualTo(true);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isFalse();
+
+        assertThat(opt.get()).isEqualTo("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).isEqualTo(com.google.common.base.Optional.of("foo"));
+        assertThat(opt).isEqualTo(com.google.common.base.Optional.fromNullable("foo"));
+        assertThat(opt).isNotEqualTo(com.google.common.base.Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(com.google.common.base.Optional.fromNullable("foo"));
+
+        assertThat(opt).isEqualTo(com.google.common.base.Optional.absent());
+        assertThat(opt).isNotEqualTo(com.google.common.base.Optional.absent());
+        assertThat(opt).isAbsent();
    }

    private void junitAssertions() {
@@ -111,13 +242,9 @@ public class Playground {
        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);
@@ -183,6 +310,61 @@ public class Playground {
        assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
        assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
        assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
+
+        assertThat(new Object()).extracting("toString");
+        assertThat(new Object()).extracting(Object::toString, Object::hashCode);
    }

+
+    private void findReferences() {
+        Contact contact = new Contact();
+        List<Contact> contactList = Collections.emptyList();
+
+        assertThat(contact).extracting("name").isEqualTo("foo");
+        assertThat(contact).extracting("age", "country", "address.street", "street", "address.noMailings", "address.REALLYnoMAILINGS").containsExactly(1, "Elmst. 42");
+        assertThat(contact).extracting(Extractors.byName("name")).isEqualTo("foo");
+        assertThat(contact).extracting(Extractors.resultOf("getStreet")).isEqualTo("foo");
+        assertThat(contact).extracting(Extractors.resultOf("getStreet"), Extractors.byName("narf")).isEqualTo("foo");
+
+        assertThat(contactList).extracting("name").isEqualTo("foo");
+        assertThat(contactList).extracting("name", "moar").isEqualTo("foo");
+        assertThat(contactList).extracting("name", String.class).isEqualTo("foo");
+        assertThat(contactList).extracting(Extractors.byName("name")).isEqualTo("foo");
+        assertThat(contactList).extracting(Extractors.resultOf("getStreet"), Extractors.byName("narf")).isEqualTo("foo");
+        assertThat(contactList).extractingResultOf("getStreet").isEqualTo("foo");
+        assertThat(contactList).extractingResultOf("getStreet", String.class).isEqualTo("foo");
+        assertThat(contactList).flatExtracting("age", "address.street", "street").containsExactly(1, "Elmst. 42");
+        assertThat(contactList).flatExtracting("age").containsExactly(1, "Elmst. 42");
+    }
+
+    public class Contact {
+        private String name;
+        private Integer age;
+        private Address address;
+
+        public String getStreet() {
+            return address.getStreet();
+        }
+    }
+
+    public class Address {
+        private String street;
+        private String country;
+
+        public String getStreet() {
+            return street;
+        }
+
+        public String getCountry() {
+            return country;
+        }
+
+        public boolean isNoMailings() {
+            return true;
+        }
+
+        public Boolean getREALLYnoMAILINGS() {
+            return true;
+        }
+    }
 }
@@ -20,7 +20,7 @@ import java.lang.reflect.InvocationTargetException
@AddLocalJarToModule(Assertions::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)

@@ -61,7 +61,7 @@ abstract class AbstractCajonTest {

    protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
        val quickfixes = myFixture.getAllQuickFixes().filter { it.familyName.matches(regex) }
-        assertThat(quickfixes).hasSize(expectedFixes)
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.familyName }}").hasSize(expectedFixes)
        quickfixes.forEach(myFixture::launchAction)
    }
 }
@@ -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 AssertThatBinaryExpressionIsTrueOrFalseInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/BinaryExpression")
+    internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        runTest {
+            myFixture.enableInspections(AssertThatBinaryExpressionIsTrueOrFalseInspection::class.java)
+            myFixture.configureByFile("BinaryExpressionBefore.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 148)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 12)
+            myFixture.checkResultByFile("BinaryExpressionAfter.java")
+        }
+    }
+}
@@ -14,7 +14,10 @@ internal class AssertThatBooleanIsTrueOrFalseInspectionTest : AbstractCajonTest(
        runTest {
            myFixture.enableInspections(AssertThatBooleanIsTrueOrFalseInspection::class.java)
            myFixture.configureByFile("BooleanIsTrueOrFalseBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace is.*"), 17)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 4)
+            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("BooleanIsTrueOrFalseAfter.java")
        }
    }
@@ -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()"), 4)
            myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
        }
    }
@@ -0,0 +1,54 @@
+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/AssertThatGuavaOptional")
+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("AssertThatGuavaOptionalBefore.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 3)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isAbsent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isAbsent()"), 3)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isAbsent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with isAbsent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with contains()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
+            myFixture.checkResultByFile("AssertThatGuavaOptionalAfter.java")
+        }
+    }
+
+    @Test
+    internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        runTest {
+            myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+            myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 7)
+            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 isAbsent()"), 1)
+            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 6)
+            myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
+        }
+    }
+}
@@ -0,0 +1,31 @@
+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/AssertThatJava8Optional")
+    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        runTest {
+            myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
+            myFixture.configureByFile("AssertThatJava8OptionalBefore.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isNotPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isNotPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with isNotPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with contains()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isSameAs() with containsSame()"), 1)
+            myFixture.checkResultByFile("AssertThatJava8OptionalAfter.java")
+        }
+    }
+}
@@ -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")
-        }
-    }
-}
@@ -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.configureByFile("ObjectIsNullBefore.java")
+            myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+            myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 3)
-            myFixture.checkResultByFile("ObjectIsNullAfter.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 3)
+            myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
        }
    }
 }
@@ -14,7 +14,19 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
        runTest {
            myFixture.enableInspections(AssertThatSizeInspection::class.java)
            myFixture.configureByFile("AssertThatSizeBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 20)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 2)
            myFixture.checkResultByFile("AssertThatSizeAfter.java")
        }
    }
@@ -14,7 +14,8 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
        runTest {
            myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
            myFixture.configureByFile("StringIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 2)
            myFixture.checkResultByFile("StringIsEmptyAfter.java")
        }
    }
@@ -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()")
+        }
+    }
+}
@@ -0,0 +1,52 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class AssertThatGuavaOptional {
+
+    private void assertThatGuavaOptional() {
+        Optional<String> opt = Optional.absent();
+
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isAbsent();
+
+        assertThat(opt).contains("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).contains("foo");
+        assertThat(opt).contains("foo");
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
+
+        assertThat(opt).isAbsent();
+        assertThat(opt).isPresent();
+
+        org.assertj.guava.api.Assertions.assertThat(opt).contains("foo");
+        org.assertj.guava.api.Assertions.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"));
+
+        org.assertj.guava.api.Assertions.assertThat(opt).isAbsent();
+        org.assertj.guava.api.Assertions.assertThat(opt).isPresent();
+
+        assertThat(opt).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).isAbsent();
+        assertThat(opt).isPresent();
+    }
+}
@@ -0,0 +1,52 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class AssertThatGuavaOptional {
+
+    private void assertThatGuavaOptional() {
+        Optional<String> opt = Optional.absent();
+
+        assertThat(opt.isPresent()).isEqualTo(true);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isNotEqualTo(false);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isTrue();
+
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isNotEqualTo(true);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isFalse();
+
+        assertThat(opt.get()).isEqualTo("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).isEqualTo(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).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).isEqualTo(Optional.absent());
+        org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.absent());
+
+        org.assertj.core.api.Assertions.assertThat(opt).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).isEqualTo(Optional.absent());
+        org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.absent());
+    }
+}
@@ -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 AssertThatGuavaOptional {
+
+    private void assertThatGuavaOptional() {
+        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();
+    }
+}
@@ -0,0 +1,26 @@
+import com.google.common.base.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AssertThatGuavaOptional {
+
+    private void assertThatGuavaOptional() {
+        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());
+    }
+}
@@ -0,0 +1,35 @@
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AssertThatJava8Optional {
+
+    private void assertThatJava8Optional() {
+        Optional<String> opt = Optional.empty();
+
+        assertThat(opt).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).contains("foo");
+        assertThat(opt).containsSame("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).contains("foo");
+        assertThat(opt).contains("foo");
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.ofNullable("foo"));
+
+        assertThat(opt).isNotPresent();
+        assertThat(opt).isPresent();
+    }
+}
@@ -0,0 +1,35 @@
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AssertThatJava8Optional {
+
+    private void assertThatJava8Optional() {
+        Optional<String> opt = Optional.empty();
+
+        assertThat(opt.isPresent()).isEqualTo(true);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isNotEqualTo(false);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isTrue();
+
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
+        assertThat(opt.isPresent()).isNotEqualTo(true);
+        assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).isFalse();
+
+        assertThat(opt.get()).isEqualTo("foo");
+        assertThat(opt.get()).isSameAs("foo");
+        assertThat(opt.get()).isNotEqualTo("foo");
+        assertThat(opt.get()).isNotSameAs("foo");
+
+        assertThat(opt).isEqualTo(Optional.of("foo"));
+        assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
+        assertThat(opt).isNotEqualTo(Optional.of("foo"));
+        assertThat(opt).isNotEqualTo(Optional.ofNullable("foo"));
+
+        assertThat(opt).isEqualTo(Optional.empty());
+        assertThat(opt).isNotEqualTo(Optional.empty());
+    }
+}
@@ -2,7 +2,7 @@ import java.util.ArrayList;

 import static org.assertj.core.api.Assertions.assertThat;

-public class assertThatSize {
+public class AssertThatSize {

    private void assertThatSize() {
        ArrayList<String> list = new ArrayList<>();
@@ -20,6 +20,10 @@ public class assertThatSize {
        assertThat(list).hasSameSizeAs(otherList);
        assertThat(list).hasSameSizeAs(array);
        assertThat(list).hasSize(1);
+        assertThat(list).hasSizeGreaterThan(list.size() * 2);
+        assertThat(list).hasSizeGreaterThanOrEqualTo(list.size() * 2);
+        assertThat(list).hasSizeLessThan(list.size() * 2);
+        assertThat(list).hasSizeLessThanOrEqualTo(list.size() * 2);

        assertThat(array).isEmpty();
        assertThat(array).isEmpty();
@@ -31,5 +35,9 @@ public class assertThatSize {
        assertThat(array).hasSameSizeAs(list);
        assertThat(array).hasSameSizeAs(otherArray);
        assertThat(array).hasSize(1);
+        assertThat(array).hasSizeGreaterThan(otherArray.length - 1);
+        assertThat(array).hasSizeGreaterThanOrEqualTo(otherArray.length + 1);
+        assertThat(array).hasSizeLessThan(otherArray.length - 3);
+        assertThat(array).hasSizeLessThanOrEqualTo(1 - otherArray.length);
    }
 }
@@ -2,7 +2,7 @@ import java.util.ArrayList;

 import static org.assertj.core.api.Assertions.assertThat;

-public class assertThatSize {
+public class AssertThatSize {

    private void assertThatSize() {
        ArrayList<String> list = new ArrayList<>();
@@ -20,6 +20,10 @@ public class assertThatSize {
        assertThat(list.size()).isEqualTo(otherList.size());
        assertThat(list.size()).isEqualTo(array.length);
        assertThat(list.size()).isEqualTo(1);
+        assertThat(list.size()).isGreaterThan(list.size() * 2);
+        assertThat(list.size()).isGreaterThanOrEqualTo(list.size() * 2);
+        assertThat(list.size()).isLessThan(list.size() * 2);
+        assertThat(list.size()).isLessThanOrEqualTo(list.size() * 2);

        assertThat(array.length).isEqualTo(0);
        assertThat(array.length).isZero();
@@ -31,5 +35,9 @@ public class assertThatSize {
        assertThat(array.length).isEqualTo(list.size());
        assertThat(array.length).isEqualTo(otherArray.length);
        assertThat(array.length).isEqualTo(1);
+        assertThat(array.length).isGreaterThan(otherArray.length - 1);
+        assertThat(array.length).isGreaterThanOrEqualTo(otherArray.length + 1);
+        assertThat(array.length).isLessThan(otherArray.length - 3);
+        assertThat(array.length).isLessThanOrEqualTo(1 - otherArray.length);
    }
 }
@@ -0,0 +1,194 @@
+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).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).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).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).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).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).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).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).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).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).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).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).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).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+
+        assertThat(null == null).isTrue();
+        assertThat(!false).isTrue();
+    }
+}
@@ -0,0 +1,194 @@
+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).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).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).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).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).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).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).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).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).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).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).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).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)).isTrue();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(true);
+
+        assertThat(stringAct == stringExp).isTrue();
+        assertThat(stringAct == stringExp).isEqualTo(true);
+        assertThat(stringAct == stringExp).isNotEqualTo(false);
+        assertThat(stringAct == stringExp).isFalse();
+        assertThat(stringAct == stringExp).isEqualTo(false);
+        assertThat(stringAct == stringExp).isNotEqualTo(true);
+
+        assertThat(stringAct.equals(stringExp)).isTrue();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isFalse();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(true);
+
+        assertThat(stringAct != stringExp).isTrue();
+        assertThat(stringAct != stringExp).isEqualTo(true);
+        assertThat(stringAct != stringExp).isNotEqualTo(false);
+        assertThat(stringAct != stringExp).isFalse();
+        assertThat(stringAct != stringExp).isEqualTo(false);
+        assertThat(stringAct != stringExp).isNotEqualTo(true);
+
+        assertThat(stringAct == null).isTrue();
+        assertThat(stringAct == null).isEqualTo(true);
+        assertThat(stringAct == null).isNotEqualTo(false);
+        assertThat(stringAct == null).isFalse();
+        assertThat(stringAct == null).isEqualTo(false);
+        assertThat(stringAct == null).isNotEqualTo(true);
+
+        assertThat(null == stringAct).isTrue();
+        assertThat(null == stringAct).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();
+    }
+}
@@ -1,10 +0,0 @@
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class ObjectIsNotNull {
-
-    private void objectIsNotNull() {
-        assertThat("").isNotNull();
-        assertThat("").as("nah").isNotNull();
-        assertThat(new Object).isNotNull();
-    }
-}
@@ -1,10 +0,0 @@
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class ObjectIsNotNull {
-
-    private void objectIsNotNull() {
-        assertThat("").isNotEqualTo(null);
-        assertThat("").as("nah").isNotEqualTo(null);
-        assertThat(new Object).isNotEqualTo(null);
-    }
-}
@@ -5,6 +5,10 @@ public class ObjectIsNull {
    private void objectIsNull() {
        assertThat("").isNull();
        assertThat("").as("nah").isNull();
-        assertThat(new Object).isNull();
+        assertThat(new Object()).isNull();
+
+        assertThat("").isNotNull();
+        assertThat("").as("nah").isNotNull();
+        assertThat(new Object()).isNotNull();
    }
 }
@@ -5,6 +5,10 @@ public class ObjectIsNull {
    private void objectIsNull() {
        assertThat("").isEqualTo(null);
        assertThat("").as("nah").isEqualTo(null);
-        assertThat(new Object).isEqualTo(null);
+        assertThat(new Object()).isEqualTo(null);
+
+        assertThat("").isNotEqualTo(null);
+        assertThat("").as("nah").isNotEqualTo(null);
+        assertThat(new Object()).isNotEqualTo(null);
    }
 }
@@ -0,0 +1,20 @@
+public class Address {
+    private String street;
+    private String country;
+
+    private String getStreet() {
+        return street;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public boolean isNoMailings() {
+        return true;
+    }
+
+    public Boolean getREALLYnoMAILINGS() {
+        return true;
+    }
+}
@@ -0,0 +1,9 @@
+public class Contact {
+    private String name;
+    public Integer age;
+    protected Address address;
+    public String getStreetName()
+    {
+        return address.getStreet();
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference1 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting("name<caret>").isEqualTo("foo");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference10 {
+
+    private void findReferences() {
+        List<Contact> contactList = Collections.emptyList();
+
+        assertThat(contactList).extractingResultOf("getStreetName<caret>").isEqualTo("foo");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference2 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting("address<caret>.street", "streetName").containsExactly(1, "Elmst. 42");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference3 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting("address.street<caret>", "address.REALLYnoMAILINGS").containsExactly(1, "Elmst. 42");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference4 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting("address.getREALLYnoMAILINGS<caret>", "address.country").containsExactly(1, "Elmst. 42");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference5 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting("address.noMailings<caret>").containsExactly(1, "Elmst. 42");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference6 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting(Extractors.byName("name<caret>")).isEqualTo("foo");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference7 {
+
+    private void findReferences() {
+        Contact contact = new Contact();
+
+        assertThat(contact).extracting(Extractors.resultOf("getStreetName<caret>")).isEqualTo("foo");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference8 {
+
+    private void findReferences() {
+        List<Contact> contactList = Collections.emptyList();
+
+        assertThat(contactList).extracting("name<caret>").isEqualTo("foo");
+    }
+}
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference9 {
+
+    private void findReferences() {
+        List<Contact> contactList = Collections.emptyList();
+
+        assertThat(contactList).flatExtracting("age", "address.street<caret>", "streetName").containsExactly(1, "Elmst. 42");
+    }
+}
Author	SHA1	Message	Date
chrisly42	9f91fb3ccf	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. Minor refactorings. Extended documentation.	2019-04-18 22:12:48 +02:00
chrisly42	b58d8cfd2f	Fix for incompatible method call regarding IDEA <2018.2. Heavy refactoring regarding quick fixes (using more extensions). Even more refactoring. Fixed/extended AssertThatGuavaOptionalInspection regarding static. imports and wrong reference to core assertThat() where Guava assertThat() actually was necessary.	2019-04-13 18:35:49 +02:00
chrisly42	4e6d53b3dc	Reduced minimal supported IDEA version from 2018.2 to 2017.2. Added AssertThatGuavaOptional inspection. Prepared next release. Bumped to Kotlin 1.3.30.	2019-04-11 23:55:35 +02:00
chrisly42	2cdc242125	Refactored Code to avoid string duplications... added Boolean.map() extension.	2019-04-11 21:09:10 +02:00
chrisly42	d49b7bf17b	Optimized even more code. Fixed BinaryExpression for Boolean.TRUE/FALSE. Added new AssertThatJava8Optional inspection. Added changelog to README.	2019-04-11 16:26:11 +02:00
chrisly42	c1d8ade7b1	Optimized code. More kotlin-style stuff. Made detecting of Boolean.TRUE/FALSE available to all constant evaluations.	2019-04-08 11:56:13 +02:00
chrisly42	bdabcc7255	Removed TODO about AssertThatBinaryExpressionIsTrueOrFalse.	2019-04-07 11:37:10 +02:00
chrisly42	5812e72227	New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and equals() statements (more than 150 combinations) inside assertThat().	2019-04-07 11:29:07 +02:00
chrisly42	6a44237ca0	Added tacky icon.	2019-04-06 21:29:18 +02:00
chrisly42	51703e8499	Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull. Extended tests to be more explicit regarding the expected quick fix messages.	2019-04-06 21:29:18 +02:00
chrisly42	ba56325299	Internally: Upgraded to AssertJ 13.2.2. Support for hasSizeLessThan(), hasSizeLessThanOrEqualTo(), hasSizeGreaterThanOrEqualTo(), and hasSizeGreaterThan() for AssertThatSizeInspection (with AssertJ >=13.2.0). Really fixed highlighting for JUnit conversion. Sorry. Fixed testing code to work against IDEA 2019.1.	2019-04-06 21:29:13 +02:00