Removed TODO about AssertThatBinaryExpressionIsTrueOrFalse.

New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and equals() statements (more than 150 combinations) inside assertThat().
Added tacky icon.
2019-04-07 11:37:10 +02:00 · 2019-04-07 11:29:07 +02:00 · 2019-04-06 21:29:18 +02:00 · 2019-04-06 21:29:18 +02:00 · 2019-04-06 21:29:13 +02:00 · 2019-04-01 16:44:52 +02:00
35 changed files with 980 additions and 158 deletions
@@ -34,13 +34,11 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to

 ## Implemented inspections

- AssertThatObjectIsNull
+- AssertThatObjectIsNullOrNotNull
  ```
  from: assertThat(object).isEqualTo(null);
    to: assertThat(object).isNull();
-  ```
- AssertThatObjectIsNotNull
-  ```
+
  from: assertThat(object).isNotEqualTo(null);  
    to: assertThat(object).isNotNull();
  ```
@@ -77,8 +75,40 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to
    to: assertThat(array).hasSameSizeAs(anotherArray);
  ```

+  with AssertJ 13.2.0 or higher
+
+  ```
+  from: assertThat(array.length).isLessThanOrEqualTo(expression);
+    to: assertThat(array).hasSizeLessThanOrEqualTo(expression);
+    
+  from: assertThat(array.length).isLessThan(expression);
+    to: assertThat(array).hasSizeLessThan(expression);
+
+  from: assertThat(array.length).isGreaterThan(expression);
+    to: assertThat(array).hasSizeGreaterThan(expression);
+
+  from: assertThat(array.length).isGreaterThanOrEqualTo(expression);
+    to: assertThat(array).hasSizeGreaterThanOrEqualTo(expression);
+  ```
+
  and analogously for collections...

+- AssertThatBinaryExpressionIsTrueOrFalse
+  ```
+  from: assertThat(primActual == primExpected).isTrue();
+    to: assertThat(primActual).isEqualTo(primExpected);
+
+  from: assertThat(10 < primActual).isNotEqualTo(false);
+    to: assertThat(primActual).isGreaterThan(primExpected);
+
+  from: assertThat(objActual != objExpected).isEqualTo(true);
+    to: assertThat(objActual).isNotSameAs(objExpected);
+
+  from: assertThat(null == objActual).isFalse();
+    to: assertThat(objActual).isNotNull();
+  ```
+  and many, many more combinations (more than 150).
+  
 - JUnitAssertToAssertJ
  ```
  assertTrue(condition);
@@ -107,6 +137,55 @@ The plugin also supports the conversion of the most common JUnit 4 assertions to
  assertArrayEquals(message, expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
  ```

+## Development notice
+
+Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one that I'm aware of ;) ).
+The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing and I took me quite a while to make it work with JUnit 5.
+Feel free to use the code (in package de.platon42.intellij.jupiter) for your projects (with attribution).
+
 ## TODO
+- AssertThatJava8OptionalContains
+  ```
+  from: assertThat(Optional.of("foo").get()).isEqualTo("foo");
+    to: assertThat(Optional.of("foo")).contains("foo");
+  ```
+- AssertThatJava8OptionalIsPresentOrAbsent
+  ```
+  from: assertThat(Optional.of("foo").isPresent()).isEqualTo(true);
+  from: assertThat(!Optional.of("foo").isPresent()).isEqualTo(false);
+  from: assertThat(Optional.of("foo").isPresent()).isTrue();
+  from: assertThat(!Optional.of("foo").isPresent()).isFalse();
+    to: assertThat(Optional.of("foo")).isPresent();
+
+  from: assertThat(Optional.of("foo").isPresent()).isEqualTo(false);
+  from: assertThat(!Optional.of("foo").isPresent()).isEqualTo(true);
+  from: assertThat(Optional.of("foo").isPresent()).isFalse();
+  from: assertThat(!Optional.of("foo").isPresent()).isTrue();
+    to: assertThat(Optional.of("foo")).isNotPresent();
+  ```
 - AssertThatGuavaOptionalContains
- extraction with property names to lambda with Java 8
+  ```
+  from: assertThat(Optional.of("foo").get()).isEqualTo("foo");
+    to: assertThat(Optional.of("foo")).contains("foo");
+  ```
+- AssertThatGuavaOptionalIsPresentOrAbsent
+  ```
+  from: assertThat(Optional.of("foo").isPresent()).isEqualTo(true);
+  from: assertThat(!Optional.of("foo").isPresent()).isEqualTo(false);
+  from: assertThat(Optional.of("foo").isPresent()).isTrue();
+  from: assertThat(!Optional.of("foo").isPresent()).isFalse();
+    to: assertThat(Optional.of("foo")).isPresent();
+
+  from: assertThat(Optional.of("foo").isPresent()).isEqualTo(false);
+  from: assertThat(!Optional.of("foo").isPresent()).isEqualTo(true);
+  from: assertThat(Optional.of("foo").isPresent()).isFalse();
+  from: assertThat(!Optional.of("foo").isPresent()).isTrue();
+    to: assertThat(Optional.of("foo")).isAbsent();
+  ```
+- Referencing string properties inside extracting()
+- Extraction with property names to lambda with Java 8
+  ```
+  from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
+    to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
+  ```
+- Kotlin support
@@ -5,7 +5,7 @@ plugins {
 }

 group 'de.platon42'
-version '0.1'
+version '0.3'

 repositories {
    mavenCentral()
@@ -18,7 +18,8 @@ repositories {

 dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testCompile "org.assertj:assertj-core:3.11.1"
+    testCompile "org.assertj:assertj-core:3.12.2"
+    testCompile "org.assertj:assertj-guava:3.2.1"
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
    testRuntimeOnly 'org.junit.vintage:junit-vintage-engine:5.4.0'
@@ -33,14 +34,26 @@ compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2018.3.4'
+    version '2019.1'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
    updateSinceUntilBuild false
 }

 patchPluginXml {
    changeNotes """
-      <h2>V0.1 (31-Mar-19)
+      <h4>V0.3 (07-Apr-19)</h4>
+      <ul>
+      <li>New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and equals() statements (more than 150 combinations) inside assertThat().
+      <li>Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull.
+      <li>Support for hasSizeLessThan(), hasSizeLessThanOrEqualTo(), hasSizeGreaterThanOrEqualTo(), and hasSizeGreaterThan() for AssertThatSizeInspection (with AssertJ >=13.2.0).
+      <li>Really fixed highlighting for JUnit conversion. Sorry.
+      </ul>
+      <h4>V0.2 (01-Apr-19)</h4>
+      <ul>
+      <li>Fixed descriptions and quick fix texts.
+      <li>Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.
+      </ul>
+      <h4>V0.1 (31-Mar-19)</h4>
      <ul>
      <li>Initial release.
      </ul>
@@ -1,13 +1,8 @@
 package de.platon42.intellij.plugins.cajon.inspections

 import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
-import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
-import com.intellij.psi.CommonClassNames
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.psi.PsiCapturedWildcardType
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.util.PsiTypesUtil
 import com.siyeh.ig.callMatcher.CallMatcher
@@ -58,11 +53,18 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
        @NonNls
        const val IS_NOT_ZERO_METHOD = "isNotZero"
        @NonNls
+        const val IS_TRUE_METHOD = "isTrue"
+        @NonNls
+        const val IS_FALSE_METHOD = "isFalse"
+        @NonNls
        const val HAS_SIZE_METHOD = "hasSize"

        val ASSERT_THAT_INT = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, ASSERT_THAT_METHOD)
            .parameterTypes("int")!!

+        val ASSERT_THAT_BOOLEAN = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, ASSERT_THAT_METHOD)
+            .parameterTypes("boolean")!!
+
        val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
        val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO_METHOD)
@@ -92,8 +94,15 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
        val IS_NOT_ZERO = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, IS_NOT_ZERO_METHOD)
            .parameterCount(0)!!

+        val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_TRUE_METHOD)
+            .parameterCount(0)!!
+        val IS_FALSE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_FALSE_METHOD)
+            .parameterCount(0)!!
+
        val COLLECTION_SIZE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "size")
            .parameterCount(0)!!
+        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "equals")
+            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
    }

    override fun getGroupDisplayName(): String {
@@ -125,8 +134,6 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
        holder.registerProblem(
            expression,
            message,
-            ProblemHighlightType.INFORMATION,
-            null as TextRange?,
            ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
        )
    }
@@ -137,4 +144,12 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
        val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
        return constantEvaluationHelper.computeConstantExpression(valueExpression)
    }
+
+    protected fun hasAssertJMethod(element: PsiElement, classAndMethod: String): Boolean {
+        val classname = "org.assertj.core.api.${classAndMethod.substringBeforeLast(".")}"
+        val findClass =
+            JavaPsiFacade.getInstance(element.project).findClass(classname, GlobalSearchScope.allScope(element.project))
+                ?: return false
+        return findClass.findMethodsByName(classAndMethod.substringAfterLast(".")).isNotEmpty()
+    }
 }
@@ -40,5 +40,4 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()

    protected fun getOriginalMethodName(expression: PsiMethodCallExpression) =
        expression.resolveMethod()?.name?.plus("()")
-
 }
@@ -0,0 +1,144 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+import com.intellij.psi.tree.IElementType
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.util.TypeConversionUtil
+import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.SplitEqualsExpressionMethodCallQuickFix
+
+class AssertThatBinaryExpressionIsTrueOrFalseInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting a binary expression"
+        private const val SPLIT_BINARY_EXPRESSION_DESCRIPTION = "Split binary expression out of assertThat()"
+        private const val SPLIT_EQUALS_EXPRESSION_DESCRIPTION = "Split equals() expression out of assertThat()"
+        private const val BINARY_MORE_MEANINGFUL_MESSAGE = "Moving binary expression out of assertThat() would be more meaningful"
+        private const val EQUALS_MORE_MEANINGFUL_MESSAGE = "Moving equals() expression out of assertThat() would be more meaningful"
+
+        private val PRIMITIVE_MAPPINGS = listOf(
+            Mapping(JavaTokenType.EQEQ, "isEqualTo()", "isNotEqualTo()"),
+            Mapping(JavaTokenType.NE, "isNotEqualTo()", "isEqualTo()"),
+            Mapping(JavaTokenType.GT, "isGreaterThan()", "isLessThanOrEqualTo()"),
+            Mapping(JavaTokenType.GE, "isGreaterThanOrEqualTo()", "isLessThan()"),
+            Mapping(JavaTokenType.LT, "isLessThan()", "isGreaterThanOrEqualTo()"),
+            Mapping(JavaTokenType.LE, "isLessThanOrEqualTo()", "isGreaterThan()")
+        )
+
+        private val PRIMITIVE_MAPPINGS_SWAPPED = listOf(
+            Mapping(JavaTokenType.EQEQ, "isEqualTo()", "isNotEqualTo()"),
+            Mapping(JavaTokenType.NE, "isNotEqualTo()", "isEqualTo()"),
+            Mapping(JavaTokenType.GT, "isLessThan()", "isGreaterThanOrEqualTo()"),
+            Mapping(JavaTokenType.GE, "isLessThanOrEqualTo()", "isGreaterThan()"),
+            Mapping(JavaTokenType.LT, "isGreaterThan()", "isLessThanOrEqualTo()"),
+            Mapping(JavaTokenType.LE, "isGreaterThanOrEqualTo()", "isLessThan()")
+        )
+
+        private val OBJECT_MAPPINGS = listOf(
+            Mapping(JavaTokenType.EQEQ, "isSameAs()", "isNotSameAs()"),
+            Mapping(JavaTokenType.NE, "isNotSameAs()", "isSameAs()")
+        )
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                if (!ASSERT_THAT_BOOLEAN.test(expression)) {
+                    return
+                }
+
+                val statement = PsiTreeUtil.getParentOfType(expression, PsiStatement::class.java) ?: return
+                val expectedCallExpression = PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java) ?: return
+                val isInverted = getExpectedResult(expectedCallExpression) ?: return
+
+                val assertThatArgument = expression.argumentList.expressions[0] ?: return
+                if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
+                    val replacementMethod = if (isInverted) "isNotEqualTo()" else "isEqualTo()"
+                    holder.registerProblem(
+                        expression,
+                        EQUALS_MORE_MEANINGFUL_MESSAGE,
+                        SplitEqualsExpressionMethodCallQuickFix(SPLIT_EQUALS_EXPRESSION_DESCRIPTION, replacementMethod)
+                    )
+                    return
+                }
+
+                val binaryExpression = assertThatArgument as? PsiBinaryExpression ?: return
+
+                val leftType = binaryExpression.lOperand.type ?: return
+                val rightType = binaryExpression.rOperand?.type ?: return
+
+                val isLeftNull = TypeConversionUtil.isNullType(leftType)
+                val isRightNull = TypeConversionUtil.isNullType(rightType)
+                if (isLeftNull && isRightNull) {
+                    return
+                } else if (isLeftNull || isRightNull) {
+                    registerSplitBinaryExpressionMethod(
+                        holder,
+                        expression,
+                        if (isInverted) "isNotNull()" else "isNull()",
+                        pickRightOperand = isLeftNull,
+                        noExpectedExpression = true
+                    )
+                    return
+                }
+
+                val isPrimitive = TypeConversionUtil.isPrimitiveAndNotNull(leftType) && TypeConversionUtil.isPrimitiveAndNotNull(rightType)
+                val isNumericType = TypeConversionUtil.isNumericType(leftType) && TypeConversionUtil.isNumericType(rightType)
+                val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
+                val swapExpectedAndActual = constantEvaluationHelper.computeConstantExpression(binaryExpression.lOperand) != null
+
+                val tokenType = binaryExpression.operationSign.tokenType
+                val mappingToUse =
+                    if (isPrimitive || isNumericType) {
+                        if (swapExpectedAndActual) PRIMITIVE_MAPPINGS_SWAPPED else PRIMITIVE_MAPPINGS
+                    } else {
+                        OBJECT_MAPPINGS
+                    }
+                val mapping = mappingToUse.find { it.tokenType == tokenType } ?: return
+                val replacementMethod = if (isInverted) mapping.replacementInverted else mapping.replacement
+
+                registerSplitBinaryExpressionMethod(holder, expression, replacementMethod, pickRightOperand = swapExpectedAndActual)
+            }
+
+            private fun getExpectedResult(expectedCallExpression: PsiMethodCallExpression): Boolean? {
+                val isTrue = IS_TRUE.test(expectedCallExpression)
+                val isFalse = IS_FALSE.test(expectedCallExpression)
+                if (isTrue || isFalse) {
+                    return isFalse
+                } else {
+                    val isEqualTo = IS_EQUAL_TO_BOOLEAN.test(expectedCallExpression)
+                    val isNotEqualTo = IS_NOT_EQUAL_TO_BOOLEAN.test(expectedCallExpression)
+                    if (isEqualTo || isNotEqualTo) {
+                        val constValue = calculateConstantParameterValue(expectedCallExpression, 0) as? Boolean ?: return null
+                        return isEqualTo xor constValue
+                    }
+                }
+                return null
+            }
+
+            private fun registerSplitBinaryExpressionMethod(
+                holder: ProblemsHolder,
+                expression: PsiMethodCallExpression,
+                replacementMethod: String,
+                pickRightOperand: Boolean = false,
+                noExpectedExpression: Boolean = false
+            ) {
+                holder.registerProblem(
+                    expression,
+                    BINARY_MORE_MEANINGFUL_MESSAGE,
+                    SplitBinaryExpressionMethodCallQuickFix(SPLIT_BINARY_EXPRESSION_DESCRIPTION, replacementMethod, pickRightOperand, noExpectedExpression)
+                )
+            }
+        }
+    }
+
+    private class Mapping(
+        val tokenType: IElementType,
+        val replacement: String,
+        val replacementInverted: String
+    )
+}
@@ -1,31 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiMethodCallExpression
-import com.intellij.psi.PsiType
-
-class AssertThatObjectIsNullInspection : AbstractAssertJInspection() {
-
-    companion object {
-        private const val DISPLAY_NAME = "Asserting null"
-    }
-
-    override fun getDisplayName() = DISPLAY_NAME
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JavaElementVisitor() {
-            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
-                super.visitMethodCallExpression(expression)
-                if (!IS_EQUAL_TO_OBJECT.test(expression)) {
-                    return
-                }
-
-                if (expression.argumentList.expressions[0].type == PsiType.NULL) {
-                    registerSimplifyMethod(holder, expression, "isNull()")
-                }
-            }
-        }
-    }
-}
@@ -6,10 +6,10 @@ import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.PsiType

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

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

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

                if (expression.argumentList.expressions[0].type == PsiType.NULL) {
-                    registerSimplifyMethod(holder, expression, "isNotNull()")
+                    registerSimplifyMethod(holder, expression, if (isEqualTo) "isNull()" else "isNotNull()")
                }
            }
        }
@@ -1,8 +1,6 @@
 package de.platon42.intellij.plugins.cajon.inspections

-import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.util.PsiTreeUtil
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickFix
@@ -11,7 +9,7 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {

    companion object {
        private const val DISPLAY_NAME = "Asserting the size of an collection or array"
-        private const val CONCISER_MESSAGE_TEMPLATE = "%s would be conciser than %s"
+        private const val MORE_CONCISE_MESSAGE_TEMPLATE = "%s would be more concise than %s"
    }

    override fun getDisplayName() = DISPLAY_NAME
@@ -31,30 +29,43 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                    val constValue = calculateConstantParameterValue(expectedCallExpression, 0)
                    if (IS_EQUAL_TO_INT.test(expectedCallExpression)) {
                        if (constValue == 0) {
-                            registerSizeMethod(holder, expression, "isEmpty()", noExpectedExpression = true)
+                            registerSizeMethod(holder, expression, expectedCallExpression, "isEmpty()", noExpectedExpression = true)
                            return
                        }
                        val equalToExpression = expectedCallExpression.argumentList.expressions[0]
                        if (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) {
-                            registerSizeMethod(holder, expression, "hasSameSizeAs()", expectedIsCollection = true)
+                            registerSizeMethod(holder, expression, expectedCallExpression, "hasSameSizeAs()", expectedIsCollection = true)
                            return
                        }
-                        registerSizeMethod(holder, expression, "hasSize()")
+                        registerSizeMethod(holder, expression, expectedCallExpression, "hasSize()")
                    } else {
                        if ((IS_LESS_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 0))
                            || (IS_LESS_THAN_INT.test(expectedCallExpression) && (constValue == 1))
                            || IS_ZERO.test(expectedCallExpression)
                        ) {
-                            registerSizeMethod(holder, expression, "isEmpty()", noExpectedExpression = true)
+                            registerSizeMethod(holder, expression, expectedCallExpression, "isEmpty()", noExpectedExpression = true)
                            return
                        }
                        if ((IS_GREATER_THAN_INT.test(expectedCallExpression) && (constValue == 0))
                            || (IS_GREATER_THAN_OR_EQUAL_TO_INT.test(expectedCallExpression) && (constValue == 1))
                            || IS_NOT_ZERO.test(expectedCallExpression)
                        ) {
-                            registerSizeMethod(holder, expression, "isNotEmpty()", noExpectedExpression = true)
+                            registerSizeMethod(holder, expression, expectedCallExpression, "isNotEmpty()", noExpectedExpression = true)
                            return
                        }
+                        // new stuff in AssertJ 13.2.0
+                        if (hasAssertJMethod(expression, "AbstractIterableAssert.hasSizeLessThan")) {
+                            val matchedMethod = listOf(
+                                Pair(IS_GREATER_THAN_INT, "hasSizeGreaterThan()"),
+                                Pair(IS_GREATER_THAN_OR_EQUAL_TO_INT, "hasSizeGreaterThanOrEqualTo()"),
+                                Pair(IS_LESS_THAN_OR_EQUAL_TO_INT, "hasSizeLessThanOrEqualTo()"),
+                                Pair(IS_LESS_THAN_INT, "hasSizeLessThan()")
+                            ).find { it.first.test(expectedCallExpression) }?.second
+                            if (matchedMethod != null) {
+                                registerSizeMethod(holder, expression, expectedCallExpression, matchedMethod)
+                                return
+                            }
+                        }
                    }
                }
            }
@@ -70,18 +81,17 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
            private fun registerSizeMethod(
                holder: ProblemsHolder,
                expression: PsiMethodCallExpression,
+                expectedCallExpression: PsiMethodCallExpression,
                replacementMethod: String,
                noExpectedExpression: Boolean = false,
                expectedIsCollection: Boolean = false
            ) {
-                val originalMethod = getOriginalMethodName(expression) ?: return
-                val description = REPLACE_DESCRIPTION_TEMPLATE.format(replacementMethod, originalMethod)
-                val message = CONCISER_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
+                val originalMethod = getOriginalMethodName(expectedCallExpression) ?: return
+                val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+                val message = MORE_CONCISE_MESSAGE_TEMPLATE.format(replacementMethod, originalMethod)
                holder.registerProblem(
                    expression,
                    message,
-                    ProblemHighlightType.INFORMATION,
-                    null as TextRange?,
                    ReplaceSizeMethodCallQuickFix(description, replacementMethod, noExpectedExpression, expectedIsCollection)
                )
            }
@@ -1,8 +1,6 @@
 package de.platon42.intellij.plugins.cajon.inspections

-import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.util.TextRange
 import com.intellij.psi.CommonClassNames
 import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
@@ -147,8 +145,6 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
        holder.registerProblem(
            expression,
            message,
-            ProblemHighlightType.INFORMATION,
-            null as TextRange?,
            ReplaceJUnitAssertMethodCallQuickFix(description, hasExpected, replacementMethod)
        )
    }
@@ -164,8 +160,6 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
        holder.registerProblem(
            expression,
            message,
-            ProblemHighlightType.INFORMATION,
-            null as TextRange?,
            ReplaceJUnitDeltaAssertMethodCallQuickFix(description, replacementMethod)
        )
    }
@@ -0,0 +1,36 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiBinaryExpression
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiStatement
+import com.intellij.psi.util.PsiTreeUtil
+
+class SplitBinaryExpressionMethodCallQuickFix(
+    description: String,
+    private val replacementMethod: String,
+    private val pickRightOperand: Boolean,
+    private val noExpectedExpression: Boolean
+) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val factory = JavaPsiFacade.getElementFactory(element.project)
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val binaryExpression = methodCallExpression.argumentList.expressions[0] as? PsiBinaryExpression ?: return
+        val expectedArgument = (if (pickRightOperand) binaryExpression.lOperand else binaryExpression.rOperand)?.copy() ?: return
+        binaryExpression.replace(if (pickRightOperand) binaryExpression.rOperand!! else binaryExpression.lOperand)
+
+        val statement = PsiTreeUtil.getParentOfType(element, PsiStatement::class.java) ?: return
+        val oldExpectedExpression = PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java) ?: return
+        val expectedExpression =
+            factory.createExpressionFromText("a.${if (noExpectedExpression) replacementMethod else replacementMethod.replace("()", "(e)")}", element) as PsiMethodCallExpression
+        if (!noExpectedExpression) {
+            expectedExpression.argumentList.expressions[0].replace(expectedArgument)
+        }
+        expectedExpression.methodExpression.qualifierExpression!!.replace(oldExpectedExpression.methodExpression.qualifierExpression!!)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}
@@ -0,0 +1,28 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.PsiStatement
+import com.intellij.psi.util.PsiTreeUtil
+
+class SplitEqualsExpressionMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val factory = JavaPsiFacade.getElementFactory(element.project)
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val equalsMethodCall = methodCallExpression.argumentList.expressions[0] as? PsiMethodCallExpression ?: return
+        val expectedArgument = equalsMethodCall.argumentList.expressions[0].copy()
+        equalsMethodCall.replace(equalsMethodCall.methodExpression.qualifierExpression!!)
+
+        val statement = PsiTreeUtil.getParentOfType(element, PsiStatement::class.java) ?: return
+        val oldExpectedExpression = PsiTreeUtil.findChildOfType(statement, PsiMethodCallExpression::class.java) ?: return
+        val expectedExpression =
+            factory.createExpressionFromText("a.${replacementMethod.replace("()", "(e)")}", element) as PsiMethodCallExpression
+        expectedExpression.argumentList.expressions[0].replace(expectedArgument)
+        expectedExpression.methodExpression.qualifierExpression!!.replace(oldExpectedExpression.methodExpression.qualifierExpression!!)
+        oldExpectedExpression.replace(expectedExpression)
+    }
+}
@@ -19,25 +19,22 @@
    <depends>com.intellij.modules.java</depends>

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

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

-        <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true"
-                         level="WARNING"
+        <localInspection groupPath="Java" shortName="AssertThatBinaryExpressionIsTrueOrFalse" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionIsTrueOrFalseInspection"/>
+
+        <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.JUnitAssertToAssertJInspection"/>
    </extensions>

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Foo" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px"
+     width="226.77px" height="226.77px" viewBox="0 0 226.77 226.77" enable-background="new 0 0 226.77 226.77" xml:space="preserve">
+<g>
+	<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="44.1792" y1="72.1201" x2="184.0214" y2="-8.6178">
+		<stop offset="0.2408" style="stop-color:#FFFFFF"/>
+        <stop offset="1" style="stop-color:#000000"/>
+	</linearGradient>
+    <path fill="url(#SVGID_1_)" stroke="#231F20" stroke-miterlimit="10" d="M210.1,36.551L122.5,7.75
+		C18.101,26.951,18.101,26.951,18.101,26.951L94.3,55.75L210.1,36.551"/>
+    <linearGradient id="SVGID_2_" gradientUnits="userSpaceOnUse" x1="-12.9795" y1="80.7827" x2="127.5331" y2="161.9077">
+		<stop offset="0.1763" style="stop-color:#FFFFFF"/>
+        <stop offset="0.2617" style="stop-color:#F9F9F9"/>
+        <stop offset="0.3726" style="stop-color:#E9E9E9"/>
+        <stop offset="0.4976" style="stop-color:#CFCECE"/>
+        <stop offset="0.6329" style="stop-color:#AAA9A9"/>
+        <stop offset="0.7765" style="stop-color:#7B7979"/>
+        <stop offset="0.9248" style="stop-color:#433F40"/>
+        <stop offset="1" style="stop-color:#231F20"/>
+	</linearGradient>
+    <polygon fill="url(#SVGID_2_)" stroke="#231F20" stroke-miterlimit="10" points="17.5,185.35 94.6,218.95 94.3,55.75
+		18.101,26.951 	"/>
+    <linearGradient id="SVGID_3_" gradientUnits="userSpaceOnUse" x1="88.6709" y1="122.3887" x2="214.4668" y2="133.3944">
+		<stop offset="0.1216" style="stop-color:#FFFFFF"/>
+        <stop offset="1" style="stop-color:#2B2728"/>
+        <stop offset="1" style="stop-color:#231F20"/>
+	</linearGradient>
+    <polygon fill="url(#SVGID_3_)" stroke="#231F20" stroke-miterlimit="10" points="94.5,55.75 94.5,56.35 94.5,55.75 95,219.25
+		209.5,190.15 209.5,36.65 	"/>
+</g>
+    <linearGradient id="SVGID_4_" gradientUnits="userSpaceOnUse" x1="51.6982" y1="79.75" x2="51.6982" y2="79.75">
+	<stop offset="0.1763" style="stop-color:#FFFFFF"/>
+        <stop offset="0.2617" style="stop-color:#F9F9F9"/>
+        <stop offset="0.3726" style="stop-color:#E9E9E9"/>
+        <stop offset="0.4976" style="stop-color:#CFCECE"/>
+        <stop offset="0.6329" style="stop-color:#AAA9A9"/>
+        <stop offset="0.7765" style="stop-color:#7B7979"/>
+        <stop offset="0.9248" style="stop-color:#433F40"/>
+        <stop offset="1" style="stop-color:#231F20"/>
+</linearGradient>
+    <path fill="url(#SVGID_4_)" stroke="#231F20" stroke-miterlimit="10" d="M51.699,79.75"/>
+    <path fill="#231F20" stroke="#231F20" stroke-miterlimit="10" d="M171.307,117.313c0.267,13.237-6.324,27.028-14.723,30.805
+	s-15.423-3.893-15.69-17.132c-0.267-13.236,6.323-27.029,14.723-30.805C164.015,96.405,171.039,104.076,171.307,117.313z"/>
+    <polygon fill="#39B54A" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" points="175.6,143.05 176.2,99.7 183.55,97
+	191.95,132.25 193.3,92.95 198.1,91.45 196.3,136.6 188.95,138.85 180.85,103.45 180.7,141.55 "/>
+    <path fill="#009444" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" d="M109.9,113.65c1.8,0,25.35-5.25,25.35-5.25
+	l1.2,38.7l-6.9,7.5l-11.25,3.15l-5.55-5.25l-1.5-6.75l5.1-1.35l1.95,6.6l3.45,1.05l5.25-1.95l4.5-4.35l-0.6-30.9l-19.2,4.051
+	L109.9,113.65z"/>
+    <path fill="#00A79D" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" d="M46.15,102.4c0-0.45-2.85-6.45-2.85-6.45
+	l-6.75-3l-5.7,0.15l-1.916,1.667L26.2,97.15l-2.4,5.1l-0.9,8.55l-0.75,12.15l0.3,12.3l2.85,8.25l8.85,4.95l7.2,0.45l5.55-5.551
+	l1.8-3.6l-3.15-4.05l-2.85,2.25l-3,3.6l-5.4,1.351l-4.2-1.95l-2.4-5.7l-1.05-5.85l0.6-10.051L28,110.8l0.9-6.75l1.95-3.75l6-0.75
+	l3.45,1.95l2.25,2.7l1.95,1.5L46.15,102.4z"/>
+    <polygon fill="#2BB673" stroke="#231F20" stroke-width="0.25" stroke-miterlimit="10" points="52.9,151.9 70.4,101.549
+	76.1,104.249 85.2,164.05 79.1,160.85 73.1,111.05 71.4,110.149 67,127.15 73.7,129.749 74.5,136.351 65.5,132.7 58.1,154.049 "/>
+</svg>
@@ -0,0 +1,11 @@
+<html>
+<body>
+Turns a binary expression in the kind of assertThat(actual &lt;operator&gt; expected) with .isTrue()/isFalse()/isEqualTo()/isNotEqualTo()
+into assertThat(actual).is&lt;operator&gt;(expected).
+<!-- tooltip end -->
+There are over 150 combinations that are found with this inspections.
+It also detects assertThat(actual.equals(expected)) assertions.
+Also works with constant expressions on the expected side.
+Swaps actual and expected when actual is a constant expression (correctly transforming the used operator).
+</body>
+</html>
@@ -1,6 +0,0 @@
-<html>
-<body>
-Turns assertThat(object).isNotEqualTo(null) into assertThat(object).isNotNull().
-<!-- tooltip end -->
-</body>
-</html>
@@ -1,6 +0,0 @@
-<html>
-<body>
-Turns assertThat(object).isEqualTo(null) into assertThat(object).isNull().
-<!-- tooltip end -->
-</body>
-</html>
@@ -0,0 +1,6 @@
+<html>
+<body>
+Turns assertThat(object).is(Not)EqualTo(null) into assertThat(object).is(Not)Null().
+<!-- tooltip end -->
+</body>
+</html>
@@ -131,7 +131,6 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
                VirtualFile jarFile = LocalFileSystem.getInstance().findFileByIoFile(jarPath.toFile());
                myFixture.allowTreeAccessForFile(jarFile);
                PsiTestUtil.addLibrary(
-                        myFixture.getModule(),
                        model,
                        jarPath.getFileName().toString().replace(".jar", ""),
                        jarPath.getParent().toString(),
@@ -4,9 +4,11 @@ import org.assertj.core.api.ListAssert;
 import org.assertj.core.data.Offset;

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

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

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

+    private void binaryExpression() {
+        int primExp = 42;
+        int primAct = 1337;
+        Double numberObjExp = 42.0;
+        Double numberObjAct = 1337.0;
+        String stringExp = "foo";
+        String stringAct = "bar";
+
+        assertThat(primAct == primExp).isTrue();
+        assertThat(primAct == 1).isTrue();
+        assertThat(primAct == primExp).isEqualTo(false);
+        assertThat(primAct != primExp).isEqualTo(true);
+        assertThat(1 != primAct).isTrue();
+        assertThat(primAct != primExp).isNotEqualTo(true);
+        assertThat(primAct > primExp).isNotEqualTo(false);
+        assertThat(primAct > primExp).isFalse();
+        assertThat(primAct > 1).isFalse();
+        assertThat(primAct >= 1).isTrue();
+        assertThat(primAct >= primExp).isEqualTo(false);
+        assertThat(1 <= primAct).isFalse();
+        assertThat(1 > primAct).isTrue();
+        assertThat(primAct < primExp).isNotEqualTo(true);
+        assertThat(primAct <= primExp).isNotEqualTo(false);
+        assertThat(primAct <= primExp).isFalse();
+        assertThat(primAct <= 1).isFalse();
+        assertThat(numberObjAct == 1).isTrue();
+        assertThat(numberObjAct == numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct != numberObjExp).isEqualTo(true);
+        assertThat(1 != numberObjAct).isTrue();
+        assertThat(numberObjAct != numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct > 1).isFalse();
+        assertThat(numberObjAct >= numberObjExp).isTrue();
+        assertThat(numberObjAct >= numberObjExp).isEqualTo(false);
+        assertThat(1 <= numberObjAct).isFalse();
+        assertThat(numberObjAct < numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct < numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct <= 1).isFalse();
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
+        assertThat(stringAct == stringExp).isNotEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
+        assertThat(stringAct != stringExp).isFalse();
+        assertThat(stringAct == null).isNotEqualTo(true);
+        assertThat(null == stringAct).isEqualTo(false);
+
+        assertThat(null == null).isTrue();
+        assertThat(!false).isTrue();
+    }
+
    private void stringIsEmpty() {
        String foo = "bar";
        assertThat(foo).isEqualTo("");
        assertThat(foo).hasSize(0);
    }

+    private void java8Optional() {
+        Optional<String> foo = Optional.empty();
+        assertThat(foo.get()).isEqualTo("bla");
+        assertThat(foo).contains("bla");
+        assertThat(foo.isPresent()).isTrue();
+        assertThat(!foo.isPresent()).isFalse();
+        assertThat(foo).isPresent();
+        assertThat(foo.isPresent()).isFalse();
+        assertThat(!foo.isPresent()).isTrue();
+        assertThat(foo).isNotPresent();
+    }
+
+    private void guavaOptional() {
+        com.google.common.base.Optional<String> foo = com.google.common.base.Optional.absent();
+        assertThat(foo.get()).isEqualTo("bla");
+        assertThat(foo).contains("bla");
+        assertThat(foo.isPresent()).isTrue();
+        assertThat(!foo.isPresent()).isFalse();
+        assertThat(foo).isPresent();
+        assertThat(foo.isPresent()).isFalse();
+        assertThat(!foo.isPresent()).isTrue();
+        assertThat(foo).isAbsent();
+    }
+
    private void junitAssertions() {
        assertTrue(true);
        assertTrue("message", true);
@@ -111,13 +188,9 @@ public class Playground {
        assertNotSame(bar, foo);
        assertNotSame("same", bar, foo);

-        assertEquals(1.0, 2.0);
        assertEquals(1.0, 2.0, 0.1);
-        assertEquals("equals", 1.0, 2.0);
        assertEquals("equals", 1.0, 2.0, 0.1);
-        assertEquals(1.0f, 2.0f);
        assertEquals(1.0f, 2.0f, 0.1f);
-        assertEquals("equals", 1.0f, 2.0f);
        assertEquals("equals", 1.0f, 2.0f, 0.1f);

        assertNotEquals(1.0, 2.0);
@@ -183,6 +256,7 @@ public class Playground {
        assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
        assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
        assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
-    }

+        assertThat(new Object()).extracting(Object::toString, Object::hashCode);
+    }
 }
@@ -61,7 +61,7 @@ abstract class AbstractCajonTest {

    protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
        val quickfixes = myFixture.getAllQuickFixes().filter { it.familyName.matches(regex) }
-        assertThat(quickfixes).hasSize(expectedFixes)
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.familyName }}").hasSize(expectedFixes)
        quickfixes.forEach(myFixture::launchAction)
    }
 }
@@ -0,0 +1,22 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.junit.jupiter.api.Test
+
+internal class AssertThatBinaryExpressionIsTrueOrFalseInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/BinaryExpression")
+    internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        runTest {
+            myFixture.enableInspections(AssertThatBinaryExpressionIsTrueOrFalseInspection::class.java)
+            myFixture.configureByFile("BinaryExpressionBefore.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 144)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 12)
+            myFixture.checkResultByFile("BinaryExpressionAfter.java")
+        }
+    }
+}
@@ -14,7 +14,10 @@ internal class AssertThatBooleanIsTrueOrFalseInspectionTest : AbstractCajonTest(
        runTest {
            myFixture.enableInspections(AssertThatBooleanIsTrueOrFalseInspection::class.java)
            myFixture.configureByFile("BooleanIsTrueOrFalseBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace is.*"), 17)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
            myFixture.checkResultByFile("BooleanIsTrueOrFalseAfter.java")
        }
    }
@@ -14,7 +14,7 @@ internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
        runTest {
            myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
            myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace hasSize.*"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 4)
            myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
        }
    }
@@ -1,21 +0,0 @@
-package de.platon42.intellij.plugins.cajon.inspections
-
-import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import de.platon42.intellij.jupiter.MyFixture
-import de.platon42.intellij.jupiter.TestDataSubPath
-import de.platon42.intellij.plugins.cajon.AbstractCajonTest
-import org.junit.jupiter.api.Test
-
-internal class AssertThatObjectIsNotNullInspectionTest : AbstractCajonTest() {
-
-    @Test
-    @TestDataSubPath("inspections/ObjectIsNotNull")
-    internal fun assertThat_with_isNotEqualTo_null_can_use_isNotNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
-            myFixture.enableInspections(AssertThatObjectIsNotNullInspection::class.java)
-            myFixture.configureByFile("ObjectIsNotNullBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 3)
-            myFixture.checkResultByFile("ObjectIsNotNullAfter.java")
-        }
-    }
-}
@@ -6,16 +6,17 @@ import de.platon42.intellij.jupiter.TestDataSubPath
 import de.platon42.intellij.plugins.cajon.AbstractCajonTest
 import org.junit.jupiter.api.Test

-internal class AssertThatObjectIsNullInspectionTest : AbstractCajonTest() {
+internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest() {

    @Test
-    @TestDataSubPath("inspections/ObjectIsNull")
+    @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
    internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
        runTest {
-            myFixture.enableInspections(AssertThatObjectIsNullInspection::class.java)
-            myFixture.configureByFile("ObjectIsNullBefore.java")
+            myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+            myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 3)
-            myFixture.checkResultByFile("ObjectIsNullAfter.java")
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 3)
+            myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
        }
    }
 }
@@ -14,7 +14,19 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
        runTest {
            myFixture.enableInspections(AssertThatSizeInspection::class.java)
            myFixture.configureByFile("AssertThatSizeBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 20)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 2)
            myFixture.checkResultByFile("AssertThatSizeAfter.java")
        }
    }
@@ -14,7 +14,8 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
        runTest {
            myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
            myFixture.configureByFile("StringIsEmptyBefore.java")
-            executeQuickFixes(myFixture, Regex("Replace .*"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 2)
            myFixture.checkResultByFile("StringIsEmptyAfter.java")
        }
    }
@@ -2,7 +2,7 @@ import java.util.ArrayList;

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

-public class assertThatSize {
+public class AssertThatSize {

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

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

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

-public class assertThatSize {
+public class AssertThatSize {

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

        assertThat(array.length).isEqualTo(0);
        assertThat(array.length).isZero();
@@ -31,5 +35,9 @@ public class assertThatSize {
        assertThat(array.length).isEqualTo(list.size());
        assertThat(array.length).isEqualTo(otherArray.length);
        assertThat(array.length).isEqualTo(1);
+        assertThat(array.length).isGreaterThan(otherArray.length - 1);
+        assertThat(array.length).isGreaterThanOrEqualTo(otherArray.length + 1);
+        assertThat(array.length).isLessThan(otherArray.length - 3);
+        assertThat(array.length).isLessThanOrEqualTo(1 - otherArray.length);
    }
 }
@@ -0,0 +1,190 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BinaryExpression {
+
+    private void binaryExpression() {
+        int primExp = 42;
+        int primAct = 1337;
+        Double numberObjExp = 42.0;
+        Double numberObjAct = 1337.0;
+        String stringExp = "foo";
+        String stringAct = "bar";
+
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(1);
+        assertThat(primAct).isEqualTo(1);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(1);
+        assertThat(primAct).isNotEqualTo(1);
+
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(primExp);
+        assertThat(primAct).isNotEqualTo(1);
+        assertThat(primAct).isNotEqualTo(1);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(primExp);
+        assertThat(primAct).isEqualTo(1);
+        assertThat(primAct).isEqualTo(1);
+
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(1);
+        assertThat(primAct).isGreaterThan(1);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(1);
+        assertThat(primAct).isLessThan(1);
+
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(primExp);
+        assertThat(primAct).isLessThan(1);
+        assertThat(primAct).isLessThan(1);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(primExp);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+        assertThat(primAct).isGreaterThanOrEqualTo(1);
+
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(primExp);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+        assertThat(primAct).isLessThanOrEqualTo(1);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(primExp);
+        assertThat(primAct).isGreaterThan(1);
+        assertThat(primAct).isGreaterThan(1);
+
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(1);
+        assertThat(numberObjAct).isEqualTo(1);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(1);
+        assertThat(numberObjAct).isNotEqualTo(1);
+
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(1);
+        assertThat(numberObjAct).isNotEqualTo(1);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(1);
+        assertThat(numberObjAct).isEqualTo(1);
+
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(1);
+        assertThat(numberObjAct).isGreaterThan(1);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(1);
+        assertThat(numberObjAct).isLessThan(1);
+
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(numberObjExp);
+        assertThat(numberObjAct).isLessThan(1);
+        assertThat(numberObjAct).isLessThan(1);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+        assertThat(numberObjAct).isGreaterThanOrEqualTo(1);
+
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(numberObjExp);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+        assertThat(numberObjAct).isLessThanOrEqualTo(1);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(numberObjExp);
+        assertThat(numberObjAct).isGreaterThan(1);
+        assertThat(numberObjAct).isGreaterThan(1);
+
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct).isNotEqualTo(stringExp);
+
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isNotSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+        assertThat(stringAct).isSameAs(stringExp);
+
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+        assertThat(stringAct).isNotNull();
+
+        assertThat(null == null).isTrue();
+        assertThat(!false).isTrue();
+    }
+}
@@ -0,0 +1,190 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BinaryExpression {
+
+    private void binaryExpression() {
+        int primExp = 42;
+        int primAct = 1337;
+        Double numberObjExp = 42.0;
+        Double numberObjAct = 1337.0;
+        String stringExp = "foo";
+        String stringAct = "bar";
+
+        assertThat(primAct == primExp).isTrue();
+        assertThat(primAct == primExp).isEqualTo(true);
+        assertThat(primAct == primExp).isNotEqualTo(false);
+        assertThat(primAct == 1).isTrue();
+        assertThat(1 == primAct).isTrue();
+        assertThat(primAct == primExp).isFalse();
+        assertThat(primAct == primExp).isEqualTo(false);
+        assertThat(primAct == primExp).isNotEqualTo(true);
+        assertThat(primAct == 1).isFalse();
+        assertThat(1 == primAct).isFalse();
+
+        assertThat(primAct != primExp).isTrue();
+        assertThat(primAct != primExp).isEqualTo(true);
+        assertThat(primAct != primExp).isNotEqualTo(false);
+        assertThat(primAct != 1).isTrue();
+        assertThat(1 != primAct).isTrue();
+        assertThat(primAct != primExp).isFalse();
+        assertThat(primAct != primExp).isEqualTo(false);
+        assertThat(primAct != primExp).isNotEqualTo(true);
+        assertThat(primAct != 1).isFalse();
+        assertThat(1 != primAct).isFalse();
+
+        assertThat(primAct > primExp).isTrue();
+        assertThat(primAct > primExp).isEqualTo(true);
+        assertThat(primAct > primExp).isNotEqualTo(false);
+        assertThat(primAct > 1).isTrue();
+        assertThat(1 < primAct).isTrue();
+        assertThat(primAct > primExp).isFalse();
+        assertThat(primAct > primExp).isEqualTo(false);
+        assertThat(primAct > primExp).isNotEqualTo(true);
+        assertThat(primAct > 1).isFalse();
+        assertThat(1 < primAct).isFalse();
+
+        assertThat(primAct >= primExp).isTrue();
+        assertThat(primAct >= primExp).isEqualTo(true);
+        assertThat(primAct >= primExp).isNotEqualTo(false);
+        assertThat(primAct >= 1).isTrue();
+        assertThat(1 <= primAct).isTrue();
+        assertThat(primAct >= primExp).isFalse();
+        assertThat(primAct >= primExp).isEqualTo(false);
+        assertThat(primAct >= primExp).isNotEqualTo(true);
+        assertThat(primAct >= 1).isFalse();
+        assertThat(1 <= primAct).isFalse();
+
+        assertThat(primAct < primExp).isTrue();
+        assertThat(primAct < primExp).isEqualTo(true);
+        assertThat(primAct < primExp).isNotEqualTo(false);
+        assertThat(primAct < 1).isTrue();
+        assertThat(1 > primAct).isTrue();
+        assertThat(primAct < primExp).isFalse();
+        assertThat(primAct < primExp).isEqualTo(false);
+        assertThat(primAct < primExp).isNotEqualTo(true);
+        assertThat(primAct < 1).isFalse();
+        assertThat(1 > primAct).isFalse();
+
+        assertThat(primAct <= primExp).isTrue();
+        assertThat(primAct <= primExp).isEqualTo(true);
+        assertThat(primAct <= primExp).isNotEqualTo(false);
+        assertThat(primAct <= 1).isTrue();
+        assertThat(1 >= primAct).isTrue();
+        assertThat(primAct <= primExp).isFalse();
+        assertThat(primAct <= primExp).isEqualTo(false);
+        assertThat(primAct <= primExp).isNotEqualTo(true);
+        assertThat(primAct <= 1).isFalse();
+        assertThat(1 >= primAct).isFalse();
+
+        assertThat(numberObjAct == numberObjExp).isTrue();
+        assertThat(numberObjAct == numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct == numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct == 1).isTrue();
+        assertThat(1 == numberObjAct).isTrue();
+        assertThat(numberObjAct == numberObjExp).isFalse();
+        assertThat(numberObjAct == numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct == numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct == 1).isFalse();
+        assertThat(1 == numberObjAct).isFalse();
+
+        assertThat(numberObjAct != numberObjExp).isTrue();
+        assertThat(numberObjAct != numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct != numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct != 1).isTrue();
+        assertThat(1 != numberObjAct).isTrue();
+        assertThat(numberObjAct != numberObjExp).isFalse();
+        assertThat(numberObjAct != numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct != numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct != 1).isFalse();
+        assertThat(1 != numberObjAct).isFalse();
+
+        assertThat(numberObjAct > numberObjExp).isTrue();
+        assertThat(numberObjAct > numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct > numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct > 1).isTrue();
+        assertThat(1 < numberObjAct).isTrue();
+        assertThat(numberObjAct > numberObjExp).isFalse();
+        assertThat(numberObjAct > numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct > numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct > 1).isFalse();
+        assertThat(1 < numberObjAct).isFalse();
+
+        assertThat(numberObjAct >= numberObjExp).isTrue();
+        assertThat(numberObjAct >= numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct >= numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct >= 1).isTrue();
+        assertThat(1 <= numberObjAct).isTrue();
+        assertThat(numberObjAct >= numberObjExp).isFalse();
+        assertThat(numberObjAct >= numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct >= numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct >= 1).isFalse();
+        assertThat(1 <= numberObjAct).isFalse();
+
+        assertThat(numberObjAct < numberObjExp).isTrue();
+        assertThat(numberObjAct < numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct < numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct < 1).isTrue();
+        assertThat(1 > numberObjAct).isTrue();
+        assertThat(numberObjAct < numberObjExp).isFalse();
+        assertThat(numberObjAct < numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct < numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct < 1).isFalse();
+        assertThat(1 > numberObjAct).isFalse();
+
+        assertThat(numberObjAct <= numberObjExp).isTrue();
+        assertThat(numberObjAct <= numberObjExp).isEqualTo(true);
+        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(false);
+        assertThat(numberObjAct <= 1).isTrue();
+        assertThat(1 >= numberObjAct).isTrue();
+        assertThat(numberObjAct <= numberObjExp).isFalse();
+        assertThat(numberObjAct <= numberObjExp).isEqualTo(false);
+        assertThat(numberObjAct <= numberObjExp).isNotEqualTo(true);
+        assertThat(numberObjAct <= 1).isFalse();
+        assertThat(1 >= numberObjAct).isFalse();
+
+        assertThat(numberObjAct.equals(numberObjExp)).isTrue();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(true);
+
+        assertThat(stringAct == stringExp).isTrue();
+        assertThat(stringAct == stringExp).isEqualTo(true);
+        assertThat(stringAct == stringExp).isNotEqualTo(false);
+        assertThat(stringAct == stringExp).isFalse();
+        assertThat(stringAct == stringExp).isEqualTo(false);
+        assertThat(stringAct == stringExp).isNotEqualTo(true);
+
+        assertThat(stringAct.equals(stringExp)).isTrue();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isFalse();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(true);
+
+        assertThat(stringAct != stringExp).isTrue();
+        assertThat(stringAct != stringExp).isEqualTo(true);
+        assertThat(stringAct != stringExp).isNotEqualTo(false);
+        assertThat(stringAct != stringExp).isFalse();
+        assertThat(stringAct != stringExp).isEqualTo(false);
+        assertThat(stringAct != stringExp).isNotEqualTo(true);
+
+        assertThat(stringAct == null).isTrue();
+        assertThat(stringAct == null).isEqualTo(true);
+        assertThat(stringAct == null).isNotEqualTo(false);
+        assertThat(stringAct == null).isFalse();
+        assertThat(stringAct == null).isEqualTo(false);
+        assertThat(stringAct == null).isNotEqualTo(true);
+
+        assertThat(null == stringAct).isTrue();
+        assertThat(null == stringAct).isEqualTo(true);
+        assertThat(null == stringAct).isNotEqualTo(false);
+        assertThat(null == stringAct).isFalse();
+        assertThat(null == stringAct).isEqualTo(false);
+        assertThat(null == stringAct).isNotEqualTo(true);
+
+        assertThat(null == null).isTrue();
+        assertThat(!false).isTrue();
+    }
+}
@@ -1,10 +0,0 @@
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class ObjectIsNotNull {
-
-    private void objectIsNotNull() {
-        assertThat("").isNotNull();
-        assertThat("").as("nah").isNotNull();
-        assertThat(new Object).isNotNull();
-    }
-}
@@ -1,10 +0,0 @@
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class ObjectIsNotNull {
-
-    private void objectIsNotNull() {
-        assertThat("").isNotEqualTo(null);
-        assertThat("").as("nah").isNotEqualTo(null);
-        assertThat(new Object).isNotEqualTo(null);
-    }
-}
@@ -5,6 +5,10 @@ public class ObjectIsNull {
    private void objectIsNull() {
        assertThat("").isNull();
        assertThat("").as("nah").isNull();
-        assertThat(new Object).isNull();
+        assertThat(new Object()).isNull();
+
+        assertThat("").isNotNull();
+        assertThat("").as("nah").isNotNull();
+        assertThat(new Object()).isNotNull();
    }
 }
@@ -5,6 +5,10 @@ public class ObjectIsNull {
    private void objectIsNull() {
        assertThat("").isEqualTo(null);
        assertThat("").as("nah").isEqualTo(null);
-        assertThat(new Object).isEqualTo(null);
+        assertThat(new Object()).isEqualTo(null);
+
+        assertThat("").isNotEqualTo(null);
+        assertThat("").as("nah").isNotEqualTo(null);
+        assertThat(new Object()).isNotEqualTo(null);
    }
 }
Author	SHA1	Message	Date
chrisly42	bdabcc7255	Removed TODO about AssertThatBinaryExpressionIsTrueOrFalse.	2019-04-07 11:37:10 +02:00
chrisly42	5812e72227	New inspection AssertThatBinaryExpressionIsTrueOrFalse that will find and fix common binary expressions and equals() statements (more than 150 combinations) inside assertThat().	2019-04-07 11:29:07 +02:00
chrisly42	6a44237ca0	Added tacky icon.	2019-04-06 21:29:18 +02:00
chrisly42	51703e8499	Merged AssertThatObjectIsNull and AssertThatObjectIsNotNull to AssertThatObjectIsNullOrNotNull. Extended tests to be more explicit regarding the expected quick fix messages.	2019-04-06 21:29:18 +02:00
chrisly42	ba56325299	Internally: Upgraded to AssertJ 13.2.2. Support for hasSizeLessThan(), hasSizeLessThanOrEqualTo(), hasSizeGreaterThanOrEqualTo(), and hasSizeGreaterThan() for AssertThatSizeInspection (with AssertJ >=13.2.0). Really fixed highlighting for JUnit conversion. Sorry. Fixed testing code to work against IDEA 2019.1.	2019-04-06 21:29:13 +02:00
chrisly42	5d91eaf276	Fixed descriptions and quick fix texts. Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.	2019-04-01 16:44:52 +02:00