From 6fb23ea89cce0e63e7dd831d337b5f022d69af50 Mon Sep 17 00:00:00 2001
From: chrisly42 <chrisly@platon42.de>
Date: Sat, 4 May 2019 15:36:04 +0200
Subject: [PATCH] Heavily reworked inspections for edge cases, such as multiple
 isEqualTo() calls inside a single statement. Corrected highlighting for most
 inspections. Lots of refactorings, tweakings. Added travis-ci file
 (untested). Added jacoco.

---
 .travis.yml                                   |  11 ++
 README.md                                     |   5 +
 build.gradle                                  |  24 ++-
 .../plugins/cajon/AssertJClassNames.kt        |   9 +-
 .../intellij/plugins/cajon/CommonMatchers.kt  |  15 ++
 .../intellij/plugins/cajon/Extensions.kt      | 113 ++++++++++--
 .../platon42/intellij/plugins/cajon/Helper.kt |   8 +
 .../intellij/plugins/cajon/MethodNames.kt     |  12 +-
 .../inspections/AbstractAssertJInspection.kt  |  91 +++-------
 .../AbstractJUnitAssertInspection.kt          |   4 -
 .../AssertThatBinaryExpressionInspection.kt   |  28 ++-
 .../AssertThatBooleanConditionInspection.kt   |   3 +-
 .../AssertThatEnumerableIsEmptyInspection.kt  |   3 +-
 .../AssertThatGuavaOptionalInspection.kt      | 144 +++++++--------
 .../AssertThatInstanceOfInspection.kt         |  33 ++--
 ...tThatInvertedBooleanConditionInspection.kt |  31 +---
 .../AssertThatJava8OptionalInspection.kt      |  77 ++++----
 .../inspections/AssertThatSizeInspection.kt   | 166 +++++++++++-------
 .../AssertThatStringExpressionInspection.kt   |  56 ++----
 .../AssertThatStringIsEmptyInspection.kt      |   3 +-
 .../JUnitAssertToAssertJInspection.kt         |   4 +-
 .../JoinAssertThatStatementsInspection.kt     |   6 +-
 .../quickfixes/AbstractCommonQuickFix.kt      |   3 +-
 .../cajon/quickfixes/ForGuavaPostFix.kt       |   3 +-
 .../InvertUnaryStatementQuickFix.kt           |  37 ++++
 .../quickfixes/JoinStatementsQuickFix.kt      |   7 +-
 ...ActualOuterExpressionMethodCallQuickFix.kt |  22 ---
 .../MoveOutInstanceOfExpressionQuickFix.kt    |  44 +++++
 .../MoveOutMethodCallExpressionQuickFix.kt    |  37 ++++
 .../quickfixes/QuickFixWithPostfixDelegate.kt |   4 +
 .../RemoveActualOutmostMethodCallQuickFix.kt  |  29 ++-
 .../RemoveInstanceOfExpressionQuickFix.kt     |  32 ----
 .../RemoveUnaryExpressionQuickFix.kt          |  27 ---
 .../ReplaceHasSizeMethodCallQuickFix.kt       |  35 ++++
 .../ReplaceJUnitAssertMethodCallQuickFix.kt   |   8 +
 ...placeJUnitDeltaAssertMethodCallQuickFix.kt |   8 +
 .../ReplaceSimpleMethodCallQuickFix.kt        |   8 +
 .../ReplaceSizeMethodCallQuickFix.kt          |  32 ++--
 ...SplitBinaryExpressionMethodCallQuickFix.kt |  35 ++--
 .../UnwrapExpectedStaticMethodCallQuickFix.kt |   8 +
 .../ExtractorReferenceContributor.kt          |   5 +-
 .../intellij/playground/Playground.java       |   1 +
 .../plugins/cajon/AbstractCajonTest.kt        |   4 +-
 ...ssertThatBinaryExpressionInspectionTest.kt |   4 +-
 .../AssertThatGuavaOptionalInspectionTest.kt  |  25 ++-
 .../AssertThatInstanceOfInspectionTest.kt     |   4 +-
 ...tInvertedBooleanConditionInspectionTest.kt |   2 +-
 .../AssertThatJava8OptionalInspectionTest.kt  |  14 +-
 .../AssertThatSizeInspectionTest.kt           |   6 +-
 ...ssertThatStringExpressionInspectionTest.kt |  28 +--
 .../AssertThatStringIsEmptyInspectionTest.kt  |   7 +
 .../JUnitAssertToAssertJInspectionTest.kt     |   2 +-
 .../org/assertj/core/api/AssertJExtensions.kt |  19 ++
 .../BinaryExpressionAfter.java                |  41 +++--
 .../BinaryExpressionBefore.java               |  41 +++--
 .../GuavaOptional/GuavaOptionalAfter.java     |  23 +--
 .../GuavaOptional/GuavaOptionalBefore.java    |  19 +-
 .../InstanceOf/InstanceOfAfter.java           |   7 +-
 .../InstanceOf/InstanceOfBefore.java          |   7 +-
 .../InvertedBooleanConditionAfter.java        |  13 +-
 .../InvertedBooleanConditionBefore.java       |  13 +-
 .../Java8Optional/Java8OptionalAfter.java     |  13 +-
 .../Java8Optional/Java8OptionalBefore.java    |  13 +-
 .../JoinStatements/JoinStatementsAfter.java   |   2 +
 .../JoinStatements/JoinStatementsBefore.java  |   2 +
 .../resources/inspections/Size/SizeAfter.java |   4 +
 .../inspections/Size/SizeBefore.java          |   4 +
 .../StringExpressionAfter.java                |   8 +-
 .../StringExpressionBefore.java               |  12 +-
 69 files changed, 944 insertions(+), 624 deletions(-)
 create mode 100644 .travis.yml
 create mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/InvertUnaryStatementQuickFix.kt
 delete mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveActualOuterExpressionMethodCallQuickFix.kt
 create mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutInstanceOfExpressionQuickFix.kt
 create mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt
 delete mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveInstanceOfExpressionQuickFix.kt
 delete mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveUnaryExpressionQuickFix.kt
 create mode 100644 src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt
 create mode 100644 src/test/java/org/assertj/core/api/AssertJExtensions.kt

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..39d6c9f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,11 @@
+language: java
+jdk:
+  - oraclejdk8
+  - openjdk8
+
+before_script:
+  - chmod +x gradlew
+  - chmod +x gradle/wrapper/gradle-wrapper.jar
+
+script:
+  - ./gradlew clean test
\ No newline at end of file
diff --git a/README.md b/README.md
index bf58809..980d993 100644
--- a/README.md
+++ b/README.md
@@ -346,6 +346,11 @@ Feel free to use the code (in package de.platon42.intellij.jupiter) for your pro
 #### V0.8 (unreleased)
 - Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
 - Fixed ```isEmpty()``` for enumerables and strings and ```isNull()``` for object conversions to be applied only if it is the terminal method call as ```isEmpty()``` and ```isNull()``` return void.
+- Heavily reworked inspections for edge cases, such as multiple ```isEqualTo()``` calls inside a single statement.
+- Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
+- Corrected highlighting for many inspections.
+- Fixed family names for inspections in batch mode.
+- Reworded many inspection messages for better understanding.
 
 #### V0.7 (28-Apr-19)
 - Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
diff --git a/build.gradle b/build.gradle
index 8fc348a..ddf12f1 100644
--- a/build.gradle
+++ b/build.gradle
@@ -2,6 +2,7 @@ plugins {
     id 'java'
     id 'org.jetbrains.intellij' version '0.4.8'
     id 'org.jetbrains.kotlin.jvm' version '1.3.31'
+    id 'jacoco'
 }
 
 group 'de.platon42'
@@ -44,6 +45,11 @@ patchPluginXml {
     <ul>
       <li>Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
       <li>Fixed isEmpty() for enumerables and strings and isNull() for object conversions to be applied only if it is the terminal method call as isEmpty() and isNull() return void.
+      <li>Heavily reworked inspections for edge cases, such as multiple isEqualTo() calls inside a single statement.
+      <li>Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
+      <li>Corrected highlighting for many inspections.
+      <li>Fixed family names for inspections in batch mode.
+      <li>Reworded many inspection messages for better understanding.
     </ul>
   <h4>V0.7 (28-Apr-19)</h4>
     <ul>
@@ -59,9 +65,21 @@ patchPluginXml {
 
 test {
     useJUnitPlatform()
-//    testLogging {
-//        events "passed", "skipped", "failed"
-//    }
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+}
+
+jacoco {
+    toolVersion = '0.8.3'
+}
+
+jacocoTestReport {
+    reports {
+        xml.enabled false
+        csv.enabled false
+        html.destination file("${buildDir}/jacocoHtml")
+    }
 }
 
 publishPlugin {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt b/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt
index 0c644b6..c6ab1e3 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt
@@ -7,6 +7,13 @@ class AssertJClassNames {
         @NonNls
         const val ASSERTIONS_CLASSNAME = "org.assertj.core.api.Assertions"
 
+        @NonNls
+        const val DESCRIPTABLE_INTERFACE = "org.assertj.core.api.Descriptable"
+        @NonNls
+        const val EXTENSION_POINTS_INTERFACE = "org.assertj.core.api.ExtensionPoints"
+
+        @NonNls
+        const val ASSERT_INTERFACE = "org.assertj.core.api.Assert"
         @NonNls
         const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
         @NonNls
@@ -32,7 +39,5 @@ class AssertJClassNames {
         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"
     }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/CommonMatchers.kt b/src/main/java/de/platon42/intellij/plugins/cajon/CommonMatchers.kt
index bafe3c2..e1b5edc 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/CommonMatchers.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/CommonMatchers.kt
@@ -6,6 +6,7 @@ import com.siyeh.ig.callMatcher.CallMatcher
 val CORE_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
 val GUAVA_ASSERT_THAT_MATCHER = CallMatcher.staticCall(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)!!
 val ALL_ASSERT_THAT_MATCHERS = CallMatcher.anyOf(CORE_ASSERT_THAT_MATCHER, GUAVA_ASSERT_THAT_MATCHER)!!
+
 val EXTRACTING_FROM_OBJECT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME, "extracting")!!
 val EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "extracting")!!
 val FLAT_EXTRACTING_FROM_ITERABLE = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "flatExtracting")!!
@@ -18,6 +19,20 @@ val EXTRACTING_CALL_MATCHERS = CallMatcher.anyOf(
     EXTRACTING_RESULT_OF_FROM_ITERABLE
 )!!
 
+val DESCRIBED_AS = CallMatcher.instanceCall(AssertJClassNames.DESCRIPTABLE_INTERFACE, MethodNames.DESCRIBED_AS, MethodNames.AS)!!
+val WITH_REPRESENTATION_AND_SUCH = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "withRepresentation", "withThreadDumpOnError")!!
+val USING_COMPARATOR = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "usingComparator", "usingDefaultComparator")!!
+val IN_HEXADECIMAL_OR_BINARY = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ASSERT_CLASSNAME, MethodNames.IN_HEXADECIMAL, MethodNames.IN_BINARY)!!
+val EXTENSION_POINTS = CallMatcher.instanceCall(AssertJClassNames.EXTENSION_POINTS_INTERFACE, "is", "isNot", "has", "doesNotHave", "satisfies")!!
+
+val NOT_ACTUAL_ASSERTIONS = CallMatcher.anyOf(
+    ALL_ASSERT_THAT_MATCHERS,
+    DESCRIBED_AS,
+    WITH_REPRESENTATION_AND_SUCH,
+    USING_COMPARATOR,
+    IN_HEXADECIMAL_OR_BINARY
+)!!
+
 val KNOWN_METHODS_WITH_SIDE_EFFECTS = CallMatcher.anyOf(
     CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_ITERATOR, "next")
 )!!
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt b/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
index c9d5563..23057a9 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
@@ -1,51 +1,71 @@
 package de.platon42.intellij.plugins.cajon
 
+import com.intellij.lang.jvm.JvmModifier
 import com.intellij.psi.*
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.codeStyle.JavaCodeStyleManager
 import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.util.PsiUtil
 import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.inspections.AbstractAssertJInspection
 
-val PsiMethodCallExpression.qualifierExpression: PsiExpression get() = this.methodExpression.qualifierExpression!!
-val PsiMethodCallExpression.firstArg: PsiExpression get() = this.argumentList.expressions[0]!!
+val PsiMethodCallExpression.qualifierExpression: PsiExpression get() = methodExpression.qualifierExpression!!
+val PsiMethodCallExpression.firstArg: PsiExpression get() = getArg(0)
 
 fun PsiMethodCallExpression.replaceQualifier(qualifier: PsiElement) {
-    this.qualifierExpression.replace(qualifier)
+    qualifierExpression.replace(qualifier)
 }
 
 fun PsiMethodCallExpression.replaceQualifierFromMethodCall(oldMethodCall: PsiMethodCallExpression) {
-    this.qualifierExpression.replace(oldMethodCall.qualifierExpression)
+    qualifierExpression.replace(oldMethodCall.qualifierExpression)
 }
 
 fun PsiElement.findOutmostMethodCall(): PsiMethodCallExpression? {
-    val statement = PsiTreeUtil.getParentOfType(this, PsiStatement::class.java) ?: return null
+    val statement = PsiTreeUtil.getParentOfType(this, PsiStatement::class.java, false) ?: return null
     return PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java)
 }
 
-fun PsiMethodCallExpression.findFluentCallTo(matcher: CallMatcher): PsiMethodCallExpression? {
-    var currentMethodCall: PsiMethodCallExpression? = this
-    while (currentMethodCall != null) {
-        if (matcher.test(currentMethodCall)) {
-            return currentMethodCall
+fun PsiElement.findStaticMethodCall(): PsiMethodCallExpression? {
+    var elem: PsiElement? = this
+    while (elem != null) {
+        if ((elem is PsiMethodCallExpression) && (elem.resolveMethod()?.hasModifier(JvmModifier.STATIC) == true)) {
+            return elem
         }
-        currentMethodCall = PsiTreeUtil.getParentOfType(currentMethodCall, PsiMethodCallExpression::class.java, true, PsiStatement::class.java)
+        elem = elem.firstChild
     }
     return null
 }
 
-fun PsiMethodCallExpression.getArg(n: Int): PsiExpression = this.argumentList.expressions[n]
+fun PsiElement.gatherAssertionCalls(): List<PsiMethodCallExpression> {
+    val assertThatMethodCall = findStaticMethodCall() ?: return emptyList()
+    return assertThatMethodCall.collectMethodCallsUpToStatement()
+        .filterNot { NOT_ACTUAL_ASSERTIONS.test(it) }
+        .toList()
+}
+
+fun PsiMethodCallExpression.collectMethodCallsUpToStatement(): Sequence<PsiMethodCallExpression> {
+    return generateSequence(this) { PsiTreeUtil.getParentOfType(it, PsiMethodCallExpression::class.java, true, PsiStatement::class.java) }
+}
+
+fun PsiMethodCallExpression.findFluentCallTo(matcher: CallMatcher): PsiMethodCallExpression? {
+    return collectMethodCallsUpToStatement().find { matcher.test(it) }
+}
+
+fun PsiMethodCallExpression.getArg(n: Int): PsiExpression = PsiUtil.skipParenthesizedExprDown(argumentList.expressions[n])!!
+
+fun PsiMethodCallExpression.getArgOrNull(n: Int): PsiExpression? = argumentList.expressions.getOrNull(n)
 
 fun <T> Boolean.map(forTrue: T, forFalse: T) = if (this) forTrue else forFalse
 
 fun PsiMethod.addAsStaticImport(context: PsiElement, vararg allowedClashes: String) {
     val factory = JavaPsiFacade.getElementFactory(context.project)
-    val methodName = this.name
-    val containingClass = this.containingClass ?: return
+    val methodName = name
+    val containingClass = containingClass ?: return
     val importList = (context.containingFile as PsiJavaFile).importList ?: return
     val notImportedStatically = importList.importStaticStatements.none {
         val targetClass = it.resolveTargetClass() ?: return@none false
         ((it.referenceName == methodName) && !allowedClashes.contains(targetClass.qualifiedName))
-                || (it.isOnDemand && (targetClass == this.containingClass))
+                || (it.isOnDemand && (targetClass == containingClass))
     }
     if (notImportedStatically) {
         importList.add(factory.createImportStaticStatement(containingClass, methodName))
@@ -56,4 +76,67 @@ fun PsiElement.shortenAndReformat() {
     val codeStyleManager = JavaCodeStyleManager.getInstance(project)
     codeStyleManager.shortenClassReferences(this)
     CodeStyleManager.getInstance(project).reformat(this)
+}
+
+fun PsiMethodCallExpression.getExpectedBooleanResult(): Boolean? {
+    val isTrue = AbstractAssertJInspection.IS_TRUE.test(this)
+    val isFalse = AbstractAssertJInspection.IS_FALSE.test(this)
+    if (isTrue || isFalse) {
+        return isTrue
+    } else {
+        val isEqualTo = AbstractAssertJInspection.IS_EQUAL_TO_BOOLEAN.test(this) || AbstractAssertJInspection.IS_EQUAL_TO_OBJECT.test(this)
+        val isNotEqualTo =
+            AbstractAssertJInspection.IS_NOT_EQUAL_TO_BOOLEAN.test(this) || AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT.test(this)
+        if (isEqualTo || isNotEqualTo) {
+            val constValue = calculateConstantParameterValue(0) as? Boolean ?: return null
+            return isNotEqualTo xor constValue
+        }
+    }
+    return null
+}
+
+fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
+    if (argIndex >= argumentList.expressions.size) return null
+    val valueExpression = getArg(argIndex)
+    val constantEvaluationHelper = JavaPsiFacade.getInstance(project).constantEvaluationHelper
+    val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
+    if (value == null) {
+        val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
+        if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
+            return when (field.name) {
+                "TRUE" -> true
+                "FALSE" -> false
+                else -> null
+            }
+        }
+    }
+    return value
+}
+
+fun PsiExpression.getAllTheSameExpectedBooleanConstants(): Boolean? {
+    val assertThatMethodCall = findStaticMethodCall() ?: return null
+    var lockedResult: Boolean? = null
+    val methodsToView = generateSequence(assertThatMethodCall) { PsiTreeUtil.getParentOfType(it, PsiMethodCallExpression::class.java) }
+
+    for (methodCall in methodsToView) {
+        val expectedResult = methodCall.getExpectedBooleanResult()
+        if (expectedResult != null) {
+            if ((lockedResult != null) && (lockedResult != expectedResult)) {
+                return null
+            }
+            lockedResult = expectedResult
+        } else {
+            val isNotConstant = CallMatcher.anyOf(
+                EXTENSION_POINTS,
+                AbstractAssertJInspection.IS_EQUAL_TO_BOOLEAN,
+                AbstractAssertJInspection.IS_EQUAL_TO_OBJECT,
+                AbstractAssertJInspection.IS_NOT_EQUAL_TO_BOOLEAN,
+                AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT
+            ).test(methodCall)
+            if (isNotConstant) {
+                return null
+            }
+        }
+    }
+    return lockedResult
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/Helper.kt b/src/main/java/de/platon42/intellij/plugins/cajon/Helper.kt
index 6509572..4e9bd4d 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/Helper.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/Helper.kt
@@ -4,6 +4,7 @@ import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiExpression
 import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.search.GlobalSearchScope
 
 fun createAssertThat(context: PsiElement, actualExpression: PsiExpression): PsiMethodCallExpression {
     return createAssertThat(context, AssertJClassNames.ASSERTIONS_CLASSNAME, actualExpression)
@@ -29,4 +30,11 @@ fun createMethodCall(context: PsiElement, fullQualifiedMethodName: String, varar
     ) as PsiMethodCallExpression
     arguments.forEachIndexed { index, newArg -> expectedExpression.getArg(index).replace(newArg) }
     return expectedExpression
+}
+
+fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
+    val findClass =
+        JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
+            ?: return false
+    return findClass.allMethods.any { it.name == methodname }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/MethodNames.kt b/src/main/java/de/platon42/intellij/plugins/cajon/MethodNames.kt
index 14f9c05..e03dfd2 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/MethodNames.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/MethodNames.kt
@@ -11,8 +11,16 @@ class MethodNames {
 
         @NonNls
         const val ASSERT_THAT = "assertThat"
+
         @NonNls
         const val AS = "as"
+        @NonNls
+        const val DESCRIBED_AS = "describedAs"
+        @NonNls
+        const val IN_HEXADECIMAL = "inHexadecimal"
+        @NonNls
+        const val IN_BINARY = "inBinary"
+
         @NonNls
         const val IS_EQUAL_TO = "isEqualTo"
         @NonNls
@@ -38,7 +46,7 @@ class MethodNames {
         @NonNls
         const val IS_FALSE = "isFalse"
         @NonNls
-        const val IS_NULL = "isNull"
+        const val IS_NULL = "isNull" // terminal, returns void
         @NonNls
         const val IS_NOT_NULL = "isNotNull"
         @NonNls
@@ -51,7 +59,7 @@ class MethodNames {
         const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"
 
         @NonNls
-        const val IS_EMPTY = "isEmpty"
+        const val IS_EMPTY = "isEmpty" // terminal, returns void
         @NonNls
         const val IS_NOT_EMPTY = "isNotEmpty"
         @NonNls
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
index 3e5cecb..d011709 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
@@ -3,6 +3,7 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.tree.IElementType
@@ -14,10 +15,10 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_C
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_OPTIONAL_CLASSNAME
 import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.getArg
 import de.platon42.intellij.plugins.cajon.qualifierExpression
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSimpleMethodCallQuickFix
 
@@ -28,8 +29,9 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         const val MORE_CONCISE_MESSAGE_TEMPLATE = "%s() would be more concise than %s()"
 
         const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with %s()"
-        const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE = "Remove unwrapping of expected expression and replace %s() with %s()"
-        const val UNWRAP_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap actual expression and replace %s() with %s()"
+        const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE = "Unwrap expected expression and replace %s() with %s()"
+        const val MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE = "Remove %s() of actual expression and use assertThat().%s() instead"
+        const val MOVING_OUT_MESSAGE_TEMPLATE = "Moving %s() expression out of assertThat() would be more concise"
 
         val TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP = mapOf<IElementType, String>(
             JavaTokenType.EQEQ to MethodNames.IS_EQUAL_TO,
@@ -74,21 +76,21 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val ASSERT_THAT_JAVA8_OPTIONAL = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
             .parameterTypes(CommonClassNames.JAVA_UTIL_OPTIONAL)!!
 
-        val ASSERT_THAT_GUAVA_OPTIONAL = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
-            .parameterTypes(GUAVA_OPTIONAL_CLASSNAME)!!
+        val GUAVA_ASSERT_THAT_ANY = CallMatcher.staticCall(GUAVA_ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
+            .parameterCount(1)!!
 
-        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
+        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("boolean")!!
         val IS_NOT_EQUAL_TO_BOOLEAN =
             CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
                 .parameterTypes("boolean")!!
-        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_SAME_AS)
+        val IS_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_SAME_AS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
-        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_NOT_SAME_AS)
+        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_SAME_AS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
 
         val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)
@@ -174,7 +176,22 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
         val quickFix = ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
-        holder.registerProblem(expression, message, quickFix)
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickFix)
+    }
+
+    protected fun registerMoveOutMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldActualExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
+        val description = MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, message, quickfix)
     }
 
     protected fun registerReplaceMethod(
@@ -199,7 +216,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         val description = descriptionTemplate.format(originalMethod, replacementMethod)
         val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickfix)
     }
 
     protected fun registerRemoveExpectedOutmostMethod(
@@ -211,55 +229,4 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
     ) {
         registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
-
-    protected fun registerRemoveActualOutmostMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldExpectedCallExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        registerConciseMethod(UNWRAP_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
-    }
-
-    protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
-        if (argIndex >= expression.argumentList.expressions.size) return null
-        val valueExpression = expression.getArg(argIndex)
-        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
-        val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
-        if (value == null) {
-            val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
-            if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
-                return when (field.name) {
-                    "TRUE" -> true
-                    "FALSE" -> false
-                    else -> null
-                }
-            }
-        }
-        return value
-    }
-
-    protected fun getExpectedBooleanResult(expectedCallExpression: PsiMethodCallExpression): Boolean? {
-        val isTrue = IS_TRUE.test(expectedCallExpression)
-        val isFalse = IS_FALSE.test(expectedCallExpression)
-        if (isTrue || isFalse) {
-            return isTrue
-        } else {
-            val isEqualTo = IS_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
-            val isNotEqualTo = IS_NOT_EQUAL_TO_BOOLEAN.test(expectedCallExpression) || IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
-            if (isEqualTo || isNotEqualTo) {
-                val constValue = calculateConstantParameterValue(expectedCallExpression, 0) as? Boolean ?: return null
-                return isNotEqualTo xor constValue
-            }
-        }
-        return null
-    }
-
-    protected fun hasAssertJMethod(element: PsiElement, classname: String, methodname: String): Boolean {
-        val findClass =
-            JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
-                ?: return false
-        return findClass.allMethods.any { it.name == methodname }
-    }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt
index aae1115..10dc818 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt
@@ -7,10 +7,6 @@ import org.jetbrains.annotations.NonNls
 open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
 
     companion object {
-        const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
-
-        const val REPLACE_DESCRIPTION_TEMPLATE = "Replace %s() with assertThat().%s()"
-
         @NonNls
         const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
 
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt
index 4f5cbe6..2036890 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt
@@ -4,11 +4,8 @@ import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
 import com.intellij.psi.util.TypeConversionUtil
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.map
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveActualOuterExpressionMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix
 
 class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
@@ -23,19 +20,20 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+                super.visitExpressionStatement(statement)
+                val staticMethodCall = statement?.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
                     return
                 }
 
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
 
-                val assertThatArgument = expression.firstArg
+                val assertThatArgument = staticMethodCall.firstArg
                 if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
                     val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
-                    registerSplitMethod(holder, expression, "${MethodNames.EQUALS}()", replacementMethod, ::MoveActualOuterExpressionMethodCallQuickFix)
+                    registerSplitMethod(holder, expectedCallExpression, "${MethodNames.EQUALS}()", replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
                     return
                 }
 
@@ -50,7 +48,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                     return
                 } else if (isLeftNull || isRightNull) {
                     val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
-                    registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                    registerSplitMethod(holder, expectedCallExpression, "binary", replacementMethod) { desc, method ->
                         SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
                     }
                     return
@@ -58,7 +56,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
 
                 val isPrimitive = bothTypes.all(TypeConversionUtil::isPrimitiveAndNotNull)
                 val isNumericType = bothTypes.all(TypeConversionUtil::isNumericType)
-                val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+                val constantEvaluationHelper = JavaPsiFacade.getInstance(statement.project).constantEvaluationHelper
                 val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
 
                 val tokenType = binaryExpression.operationTokenType
@@ -72,7 +70,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                     (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
                 val replacementMethod = mappingToUse[tokenType] ?: return
 
-                registerSplitMethod(holder, expression, "binary", replacementMethod) { desc, method ->
+                registerSplitMethod(holder, expectedCallExpression, "binary", replacementMethod) { desc, method ->
                     SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
                 }
             }
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspection.kt
index 6c02b21..6d6f38b 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspection.kt
@@ -7,6 +7,7 @@ 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.calculateConstantParameterValue
 import de.platon42.intellij.plugins.cajon.firstArg
 import de.platon42.intellij.plugins.cajon.map
 
@@ -37,7 +38,7 @@ class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
                 if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) {
                     return
                 }
-                val expectedResult = calculateConstantParameterValue(expression, 0) as? Boolean ?: return
+                val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
                 val flippedBooleanTest = matchingCalls.drop(2).any { it }
 
                 val replacementMethod = (expectedResult xor flippedBooleanTest).map(MethodNames.IS_TRUE, MethodNames.IS_FALSE)
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt
index 594e16f..b1869b9 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt
@@ -6,6 +6,7 @@ import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.PsiStatement
 import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.calculateConstantParameterValue
 
 class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
 
@@ -24,7 +25,7 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
                     return
                 }
 
-                val value = calculateConstantParameterValue(expression, 0) ?: return
+                val value = expression.calculateConstantParameterValue(0) ?: return
                 if (value == 0) {
                     registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                 }
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt
index 2ca223e..455ef97 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt
@@ -1,10 +1,8 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
@@ -15,97 +13,82 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
     companion object {
         private const val DISPLAY_NAME = "Asserting an Optional (Guava)"
         private const val REPLACE_GUAVA_DESCRIPTION_TEMPLATE = "Replace %s() with Guava assertThat().%s()"
-        private const val REMOVE_EXPECTED_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE = "Remove unwrapping of expected expression and replace %s() with Guava assertThat().%s()"
-        private const val REMOVE_ACTUAL_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE = "Unwrap actual expression and replace %s() with Guava assertThat().%s()"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun 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)) {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+                super.visitExpressionStatement(statement)
+                val staticMethodCall = statement?.findStaticMethodCall() ?: return
+
+                if (!checkPreconditions(staticMethodCall)) {
                     return
                 }
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
+                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
 
-                val isEqualTo = IS_EQUAL_TO_OBJECT.test(expectedCallExpression)
-                val isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expectedCallExpression)
-                if (assertThatGuava) {
-                    if (isEqualTo) {
-                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
-                        if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
-                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS, ::UnwrapExpectedStaticMethodCallQuickFix)
-                        } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
-                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_ABSENT)
-                        }
-                    } else if (isNotEqualTo) {
-                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
-                        if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
-                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_PRESENT)
+                val outmostMethodCall = statement.findOutmostMethodCall() ?: return
+                if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
+                    val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
+                    if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
+                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
+                            QuickFixWithPostfixDelegate(
+                                RemoveActualOutmostMethodCallQuickFix(desc, method),
+                                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                            )
                         }
                     }
-                } else {
-                    // 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)) {
-                            registerRemoveExpectedOutmostGuavaMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS)
-                        } 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)
-                        }
+                } else if (GUAVA_OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                    val expectedPresence = outmostMethodCall.getAllTheSameExpectedBooleanConstants() ?: return
+                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_ABSENT)
+                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
+                        QuickFixWithPostfixDelegate(
+                            MoveOutMethodCallExpressionQuickFix(desc, method),
+                            ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                        )
                     }
                 }
             }
-        }
-    }
 
-    private fun registerRemoveExpectedOutmostGuavaMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldExpectedCallExpression: PsiMethodCallExpression,
-        replacementMethod: String
-    ) {
-        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
-            QuickFixWithPostfixDelegate(
-                UnwrapExpectedStaticMethodCallQuickFix(desc, method),
-                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
-            )
-        }
-    }
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                if (!checkPreconditions(staticMethodCall)) {
+                    return
+                }
+                // We're not calling an assertThat() from Guava, but a core-AssertJ one!
+                // We need to replace that by the Guava one, if we want to apply a formally correct fix.
+                if (IS_EQUAL_TO_OBJECT.test(expression)) {
+                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
+                        registerRemoveExpectedOutmostMethod(holder, expression, expression, MethodNames.CONTAINS) { desc, method ->
+                            QuickFixWithPostfixDelegate(
+                                UnwrapExpectedStaticMethodCallQuickFix(desc, method),
+                                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                            )
+                        }
+                    } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                        registerSimplifyForGuavaMethod(holder, expression, MethodNames.IS_ABSENT)
+                    }
+                } else if (IS_NOT_EQUAL_TO_OBJECT.test(expression)) {
+                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
+                        registerSimplifyForGuavaMethod(holder, expression, MethodNames.IS_PRESENT)
+                    }
+                }
+            }
 
-    private fun registerRemoveActualOutmostForGuavaMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldExpectedCallExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        noExpectedExpression: Boolean = false
-    ) {
-        registerConciseMethod(REMOVE_ACTUAL_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
-            QuickFixWithPostfixDelegate(
-                RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression),
-                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
-            )
+            private fun checkPreconditions(staticMethodCall: PsiMethodCallExpression): Boolean {
+                val assertThatGuava = GUAVA_ASSERT_THAT_ANY.test(staticMethodCall)
+
+                if (ASSERT_THAT_ANY.test(staticMethodCall) || assertThatGuava) {
+                    JavaPsiFacade.getInstance(staticMethodCall.project)
+                        .findClass(AssertJClassNames.GUAVA_ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(staticMethodCall.project)) ?: return false
+                    return true
+                }
+                return false
+            }
         }
     }
 
@@ -117,6 +100,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
             ReplaceSimpleMethodCallQuickFix(description, replacementMethod),
             ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
         )
-        holder.registerProblem(expression, message, quickFix)
+        val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+        holder.registerProblem(expression, textRange, message, quickFix)
     }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt
index bbf0ee2..43eb833 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt
@@ -2,21 +2,15 @@ package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiInstanceOfExpression
-import com.intellij.psi.PsiMethodCallExpression
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.map
-import de.platon42.intellij.plugins.cajon.quickfixes.RemoveInstanceOfExpressionQuickFix
+import com.intellij.psi.*
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutInstanceOfExpressionQuickFix
 
 class AssertThatInstanceOfInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a class instance"
-        private const val REPLACE_INSTANCEOF_DESCRIPTION_TEMPLATE = "Replace instanceof expression by assertThat().%s()"
+        private const val REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE = "Remove instanceof in actual expression and use assertThat().%s() instead"
         private const val MOVE_OUT_INSTANCEOF_MESSAGE = "instanceof expression could be moved out of assertThat()"
     }
 
@@ -24,30 +18,31 @@ class AssertThatInstanceOfInspection : AbstractAssertJInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+                super.visitExpressionStatement(statement)
+                val staticMethodCall = statement?.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
                     return
                 }
 
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
 
-                if (expression.firstArg is PsiInstanceOfExpression) {
+                if (staticMethodCall.firstArg is PsiInstanceOfExpression) {
                     val replacementMethod = expectedResult.map(MethodNames.IS_INSTANCE_OF, MethodNames.IS_NOT_INSTANCE_OF)
-                    registerRemoveInstanceOfMethod(holder, expression, replacementMethod, ::RemoveInstanceOfExpressionQuickFix)
+                    registerMoveOutInstanceOfMethod(holder, expectedCallExpression, replacementMethod, ::MoveOutInstanceOfExpressionQuickFix)
                 }
             }
         }
     }
 
-    private fun registerRemoveInstanceOfMethod(
+    private fun registerMoveOutInstanceOfMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        val description = REPLACE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(replacementMethod)
+        val description = REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(replacementMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
         holder.registerProblem(expression, MOVE_OUT_INSTANCEOF_MESSAGE, quickfix)
     }
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt
index ddf1934..12c0e5c 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt
@@ -1,19 +1,17 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
-import de.platon42.intellij.plugins.cajon.MethodNames
 import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
+import de.platon42.intellij.plugins.cajon.findStaticMethodCall
 import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.map
-import de.platon42.intellij.plugins.cajon.quickfixes.RemoveUnaryExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.getExpectedBooleanResult
+import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryStatementQuickFix
 
 class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting an inverted boolean condition"
-        private const val INVERT_CONDITION_DESCRIPTION = "Invert condition in assertThat()"
         private const val INVERT_CONDITION_MESSAGE = "Condition inside assertThat() could be inverted"
     }
 
@@ -23,29 +21,18 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
+                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
                     return
                 }
+                expression.getExpectedBooleanResult() ?: return
 
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
-
-                val prefixExpression = expression.firstArg as? PsiPrefixExpression ?: return
+                val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
                 if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
-                    val replacementMethod = expectedResult.map(MethodNames.IS_FALSE, MethodNames.IS_TRUE)
-                    registerInvertMethod(holder, expression, replacementMethod, ::RemoveUnaryExpressionQuickFix)
+                    val outmostMethodCall = expression.findOutmostMethodCall() ?: return
+                    holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
                 }
             }
         }
     }
-
-    private fun registerInvertMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val quickfix = quickFixSupplier(INVERT_CONDITION_DESCRIPTION, replacementMethod)
-        holder.registerProblem(expression, INVERT_CONDITION_MESSAGE, quickfix)
-    }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt
index 5c3a788..ab46c3d 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt
@@ -3,12 +3,11 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiExpressionStatement
 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.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.UnwrapExpectedStaticMethodCallQuickFix
 
@@ -22,46 +21,52 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_ANY.test(expression)) {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+                super.visitExpressionStatement(statement)
+                val staticMethodCall = statement?.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_ANY.test(staticMethodCall)) {
                     return
                 }
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
+                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
 
-                if (ASSERT_THAT_JAVA8_OPTIONAL.test(expression)) {
+                val outmostMethodCall = statement.findOutmostMethodCall() ?: return
+                if (OPTIONAL_GET.test(actualExpression)) {
+                    val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
                     if (IS_EQUAL_TO_OBJECT.test(expectedCallExpression)) {
-                        val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
-                        if (CallMatcher.anyOf(OPTIONAL_OF, OPTIONAL_OF_NULLABLE).test(innerExpectedCall)) {
-                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS, ::UnwrapExpectedStaticMethodCallQuickFix)
-                        } else if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
-                            registerSimplifyMethod(holder, expectedCallExpression, MethodNames.IS_NOT_PRESENT)
+                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method)
                         }
-                    } 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 if (IS_SAME_AS_OBJECT.test(expectedCallExpression)) {
+                        registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS_SAME) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method)
                         }
                     }
-                } else {
-                    val actualExpression = expression.firstArg as? PsiMethodCallExpression ?: return
+                } else if (OPTIONAL_IS_PRESENT.test(actualExpression)) {
+                    val expectedPresence = outmostMethodCall.getAllTheSameExpectedBooleanConstants() ?: return
+                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
+                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
+                        MoveOutMethodCallExpressionQuickFix(desc, method)
+                    }
+                }
+            }
 
-                    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)
-                        }
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                val staticMethodCall = expression.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_JAVA8_OPTIONAL.test(staticMethodCall)) {
+                    return
+                }
+                if (IS_EQUAL_TO_OBJECT.test(expression)) {
+                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    if (CallMatcher.anyOf(OPTIONAL_OF, OPTIONAL_OF_NULLABLE).test(innerExpectedCall)) {
+                        registerRemoveExpectedOutmostMethod(holder, expression, expression, MethodNames.CONTAINS, ::UnwrapExpectedStaticMethodCallQuickFix)
+                    } else if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+                        registerSimplifyMethod(holder, expression, MethodNames.IS_NOT_PRESENT)
+                    }
+                } else if (IS_NOT_EQUAL_TO_OBJECT.test(expression)) {
+                    val innerExpectedCall = expression.firstArg as? PsiMethodCallExpression ?: return
+                    if (OPTIONAL_EMPTY.test(innerExpectedCall)) {
+                        registerSimplifyMethod(holder, expression, MethodNames.IS_PRESENT)
                     }
                 }
             }
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt
index 3357b24..e84d1d1 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt
@@ -2,10 +2,10 @@ package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
-import com.intellij.psi.util.PsiTreeUtil
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ITERABLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceHasSizeMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickFix
 
 class AssertThatSizeInspection : AbstractAssertJInspection() {
@@ -13,6 +13,7 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
     companion object {
         private const val DISPLAY_NAME = "Asserting the size of an collection, array or string"
         private const val REMOVE_SIZE_DESCRIPTION_TEMPLATE = "Remove size determination of expected expression and replace %s() with %s()"
+        private const val REMOVE_ALL_MESSAGE = "Try to operate on the iterable itself rather than its size"
 
         private val BONUS_EXPRESSIONS_CALL_MATCHER_MAP = listOf(
             IS_LESS_THAN_INT to MethodNames.HAS_SIZE_LESS_THAN,
@@ -20,90 +21,123 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
             IS_GREATER_THAN_INT to MethodNames.HAS_SIZE_GREATER_THAN,
             IS_GREATER_THAN_OR_EQUAL_TO_INT to MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO
         )
+
+        private fun isCharSequenceLength(expression: PsiExpression) = (expression is PsiMethodCallExpression) && CHAR_SEQUENCE_LENGTH.test(expression)
+
+        private fun isCollectionSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && COLLECTION_SIZE.test(expression)
+
+        private fun isArrayLength(expression: PsiExpression): Boolean {
+            val psiReferenceExpression = expression as? PsiReferenceExpression ?: return false
+            return ((psiReferenceExpression.qualifierExpression?.type is PsiArrayType)
+                    && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
+        }
+
+        fun getMatch(expression: PsiMethodCallExpression, isForArrayOrCollection: Boolean, isForString: Boolean): Match? {
+            val isLastExpression = expression.parent is PsiStatement
+            val constValue = expression.calculateConstantParameterValue(0)
+            if (IS_EQUAL_TO_INT.test(expression)) {
+                return if ((constValue == 0) && isLastExpression) {
+                    Match(expression, MethodNames.IS_EMPTY, noExpectedExpression = true)
+                } else {
+                    val equalToExpression = expression.firstArg
+                    if (isForArrayOrCollection && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) ||
+                        isForString && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression) || isCharSequenceLength(equalToExpression))
+                    ) {
+                        Match(expression, MethodNames.HAS_SAME_SIZE_AS, expectedIsCollection = true)
+                    } else {
+                        Match(expression, MethodNames.HAS_SIZE)
+                    }
+                }
+            } else {
+                val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 0))
+                        || (IS_LESS_THAN_INT.test(expression) && (constValue == 1))
+                        || IS_ZERO.test(expression))
+                val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expression) && (constValue == 0))
+                        || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (constValue == 1))
+                        || IS_NOT_ZERO.test(expression))
+                if ((isTestForEmpty && isLastExpression) || isTestForNotEmpty) {
+                    val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
+                    return Match(expression, replacementMethod, noExpectedExpression = true)
+                } else if (hasAssertJMethod(expression, ABSTRACT_ITERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE_LESS_THAN)) {
+                    // new stuff in AssertJ 13.2.0
+                    val replacementMethod = BONUS_EXPRESSIONS_CALL_MATCHER_MAP.find { it.first.test(expression) }?.second ?: return null
+                    return Match(expression, replacementMethod)
+                }
+                return null
+            }
+        }
     }
 
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+                super.visitExpressionStatement(statement)
+                val staticMethodCall = statement?.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_INT.test(staticMethodCall)) {
+                    return
+                }
+                val actualExpression = staticMethodCall.firstArg
+                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForString = isCharSequenceLength(actualExpression)
+                if (!(isForArrayOrCollection || isForString)) {
+                    return
+                }
+                val matches = staticMethodCall.collectMethodCallsUpToStatement()
+                    .mapNotNull { getMatch(it, isForArrayOrCollection, isForString) }
+                    .toList()
+                if (matches.isNotEmpty()) {
+                    if (matches.size == 1) {
+                        val match = matches.single()
+                        val expression = match.methodCall
+                        registerReplaceMethod(
+                            holder,
+                            expression,
+                            expression,
+                            match.replacementMethod
+                        )
+                        { desc, method ->
+                            ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = match.noExpectedExpression, expectedIsCollection = match.expectedIsCollection)
+                        }
+                    } else {
+                        // I could try to create a quickfix for this, too, but it's probably not worth the effort
+                        holder.registerProblem(statement, REMOVE_ALL_MESSAGE)
+                    }
+                }
+            }
+
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                val isAssertThatWithInt = ASSERT_THAT_INT.test(expression)
                 val isHasSize = HAS_SIZE.test(expression)
-                if (!(isAssertThatWithInt || isHasSize)) {
+                if (!(isHasSize)) {
                     return
                 }
                 val actualExpression = expression.firstArg
 
                 val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (isHasSize && (isForArrayOrCollection
+                if (!(isForArrayOrCollection
                             || (isForString && checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)))
                 ) {
-                    val assertThatCall = PsiTreeUtil.findChildrenOfType(expression, PsiMethodCallExpression::class.java).find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return
-                    registerConciseMethod(
-                        REMOVE_SIZE_DESCRIPTION_TEMPLATE,
-                        holder,
-                        assertThatCall,
-                        expression,
-                        MethodNames.HAS_SAME_SIZE_AS
-                    ) { desc, method ->
-                        ReplaceSizeMethodCallQuickFix(desc, method, expectedIsCollection = true, keepActualAsIs = true)
-                    }
-                } else if (isForArrayOrCollection || isForString) {
-                    val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                    val constValue = calculateConstantParameterValue(expectedCallExpression, 0)
-                    if (IS_EQUAL_TO_INT.test(expectedCallExpression)) {
-                        if (constValue == 0) {
-                            registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.IS_EMPTY) { desc, method ->
-                                ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = true)
-                            }
-                        } else {
-                            val equalToExpression = expectedCallExpression.firstArg
-                            if (isForArrayOrCollection && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) ||
-                                isForString && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression) || isCharSequenceLength(equalToExpression))
-                            ) {
-                                registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.HAS_SAME_SIZE_AS) { desc, method ->
-                                    ReplaceSizeMethodCallQuickFix(desc, method, expectedIsCollection = true)
-                                }
-                            } else {
-                                registerReplaceMethod(holder, expression, expectedCallExpression, MethodNames.HAS_SIZE) { desc, method ->
-                                    ReplaceSizeMethodCallQuickFix(desc, method)
-                                }
-                            }
-                        }
-                    } else {
-                        val isTestForEmpty = ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 0))
-                                || (IS_LESS_THAN_INT.test(expectedCallExpression) && (constValue == 1))
-                                || IS_ZERO.test(expectedCallExpression))
-                        val isTestForNotEmpty = ((IS_GREATER_THAN_INT.test(expectedCallExpression) && (constValue == 0))
-                                || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 1))
-                                || IS_NOT_ZERO.test(expectedCallExpression))
-                        if (isTestForEmpty || isTestForNotEmpty) {
-                            val replacementMethod = isTestForEmpty.map(MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY)
-                            registerReplaceMethod(holder, expression, expectedCallExpression, replacementMethod) { desc, method ->
-                                ReplaceSizeMethodCallQuickFix(desc, method, noExpectedExpression = true)
-                            }
-                        } else if (hasAssertJMethod(expression, ABSTRACT_ITERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE_LESS_THAN)) {
-                            // new stuff in AssertJ 13.2.0
-                            val matchedMethod = BONUS_EXPRESSIONS_CALL_MATCHER_MAP.find { it.first.test(expectedCallExpression) }?.second ?: return
-                            registerReplaceMethod(holder, expression, expectedCallExpression, matchedMethod) { desc, method ->
-                                ReplaceSizeMethodCallQuickFix(desc, method)
-                            }
-                        }
-                    }
+                    return
                 }
-            }
-
-            private fun isCharSequenceLength(expression: PsiExpression) = (expression is PsiMethodCallExpression) && CHAR_SEQUENCE_LENGTH.test(expression)
-
-            private fun isCollectionSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && COLLECTION_SIZE.test(expression)
-
-            private fun isArrayLength(expression: PsiExpression): Boolean {
-                val psiReferenceExpression = expression as? PsiReferenceExpression ?: return false
-                return ((psiReferenceExpression.qualifierExpression?.type is PsiArrayType)
-                        && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
+                registerConciseMethod(
+                    REMOVE_SIZE_DESCRIPTION_TEMPLATE,
+                    holder,
+                    expression,
+                    expression,
+                    MethodNames.HAS_SAME_SIZE_AS,
+                    ::ReplaceHasSizeMethodCallQuickFix
+                )
             }
         }
     }
+
+    class Match(
+        val methodCall: PsiMethodCallExpression,
+        val replacementMethod: String,
+        val noExpectedExpression: Boolean = false,
+        val expectedIsCollection: Boolean = false
+    )
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt
index 8b3f07b..904296e 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt
@@ -1,29 +1,20 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
-import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.CommonClassNames
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.*
 import com.siyeh.ig.callMatcher.CallMatcher
-import de.platon42.intellij.plugins.cajon.MethodNames
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveActualOuterExpressionMethodCallQuickFix
-import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
 
 class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a string specific expression"
-        private const val MOVE_EXPECTED_EXPRESSION_DESCRIPTION_TEMPLATE = "Remove %s() of expected expression and use assertThat().%s() instead"
-        private const val MOVING_OUT_MESSAGE_TEMPLATE = "Moving %s() expression out of assertThat() would be more concise"
 
         private val MAPPINGS = listOf(
             Mapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0)!!,
-                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, hasExpected = false
+                MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
             ),
             Mapping(
                 CallMatcher.anyOf(
@@ -55,48 +46,27 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+                super.visitExpressionStatement(statement)
+                val staticMethodCall = statement?.findStaticMethodCall() ?: return
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
                     return
                 }
-                val assertThatArgument = expression.firstArg as? PsiMethodCallExpression ?: return
-
+                val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
 
-                val expectedCallExpression = expression.findOutmostMethodCall() ?: return
-                val expectedResult = getExpectedBooleanResult(expectedCallExpression) ?: return
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
 
                 val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse
-                if (mapping.hasExpected) {
-                    registerMoveOutMethod(holder, expression, assertThatArgument, replacementMethod, ::MoveActualOuterExpressionMethodCallQuickFix)
-                } else {
-                    registerMoveOutMethod(holder, expression, assertThatArgument, replacementMethod) { desc, method ->
-                        RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression = true)
-                    }
-                }
+                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
             }
         }
     }
 
-    private fun registerMoveOutMethod(
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression,
-        oldActualExpression: PsiMethodCallExpression,
-        replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix
-    ) {
-        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
-        val description = MOVE_EXPECTED_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
-    }
-
     private class Mapping(
         val callMatcher: CallMatcher,
         val replacementForTrue: String,
-        val replacementForFalse: String,
-        val hasExpected: Boolean = true
+        val replacementForFalse: String
     )
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt
index ea53105..10c0a92 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt
@@ -7,6 +7,7 @@ import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.PsiStatement
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.MethodNames
+import de.platon42.intellij.plugins.cajon.calculateConstantParameterValue
 
 class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
 
@@ -31,7 +32,7 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
                     return
                 }
 
-                val value = calculateConstantParameterValue(expression, 0) ?: return
+                val value = expression.calculateConstantParameterValue(0) ?: return
                 if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
                     registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
                 }
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt
index 56ea732..b8682ce 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt
@@ -16,6 +16,8 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Convert JUnit assertions to AssertJ"
+        private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
+        private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to assertThat().%s()"
 
         private val MAPPINGS = listOf(
             Mapping(
@@ -142,7 +144,7 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
         val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
         val quickfix = quickFixSupplier(description, replacementMethod)
         holder.registerProblem(expression, message, quickfix)
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt
index 694331b..fc79c28 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt
@@ -37,7 +37,11 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                         if (!reset) {
                             val isSame = when (actualExpression) {
                                 is PsiMethodCallExpression -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                                        && !KNOWN_METHODS_WITH_SIDE_EFFECTS.test(actualExpression)
+                                        && PsiTreeUtil.findChildrenOfAnyType(
+                                    actualExpression,
+                                    false,
+                                    PsiMethodCallExpression::class.java
+                                ).none { KNOWN_METHODS_WITH_SIDE_EFFECTS.test(it) }
                                 else -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
                             }
                             if (isSame) {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/AbstractCommonQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/AbstractCommonQuickFix.kt
index 3eecf79..dcb4ac2 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/AbstractCommonQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/AbstractCommonQuickFix.kt
@@ -4,6 +4,7 @@ import com.intellij.codeInspection.LocalQuickFix
 
 abstract class AbstractCommonQuickFix(private val description: String) : LocalQuickFix {
 
-    override fun getFamilyName() = description
+    override fun getName() = description
 
+    override fun getFamilyName() = description
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ForGuavaPostFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ForGuavaPostFix.kt
index 01ce9cf..67a4aad 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ForGuavaPostFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ForGuavaPostFix.kt
@@ -8,12 +8,13 @@ import com.intellij.psi.util.PsiTreeUtil
 import de.platon42.intellij.plugins.cajon.*
 
 class ForGuavaPostFix {
+
     companion object {
         val REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT: (Project, ProblemDescriptor) -> Unit = exit@
         { _, descriptor ->
             val element = descriptor.startElement
             val statement = PsiTreeUtil.getParentOfType(element, PsiStatement::class.java) ?: return@exit
-            val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return@exit
+            val assertThatCall = statement.findStaticMethodCall() ?: return@exit
 
             val newMethodCall = createGuavaAssertThat(element, assertThatCall.firstArg)
             newMethodCall.resolveMethod()?.addAsStaticImport(element, AssertJClassNames.ASSERTIONS_CLASSNAME)
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/InvertUnaryStatementQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/InvertUnaryStatementQuickFix.kt
new file mode 100644
index 0000000..616c1d5
--- /dev/null
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/InvertUnaryStatementQuickFix.kt
@@ -0,0 +1,37 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiUnaryExpression
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.util.PsiUtil
+import de.platon42.intellij.plugins.cajon.*
+
+class InvertUnaryStatementQuickFix : AbstractCommonQuickFix(INVERT_CONDITION_DESCRIPTION) {
+
+    companion object {
+        private const val INVERT_CONDITION_DESCRIPTION = "Invert condition in assertThat()"
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val assertExpression = assertThatMethodCall.firstArg as? PsiUnaryExpression ?: return
+        val operand = PsiUtil.skipParenthesizedExprDown(assertExpression.operand) ?: return
+        assertExpression.replace(operand)
+
+        var methodCall: PsiMethodCallExpression? = assertThatMethodCall
+        while (methodCall != null) {
+            val expectedResult = methodCall.getExpectedBooleanResult()
+            val nextMethodCall = PsiTreeUtil.getParentOfType(methodCall, PsiMethodCallExpression::class.java)
+            if (expectedResult != null) {
+                val replacementMethod = expectedResult.map(MethodNames.IS_FALSE, MethodNames.IS_TRUE)
+                val expectedExpression = createExpectedMethodCall(methodCall, replacementMethod)
+                expectedExpression.replaceQualifierFromMethodCall(methodCall)
+                methodCall.replace(expectedExpression)
+            }
+            methodCall = nextMethodCall
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/JoinStatementsQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/JoinStatementsQuickFix.kt
index ed94fcc..a033dcf 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/JoinStatementsQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/JoinStatementsQuickFix.kt
@@ -5,9 +5,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.*
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.util.PsiTreeUtil
-import de.platon42.intellij.plugins.cajon.ALL_ASSERT_THAT_MATCHERS
+import de.platon42.intellij.plugins.cajon.findStaticMethodCall
 
 class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
+
     companion object {
         private const val JOIN_STATEMENTS_MESSAGE = "Join assertThat() statements"
     }
@@ -31,9 +32,7 @@ class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
             val statementComments = PsiTreeUtil.getChildrenOfAnyType(previousStatement, PsiComment::class.java)
             commentsToKeep.addAll(statementComments)
 
-            val assertThatCallOfCursorStatement =
-                PsiTreeUtil.findChildrenOfType(lastStatement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
-                    ?: throw IllegalStateException("Internal error")
+            val assertThatCallOfCursorStatement = lastStatement.findStaticMethodCall() ?: throw IllegalStateException("Internal error")
 
             val lastElementBeforeConcat = assertThatCallOfCursorStatement.parent
             commentsToKeep.forEach {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveActualOuterExpressionMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveActualOuterExpressionMethodCallQuickFix.kt
deleted file mode 100644
index d81cd9b..0000000
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveActualOuterExpressionMethodCallQuickFix.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import de.platon42.intellij.plugins.cajon.*
-
-class MoveActualOuterExpressionMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCallExpression.firstArg as? PsiMethodCallExpression ?: return
-        val assertExpressionArg = assertExpression.firstArg.copy()
-        assertExpression.replace(assertExpression.qualifierExpression)
-
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod, assertExpressionArg)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutInstanceOfExpressionQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutInstanceOfExpressionQuickFix.kt
new file mode 100644
index 0000000..58d1596
--- /dev/null
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutInstanceOfExpressionQuickFix.kt
@@ -0,0 +1,44 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiInstanceOfExpression
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.util.PsiUtil
+import de.platon42.intellij.plugins.cajon.*
+
+class MoveOutInstanceOfExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val REMOVE_INSTANCEOF_DESCRIPTION = "Move instanceof in actual expressions out of assertThat()"
+    }
+
+    override fun getFamilyName(): String {
+        return REMOVE_INSTANCEOF_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val assertExpression = assertThatMethodCall.firstArg as? PsiInstanceOfExpression ?: return
+        val expectedClass = assertExpression.checkType ?: return
+
+        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
+            .filter { it.getExpectedBooleanResult() != null }
+            .toList()
+
+        val factory = JavaPsiFacade.getElementFactory(project)
+        val classObjectAccess = factory.createExpressionFromText("${expectedClass.type.canonicalText}.class", null)
+
+        val operand = PsiUtil.deparenthesizeExpression(assertExpression.operand) ?: return
+        assertExpression.replace(operand)
+
+        methodsToFix
+            .forEach {
+                val expectedExpression = createExpectedMethodCall(it, replacementMethod, classObjectAccess)
+                expectedExpression.replaceQualifierFromMethodCall(it)
+                it.replace(expectedExpression)
+            }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt
new file mode 100644
index 0000000..d7db193
--- /dev/null
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt
@@ -0,0 +1,37 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.*
+
+class MoveOutMethodCallExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val REMOVE_ACTUAL_EXPRESSION_DESCRIPTION = "Move method calls in actual expressions out of assertThat()"
+    }
+
+    override fun getFamilyName(): String {
+        return REMOVE_ACTUAL_EXPRESSION_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
+        val assertExpressionArg = assertExpression.getArgOrNull(0)?.copy()
+
+        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
+            .filter { it.getExpectedBooleanResult() != null }
+            .toList()
+
+        assertExpression.replace(assertExpression.qualifierExpression)
+
+        methodsToFix
+            .forEach {
+                val expectedExpression = createExpectedMethodCall(it, replacementMethod, *listOfNotNull(assertExpressionArg).toTypedArray())
+                expectedExpression.replaceQualifierFromMethodCall(it)
+                it.replace(expectedExpression)
+            }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/QuickFixWithPostfixDelegate.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/QuickFixWithPostfixDelegate.kt
index 042e0e8..97a5dcd 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/QuickFixWithPostfixDelegate.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/QuickFixWithPostfixDelegate.kt
@@ -9,6 +9,10 @@ class QuickFixWithPostfixDelegate(
     private val postfix: (Project, ProblemDescriptor) -> Unit
 ) : LocalQuickFix by mainFix {
 
+    override fun getName(): String {
+        return mainFix.name
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         mainFix.applyFix(project, descriptor)
         postfix(project, descriptor)
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveActualOutmostMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveActualOutmostMethodCallQuickFix.kt
index 71ab22c..da43e58 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveActualOutmostMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveActualOutmostMethodCallQuickFix.kt
@@ -11,16 +11,29 @@ class RemoveActualOutmostMethodCallQuickFix(
     private val noExpectedExpression: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val REMOVE_ACTUAL_EXPRESSION_DESCRIPTION = "Remove method calls in actual expressions and use better assertion"
+    }
+
+    override fun getFamilyName(): String {
+        return REMOVE_ACTUAL_EXPRESSION_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCallExpression.firstArg as? PsiMethodCallExpression ?: return
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
+
+        val methodsToFix = assertThatMethodCall.gatherAssertionCalls()
+
         assertExpression.replace(assertExpression.qualifierExpression)
 
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-        val args = if (noExpectedExpression) emptyArray() else oldExpectedExpression.argumentList.expressions
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
+        methodsToFix
+            .forEach {
+                val args = if (noExpectedExpression) emptyArray() else it.argumentList.expressions
+                val expectedExpression = createExpectedMethodCall(it, replacementMethod, *args)
+                expectedExpression.replaceQualifierFromMethodCall(it)
+                it.replace(expectedExpression)
+            }
     }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveInstanceOfExpressionQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveInstanceOfExpressionQuickFix.kt
deleted file mode 100644
index 6692b10..0000000
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveInstanceOfExpressionQuickFix.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiInstanceOfExpression
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
-
-class RemoveInstanceOfExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCallExpression.firstArg as? PsiInstanceOfExpression ?: return
-        val expectedClass = assertExpression.checkType ?: return
-        val factory = JavaPsiFacade.getElementFactory(project)
-        val classObjectAccess = factory.createExpressionFromText("${expectedClass.type.canonicalText}.class", null)
-
-        val operand = PsiUtil.deparenthesizeExpression(assertExpression.operand) ?: return
-        assertExpression.replace(operand)
-
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod, classObjectAccess)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveUnaryExpressionQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveUnaryExpressionQuickFix.kt
deleted file mode 100644
index e29e248..0000000
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/RemoveUnaryExpressionQuickFix.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package de.platon42.intellij.plugins.cajon.quickfixes
-
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiUnaryExpression
-import com.intellij.psi.util.PsiUtil
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
-
-class RemoveUnaryExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
-
-    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val assertExpression = methodCallExpression.firstArg as? PsiUnaryExpression ?: return
-        val operand = PsiUtil.skipParenthesizedExprDown(assertExpression.operand) ?: return
-        assertExpression.replace(operand)
-
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt
new file mode 100644
index 0000000..aa0bb0c
--- /dev/null
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt
@@ -0,0 +1,35 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiExpression
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiReferenceExpression
+import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
+import de.platon42.intellij.plugins.cajon.firstArg
+import de.platon42.intellij.plugins.cajon.qualifierExpression
+import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
+
+class ReplaceHasSizeMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val methodCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+
+        replaceCollectionSizeOrArrayLength(methodCallExpression.firstArg)
+
+        val expectedExpression = createExpectedMethodCall(methodCallExpression, replacementMethod, methodCallExpression.firstArg)
+
+        expectedExpression.replaceQualifierFromMethodCall(methodCallExpression)
+        methodCallExpression.replace(expectedExpression)
+    }
+
+    private fun replaceCollectionSizeOrArrayLength(assertExpression: PsiExpression) {
+        assertExpression.replace(
+            when (assertExpression) {
+                is PsiReferenceExpression -> assertExpression.qualifierExpression!!
+                is PsiMethodCallExpression -> assertExpression.qualifierExpression
+                else -> return
+            }
+        )
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt
index 68a31cb..1653e8d 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt
@@ -10,6 +10,14 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSE
 class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean) :
     AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val CONVERT_DESCRIPTION = "Convert JUnit assertions to assertJ"
+    }
+
+    override fun getFamilyName(): String {
+        return CONVERT_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt
index 1e85960..69ef076 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt
@@ -8,6 +8,14 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSE
 
 class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val CONVERT_DESCRIPTION = "Convert JUnit assertions to assertJ"
+    }
+
+    override fun getFamilyName(): String {
+        return CONVERT_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSimpleMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSimpleMethodCallQuickFix.kt
index 5bbfe86..9127ed4 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSimpleMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSimpleMethodCallQuickFix.kt
@@ -8,6 +8,14 @@ import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
 
 class ReplaceSimpleMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val REPLACE_DESCRIPTION = "Replace methods by better ones"
+    }
+
+    override fun getFamilyName(): String {
+        return REPLACE_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt
index e986d58..1e866be 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt
@@ -11,28 +11,32 @@ class ReplaceSizeMethodCallQuickFix(
     description: String,
     private val replacementMethod: String,
     private val noExpectedExpression: Boolean = false,
-    private val expectedIsCollection: Boolean = false,
-    private val keepActualAsIs: Boolean = false
+    private val expectedIsCollection: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val REPLACE_DESCRIPTION = "Replace methods by better ones"
+    }
+
+    override fun getFamilyName(): String {
+        return REPLACE_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        if (!keepActualAsIs) {
-            val assertExpression = methodCallExpression.firstArg
-            replaceCollectionSizeOrArrayLength(assertExpression)
-        }
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+        val assertExpression = assertThatMethodCall.firstArg
+        replaceCollectionSizeOrArrayLength(assertExpression)
 
         if (expectedIsCollection) {
-            replaceCollectionSizeOrArrayLength(oldExpectedExpression.firstArg)
+            replaceCollectionSizeOrArrayLength(outmostCallExpression.firstArg)
         }
 
-        val args = if (noExpectedExpression) emptyArray() else arrayOf(oldExpectedExpression.firstArg)
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
+        val args = if (noExpectedExpression) emptyArray() else arrayOf(outmostCallExpression.firstArg)
+        val expectedExpression = createExpectedMethodCall(outmostCallExpression, replacementMethod, *args)
 
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
+        expectedExpression.replaceQualifierFromMethodCall(outmostCallExpression)
+        outmostCallExpression.replace(expectedExpression)
     }
 
     private fun replaceCollectionSizeOrArrayLength(assertExpression: PsiExpression) {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/SplitBinaryExpressionMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/SplitBinaryExpressionMethodCallQuickFix.kt
index 12314a8..0f5c783 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/SplitBinaryExpressionMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/SplitBinaryExpressionMethodCallQuickFix.kt
@@ -4,10 +4,7 @@ import com.intellij.codeInspection.ProblemDescriptor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiBinaryExpression
 import com.intellij.psi.PsiMethodCallExpression
-import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
-import de.platon42.intellij.plugins.cajon.findOutmostMethodCall
-import de.platon42.intellij.plugins.cajon.firstArg
-import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
+import de.platon42.intellij.plugins.cajon.*
 
 class SplitBinaryExpressionMethodCallQuickFix(
     description: String,
@@ -16,17 +13,33 @@ class SplitBinaryExpressionMethodCallQuickFix(
     private val noExpectedExpression: Boolean = false
 ) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val SPLIT_EXPRESSION_DESCRIPTION = "Split binary expressions out of assertThat()"
+    }
+
+    override fun getFamilyName(): String {
+        return SPLIT_EXPRESSION_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val element = descriptor.startElement
-        val methodCallExpression = element as? PsiMethodCallExpression ?: return
-        val binaryExpression = methodCallExpression.firstArg as? PsiBinaryExpression ?: return
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+
+        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
+            .filter { it.getExpectedBooleanResult() != null }
+            .toList()
+
+        val binaryExpression = assertThatMethodCall.firstArg as? PsiBinaryExpression ?: return
         val expectedArgument = (if (pickRightOperand) binaryExpression.lOperand else binaryExpression.rOperand)?.copy() ?: return
         binaryExpression.replace(if (pickRightOperand) binaryExpression.rOperand!! else binaryExpression.lOperand)
 
-        val oldExpectedExpression = element.findOutmostMethodCall() ?: return
         val args = if (noExpectedExpression) emptyArray() else arrayOf(expectedArgument)
-        val expectedExpression = createExpectedMethodCall(element, replacementMethod, *args)
-        expectedExpression.replaceQualifierFromMethodCall(oldExpectedExpression)
-        oldExpectedExpression.replace(expectedExpression)
+
+        methodsToFix
+            .forEach {
+                val expectedExpression = createExpectedMethodCall(it, replacementMethod, *args)
+                expectedExpression.replaceQualifierFromMethodCall(it)
+                it.replace(expectedExpression)
+            }
     }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/UnwrapExpectedStaticMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/UnwrapExpectedStaticMethodCallQuickFix.kt
index 9ac6f4f..af27583 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/UnwrapExpectedStaticMethodCallQuickFix.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/UnwrapExpectedStaticMethodCallQuickFix.kt
@@ -10,6 +10,14 @@ import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
 
 class UnwrapExpectedStaticMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
 
+    companion object {
+        private const val REMOVE_EXPECTED_OUTMOST_DESCRIPTION = "Unwrap expected expressions and use better assertion"
+    }
+
+    override fun getFamilyName(): String {
+        return REMOVE_EXPECTED_OUTMOST_DESCRIPTION
+    }
+
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val element = descriptor.startElement
         val oldExpectedExpression = element.findOutmostMethodCall() ?: return
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributor.kt b/src/main/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributor.kt
index 5f41ed4..6b4e1d9 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributor.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributor.kt
@@ -50,9 +50,8 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
         }
 
         private fun findActualType(element: PsiElement): PsiClassType? {
-            val assertThatCall = PsiTreeUtil.findChildrenOfType(element, PsiMethodCallExpression::class.java)
-                .find { CORE_ASSERT_THAT_MATCHER.test(it) } ?: return null
-            return assertThatCall.firstArg.type as? PsiClassType
+            val assertThatCall = element.findStaticMethodCall()
+            return assertThatCall?.firstArg?.type as? PsiClassType
         }
 
         private fun findAndCreateReferences(element: PsiElement, finder: (PsiLiteralExpression) -> List<Pair<TextRange, List<PsiElement>>>?): Array<PsiReference> {
diff --git a/src/test/java/de/platon42/intellij/playground/Playground.java b/src/test/java/de/platon42/intellij/playground/Playground.java
index b3e86e0..aa8a115 100644
--- a/src/test/java/de/platon42/intellij/playground/Playground.java
+++ b/src/test/java/de/platon42/intellij/playground/Playground.java
@@ -283,6 +283,7 @@ public class Playground {
         assertFalse(!(new int[3].length == new ArrayList<Integer>().size()));
         assertThat(!(new int[3].length == new ArrayList<Integer>().size())).isFalse();
         assertThat((new int[3].length == new ArrayList<Integer>().size())).isTrue();
+        assertThat(new int[3].length == new ArrayList<Integer>().size()).isTrue();
         assertThat(new int[3].length).isEqualTo(new ArrayList<Integer>().size());
         assertThat(new int[3]).hasSameSizeAs(new ArrayList<Integer>());
 
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
index 4f96228..7799e8e 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
@@ -60,8 +60,8 @@ abstract class AbstractCajonTest {
     }
 
     protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
-        val quickfixes = myFixture.getAllQuickFixes().filter { it.familyName.matches(regex) }
-        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.familyName }}").hasSize(expectedFixes)
+        val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
         quickfixes.forEach(myFixture::launchAction)
     }
 }
\ No newline at end of file
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt
index 0d317b4..e883a79 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt
@@ -14,8 +14,8 @@ internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
             myFixture.configureByFile("BinaryExpressionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 148)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 12)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 149)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 13)
             myFixture.checkResultByFile("BinaryExpressionAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
index 5e01219..67ca16e 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
@@ -17,19 +17,12 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
             myFixture.configureByFile("GuavaOptionalBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with Guava assertThat().isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with Guava assertThat().isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with Guava assertThat().isPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with Guava assertThat().isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().contains()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with contains()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with Guava assertThat().contains()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
             myFixture.checkResultByFile("GuavaOptionalAfter.java")
         }
     }
@@ -39,7 +32,8 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
             myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 7)
+            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 4)
+            executeQuickFixes(myFixture, Regex("Remove .*"), 3)
             myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
         }
     }
@@ -50,7 +44,8 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
             myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
             myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 6)
+            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 3)
+            executeQuickFixes(myFixture, Regex("Remove .*"), 3)
             myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt
index 756d8ba..789e5d9 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt
@@ -14,8 +14,8 @@ internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
             myFixture.configureByFile("InstanceOfBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace instanceof expression by assertThat().isInstanceOf()"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace instanceof expression by assertThat().isNotInstanceOf()"), 6)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
             myFixture.checkResultByFile("InstanceOfAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt
index 4c85f31..66cc02f 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt
@@ -14,7 +14,7 @@ internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonT
         runTest {
             myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
             myFixture.configureByFile("InvertedBooleanConditionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 21)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
             myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt
index c2e1a85..46b8072 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt
@@ -14,17 +14,13 @@ internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
             myFixture.configureByFile("Java8OptionalBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isNotPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isNotPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with isNotPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with contains()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with contains()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isSameAs() with containsSame()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
             myFixture.checkResultByFile("Java8OptionalAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt
index 5a1f8ba..5934277 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt
@@ -4,6 +4,8 @@ import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.extrakting
 import org.junit.jupiter.api.Test
 
 internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
@@ -14,6 +16,8 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatSizeInspection::class.java)
             myFixture.configureByFile("SizeBefore.java")
+            assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
+
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 4)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 4)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 4)
@@ -27,7 +31,7 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 4)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 4)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 12)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14)
             myFixture.checkResultByFile("SizeAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt
index 9f63db4..0c66936 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt
@@ -14,20 +14,20 @@ internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
             myFixture.configureByFile("StringExpressionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of expected expression and use assertThat().isEmpty() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of expected expression and use assertThat().isEqualTo() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of expected expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of expected expression and use assertThat().isEqualTo() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of expected expression and use assertThat().contains() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of expected expression and use assertThat().startsWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of expected expression and use assertThat().endsWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of expected expression and use assertThat().isNotEmpty() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of expected expression and use assertThat().isNotEqualTo() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of expected expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of expected expression and use assertThat().isNotEqualTo() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of expected expression and use assertThat().doesNotContain() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of expected expression and use assertThat().doesNotStartWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of expected expression and use assertThat().doesNotEndWith() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
             myFixture.checkResultByFile("StringExpressionAfter.java")
         }
     }
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt
index 0653423..5ef11ad 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt
@@ -4,6 +4,8 @@ import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.extrakting
 import org.junit.jupiter.api.Test
 
 internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
@@ -14,6 +16,11 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
             myFixture.configureByFile("StringIsEmptyBefore.java")
+            val highlights = myFixture.doHighlighting()
+                .asSequence()
+                .filter { it.description?.contains(" can be simplified to") ?: false }
+                .toList()
+            assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
             executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
             myFixture.checkResultByFile("StringIsEmptyAfter.java")
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt
index deb3dc2..027bd0d 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt
@@ -18,7 +18,7 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
             myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 38)
+            executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 38)
             myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
         }
     }
diff --git a/src/test/java/org/assertj/core/api/AssertJExtensions.kt b/src/test/java/org/assertj/core/api/AssertJExtensions.kt
new file mode 100644
index 0000000..ec84b38
--- /dev/null
+++ b/src/test/java/org/assertj/core/api/AssertJExtensions.kt
@@ -0,0 +1,19 @@
+package org.assertj.core.api
+
+import org.assertj.core.groups.FieldsOrPropertiesExtractor
+import java.util.*
+
+// Workaround for ambiguous method signature of .extracting() see https://github.com/joel-costigliola/assertj-core/issues/1499
+fun <SELF : AbstractIterableAssert<SELF, ACTUAL, ELEMENT, ELEMENT_ASSERT>,
+        ACTUAL : Iterable<ELEMENT>,
+        ELEMENT,
+        ELEMENT_ASSERT : AbstractAssert<ELEMENT_ASSERT, ELEMENT>,
+        V>
+        AbstractIterableAssert<SELF, ACTUAL, ELEMENT, ELEMENT_ASSERT>.extrakting(extractor: (ELEMENT) -> V): AbstractListAssert<*, List<V>, V, ObjectAssert<V>> {
+    val values = FieldsOrPropertiesExtractor.extract(actual, extractor)
+    if (actual is SortedSet<*>) {
+        usingDefaultElementComparator()
+    }
+    @Suppress("UNCHECKED_CAST")
+    return newListAssertInstance(values).withAssertionState(myself) as AbstractListAssert<*, List<V>, V, ObjectAssert<V>>
+}
\ No newline at end of file
diff --git a/src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java b/src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java
index 8279182..edd0042 100644
--- a/src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java
+++ b/src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java
@@ -10,7 +10,7 @@ public class BinaryExpression {
         String stringExp = "foo";
         String stringAct = "bar";
 
-        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).as("doh!").isEqualTo(primExp);
         assertThat(primAct).isEqualTo(primExp);
         assertThat(primAct).isEqualTo(primExp);
         assertThat(primAct).isEqualTo(primExp);
@@ -25,7 +25,7 @@ public class BinaryExpression {
         assertThat(primAct).isNotEqualTo(1);
         assertThat(primAct).isNotEqualTo(1);
 
-        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).as("doh!").isNotEqualTo(primExp);
         assertThat(primAct).isNotEqualTo(primExp);
         assertThat(primAct).isNotEqualTo(primExp);
         assertThat(primAct).isNotEqualTo(1);
@@ -36,7 +36,7 @@ public class BinaryExpression {
         assertThat(primAct).isEqualTo(1);
         assertThat(primAct).isEqualTo(1);
 
-        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).as("doh!").isGreaterThan(primExp);
         assertThat(primAct).isGreaterThan(primExp);
         assertThat(primAct).isGreaterThan(primExp);
         assertThat(primAct).isGreaterThan(1);
@@ -47,7 +47,7 @@ public class BinaryExpression {
         assertThat(primAct).isLessThanOrEqualTo(1);
         assertThat(primAct).isLessThanOrEqualTo(1);
 
-        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).as("doh!").isGreaterThanOrEqualTo(primExp);
         assertThat(primAct).isGreaterThanOrEqualTo(primExp);
         assertThat(primAct).isGreaterThanOrEqualTo(primExp);
         assertThat(primAct).isGreaterThanOrEqualTo(1);
@@ -58,7 +58,7 @@ public class BinaryExpression {
         assertThat(primAct).isLessThan(1);
         assertThat(primAct).isLessThan(1);
 
-        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).as("doh!").isLessThan(primExp);
         assertThat(primAct).isLessThan(primExp);
         assertThat(primAct).isLessThan(primExp);
         assertThat(primAct).isLessThan(1);
@@ -69,7 +69,7 @@ public class BinaryExpression {
         assertThat(primAct).isGreaterThanOrEqualTo(1);
         assertThat(primAct).isGreaterThanOrEqualTo(1);
 
-        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).as("doh!").isLessThanOrEqualTo(primExp);
         assertThat(primAct).isLessThanOrEqualTo(primExp);
         assertThat(primAct).isLessThanOrEqualTo(primExp);
         assertThat(primAct).isLessThanOrEqualTo(1);
@@ -80,7 +80,7 @@ public class BinaryExpression {
         assertThat(primAct).isGreaterThan(1);
         assertThat(primAct).isGreaterThan(1);
 
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(1);
@@ -91,7 +91,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isNotEqualTo(1);
         assertThat(numberObjAct).isNotEqualTo(1);
 
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(1);
@@ -102,7 +102,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isEqualTo(1);
         assertThat(numberObjAct).isEqualTo(1);
 
-        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isGreaterThan(numberObjExp);
         assertThat(numberObjAct).isGreaterThan(numberObjExp);
         assertThat(numberObjAct).isGreaterThan(numberObjExp);
         assertThat(numberObjAct).isGreaterThan(1);
@@ -113,7 +113,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isLessThanOrEqualTo(1);
         assertThat(numberObjAct).isLessThanOrEqualTo(1);
 
-        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isGreaterThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
@@ -124,7 +124,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isLessThan(1);
         assertThat(numberObjAct).isLessThan(1);
 
-        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isLessThan(numberObjExp);
         assertThat(numberObjAct).isLessThan(numberObjExp);
         assertThat(numberObjAct).isLessThan(numberObjExp);
         assertThat(numberObjAct).isLessThan(1);
@@ -135,7 +135,7 @@ public class BinaryExpression {
         assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
         assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
 
-        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isLessThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
         assertThat(numberObjAct).isLessThanOrEqualTo(1);
@@ -146,42 +146,42 @@ public class BinaryExpression {
         assertThat(numberObjAct).isGreaterThan(1);
         assertThat(numberObjAct).isGreaterThan(1);
 
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(numberObjExp);
         assertThat(numberObjAct).isEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
         assertThat(numberObjAct).isNotEqualTo(numberObjExp);
 
-        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).as("doh!").isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
 
-        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).as("doh!").isEqualTo(stringExp);
         assertThat(stringAct).isEqualTo(stringExp);
         assertThat(stringAct).isEqualTo(stringExp);
         assertThat(stringAct).isNotEqualTo(stringExp);
         assertThat(stringAct).isNotEqualTo(stringExp);
         assertThat(stringAct).isNotEqualTo(stringExp);
 
-        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).as("doh!").isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isNotSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
         assertThat(stringAct).isSameAs(stringExp);
 
-        assertThat(stringAct).isNull();
+        assertThat(stringAct).as("doh!").isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNotNull();
         assertThat(stringAct).isNotNull();
         assertThat(stringAct).isNotNull();
 
-        assertThat(stringAct).isNull();
+        assertThat(stringAct).as("doh!").isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNull();
         assertThat(stringAct).isNotNull();
@@ -190,5 +190,10 @@ public class BinaryExpression {
 
         assertThat(null == null).isTrue();
         assertThat(!false).isTrue();
+
+        assertThat(primAct).as("doh!").isEqualTo(primExp).isEqualTo(primExp);
+        assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);
+
+        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp).isEqualTo(numberObjExp);
     }
 }
diff --git a/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java b/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java
index 88508e8..e7f417a 100644
--- a/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java
+++ b/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java
@@ -10,7 +10,7 @@ public class BinaryExpression {
         String stringExp = "foo";
         String stringAct = "bar";
 
-        assertThat(primAct == primExp).isTrue();
+        assertThat(primAct == primExp).as("doh!").isTrue();
         assertThat(primAct == primExp).isEqualTo(true);
         assertThat(primAct == primExp).isEqualTo(Boolean.TRUE);
         assertThat(primAct == primExp).isNotEqualTo(false);
@@ -25,7 +25,7 @@ public class BinaryExpression {
         assertThat(primAct == 1).isFalse();
         assertThat(1 == primAct).isFalse();
 
-        assertThat(primAct != primExp).isTrue();
+        assertThat(primAct != primExp).as("doh!").isTrue();
         assertThat(primAct != primExp).isEqualTo(true);
         assertThat(primAct != primExp).isNotEqualTo(false);
         assertThat(primAct != 1).isTrue();
@@ -36,7 +36,7 @@ public class BinaryExpression {
         assertThat(primAct != 1).isFalse();
         assertThat(1 != primAct).isFalse();
 
-        assertThat(primAct > primExp).isTrue();
+        assertThat(primAct > primExp).as("doh!").isTrue();
         assertThat(primAct > primExp).isEqualTo(true);
         assertThat(primAct > primExp).isNotEqualTo(false);
         assertThat(primAct > 1).isTrue();
@@ -47,7 +47,7 @@ public class BinaryExpression {
         assertThat(primAct > 1).isFalse();
         assertThat(1 < primAct).isFalse();
 
-        assertThat(primAct >= primExp).isTrue();
+        assertThat(primAct >= primExp).as("doh!").isTrue();
         assertThat(primAct >= primExp).isEqualTo(true);
         assertThat(primAct >= primExp).isNotEqualTo(false);
         assertThat(primAct >= 1).isTrue();
@@ -58,7 +58,7 @@ public class BinaryExpression {
         assertThat(primAct >= 1).isFalse();
         assertThat(1 <= primAct).isFalse();
 
-        assertThat(primAct < primExp).isTrue();
+        assertThat(primAct < primExp).as("doh!").isTrue();
         assertThat(primAct < primExp).isEqualTo(true);
         assertThat(primAct < primExp).isNotEqualTo(false);
         assertThat(primAct < 1).isTrue();
@@ -69,7 +69,7 @@ public class BinaryExpression {
         assertThat(primAct < 1).isFalse();
         assertThat(1 > primAct).isFalse();
 
-        assertThat(primAct <= primExp).isTrue();
+        assertThat(primAct <= primExp).as("doh!").isTrue();
         assertThat(primAct <= primExp).isEqualTo(true);
         assertThat(primAct <= primExp).isNotEqualTo(false);
         assertThat(primAct <= 1).isTrue();
@@ -80,7 +80,7 @@ public class BinaryExpression {
         assertThat(primAct <= 1).isFalse();
         assertThat(1 >= primAct).isFalse();
 
-        assertThat(numberObjAct == numberObjExp).isTrue();
+        assertThat(numberObjAct == numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct == numberObjExp).isEqualTo(true);
         assertThat(numberObjAct == numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct == 1).isTrue();
@@ -91,7 +91,7 @@ public class BinaryExpression {
         assertThat(numberObjAct == 1).isFalse();
         assertThat(1 == numberObjAct).isFalse();
 
-        assertThat(numberObjAct != numberObjExp).isTrue();
+        assertThat(numberObjAct != numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct != numberObjExp).isEqualTo(true);
         assertThat(numberObjAct != numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct != 1).isTrue();
@@ -102,7 +102,7 @@ public class BinaryExpression {
         assertThat(numberObjAct != 1).isFalse();
         assertThat(1 != numberObjAct).isFalse();
 
-        assertThat(numberObjAct > numberObjExp).isTrue();
+        assertThat(numberObjAct > numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct > numberObjExp).isEqualTo(true);
         assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct > 1).isTrue();
@@ -113,7 +113,7 @@ public class BinaryExpression {
         assertThat(numberObjAct > 1).isFalse();
         assertThat(1 < numberObjAct).isFalse();
 
-        assertThat(numberObjAct >= numberObjExp).isTrue();
+        assertThat(numberObjAct >= numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct >= numberObjExp).isEqualTo(true);
         assertThat(numberObjAct >= numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct >= 1).isTrue();
@@ -124,7 +124,7 @@ public class BinaryExpression {
         assertThat(numberObjAct >= 1).isFalse();
         assertThat(1 <= numberObjAct).isFalse();
 
-        assertThat(numberObjAct < numberObjExp).isTrue();
+        assertThat(numberObjAct < numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct < numberObjExp).isEqualTo(true);
         assertThat(numberObjAct < numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct < 1).isTrue();
@@ -135,7 +135,7 @@ public class BinaryExpression {
         assertThat(numberObjAct < 1).isFalse();
         assertThat(1 > numberObjAct).isFalse();
 
-        assertThat(numberObjAct <= numberObjExp).isTrue();
+        assertThat(numberObjAct <= numberObjExp).as("doh!").isTrue();
         assertThat(numberObjAct <= numberObjExp).isEqualTo(true);
         assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
         assertThat(numberObjAct <= 1).isTrue();
@@ -146,42 +146,42 @@ public class BinaryExpression {
         assertThat(numberObjAct <= 1).isFalse();
         assertThat(1 >= numberObjAct).isFalse();
 
-        assertThat(numberObjAct.equals(numberObjExp)).isTrue();
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue();
         assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
         assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
         assertThat(numberObjAct.equals(numberObjExp)).isFalse();
         assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
         assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(true);
 
-        assertThat(stringAct == stringExp).isTrue();
+        assertThat(stringAct == stringExp).as("doh!").isTrue();
         assertThat(stringAct == stringExp).isEqualTo(true);
         assertThat(stringAct == stringExp).isNotEqualTo(false);
         assertThat(stringAct == stringExp).isFalse();
         assertThat(stringAct == stringExp).isEqualTo(false);
         assertThat(stringAct == stringExp).isNotEqualTo(true);
 
-        assertThat(stringAct.equals(stringExp)).isTrue();
+        assertThat(stringAct.equals(stringExp)).as("doh!").isTrue();
         assertThat(stringAct.equals(stringExp)).isEqualTo(true);
         assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
         assertThat(stringAct.equals(stringExp)).isFalse();
         assertThat(stringAct.equals(stringExp)).isEqualTo(false);
         assertThat(stringAct.equals(stringExp)).isNotEqualTo(true);
 
-        assertThat(stringAct != stringExp).isTrue();
+        assertThat(stringAct != stringExp).as("doh!").isTrue();
         assertThat(stringAct != stringExp).isEqualTo(true);
         assertThat(stringAct != stringExp).isNotEqualTo(false);
         assertThat(stringAct != stringExp).isFalse();
         assertThat(stringAct != stringExp).isEqualTo(false);
         assertThat(stringAct != stringExp).isNotEqualTo(true);
 
-        assertThat(stringAct == null).isTrue();
+        assertThat(stringAct == null).as("doh!").isTrue();
         assertThat(stringAct == null).isEqualTo(true);
         assertThat(stringAct == null).isNotEqualTo(false);
         assertThat(stringAct == null).isFalse();
         assertThat(stringAct == null).isEqualTo(false);
         assertThat(stringAct == null).isNotEqualTo(true);
 
-        assertThat(null == stringAct).isTrue();
+        assertThat(null == stringAct).as("doh!").isTrue();
         assertThat(null == stringAct).isEqualTo(true);
         assertThat(null == stringAct).isNotEqualTo(false);
         assertThat(null == stringAct).isFalse();
@@ -190,5 +190,10 @@ public class BinaryExpression {
 
         assertThat(null == null).isTrue();
         assertThat(!false).isTrue();
+
+        assertThat(primAct == primExp).as("doh!").isTrue().isEqualTo(true);
+        assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);
+
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue().isEqualTo(true);
     }
 }
diff --git a/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java b/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java
index d8fdec3..f2c2f0e 100644
--- a/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java
+++ b/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java
@@ -8,24 +8,24 @@ public class GuavaOptional {
     private void guavaOptional() {
         Optional<String> opt = Optional.absent();
 
-        assertThat(opt).isPresent();
+        assertThat(opt).as("foo").isPresent();
         assertThat(opt).isPresent();
         assertThat(opt).isPresent();
         assertThat(opt).isPresent();
         assertThat(opt).isPresent();
 
-        assertThat(opt).isAbsent();
+        assertThat(opt).as("foo").isAbsent();
         assertThat(opt).isAbsent();
         assertThat(opt).isAbsent();
         assertThat(opt).isAbsent();
         assertThat(opt).isAbsent();
 
-        assertThat(opt).contains("foo");
+        assertThat(opt).as("foo").contains("foo");
         assertThat(opt.get()).isSameAs("foo");
         assertThat(opt.get()).isNotEqualTo("foo");
         assertThat(opt.get()).isNotSameAs("foo");
 
-        assertThat(opt).contains("foo");
+        assertThat(opt).as("foo").contains("foo");
         assertThat(opt).contains("foo");
         assertThat(opt).isNotEqualTo(Optional.of("foo"));
         assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
@@ -33,20 +33,23 @@ public class GuavaOptional {
         assertThat(opt).isAbsent();
         assertThat(opt).isPresent();
 
-        org.assertj.guava.api.Assertions.assertThat(opt).contains("foo");
-        org.assertj.guava.api.Assertions.assertThat(opt).contains("foo");
+        assertThat(opt).as("foo").contains("foo");
+        assertThat(opt).contains("foo");
         org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
         org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
 
-        org.assertj.guava.api.Assertions.assertThat(opt).isAbsent();
-        org.assertj.guava.api.Assertions.assertThat(opt).isPresent();
+        assertThat(opt).as("foo").isAbsent();
+        assertThat(opt).isPresent();
 
-        assertThat(opt).contains("foo");
+        assertThat(opt).as("foo").contains("foo");
         assertThat(opt).contains("foo");
         org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
         org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
 
-        assertThat(opt).isAbsent();
+        assertThat(opt).as("foo").isAbsent();
         assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").isPresent().as("bar").isPresent();
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.FALSE);
     }
 }
diff --git a/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java b/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java
index 640a3e1..254574d 100644
--- a/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java
+++ b/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java
@@ -8,24 +8,24 @@ public class GuavaOptional {
     private void guavaOptional() {
         Optional<String> opt = Optional.absent();
 
-        assertThat(opt.isPresent()).isEqualTo(true);
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true);
         assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
         assertThat(opt.isPresent()).isNotEqualTo(false);
         assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
         assertThat(opt.isPresent()).isTrue();
 
-        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isPresent()).as("foo").isEqualTo(false);
         assertThat(opt.isPresent()).isEqualTo(Boolean.FALSE);
         assertThat(opt.isPresent()).isNotEqualTo(true);
         assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
         assertThat(opt.isPresent()).isFalse();
 
-        assertThat(opt.get()).isEqualTo("foo");
+        assertThat(opt.get()).as("foo").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).as("foo").isEqualTo(Optional.of("foo"));
         assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
         assertThat(opt).isNotEqualTo(Optional.of("foo"));
         assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
@@ -33,20 +33,23 @@ public class GuavaOptional {
         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).as("foo").isEqualTo(Optional.of("foo"));
         org.assertj.guava.api.Assertions.assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
         org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
         org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
 
-        org.assertj.guava.api.Assertions.assertThat(opt).isEqualTo(Optional.absent());
+        org.assertj.guava.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.absent());
         org.assertj.guava.api.Assertions.assertThat(opt).isNotEqualTo(Optional.absent());
 
-        org.assertj.core.api.Assertions.assertThat(opt).isEqualTo(Optional.of("foo"));
+        org.assertj.core.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.of("foo"));
         org.assertj.core.api.Assertions.assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
         org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.of("foo"));
         org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.fromNullable("foo"));
 
-        org.assertj.core.api.Assertions.assertThat(opt).isEqualTo(Optional.absent());
+        org.assertj.core.api.Assertions.assertThat(opt).as("foo").isEqualTo(Optional.absent());
         org.assertj.core.api.Assertions.assertThat(opt).isNotEqualTo(Optional.absent());
+
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.TRUE);
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.FALSE);
     }
 }
diff --git a/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java b/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java
index c39fb0a..3e7f668 100644
--- a/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java
+++ b/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java
@@ -5,18 +5,21 @@ public class InstanceOf {
     private void instanceOf() {
         Boolean object = Boolean.TRUE;
 
-        assertThat(object).isInstanceOf(Boolean.class);
+        assertThat(object).as("foo").isInstanceOf(Boolean.class);
         assertThat(object).isInstanceOf(Boolean.class);
         assertThat(object).isInstanceOf(Boolean.class);
         assertThat(object).isInstanceOf(Boolean.class);
         assertThat(object).isInstanceOf(Boolean.class);
 
-        assertThat(object).isNotInstanceOf(Boolean.class);
+        assertThat(object).as("foo").isNotInstanceOf(Boolean.class);
         assertThat(object).isNotInstanceOf(Boolean.class);
         assertThat(object).isNotInstanceOf(Boolean.class);
         assertThat(object).isNotInstanceOf(Boolean.class);
         assertThat(object).isNotInstanceOf(Boolean.class);
 
         assertThat(object).as("nah").isNotInstanceOf(Boolean.class);
+
+        assertThat(object).as("foo").isInstanceOf(Boolean.class).as("bar").isInstanceOf(Boolean.class);
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE).as("bar").isEqualTo(false);
     }
 }
diff --git a/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java b/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java
index 2d22fe4..cb38517 100644
--- a/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java
+++ b/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java
@@ -5,18 +5,21 @@ public class InstanceOf {
     private void instanceOf() {
         Boolean object = Boolean.TRUE;
 
-        assertThat(object instanceof Boolean).isEqualTo(Boolean.TRUE);
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE);
         assertThat(object instanceof Boolean).isEqualTo(true);
         assertThat(object instanceof Boolean).isNotEqualTo(Boolean.FALSE);
         assertThat(object instanceof Boolean).isNotEqualTo(false);
         assertThat(object instanceof Boolean).isTrue();
 
-        assertThat(object instanceof Boolean).isEqualTo(Boolean.FALSE);
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.FALSE);
         assertThat(object instanceof Boolean).isEqualTo(false);
         assertThat(object instanceof Boolean).isNotEqualTo(Boolean.TRUE);
         assertThat(object instanceof Boolean).isNotEqualTo(true);
         assertThat(object instanceof Boolean).isFalse();
 
         assertThat(((object)) instanceof Boolean).as("nah").isEqualTo(true && !true);
+
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE).as("bar").isEqualTo(true);
+        assertThat(object instanceof Boolean).as("foo").isEqualTo(Boolean.TRUE).as("bar").isEqualTo(false);
     }
 }
diff --git a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java
index 4610f5d..f13dae9 100644
--- a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java
+++ b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java
@@ -6,23 +6,25 @@ public class InvertedBooleanCondition {
         boolean primitive = false;
         Boolean object = Boolean.TRUE;
 
+        assertThat(primitive).as("foo").isFalse();
         assertThat(primitive).isFalse();
         assertThat(primitive).isFalse();
         assertThat(primitive).isFalse();
         assertThat(primitive).isFalse();
-        assertThat(primitive).isFalse();
-        assertThat(object).isFalse();
+
+        assertThat(object).as("foo").isFalse();
         assertThat(object).isFalse();
         assertThat(object).isFalse();
         assertThat(object).isFalse();
         assertThat(object).isFalse();
 
+        assertThat(primitive).as("foo").isTrue();
         assertThat(primitive).isTrue();
         assertThat(primitive).isTrue();
         assertThat(primitive).isTrue();
         assertThat(primitive).isTrue();
-        assertThat(primitive).isTrue();
-        assertThat(object).isTrue();
+
+        assertThat(object).as("foo").isTrue();
         assertThat(object).isTrue();
         assertThat(object).isTrue();
         assertThat(object).isTrue();
@@ -30,5 +32,8 @@ public class InvertedBooleanCondition {
 
         assertThat(!((primitive))).as("nah").isTrue();
         assertThat(!object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
+
+        assertThat(primitive).as("foo").isFalse().as("bar").isFalse();
+        assertThat(primitive).as("foo").isFalse().as("bar").isTrue();
     }
 }
diff --git a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java
index 5dfe486..514caea 100644
--- a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java
+++ b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java
@@ -6,23 +6,25 @@ public class InvertedBooleanCondition {
         boolean primitive = false;
         Boolean object = Boolean.TRUE;
 
-        assertThat(!primitive).isEqualTo(Boolean.TRUE);
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE);
         assertThat(!primitive).isEqualTo(true);
         assertThat(!primitive).isNotEqualTo(Boolean.FALSE);
         assertThat(!primitive).isNotEqualTo(false);
         assertThat(!primitive).isTrue();
-        assertThat(!object).isEqualTo(Boolean.TRUE);
+
+        assertThat(!object).as("foo").isEqualTo(Boolean.TRUE);
         assertThat(!object).isEqualTo(true);
         assertThat(!object).isNotEqualTo(Boolean.FALSE);
         assertThat(!object).isNotEqualTo(false);
         assertThat(!object).isTrue();
 
-        assertThat(!primitive).isEqualTo(Boolean.FALSE);
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.FALSE);
         assertThat(!primitive).isEqualTo(false);
         assertThat(!primitive).isNotEqualTo(Boolean.TRUE);
         assertThat(!primitive).isNotEqualTo(true);
         assertThat(!primitive).isFalse();
-        assertThat(!object).isEqualTo(Boolean.FALSE);
+
+        assertThat(!object).as("foo").isEqualTo(Boolean.FALSE);
         assertThat(!object).isEqualTo(false);
         assertThat(!object).isNotEqualTo(Boolean.TRUE);
         assertThat(!object).isNotEqualTo(true);
@@ -30,5 +32,8 @@ public class InvertedBooleanCondition {
 
         assertThat(!(((!((primitive)))))).as("nah").isEqualTo(true && !true);
         assertThat(!object).isEqualTo(Boolean.TRUE && !Boolean.TRUE);
+
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(false);
+        assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(true);
     }
 }
diff --git a/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java b/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java
index fd259ac..1eaf82c 100644
--- a/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java
+++ b/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java
@@ -7,7 +7,7 @@ public class Java8Optional {
     private void java8Optional() {
         Optional<String> opt = Optional.empty();
 
-        assertThat(opt).isPresent();
+        assertThat(opt).as("foo").isPresent();
         assertThat(opt).isPresent();
         assertThat(opt).isPresent();
         assertThat(opt).isPresent();
@@ -19,17 +19,22 @@ public class Java8Optional {
         assertThat(opt).isNotPresent();
         assertThat(opt).isNotPresent();
 
-        assertThat(opt).contains("foo");
+        assertThat(opt).as("foo").contains("foo");
         assertThat(opt).containsSame("foo");
         assertThat(opt.get()).isNotEqualTo("foo");
         assertThat(opt.get()).isNotSameAs("foo");
 
-        assertThat(opt).contains("foo");
+        assertThat(opt).as("foo").contains("foo");
         assertThat(opt).contains("foo");
         assertThat(opt).isNotEqualTo(Optional.of("foo"));
         assertThat(opt).isNotEqualTo(Optional.ofNullable("foo"));
 
-        assertThat(opt).isNotPresent();
+        assertThat(opt).as("foo").isNotPresent();
         assertThat(opt).isPresent();
+
+        assertThat(opt).as("foo").isPresent().as("bar").isPresent();
+        assertThat(opt.isPresent()).as("foo").isEqualTo(false).as("bar").isTrue();
+
+        assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
     }
 }
diff --git a/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java b/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java
index ae1ed90..672cd7f 100644
--- a/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java
+++ b/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java
@@ -7,7 +7,7 @@ public class Java8Optional {
     private void java8Optional() {
         Optional<String> opt = Optional.empty();
 
-        assertThat(opt.isPresent()).isEqualTo(true);
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true);
         assertThat(opt.isPresent()).isEqualTo(Boolean.TRUE);
         assertThat(opt.isPresent()).isNotEqualTo(false);
         assertThat(opt.isPresent()).isNotEqualTo(Boolean.FALSE);
@@ -19,17 +19,22 @@ public class Java8Optional {
         assertThat(opt.isPresent()).isNotEqualTo(Boolean.TRUE);
         assertThat(opt.isPresent()).isFalse();
 
-        assertThat(opt.get()).isEqualTo("foo");
+        assertThat(opt.get()).as("foo").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).as("foo").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).as("foo").isEqualTo(Optional.empty());
         assertThat(opt).isNotEqualTo(Optional.empty());
+
+        assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isTrue();
+        assertThat(opt.isPresent()).as("foo").isEqualTo(false).as("bar").isTrue();
+
+        assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
     }
 }
diff --git a/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java b/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java
index 4d8a8eb..21ab11f 100644
--- a/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java
+++ b/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java
@@ -46,5 +46,7 @@ public class JoinStatements {
         Iterator<String> iterator = list.iterator();
         assertThat(iterator.next()).isEqualTo("foo");
         assertThat(iterator.next()).isEqualTo("bar");
+        assertThat(iterator.next().toLowerCase()).isEqualTo("foo");
+        assertThat(iterator.next().toLowerCase()).isEqualTo("bar");
     }
 }
diff --git a/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java b/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java
index c74379a..737d781 100644
--- a/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java
+++ b/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java
@@ -48,5 +48,7 @@ public class JoinStatements {
         Iterator<String> iterator = list.iterator();
         assertThat(iterator.next()).isEqualTo("foo");
         assertThat(iterator.next()).isEqualTo("bar");
+        assertThat(iterator.next().toLowerCase()).isEqualTo("foo");
+        assertThat(iterator.next().toLowerCase()).isEqualTo("bar");
     }
 }
diff --git a/src/test/resources/inspections/Size/SizeAfter.java b/src/test/resources/inspections/Size/SizeAfter.java
index f807a52..159bd97 100644
--- a/src/test/resources/inspections/Size/SizeAfter.java
+++ b/src/test/resources/inspections/Size/SizeAfter.java
@@ -95,5 +95,9 @@ public class Size {
         assertThat(stringBuilder).hasSameSizeAs(array);
         assertThat(stringBuilder).hasSameSizeAs(string);
         assertThat(stringBuilder).hasSameSizeAs(stringBuilder);
+
+        assertThat(stringBuilder.length()).as("foo").isEqualTo(0).isZero().as("bar").isNotZero().isEqualTo(10);
+
+        assertThat(stringBuilder).as("foo").isNotEmpty().hasSize(2).as("bar").hasSameSizeAs(otherList).hasSameSizeAs(array);
     }
 }
diff --git a/src/test/resources/inspections/Size/SizeBefore.java b/src/test/resources/inspections/Size/SizeBefore.java
index af48da1..a9d2498 100644
--- a/src/test/resources/inspections/Size/SizeBefore.java
+++ b/src/test/resources/inspections/Size/SizeBefore.java
@@ -95,5 +95,9 @@ public class Size {
         assertThat(stringBuilder).hasSize(array.length);
         assertThat(stringBuilder).hasSize(string.length());
         assertThat(stringBuilder).hasSize(stringBuilder.length());
+
+        assertThat(stringBuilder.length()).as("foo").isEqualTo(0).isZero().as("bar").isNotZero().isEqualTo(10);
+
+        assertThat(stringBuilder).as("foo").isNotEmpty().hasSize(2).as("bar").hasSize(otherList.size()).hasSize(array.length);
     }
 }
diff --git a/src/test/resources/inspections/StringExpression/StringExpressionAfter.java b/src/test/resources/inspections/StringExpression/StringExpressionAfter.java
index 7876f75..8cdaaba 100644
--- a/src/test/resources/inspections/StringExpression/StringExpressionAfter.java
+++ b/src/test/resources/inspections/StringExpression/StringExpressionAfter.java
@@ -6,7 +6,7 @@ public class StringExpression {
         String string = "string";
         StringBuilder stringBuilder = new StringBuilder();
 
-        assertThat(string).isEmpty();
+        assertThat(string).as("foo").isEmpty();
         assertThat(string).isEmpty();
         assertThat(string).isEqualTo("foo");
         assertThat(string).isEqualTo("foo");
@@ -25,7 +25,7 @@ public class StringExpression {
         assertThat(string).endsWith("foo");
         assertThat(string).endsWith("foo");
 
-        assertThat(string).isNotEmpty();
+        assertThat(string).as("foo").isNotEmpty();
         assertThat(string).isNotEmpty();
         assertThat(string).isNotEqualTo("foo");
         assertThat(string).isNotEqualTo("foo");
@@ -43,5 +43,9 @@ public class StringExpression {
         assertThat(string).doesNotStartWith("foo");
         assertThat(string).doesNotEndWith("foo");
         assertThat(string).doesNotEndWith("foo");
+
+        assertThat(string).as("foo").doesNotEndWith("foo").as("bar").doesNotEndWith("foo");
+        assertThat(string.endsWith("foo")).as("foo").isEqualTo(false).as("bar").isTrue();
+        assertThat(string.endsWith("foo")).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
     }
 }
diff --git a/src/test/resources/inspections/StringExpression/StringExpressionBefore.java b/src/test/resources/inspections/StringExpression/StringExpressionBefore.java
index b8b8e3f..fb2c110 100644
--- a/src/test/resources/inspections/StringExpression/StringExpressionBefore.java
+++ b/src/test/resources/inspections/StringExpression/StringExpressionBefore.java
@@ -6,7 +6,7 @@ public class StringExpression {
         String string = "string";
         StringBuilder stringBuilder = new StringBuilder();
 
-        assertThat(string.isEmpty()).isEqualTo(true);
+        assertThat(string.isEmpty()).as("foo").isEqualTo(true);
         assertThat(string.isEmpty()).isTrue();
         assertThat(string.equals("foo")).isEqualTo(true);
         assertThat(string.equals("foo")).isTrue();
@@ -14,8 +14,8 @@ public class StringExpression {
         assertThat(string.equalsIgnoreCase("foo")).isTrue();
         assertThat(string.contentEquals("foo")).isEqualTo(true);
         assertThat(string.contentEquals("foo")).isTrue();
-        assertThat(string.contentEquals(stringBuilder)).isTrue();
         assertThat(string.contentEquals(stringBuilder)).isEqualTo(true);
+        assertThat(string.contentEquals(stringBuilder)).isTrue();
         assertThat(string.contains("foo")).isEqualTo(true);
         assertThat(string.contains("foo")).isTrue();
         assertThat(string.contains(stringBuilder)).isEqualTo(true);
@@ -25,7 +25,7 @@ public class StringExpression {
         assertThat(string.endsWith("foo")).isEqualTo(true);
         assertThat(string.endsWith("foo")).isTrue();
 
-        assertThat(string.isEmpty()).isEqualTo(false);
+        assertThat(string.isEmpty()).as("foo").isEqualTo(false);
         assertThat(string.isEmpty()).isFalse();
         assertThat(string.equals("foo")).isEqualTo(false);
         assertThat(string.equals("foo")).isFalse();
@@ -33,8 +33,8 @@ public class StringExpression {
         assertThat(string.equalsIgnoreCase("foo")).isFalse();
         assertThat(string.contentEquals("foo")).isEqualTo(false);
         assertThat(string.contentEquals("foo")).isFalse();
-        assertThat(string.contentEquals(stringBuilder)).isFalse();
         assertThat(string.contentEquals(stringBuilder)).isEqualTo(false);
+        assertThat(string.contentEquals(stringBuilder)).isFalse();
         assertThat(string.contains("foo")).isEqualTo(false);
         assertThat(string.contains("foo")).isFalse();
         assertThat(string.contains(stringBuilder)).isEqualTo(false);
@@ -43,5 +43,9 @@ public class StringExpression {
         assertThat(string.startsWith("foo")).isFalse();
         assertThat(string.endsWith("foo")).isEqualTo(false);
         assertThat(string.endsWith("foo")).isFalse();
+
+        assertThat(string.endsWith("foo")).as("foo").isEqualTo(false).as("bar").isFalse();
+        assertThat(string.endsWith("foo")).as("foo").isEqualTo(false).as("bar").isTrue();
+        assertThat(string.endsWith("foo")).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
     }
 }