diff --git a/README.md b/README.md
index 0ddab9f..18188d2 100644
--- a/README.md
+++ b/README.md
@@ -79,7 +79,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   ```
   from: assertThat(expected).someCondition();
         assertThat(expected).anotherCondition();
-    to: assertThat(expected).someCondition().anotherCondition();
+    to: assertThat(expected).someCondition()
+                            .anotherCondition();
   ```
   Joining will work on actual expressions inside ```assertThat()``` that are equivalent expressions,
   except for method calls with known side-effect methods such as ```Iterator.next()``` and
@@ -87,6 +88,9 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
   The comments of the statements will be preserved. When using ```extracting()``` or similar,
   the statements will not be merged.
+  
+  The behavior regarding the insertion of line breaks between the expressions can be configured in the
+  inspection settings.
 
 - AssertThatObjectIsNullOrNotNull
 
@@ -516,6 +520,10 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 ## Changelog
 
+#### V1.2 (23-Jun-19)
+- Due to popular demand the JoinAssertThatStatements inspection will now add line breaks on joining statements.
+  The amount of statements joined without causing line breaks can be configured but defaults to 1 (always).
+          
 #### V1.1 (09-Jun-19)
 - Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
 - Added Guava Optional ```opt.orNull() == null``` case. You know, I'm not making this stuff up, people actually write this kind of code.
diff --git a/build.gradle b/build.gradle
index e9c106f..07a8f5d 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,13 +1,13 @@
 plugins {
     id 'java'
     id 'org.jetbrains.intellij' version '0.4.9'
-    id 'org.jetbrains.kotlin.jvm' version '1.3.31'
+    id 'org.jetbrains.kotlin.jvm' version '1.3.40'
     id 'jacoco'
     id 'com.github.kt3k.coveralls' version '2.8.2'
 }
 
 group 'de.platon42'
-version '1.1'
+version '1.2'
 
 repositories {
     mavenCentral()
@@ -22,8 +22,8 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     testCompile "org.assertj:assertj-core:3.12.2"
     testCompile "org.assertj:assertj-guava:3.2.1"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.0-RC1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.0-RC1'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.0-RC2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.0-RC2'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
 }
@@ -35,23 +35,17 @@ compileTestKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2019.1.2'
+    version '2019.1.3'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
     updateSinceUntilBuild false
 }
 
 patchPluginXml {
     changeNotes """
-  <h4>V1.1 (09-Jun-19)</h4>
+  <h4>V1.2 (23-Jun-19)</h4>
     <ul>
-      <li>Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
-      <li>Added Guava Optional opt.orNull() == null case. You know, I'm not making this stuff up, people actually write this kind of code.
-      <li>Added Java 8 Optional opt.orElse(null) == null case, too.
-      <li>Extended JUnitAssertToAssertJ inspection to convert JUnit assume statements, too.
-      <li>Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.
-      <li>New ImplicitAssertion inspection for implicit isNotNull(), isNotEmpty() and isPresent() assertions that will be covered by chained assertions.
-      <li>Fix for multiple JUnit Conversions in batch mode with and without delta creating an exception.
-      <li>Added new AssertThatObjectExpression inspection for toString() and hashCode() and moved equals() from AssertThatBinaryExpression there.
+      <li>Due to popular demand the JoinAssertThatStatements inspection will now add line breaks on joining statements.
+          The amount of statements joined without causing line breaks can be configured but defaults to 1 (always).
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """
@@ -65,7 +59,7 @@ test {
 }
 
 jacoco {
-    toolVersion = '0.8.3'
+    toolVersion = '0.8.4'
 }
 
 jacocoTestReport {
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index ad9423e..e3dc04d 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
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 a566ed8..059a09b 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
@@ -144,9 +144,7 @@ fun PsiExpression.getAllTheSameExpectedBooleanConstants(): Boolean? {
     for (methodCall in methodsToView) {
         val expectedResult = methodCall.getExpectedBooleanResult()
         if (expectedResult != null) {
-            if ((lockedResult != null) && (lockedResult != expectedResult)) {
-                return null
-            }
+            if ((lockedResult != null) && (lockedResult != expectedResult)) return null
             lockedResult = expectedResult
         } else {
             val isNotConstant = CallMatcher.anyOf(
@@ -157,9 +155,7 @@ fun PsiExpression.getAllTheSameExpectedBooleanConstants(): Boolean? {
                 AbstractAssertJInspection.IS_NOT_EQUAL_TO_BOOLEAN,
                 AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT
             ).test(methodCall)
-            if (isNotConstant) {
-                return null
-            }
+            if (isNotConstant) return null
         }
     }
     return lockedResult
@@ -173,9 +169,7 @@ fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
     for (methodCall in methodsToView) {
         val expectedResult = methodCall.getExpectedNullNonNullResult()
         if (expectedResult != null) {
-            if ((lockedResult != null) && (lockedResult != expectedResult)) {
-                return null
-            }
+            if ((lockedResult != null) && (lockedResult != expectedResult)) return null
             lockedResult = expectedResult
         } else {
             val isNotConstant = CallMatcher.anyOf(
@@ -184,9 +178,7 @@ fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
                 AbstractAssertJInspection.IS_EQUAL_TO_OBJECT,
                 AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT
             ).test(methodCall)
-            if (isNotConstant) {
-                return null
-            }
+            if (isNotConstant) return null
         }
     }
     return lockedResult
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 a87ff20..5bfab13 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
@@ -21,13 +21,9 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
-                    return
-                }
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
 
                 val expectedCallExpression = statement.findOutmostMethodCall() ?: return
                 val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
@@ -39,9 +35,9 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
 
                 val bothTypes = listOf(leftType, rightType)
                 val (isLeftNull, isRightNull) = bothTypes.map(TypeConversionUtil::isNullType)
-                if (isLeftNull && isRightNull) {
-                    return
-                } else if (isLeftNull || isRightNull) {
+
+                if (isLeftNull && isRightNull) return
+                if (isLeftNull || isRightNull) {
                     val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
                     registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
                         SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
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 38e5759..442e551 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
@@ -20,24 +20,17 @@ class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val matchingCalls = listOf(
                     IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_BOOLEAN,
                     IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_BOOLEAN
                 ).map { it.test(expression) }
-                if (matchingCalls.none { it }) {
-                    return
-                }
-                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) {
-                    return
-                }
+                if (matchingCalls.none { it }) return
+                if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) return
 
                 val expectedExpression = expression.firstArg
-                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) {
-                    return
-                }
+                if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) return
+
                 val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
                 val flippedBooleanTest = matchingCalls.drop(2).any { it }
 
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspection.kt
index 36207d1..6bf13e6 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspection.kt
@@ -44,13 +44,10 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
-                    return
-                }
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
+
                 val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
 
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 dc86576..1842204 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
@@ -21,13 +21,9 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val isLastExpression = expression.parent is PsiStatement
-                if (!(HAS_SIZE.test(expression) && isLastExpression)) {
-                    return
-                }
+                if (!(HAS_SIZE.test(expression) && isLastExpression)) return
 
                 val value = expression.calculateConstantParameterValue(0) ?: return
                 if (value == 0) {
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 3c541ce..84e376d 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
@@ -21,16 +21,12 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
 
-                if (!checkPreconditions(staticMethodCall)) {
-                    return
-                }
-                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
+                if (!checkPreconditions(staticMethodCall)) return
 
+                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val outmostMethodCall = statement.findOutmostMethodCall() ?: return
                 if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
                     val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
@@ -65,13 +61,10 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
 
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val staticMethodCall = expression.findStaticMethodCall() ?: return
-                if (!checkPreconditions(staticMethodCall)) {
-                    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)) {
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 ce3d533..fb0adb6 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
@@ -20,13 +20,9 @@ class AssertThatInstanceOfInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
-                    return
-                }
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
 
                 val expectedCallExpression = statement.findOutmostMethodCall() ?: return
                 val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
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 0dba5b5..39b86d7 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
@@ -18,13 +18,9 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val staticMethodCall = expression.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
-                    return
-                }
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
                 expression.getExpectedBooleanResult() ?: return
 
                 val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
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 d662d59..a4644f9 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
@@ -20,15 +20,11 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_ANY.test(staticMethodCall)) {
-                    return
-                }
-                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
+                if (!ASSERT_THAT_ANY.test(staticMethodCall)) return
 
+                val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val outmostMethodCall = statement.findOutmostMethodCall() ?: return
                 if (OPTIONAL_GET.test(actualExpression)) {
                     val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
@@ -58,13 +54,9 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
 
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val staticMethodCall = expression.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_JAVA8_OPTIONAL.test(staticMethodCall)) {
-                    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)) {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspection.kt
index a6b3737..b93a5a7 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspection.kt
@@ -24,9 +24,7 @@ class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
 
                 val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt
index 301ac74..0606859 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspection.kt
@@ -19,15 +19,11 @@ class AssertThatObjectIsNullOrNotNullInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val isNotEqualTo = IS_NOT_EQUAL_TO_OBJECT.test(expression)
                 val isEqualTo = IS_EQUAL_TO_OBJECT.test(expression)
                 val isLastExpression = expression.parent is PsiStatement
-                if (!((isEqualTo && isLastExpression) || isNotEqualTo)) {
-                    return
-                }
+                if (!((isEqualTo && isLastExpression) || isNotEqualTo)) return
 
                 if (expression.firstArg.type == PsiType.NULL) {
                     registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL))
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 e2756c3..0ba11e6 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
@@ -74,19 +74,15 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_INT.test(staticMethodCall)) {
-                    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
-                }
+                if (!(isForArrayOrCollection || isForString)) return
+
                 val matches = staticMethodCall.collectMethodCallsUpToStatement()
                     .mapNotNull { getMatch(it, isForArrayOrCollection, isForString) }
                     .toList()
@@ -112,21 +108,16 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
 
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
-                if (!HAS_SIZE.test(expression)) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
+                if (!HAS_SIZE.test(expression)) return
                 val actualExpression = expression.firstArg
 
                 val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
                 if (!(isForArrayOrCollection
                             || (isForString && checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)))
-                ) {
-                    return
-                }
+                ) return
+
                 registerConciseMethod(
                     REMOVE_SIZE_DESCRIPTION_TEMPLATE,
                     holder,
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 ea761f0..0a75609 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
@@ -48,13 +48,10 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
                 super.visitExpressionStatement(statement)
-                if (!statement.hasAssertThat()) {
-                    return
-                }
+                if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
-                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) {
-                    return
-                }
+                if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
+
                 val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(assertThatArgument) } ?: return
 
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 2f67226..ae55a7f 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
@@ -22,19 +22,13 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
                 val isEqual = IS_EQUAL_TO_OBJECT.test(expression)
                 val hasSize = HAS_SIZE.test(expression)
                 val isLastExpression = expression.parent is PsiStatement
-                if (!((isEqual || hasSize) && isLastExpression)) {
-                    return
-                }
+                if (!((isEqual || hasSize) && isLastExpression)) return
 
-                if (!checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)) {
-                    return
-                }
+                if (!checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)) return
 
                 val value = expression.calculateConstantParameterValue(0) ?: return
                 if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspection.kt
index 81117f3..7ad5db5 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspection.kt
@@ -54,9 +54,7 @@ class AssumeThatInsteadOfReturnInspection : AbstractAssertJInspection() {
                 super.visitMethod(method)
                 // Note: replace with if(TEST_ANNOTATIONS.none(method::hasAnnotation)) for IDEA >= 2018.2
                 val annotations = method.annotations.mapNotNull { it.qualifiedName }
-                if (annotations.none(TEST_ANNOTATIONS::contains)) {
-                    return
-                }
+                if (annotations.none(TEST_ANNOTATIONS::contains)) return
                 val containingClass = method.containingClass ?: return
                 val visitor: PsiElementVisitor = TestMethodVisitor(holder, isOnTheFly, containingClass)
                 method.accept(visitor)
@@ -119,9 +117,7 @@ class AssumeThatInsteadOfReturnInspection : AbstractAssertJInspection() {
         var aborted = false
 
         override fun visitExpressionStatement(statement: PsiExpressionStatement) {
-            if (foundAssertThat || aborted) {
-                return
-            }
+            if (foundAssertThat || aborted) return
             if (++statementCount > MAX_STATEMENTS_COUNT) {
                 aborted = true
                 return
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspection.kt
index d25aac0..c4f6fdb 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspection.kt
@@ -113,9 +113,8 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                if (!expression.hasAssertThat()) {
-                    return
-                }
+                if (!expression.hasAssertThat()) return
+
                 val mapping = MAPPINGS.firstOrNull { it.first.test(expression) } ?: return
                 val followupExpression = expression.findFluentCallTo(mapping.second) ?: return
                 val redundantName = getOriginalMethodName(expression) ?: return
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 7468c88..6105284 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
@@ -2,19 +2,25 @@ package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.codeInspection.ui.SingleIntegerFieldOptionsPanel
 import com.intellij.psi.*
 import com.intellij.psi.util.PsiTreeUtil
 import com.siyeh.ig.psiutils.EquivalenceChecker
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.JoinStatementsQuickFix
+import javax.swing.JComponent
 
 class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Join multiple assertThat() statements with same actual expression"
         private const val CAN_BE_JOINED_DESCRIPTION = "Multiple assertThat() statements can be joined together"
+        private const val DEFAULT_SEPARATE_LINE_LIMIT = 1
     }
 
+    @JvmField
+    var separateLineLimit: Int = DEFAULT_SEPARATE_LINE_LIMIT
+
     override fun getDisplayName() = DISPLAY_NAME
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
@@ -63,9 +69,8 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
 
             private fun isLegitAssertThatCall(statement: PsiStatement?): PsiMethodCallExpression? {
                 if ((statement is PsiExpressionStatement) && (statement.expression is PsiMethodCallExpression)) {
-                    if (!statement.hasAssertThat()) {
-                        return null
-                    }
+                    if (!statement.hasAssertThat()) return null
+
                     val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
                     return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
                 }
@@ -93,6 +98,10 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
         }
     }
 
+    override fun createOptionsPanel(): JComponent {
+        return SingleIntegerFieldOptionsPanel("Limit for joins before adding line breaks:", this, "separateLineLimit")
+    }
+
     private fun registerProblem(holder: ProblemsHolder, isOnTheFly: Boolean, firstStatement: PsiStatement, lastStatement: PsiStatement) {
         val problemDescriptor = holder.manager.createProblemDescriptor(
             firstStatement,
@@ -100,7 +109,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
             CAN_BE_JOINED_DESCRIPTION,
             ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
             isOnTheFly,
-            JoinStatementsQuickFix()
+            JoinStatementsQuickFix(separateLineLimit)
         )
         holder.registerProblem(problemDescriptor)
     }
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 e1a2891..db7a2fb 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
@@ -7,7 +7,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import de.platon42.intellij.plugins.cajon.findStaticMethodCall
 import de.platon42.intellij.plugins.cajon.shortenAndReformat
 
-class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
+class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
 
     companion object {
         private const val JOIN_STATEMENTS_MESSAGE = "Join assertThat() statements"
@@ -16,6 +16,10 @@ class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val firstStatement = descriptor.startElement as PsiExpressionStatement
         val lastStatement = descriptor.endElement as PsiExpressionStatement
+
+        val expressionCount = countExpressions(firstStatement, lastStatement)
+        val addLineBreaks = (expressionCount > separateLineLimit)
+
         do {
             val commentsToKeep = ArrayList<PsiComment>()
             val stuffToDelete = ArrayList<PsiElement>()
@@ -37,10 +41,10 @@ class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
             val lastElementBeforeConcat = assertThatCallOfCursorStatement.parent
             commentsToKeep.forEach {
                 lastElementBeforeConcat.addAfter(it, lastElementBeforeConcat.firstChild)
-                val newLineNode =
-                    PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
-
-                lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
+                addLineBreak(project, lastElementBeforeConcat)
+            }
+            if (commentsToKeep.isEmpty() && addLineBreaks) {
+                addLineBreak(project, lastElementBeforeConcat)
             }
 
             val newLeaf = previousStatement.firstChild
@@ -50,4 +54,27 @@ class JoinStatementsQuickFix : AbstractCommonQuickFix(JOIN_STATEMENTS_MESSAGE) {
         val codeBlock = PsiTreeUtil.getParentOfType(lastStatement, PsiCodeBlock::class.java) ?: return
         codeBlock.shortenAndReformat()
     }
+
+    private fun addLineBreak(project: Project, lastElementBeforeConcat: PsiElement) {
+        val newLineNode =
+            PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
+
+        lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
+    }
+
+    private fun countExpressions(firstStatement: PsiElement, lastStatement: PsiElement): Int {
+        var count = 0
+        var currentStatement = firstStatement
+        do {
+            while (currentStatement !is PsiExpressionStatement) {
+                currentStatement = currentStatement.nextSibling!!
+            }
+            count++
+            if (currentStatement === lastStatement) {
+                break
+            }
+            currentStatement = currentStatement.nextSibling!!
+        } while (true)
+        return count
+    }
 }
\ No newline at end of file
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 6b4e1d9..d170544 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
@@ -7,7 +7,6 @@ import com.intellij.psi.*
 import com.intellij.psi.util.PropertyUtilBase
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.PsiTypesUtil
-import com.intellij.util.ArrayUtil
 import com.intellij.util.ProcessingContext
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
@@ -56,11 +55,9 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
         private fun findAndCreateReferences(element: PsiElement, finder: (PsiLiteralExpression) -> List<Pair<TextRange, List<PsiElement>>>?): Array<PsiReference> {
             val literal = element as PsiLiteralExpression
-            val results = finder(literal)
-            if (results != null) {
-                return results.map { ExtractorReference(literal, it.first, it.second) }.toTypedArray()
-            }
-            return PsiReference.EMPTY_ARRAY
+            val results = finder(literal) ?: return PsiReference.EMPTY_ARRAY
+
+            return results.map { ExtractorReference(literal, it.first, it.second) }.toTypedArray()
         }
     }
 
@@ -73,10 +70,6 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
     class ExtractorReference(literal: PsiLiteralExpression, range: TextRange, private val targets: List<PsiElement>) :
         PsiPolyVariantReferenceBase<PsiLiteralExpression>(literal, range, true) {
 
-        override fun getVariants(): Array<Any> {
-            return ArrayUtil.EMPTY_OBJECT_ARRAY
-        }
-
         override fun resolve(): PsiElement? {
             return multiResolve(false).map(ResolveResult::getElement).firstOrNull()
         }
@@ -88,9 +81,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class PropertyOrFieldReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-            return findAndCreateReferences(element, ::findReferences)
-        }
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
@@ -112,9 +103,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class IterablePropertyOrFieldReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-            return findAndCreateReferences(element, ::findReferences)
-        }
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
@@ -127,9 +116,8 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
                 isResultOf = true
             }
 
-            if (!CallMatcher.anyOf(EXTRACTING_FROM_ITERABLE, FLAT_EXTRACTING_FROM_ITERABLE).test(methodCallExpression)) {
-                return null
-            }
+            if (!CallMatcher.anyOf(EXTRACTING_FROM_ITERABLE, FLAT_EXTRACTING_FROM_ITERABLE).test(methodCallExpression)) return null
+
             val iterableType = findActualType(methodCallExpression) ?: return null
             val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
             val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null
@@ -139,16 +127,13 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
 
     class IterableResultOfReferenceProvider : PsiReferenceProvider() {
 
-        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-            return findAndCreateReferences(element, ::findReferences)
-        }
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> = findAndCreateReferences(element, ::findReferences)
 
         fun findReferences(element: PsiLiteralExpression): List<Pair<TextRange, List<PsiElement>>>? {
             val literal = element.value as? String ?: return null
             val methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression::class.java) ?: return null
-            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) {
-                return null
-            }
+            if (!EXTRACTING_RESULT_OF_FROM_ITERABLE.test(methodCallExpression)) return null
+
             val iterableType = findActualType(methodCallExpression) ?: return null
             val innerType = iterableType.resolveGenerics().substitutor.substitute(iterableType.parameters[0])
             val containingClass = PsiTypesUtil.getPsiClass(innerType) ?: return null
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
index 91e8075..0bcd477 100644
--- a/src/main/resources/META-INF/plugin.xml
+++ b/src/main/resources/META-INF/plugin.xml
@@ -7,15 +7,14 @@
     Cajon is an IntelliJ IDEA Plugin for shortening and optimizing AssertJ assertions.
     It adds several inspections and quick fixes to fully use the fluent assertion methods
     and thus makes the intention clear and concise, also generating better messages on test failures.
-    It can also be used to convert JUnit 4 assertions to AssertJ.
+    It can also be used to convert JUnit 4 assertions and assumptions to AssertJ.
     It supports referencing inside extracting()-methods with strings, adding refactoring safety.
+    <p>
+    <a href="https://github.com/chrisly42/cajon-plugin/blob/master/README.md">Full documentation here...</a>
     ]]></description>
 
-    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
     <idea-version since-build="173.2696.26"/>
 
-    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
-         on how to target different products -->
     <depends>com.intellij.modules.lang</depends>
     <depends>com.intellij.modules.platform</depends>
     <depends>com.intellij.modules.java</depends>
diff --git a/src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html b/src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html
index efdb20b..067e07c 100644
--- a/src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html
+++ b/src/main/resources/inspectionDescriptions/JoinAssertThatStatements.html
@@ -2,6 +2,9 @@
 <body>
 Joins consecutive assertThat() statements with the same actual expression together.
 <!-- tooltip end -->
-<br>Retains comments during operation. If the AssertThat()-Statement contains .extracting() methods, they will not be joined.
+<br>If the AssertThat()-Statement contains .extracting() methods, they will not be joined.
+<br>During joining multiple statements, line breaks may be added to avoid too long lines. The number of statements to join without
+adding line breaks can be configured.
+<br>Also retains comments during operation and forces a line break for these cases.
 </body>
 </html>
\ No newline at end of file
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 22619fb..fe0b0b4 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt
@@ -23,6 +23,7 @@ abstract class AbstractCajonTest {
     protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
         val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
         assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
+        quickfixes.forEach { it.familyName }
         quickfixes.forEach(myFixture::launchAction)
     }
 
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt
index e567ef6..0278de6 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt
@@ -5,6 +5,7 @@ import de.platon42.intellij.jupiter.MyFixture
 import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.jupiter.api.Test
 
 
@@ -70,4 +71,10 @@ internal class ExtractorReferenceContributorTest : AbstractCajonTest() {
         myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
         assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
     }
+
+    @Test
+    internal fun extractor_is_unable_to_find_reference(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        myFixture.configureByFiles("FindReference11.java", "Address.java", "Contact.java")
+        assertThatThrownBy { myFixture.elementAtCaret.text }.isInstanceOf(AssertionError::class.java)
+    }
 }
\ 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 16de724..dffb361 100644
--- a/src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java
+++ b/src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java
@@ -195,5 +195,8 @@ public class BinaryExpression {
         assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);
 
         assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue().isEqualTo(true);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java b/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java
index e7f417a..9ff13dd 100644
--- a/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java
+++ b/src/test/resources/inspections/BinaryExpression/BinaryExpressionBefore.java
@@ -195,5 +195,8 @@ public class BinaryExpression {
         assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);
 
         assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue().isEqualTo(true);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/BooleanCondition/BooleanConditionAfter.java b/src/test/resources/inspections/BooleanCondition/BooleanConditionAfter.java
index c25b0bb..5cef929 100644
--- a/src/test/resources/inspections/BooleanCondition/BooleanConditionAfter.java
+++ b/src/test/resources/inspections/BooleanCondition/BooleanConditionAfter.java
@@ -30,5 +30,9 @@ public class BooleanCondition {
         assertThat("").isEqualTo(Boolean.TRUE);
 
         assertThat(primitive).isTrue().as("foo").isTrue().as("bar").isTrue().isFalse();
+
+        assertThat(object).isEqualTo(Boolean.TYPE);
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/BooleanCondition/BooleanConditionBefore.java b/src/test/resources/inspections/BooleanCondition/BooleanConditionBefore.java
index e3ecf27..f75ba6a 100644
--- a/src/test/resources/inspections/BooleanCondition/BooleanConditionBefore.java
+++ b/src/test/resources/inspections/BooleanCondition/BooleanConditionBefore.java
@@ -30,5 +30,9 @@ public class BooleanCondition {
         assertThat("").isEqualTo(Boolean.TRUE);
 
         assertThat(primitive).isEqualTo(Boolean.TRUE).as("foo").isEqualTo(true).as("bar").isTrue().isFalse();
+
+        assertThat(object).isEqualTo(Boolean.TYPE);
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionAfter.java b/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionAfter.java
index 3a7e546..101f10f 100644
--- a/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionAfter.java
+++ b/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionAfter.java
@@ -40,5 +40,8 @@ public class CollectionMapExpression {
         assertThat(stringList).as("foo").isNotEmpty().as("bar").isNotEmpty();
         assertThat(stringList.isEmpty()).as("foo").isEqualTo(false).as("bar").isTrue();
         assertThat(stringList.isEmpty()).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionBefore.java b/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionBefore.java
index b43a4e0..86f817c 100644
--- a/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionBefore.java
+++ b/src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionBefore.java
@@ -40,5 +40,8 @@ public class CollectionMapExpression {
         assertThat(stringList.isEmpty()).as("foo").isEqualTo(false).as("bar").isFalse();
         assertThat(stringList.isEmpty()).as("foo").isEqualTo(false).as("bar").isTrue();
         assertThat(stringList.isEmpty()).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java b/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java
index 3531e5a..8aa223a 100644
--- a/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java
+++ b/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java
@@ -16,5 +16,8 @@ public class EnumerableIsEmpty {
         assertThat(new Long[1]).as("etc").hasSize(1);
 
         assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").isEmpty();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java b/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java
index e7fe848..1df5e78 100644
--- a/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java
+++ b/src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java
@@ -16,5 +16,8 @@ public class EnumerableIsEmpty {
         assertThat(new Long[1]).as("etc").hasSize(1);
 
         assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").hasSize(0);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java b/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java
index 3e73115..21eea9e 100644
--- a/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java
+++ b/src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java
@@ -56,5 +56,10 @@ public class GuavaOptional {
 
         assertThat(opt).as("foo").isPresent().as("bar").isPresent();
         assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.FALSE);
+
+        assertThat(opt.orNull()).as("foo").isEqualTo(null).isNotNull();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java b/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java
index ff49238..81fde45 100644
--- a/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java
+++ b/src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java
@@ -56,5 +56,10 @@ public class GuavaOptional {
 
         assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.TRUE);
         assertThat(opt.isPresent()).as("foo").isEqualTo(true).as("bar").isEqualTo(Boolean.FALSE);
+
+        assertThat(opt.orNull()).as("foo").isEqualTo(null).isNotNull();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionAfter.java b/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionAfter.java
index 392f2f6..8503ed1 100644
--- a/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionAfter.java
+++ b/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionAfter.java
@@ -284,5 +284,8 @@ public class ImplicitAssertion {
         assertThat(guavaOptional).contains("foo");
         assertThat(guavaOptional).extractingValue().isEqualTo("foo");
         assertThat(guavaOptional).extractingCharSequence().isEqualTo("foo");
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionBefore.java b/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionBefore.java
index e9e765e..f3b8726 100644
--- a/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionBefore.java
+++ b/src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionBefore.java
@@ -284,5 +284,8 @@ public class ImplicitAssertion {
         assertThat(guavaOptional).isPresent().contains("foo");
         assertThat(guavaOptional).isPresent().extractingValue().isEqualTo("foo");
         assertThat(guavaOptional).isPresent().extractingCharSequence().isEqualTo("foo");
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java b/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java
index 3e7f668..4af0f5b 100644
--- a/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java
+++ b/src/test/resources/inspections/InstanceOf/InstanceOfAfter.java
@@ -21,5 +21,8 @@ public class InstanceOf {
 
         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);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java b/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java
index cb38517..2ed6697 100644
--- a/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java
+++ b/src/test/resources/inspections/InstanceOf/InstanceOfBefore.java
@@ -21,5 +21,8 @@ public class InstanceOf {
 
         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);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java
index f13dae9..37c5833 100644
--- a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java
+++ b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionAfter.java
@@ -35,5 +35,8 @@ public class InvertedBooleanCondition {
 
         assertThat(primitive).as("foo").isFalse().as("bar").isFalse();
         assertThat(primitive).as("foo").isFalse().as("bar").isTrue();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java
index 514caea..acbe698 100644
--- a/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java
+++ b/src/test/resources/inspections/InvertedBooleanCondition/InvertedBooleanConditionBefore.java
@@ -35,5 +35,8 @@ public class InvertedBooleanCondition {
 
         assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(false);
         assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(true);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java b/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java
index 545b6c8..6a1fa14 100644
--- a/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java
+++ b/src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java
@@ -43,5 +43,10 @@ public class Java8Optional {
         assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
 
         assertThat(opt.orElse("foo")).as("foo").isEqualTo(null);
+
+        assertThat(opt.orElse(null)).as("foo").isEqualTo(null).isNotNull();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java b/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java
index 7d43b50..43f4bf9 100644
--- a/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java
+++ b/src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java
@@ -43,5 +43,10 @@ public class Java8Optional {
         assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
 
         assertThat(opt.orElse("foo")).as("foo").isEqualTo(null);
+
+        assertThat(opt.orElse(null)).as("foo").isEqualTo(null).isNotNull();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java b/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java
index e6ffe1e..faf5497 100644
--- a/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java
+++ b/src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java
@@ -1,6 +1,7 @@
 import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 public class JoinStatements {
 
@@ -24,21 +25,28 @@ public class JoinStatements {
                 .doesNotContain("foobar");
 
         assertThat("narf").isNotEqualTo("puit");
-        assertThat(list).as("bar").contains("barbar").as("foo").hasSize(2);
+        assertThat(list).as("bar").contains("barbar")
+                .as("foo").hasSize(2);
         assertThat(list).as("evil").extracting(String::length).contains(2);
 
         assertThat(list).as("bar").contains("barbar");
         assertThat(otherList).contains("puit");
         assertThat(list).as("foo").hasSize(2);
         if (true) {
-            assertThat(list).doesNotContain("narf").as("bar").contains("barbar");
+            assertThat(list).doesNotContain("narf")
+                    .as("bar").contains("barbar");
         }
-        assertThat(list.get(0)).isNotEmpty().hasSize(3).isEqualTo("bar");
+        assertThat(list.get(0)).isNotEmpty()
+                .hasSize(3)
+                .isEqualTo("bar");
 
         assertThat(otherList.get(0)).isNotEmpty();
         assertThat(list.get(0)).hasSize(3);
 
-        assertThat(list.get(0) + "foo").isEqualTo("bar").doesNotStartWith("foo");
+        assertThat(list.get(0) + "foo").isNotNull()
+                // hey, a comment mixed with line breaks due to too many joins
+                .isEqualTo("bar")
+                .doesNotStartWith("foo");
 
         assertThat(otherList.get(0) + "foo").isEqualTo("bar");
         assertThat(list.get(0) + "foo").doesNotStartWith("foo");
@@ -57,5 +65,8 @@ public class JoinStatements {
         assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java b/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java
index 6fea244..1834ad6 100644
--- a/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java
+++ b/src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java
@@ -1,6 +1,7 @@
 import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 public class JoinStatements {
 
@@ -39,6 +40,8 @@ public class JoinStatements {
         assertThat(otherList.get(0)).isNotEmpty();
         assertThat(list.get(0)).hasSize(3);
 
+        assertThat(list.get(0) + "foo").isNotNull();
+        // hey, a comment mixed with line breaks due to too many joins
         assertThat(list.get(0) + "foo").isEqualTo("bar");
         assertThat(list.get(0) + "foo").doesNotStartWith("foo");
 
@@ -59,5 +62,8 @@ public class JoinStatements {
         assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/ObjectExpression/ObjectExpressionAfter.java b/src/test/resources/inspections/ObjectExpression/ObjectExpressionAfter.java
index 63f8eb0..ea08db4 100644
--- a/src/test/resources/inspections/ObjectExpression/ObjectExpressionAfter.java
+++ b/src/test/resources/inspections/ObjectExpression/ObjectExpressionAfter.java
@@ -23,5 +23,8 @@ public class ObjectExpression {
         assertThat(object.equals(otherObject)).isEqualTo(foo);
 
         assertThat(object).as("doh!").isEqualTo(otherObject).isEqualTo(otherObject);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/ObjectExpression/ObjectExpressionBefore.java b/src/test/resources/inspections/ObjectExpression/ObjectExpressionBefore.java
index 7ee6959..a996ba9 100644
--- a/src/test/resources/inspections/ObjectExpression/ObjectExpressionBefore.java
+++ b/src/test/resources/inspections/ObjectExpression/ObjectExpressionBefore.java
@@ -23,5 +23,8 @@ public class ObjectExpression {
         assertThat(object.equals(otherObject)).isEqualTo(foo);
 
         assertThat(object.equals(otherObject)).as("doh!").isTrue().isEqualTo(true);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullAfter.java b/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullAfter.java
index bf5de76..612035f 100644
--- a/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullAfter.java
+++ b/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullAfter.java
@@ -13,5 +13,8 @@ public class ObjectIsNull {
 
         assertThat(new Object()).as("foo").isNotNull().as("bar").isEqualTo(new Object()).as("etc").isNull();
         assertThat(new Object()).as("foo").isEqualTo(null).as("bar").isEqualTo(new Object()).as("etc").isNotNull();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullBefore.java b/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullBefore.java
index ec274b3..627bfaf 100644
--- a/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullBefore.java
+++ b/src/test/resources/inspections/ObjectIsNullOrNotNull/ObjectIsNullOrNotNullBefore.java
@@ -13,5 +13,8 @@ public class ObjectIsNull {
 
         assertThat(new Object()).as("foo").isNotEqualTo(null).as("bar").isEqualTo(new Object()).as("etc").isEqualTo(null);
         assertThat(new Object()).as("foo").isEqualTo(null).as("bar").isEqualTo(new Object()).as("etc").isNotEqualTo(null);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/Size/SizeAfter.java b/src/test/resources/inspections/Size/SizeAfter.java
index 159bd97..63a5835 100644
--- a/src/test/resources/inspections/Size/SizeAfter.java
+++ b/src/test/resources/inspections/Size/SizeAfter.java
@@ -99,5 +99,12 @@ public class Size {
         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);
+
+        int foo = 1;
+        assertThat(foo).isEqualTo(0);
+        assertThat(string.length()).isPositive();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/Size/SizeBefore.java b/src/test/resources/inspections/Size/SizeBefore.java
index a9d2498..f273b3b 100644
--- a/src/test/resources/inspections/Size/SizeBefore.java
+++ b/src/test/resources/inspections/Size/SizeBefore.java
@@ -99,5 +99,12 @@ public class Size {
         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);
+
+        int foo = 1;
+        assertThat(foo).isEqualTo(0);
+        assertThat(string.length()).isPositive();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/StringExpression/StringExpressionAfter.java b/src/test/resources/inspections/StringExpression/StringExpressionAfter.java
index 928853f..fc2a125 100644
--- a/src/test/resources/inspections/StringExpression/StringExpressionAfter.java
+++ b/src/test/resources/inspections/StringExpression/StringExpressionAfter.java
@@ -49,5 +49,8 @@ public class StringExpression {
         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();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/StringExpression/StringExpressionBefore.java b/src/test/resources/inspections/StringExpression/StringExpressionBefore.java
index e2c51ba..3342081 100644
--- a/src/test/resources/inspections/StringExpression/StringExpressionBefore.java
+++ b/src/test/resources/inspections/StringExpression/StringExpressionBefore.java
@@ -49,5 +49,8 @@ public class StringExpression {
         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();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/StringIsEmpty/StringIsEmptyAfter.java b/src/test/resources/inspections/StringIsEmpty/StringIsEmptyAfter.java
index bc12c9a..cb9f834 100644
--- a/src/test/resources/inspections/StringIsEmpty/StringIsEmptyAfter.java
+++ b/src/test/resources/inspections/StringIsEmpty/StringIsEmptyAfter.java
@@ -18,5 +18,8 @@ public class StringIsEmpty {
 
         assertThat(string).as("foo").isEqualTo("").as("bar").hasSize(0).hasSameSizeAs("foo").isEmpty();
         assertThat(string).as("foo").isEqualTo("").as("bar").hasSize(0).hasSameSizeAs("foo").isEmpty();
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java b/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java
index 959452b..4f62bd2 100644
--- a/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java
+++ b/src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java
@@ -18,5 +18,8 @@ public class StringIsEmpty {
 
         assertThat(string).as("foo").isEqualTo("").as("bar").hasSize(0).hasSameSizeAs("foo").isEqualTo("");
         assertThat(string).as("foo").isEqualTo("").as("bar").hasSize(0).hasSameSizeAs("foo").hasSize(0);
+
+        org.junit.Assert.assertThat(foo, null);
+        fail("oh no!");
     }
 }
diff --git a/src/test/resources/references/FindReference11.java b/src/test/resources/references/FindReference11.java
new file mode 100644
index 0000000..5e8d090
--- /dev/null
+++ b/src/test/resources/references/FindReference11.java
@@ -0,0 +1,15 @@
+import org.assertj.core.extractor.Extractors;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FindReference10 {
+
+    private void findReferences() {
+        List<Contact> contactList = Collections.emptyList();
+
+        assertThat(contactList).extracting("narf<caret>").isEqualTo("foo");
+    }
+}
\ No newline at end of file