Fix for multiple JUnit Conversions in batch mode with and without delta creating an exception.

Added new AssertThatObjectExpression inspection for toString() and hashCode() and moved equals() from AssertThatBinaryExpression there.
Finally was able to remove JUnit workaround for test invokation with availability of JUnit 5.5.0-RC1.
2019-06-09 21:35:23 +02:00 · 2019-06-09 14:17:44 +02:00 · 2019-06-09 14:04:01 +02:00 · 2019-05-17 12:17:01 +02:00 · 2019-05-16 20:06:14 +02:00 · 2019-05-15 20:50:30 +02:00
65 changed files with 1651 additions and 423 deletions
@@ -81,10 +81,12 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
        assertThat(expected).anotherCondition();
    to: assertThat(expected).someCondition().anotherCondition();
  ```
-  Joining will work on actual expressions inside assertThat() that are equivalent expressions,
-  except for method calls with known side-effect methods such as ```Iterator.next()``` -- please notify me about others.
+  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
+  pre/post-increment/decrement operations -- please notify me about others.

-  The comments of the statements will be preserved. When using ```.extracting()``` or similar, the statements will not be merged.
+  The comments of the statements will be preserved. When using ```extracting()``` or similar,
+  the statements will not be merged.

 - AssertThatObjectIsNullOrNotNull

@@ -145,7 +147,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the

 - AssertThatStringExpression
  
-  Moves string operations inside assertThat() out.
+  Moves string operations inside ```assertThat()``` out.
  
  ```
  from: assertThat(stringActual.isEmpty()).isTrue();
@@ -169,9 +171,24 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  ```
  Analogously with ```isFalse()```.

+- AssertThatObjectExpression
+
+  Handles equals(), toString() and hashCode() inside an expected expression.
+  
+  ```
+  from: assertThat(objActual.equals(objExpected)).isTrue();
+    to: assertThat(objActual).isEqualTo(objExpected);
+
+  from: assertThat(objActual.toString()).isEqualTo(stringExpected);
+    to: assertThat(objActual).hasToString(stringExpected);
+
+  from: assertThat(objActual.hashCode()).isEqualTo(objExpected.hashCode());
+    to: assertThat(objActual).hasSameHashCodeAs(objExpected);
+  ```
+
 - AssertThatCollectionOrMapExpression

-  Moves collection and map operations inside assertThat() out.
+  Moves collection and map operations inside ```assertThat()``` out.

  ```
  from: assertThat(collection.isEmpty()).isTrue();
@@ -192,7 +209,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  from: assertThat(map.containsValue(value)).isTrue();
    to: assertThat(map).containsValue(value);
  ```
-  Analogously with ```isFalse()``` (except for containsAll()).
+  Analogously with ```isFalse()``` (except for ```containsAll()```).

 - AssertThatEnumerableIsEmpty

@@ -264,22 +281,37 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
    to: assertThat(primActual).isEqualTo(primExpected);

  from: assertThat(10 < primActual).isNotEqualTo(false);
-    to: assertThat(primActual).isGreaterThan(primExpected);
+    to: assertThat(primActual).isGreaterThan(10);

  from: assertThat(objActual != objExpected).isEqualTo(true);
    to: assertThat(objActual).isNotSameAs(objExpected);

  from: assertThat(null == objActual).isFalse();
    to: assertThat(objActual).isNotNull();
-
-  from: assertThat(objActual.equals(objExpected).isTrue();
-    to: assertThat(objActual).isEqualTo(objExpected);
  ```
  ...and many, many more combinations (more than 150).

+- ImplicitAssertion
+
+  Detects and removes implicit use of ```isNotNull()```, ```isNotEmpty()``` and
+  ```isPresent()``` when followed by an assertion that will implicitly cover this
+  check.
+
+  ```
+  from: assertThat(string).isNotNull().startsWith("foo");
+    to: assertThat(string).startsWith("foo");
+
+  from: assertThat(list).isNotEmpty().hasSize(10);
+    to: assertThat(list).hasSize(10);
+
+  from: assertThat(optional).isPresent().contains("foo");
+    to: assertThat(optional).contains("foo");
+  ```
+  ...and many more combinations (more than 100).
+
 - AssertThatJava8Optional

-  Examines the statement for Java 8 Optional type and whether the statement
+  Examines the statement for Java 8 ```Optional``` type and whether the statement
  effectively tries to assert the presence, absence or content and then 
  replaces the statement by better assertions.
  
@@ -300,6 +332,12 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  from: assertThat(opt.get()).isSameAs("foo");
    to: assertThat(opt).containsSame("foo"); 

+  from: assertThat(opt.orElse(null)).isEqualTo(null);
+    to: assertThat(opt).isNotPresent();
+     
+  from: assertThat(opt.orElse(null)).isNotEqualTo(null);
+    to: assertThat(opt).isPresent();
+     
  from: assertThat(opt).isEqualTo(Optional.of("foo"));
  from: assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
    to: assertThat(opt).contains("foo"); 
@@ -313,7 +351,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the

 - AssertThatGuavaOptional

-  Examines the statement for Google Guava Optional type and whether the statement
+  Examines the statement for Google Guava ```Optional``` type and whether the statement
  effectively tries to assert the presence, absence or content and then 
  replaces the statement by better assertions.

@@ -331,6 +369,12 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  from: assertThat(opt.get()).isEqualTo("foo");
    to: assertThat(opt).contains("foo");
     
+  from: assertThat(opt.orNull()).isEqualTo(null);
+    to: assertThat(opt).isAbsent();
+     
+  from: assertThat(opt.orNull()).isNotEqualTo(null);
+    to: assertThat(opt).isPresent();
+     
  from: assertThat(opt).isEqualTo(Optional.of("foo"));
  from: assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
    to: assertThat(opt).contains("foo"); 
@@ -353,14 +397,17 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  as being skipped.

  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or 
-  Jupiter @Test annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
+  Jupiter ```@Test``` annotations) will be verified to have at least one ```assertThat()``` statement in the code flow.
  Method calls within the same class will be examined for ```assertThat()``` statements, too.
  However, at most 50 statements and down to five recursions will be tolerated before giving up.
  
  Currently, the quickfix may lose some comments during operation. The other branch of the ```if``` statement
  will be inlined (blocks with declarations will remain a code block due to variable scope).
+  The quickfix will only work with AssertJ >= 2.9.0 (for 2.x releases) or >= 3.9.0 (for 3.x releases).
  
-  The generated ```assumeThat()``` statement could be optimized further (similar to ```assertThat()```).
+  The generated ```assumeThat()``` statement could be optimized further (similar to ```assertThat()```), but
+  there is currently no support in Cajon for this (you could rename the method to ```assertThat()``` optimize it
+  and turn it back into ```assumeThat()``` in the end).

  Example:
  
@@ -386,7 +433,10 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the

 - JUnitAssertToAssertJ

-  Tries to convert most of the JUnit 4 assertions to AssertJ format.
+  Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
+  Sometimes the expected and actual expressions are specified in wrong order -- 
+  Cajon tries to swap these when it detects the supposed actual expression to be a
+  constant while the expected one is not.

  Does not support Hamcrest-Matchers.
  If you need that kind of conversion, you might want to check out the
@@ -399,8 +449,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  assertFalse(message, condition);
  assertNull(object);
  assertNull(message, object);
-  assertNonNull(object);
-  assertNonNull(message, object);
+  assertNotNull(object);
+  assertNotNull(message, object);
  assertEquals(expected, actual);
  assertEquals(message, expected, actual);
  assertEquals(expectedDoubleOrFloat, actualDoubleOrFloat, delta);
@@ -417,6 +467,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  assertArrayEquals(message, expectedArray, actualArray);
  assertArrayEquals(expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
  assertArrayEquals(message, expectedDoubleOrFloatArray, actualDoubleOrFloatArray, delta);
+  
+  assumeTrue(condition);
+  assumeTrue(message, condition);
+  assumeFalse(condition);
+  assumeFalse(message, condition);
+  assumeNotNull(object); // single argument only!
+  assumeNoException(throwable);
+  assumeNoException(message, throwable);
  ```

 ### Implemented referencing
@@ -435,8 +493,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
  .flatExtracting(Extractors.resultOf("bareMethod")
  ```
  Works on both POJOs and ```Iterable```s/```Array```s. 
-  Implementation is very basic though and does not work with fancy cascaded .extracting() sequences.
-  If there's demand, I will add it.
+  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
+  If there's demand, I could add it.

 ## Development notice

@@ -444,10 +502,13 @@ Cajon is written in Kotlin 1.3.

 Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one that I'm aware of ;) ).
 The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing and it took me quite a while to make it work with JUnit 5.
-Feel free to use the code (in package de.platon42.intellij.jupiter) for your projects (with attribution).
+Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).

 ## Planned features
+- Joining .contains() expressions
+- Converting ```foo.compareTo(bar) == 0``` to ```isEqualTo()``` (yes, I've *really* seen code like that)
 - 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())...
@@ -455,11 +516,21 @@ Feel free to use the code (in package de.platon42.intellij.jupiter) for your pro

 ## Changelog

+#### 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.
+- Added Java 8 Optional ```opt.orElse(null) == null``` case, too.
+- Extended JUnitAssertToAssertJ inspection to convert JUnit ```assume``` statements, too.
+- Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.
+- New ImplicitAssertion inspection for implicit ```isNotNull()```, ```isNotEmpty()``` and ```isPresent()``` assertions that will be covered by chained assertions.
+- Fix for multiple JUnit Conversions in batch mode with and without delta creating an exception.
+- Added new AssertThatObjectExpression inspection for ```toString()``` and ```hashCode()``` and moved ```equals()``` from AssertThatBinaryExpression there.
+
 #### V1.0 (06-May-19)
 - First release to be considered stable enough for production use.
 - Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
 - Fixed missing description for AssumeThatInsteadOfReturn inspection.
- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual assertThat() expression.
+- Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as ```isEmpty()``` or ```contains()``` out of an actual ```assertThat()``` expression.

 #### V0.8 (05-May-19)
 - Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
@@ -1,13 +1,13 @@
 plugins {
    id 'java'
-    id 'org.jetbrains.intellij' version '0.4.8'
+    id 'org.jetbrains.intellij' version '0.4.9'
    id 'org.jetbrains.kotlin.jvm' version '1.3.31'
    id 'jacoco'
    id 'com.github.kt3k.coveralls' version '2.8.2'
 }

 group 'de.platon42'
-version '1.0'
+version '1.1'

 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.4.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.0-RC1'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.0-RC1'
    testImplementation "org.jetbrains.kotlin:kotlin-test"
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
 }
@@ -35,30 +35,23 @@ compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2019.1.1'
+    version '2019.1.2'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
    updateSinceUntilBuild false
 }

 patchPluginXml {
    changeNotes """
-  <h4>V1.0 (06-May-19)</h4>
+  <h4>V1.1 (09-Jun-19)</h4>
    <ul>
-      <li>First release to be considered stable enough for production use.
-      <li>Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
-      <li>Fixed missing description for AssumeThatInsteadOfReturn inspection.
-      <li>Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as isEmpty() or contains() out of an actual assertThat() expression.
-    </ul>
-  <h4>V0.8 (05-May-19)</h4>
-    <ul>
-      <li>Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
-      <li>Fixed isEmpty() for enumerables and strings and isNull() for object conversions to be applied only if it is the terminal method call as isEmpty() and isNull() return void.
-      <li>Heavily reworked inspections for edge cases, such as multiple isEqualTo() calls inside a single statement.
-      <li>Some inspections could generate bogus code for weird situations, this has been made more fool-proof.
-      <li>Corrected highlighting for many inspections.
-      <li>Fixed family names for inspections in batch mode.
-      <li>Reworded many inspection messages for better understanding.
-      <li>Added a first version of a new inspection that tries to detect bogus uses of return statements in test methods and replaces them by assumeThat() calls.
+      <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.
    </ul>
  <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """
@@ -15,6 +15,8 @@ class AssertJClassNames {
        @NonNls
        const val EXTENSION_POINTS_INTERFACE = "org.assertj.core.api.ExtensionPoints"
        @NonNls
+        const val ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.EnumerableAssert"
+        @NonNls
        const val OBJECT_ENUMERABLE_ASSERT_INTERFACE = "org.assertj.core.api.ObjectEnumerableAssert"

        @NonNls
@@ -36,7 +38,7 @@ class AssertJClassNames {
        @NonNls
        const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
        @NonNls
-        const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
+        const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"
        @NonNls
        const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"

@@ -44,5 +46,7 @@ class AssertJClassNames {
        const val GUAVA_OPTIONAL_CLASSNAME = "com.google.common.base.Optional"
        @NonNls
        const val GUAVA_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.Assertions"
+        @NonNls
+        const val GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME = "org.assertj.guava.api.OptionalAssert"
    }
 }
@@ -100,13 +100,31 @@ fun PsiMethodCallExpression.getExpectedBooleanResult(): Boolean? {
    return null
 }

+fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
+    val isNull = AbstractAssertJInspection.IS_NULL.test(this)
+    val isNotNull = AbstractAssertJInspection.IS_NOT_NULL.test(this)
+    if (isNull || isNotNull) {
+        return isNotNull
+    } else {
+        val isEqualTo = AbstractAssertJInspection.IS_EQUAL_TO_OBJECT.test(this)
+        val isNotEqualTo = AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT.test(this)
+        if ((isEqualTo || isNotEqualTo) && firstArg.type == PsiType.NULL) {
+            return isNotEqualTo
+        }
+    }
+    return null
+}
+
 fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
    if (argIndex >= argumentList.expressions.size) return null
-    val valueExpression = getArg(argIndex)
+    return getArg(argIndex).calculateConstantValue()
+}
+
+fun PsiExpression.calculateConstantValue(): Any? {
    val constantEvaluationHelper = JavaPsiFacade.getInstance(project).constantEvaluationHelper
-    val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
+    val value = constantEvaluationHelper.computeConstantExpression(this)
    if (value == null) {
-        val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
+        val field = (this as? PsiReferenceExpression)?.resolve() as? PsiField
        if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
            return when (field.name) {
                "TRUE" -> true
@@ -146,3 +164,30 @@ fun PsiExpression.getAllTheSameExpectedBooleanConstants(): Boolean? {
    }
    return lockedResult
 }
+
+fun PsiExpression.getAllTheSameNullNotNullConstants(): Boolean? {
+    val assertThatMethodCall = findStaticMethodCall() ?: return null
+    var lockedResult: Boolean? = null
+    val methodsToView = generateSequence(assertThatMethodCall) { PsiTreeUtil.getParentOfType(it, PsiMethodCallExpression::class.java) }
+
+    for (methodCall in methodsToView) {
+        val expectedResult = methodCall.getExpectedNullNonNullResult()
+        if (expectedResult != null) {
+            if ((lockedResult != null) && (lockedResult != expectedResult)) {
+                return null
+            }
+            lockedResult = expectedResult
+        } else {
+            val isNotConstant = CallMatcher.anyOf(
+                EXTENSION_POINTS,
+                MORE_EXTENSION_POINTS,
+                AbstractAssertJInspection.IS_EQUAL_TO_OBJECT,
+                AbstractAssertJInspection.IS_NOT_EQUAL_TO_OBJECT
+            ).test(methodCall)
+            if (isNotConstant) {
+                return null
+            }
+        }
+    }
+    return lockedResult
+}
@@ -18,6 +18,10 @@ fun createAssertThat(context: PsiElement, baseclass: String, actualExpression: P
    return createMethodCall(context, "$baseclass.${MethodNames.ASSERT_THAT}", actualExpression)
 }

+fun createAssumeThat(context: PsiElement, actualExpression: PsiExpression): PsiMethodCallExpression {
+    return createMethodCall(context, "${AssertJClassNames.ASSUMPTIONS_CLASSNAME}.${MethodNames.ASSUME_THAT}", actualExpression)
+}
+
 fun createExpectedMethodCall(context: PsiElement, methodName: String, vararg arguments: PsiElement): PsiMethodCallExpression {
    return createMethodCall(context, "a.$methodName", *arguments)
 }
@@ -32,6 +32,10 @@ class MethodNames {
        const val IS_SAME_AS = "isSameAs"
        @NonNls
        const val IS_NOT_SAME_AS = "isNotSameAs"
+
+        @NonNls
+        const val HAS_TO_STRING = "hasToString"
+
        @NonNls
        const val IS_GREATER_THAN = "isGreaterThan"
        @NonNls
@@ -61,6 +65,8 @@ class MethodNames {
        @NonNls
        const val IS_NOT_INSTANCE_OF = "isNotInstanceOf"

+        @NonNls
+        const val IS_NULL_OR_EMPTY = "isNullOrEmpty" // terminal, returns void
        @NonNls
        const val IS_EMPTY = "isEmpty" // terminal, returns void
        @NonNls
@@ -12,10 +12,10 @@ import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_BOOLEAN_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_COMPARABLE_ASSERT_CLASSNAME
-import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ENUMERABLE_ASSERT_INTERFACE
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_OPTIONAL_CLASSNAME
 import de.platon42.intellij.plugins.cajon.MethodNames
@@ -93,7 +93,14 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
        val IS_NOT_SAME_AS_OBJECT = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_SAME_AS)
            .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!

-        val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, MethodNames.HAS_SIZE)
+        val IS_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NULL)
+            .parameterCount(0)!!
+        val IS_NOT_NULL = CallMatcher.instanceCall(ASSERT_INTERFACE, MethodNames.IS_NOT_NULL)
+            .parameterCount(0)!!
+
+        val IS_NOT_EMPTY = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.IS_NOT_EMPTY)
+            .parameterCount(0)!!
+        val HAS_SIZE = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE)
            .parameterTypes("int")!!

        val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
@@ -129,6 +136,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
            .parameterCount(0)!!
        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "isPresent")
            .parameterCount(0)!!
+        val OPTIONAL_OR_ELSE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "orElse")
+            .parameterCount(1)!!

        val OPTIONAL_OF = CallMatcher.staticCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "of")
            .parameterCount(1)!!
@@ -141,6 +150,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
            .parameterCount(0)!!
        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "isPresent")
            .parameterCount(0)!!
+        val GUAVA_OPTIONAL_OR_NULL = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "orNull")
+            .parameterCount(0)!!

        val GUAVA_OPTIONAL_OF = CallMatcher.staticCall(GUAVA_OPTIONAL_CLASSNAME, "of")
            .parameterCount(1)!!
@@ -9,6 +9,8 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
    companion object {
        @NonNls
        const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
+        @NonNls
+        const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"

        @NonNls
        const val ASSERT_TRUE_METHOD = "assertTrue"
@@ -28,6 +30,16 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
        const val ASSERT_NOT_SAME_METHOD = "assertNotSame"
        @NonNls
        const val ASSERT_ARRAY_EQUALS_METHOD = "assertArrayEquals"
+
+        @NonNls
+        const val ASSUME_TRUE_METHOD = "assumeTrue"
+        @NonNls
+        const val ASSUME_FALSE_METHOD = "assumeFalse"
+        @NonNls
+        const val ASSUME_NOT_NULL_METHOD = "assumeNotNull"
+        @NonNls
+        const val ASSUME_NO_EXCEPTION = "assumeNoException"
+
    }

    override fun getGroupDisplayName(): String {
@@ -5,15 +5,14 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
 import com.intellij.psi.util.TypeConversionUtil
 import de.platon42.intellij.plugins.cajon.*
-import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.SplitBinaryExpressionMethodCallQuickFix

 class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {

    companion object {
        private const val DISPLAY_NAME = "Asserting a binary expression"
-        private const val SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split %s expression out of assertThat()"
-        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving %s expression out of assertThat() would be more meaningful"
+        private const val SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split binary expression out of assertThat()"
+        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving binary expression out of assertThat() would be more meaningful"
    }

    override fun getDisplayName() = DISPLAY_NAME
@@ -33,14 +32,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return

-                val assertThatArgument = staticMethodCall.firstArg
-                if (assertThatArgument is PsiMethodCallExpression && OBJECT_EQUALS.test(assertThatArgument)) {
-                    val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
-                    registerSplitMethod(holder, expectedCallExpression, "${MethodNames.EQUALS}()", replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
-                    return
-                }
-
-                val binaryExpression = assertThatArgument as? PsiBinaryExpression ?: return
+                val binaryExpression = staticMethodCall.firstArg as? PsiBinaryExpression ?: return

                val leftType = binaryExpression.lOperand.type ?: return
                val rightType = binaryExpression.rOperand?.type ?: return
@@ -51,7 +43,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                    return
                } else if (isLeftNull || isRightNull) {
                    val replacementMethod = expectedResult.map(MethodNames.IS_NULL, MethodNames.IS_NOT_NULL)
-                    registerSplitMethod(holder, expectedCallExpression, "binary", replacementMethod) { desc, method ->
+                    registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
                        SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = isLeftNull, noExpectedExpression = true)
                    }
                    return
@@ -73,7 +65,7 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                    (isPrimitive || isNumericType).map(TOKEN_TO_ASSERTJ_FOR_PRIMITIVE_MAP, TOKEN_TO_ASSERTJ_FOR_OBJECT_MAPPINGS)
                val replacementMethod = mappingToUse[tokenType] ?: return

-                registerSplitMethod(holder, expectedCallExpression, "binary", replacementMethod) { desc, method ->
+                registerSplitMethod(holder, expectedCallExpression, replacementMethod) { desc, method ->
                    SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
                }
            }
@@ -83,13 +75,10 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
    private fun registerSplitMethod(
        holder: ProblemsHolder,
        expression: PsiMethodCallExpression,
-        type: String,
        replacementMethod: String,
        quickFixSupplier: (String, String) -> LocalQuickFix
    ) {
-        val description = SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE.format(type)
-        val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
+        val quickfix = quickFixSupplier(SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE, replacementMethod)
+        holder.registerProblem(expression, MORE_MEANINGFUL_MESSAGE_TEMPLATE, quickfix)
    }
 }
@@ -58,7 +58,9 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return

                val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse ?: return
-                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
+                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                    MoveOutMethodCallExpressionQuickFix(desc, method)
+                }
            }
        }
    }
@@ -51,6 +51,15 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
                            ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
                        )
                    }
+                } else if (GUAVA_OPTIONAL_OR_NULL.test(actualExpression)) {
+                    val expectedPresence = outmostMethodCall.getAllTheSameNullNotNullConstants() ?: return
+                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_ABSENT)
+                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
+                        QuickFixWithPostfixDelegate(
+                            MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true),
+                            ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+                        )
+                    }
                }
            }

@@ -1,10 +1,7 @@
 package de.platon42.intellij.plugins.cajon.inspections

 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.psi.JavaElementVisitor
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiExpressionStatement
-import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.*
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
@@ -50,6 +47,12 @@ class AssertThatJava8OptionalInspection : AbstractAssertJInspection() {
                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
                        MoveOutMethodCallExpressionQuickFix(desc, method)
                    }
+                } else if (OPTIONAL_OR_ELSE.test(actualExpression) && (actualExpression.firstArg.type == PsiType.NULL)) {
+                    val expectedPresence = outmostMethodCall.getAllTheSameNullNotNullConstants() ?: return
+                    val replacementMethod = expectedPresence.map(MethodNames.IS_PRESENT, MethodNames.IS_NOT_PRESENT)
+                    registerMoveOutMethod(holder, outmostMethodCall, actualExpression, replacementMethod) { desc, method ->
+                        MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true, noExpectedExpression = true)
+                    }
                }
            }

@@ -0,0 +1,59 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.*
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.HasHashCodeQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.RemoveActualOutmostMethodCallQuickFix
+
+class AssertThatObjectExpressionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting equals(), toString(), or hashCode()"
+        private const val HASHCODE_MESSAGE_TEMPLATE = "Replacing hashCode() expressions by hasSameHashCode() would be more concise"
+
+        private val OBJECT_TO_STRING = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "toString").parameterCount(0)
+        private val OBJECT_HASHCODE = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "hashCode").parameterCount(0)
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitExpressionStatement(statement: PsiExpressionStatement) {
+                super.visitExpressionStatement(statement)
+                if (!statement.hasAssertThat()) {
+                    return
+                }
+                val staticMethodCall = statement.findStaticMethodCall() ?: return
+
+                val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
+                val expectedCallExpression = statement.findOutmostMethodCall() ?: return
+                when {
+                    OBJECT_EQUALS.test(assertThatArgument) -> {
+                        val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return
+                        val replacementMethod = expectedResult.map(MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO)
+                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                            MoveOutMethodCallExpressionQuickFix(desc, method)
+                        }
+                    }
+                    OBJECT_TO_STRING.test(assertThatArgument) -> {
+                        staticMethodCall.findFluentCallTo(IS_EQUAL_TO_OBJECT) ?: return
+                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.HAS_TO_STRING) { desc, method ->
+                            RemoveActualOutmostMethodCallQuickFix(desc, method)
+                        }
+                    }
+                    OBJECT_HASHCODE.test(assertThatArgument) -> {
+                        val isEqualTo = staticMethodCall.findFluentCallTo(IS_EQUAL_TO_INT) ?: return
+                        val expectedExpression = isEqualTo.firstArg as? PsiMethodCallExpression ?: return
+                        if (OBJECT_HASHCODE.test(expectedExpression)) {
+                            holder.registerProblem(expectedCallExpression, HASHCODE_MESSAGE_TEMPLATE, HasHashCodeQuickFix())
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -115,8 +115,7 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                if (!expression.hasAssertThat()) {
                    return
                }
-                val isHasSize = HAS_SIZE.test(expression)
-                if (!(isHasSize)) {
+                if (!HAS_SIZE.test(expression)) {
                    return
                }
                val actualExpression = expression.firstArg
@@ -62,7 +62,9 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
                val expectedResult = expectedCallExpression.getAllTheSameExpectedBooleanConstants() ?: return

                val replacementMethod = if (expectedResult) mapping.replacementForTrue else mapping.replacementForFalse
-                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod, ::MoveOutMethodCallExpressionQuickFix)
+                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                    MoveOutMethodCallExpressionQuickFix(desc, method)
+                }
            }
        }
    }
@@ -0,0 +1,131 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+import de.platon42.intellij.plugins.cajon.quickfixes.DeleteMethodCallQuickFix
+
+class ImplicitAssertionInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting implicitly covered conditions"
+        private const val DELETE_IMPLICIT_DESCRIPTION_TEMPLATE = "Delete implicit %s() covered by %s()"
+        private const val SURPLUS_ASSERTION_MESSAGE = "Implicit %s() assertion is covered by %s()"
+
+        private val IS_PRESENT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OPTIONAL_ASSERT_CLASSNAME, MethodNames.IS_PRESENT, MethodNames.IS_NOT_EMPTY)
+            .parameterCount(0)!!
+        private val IS_NOT_PRESENT = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_OPTIONAL_ASSERT_CLASSNAME, MethodNames.IS_NOT_PRESENT, MethodNames.IS_EMPTY)
+            .parameterCount(0)!!
+        private val OPTIONAL_CONTAINS =
+            CallMatcher.instanceCall(
+                AssertJClassNames.ABSTRACT_OPTIONAL_ASSERT_CLASSNAME,
+                MethodNames.CONTAINS, MethodNames.CONTAINS_SAME,
+                "hasValue", "hasValueSatisfying", "containsInstanceOf"
+            ).parameterCount(1)!!
+
+        private val OBJECT_ENUMERABLE_ANY_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
+            AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
+            MethodNames.CONTAINS, "containsOnly", "containsOnlyNulls", "containsOnlyOnce",
+            "containsExactly", "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
+            "containsAll", "containsAnyOf",
+            "containsAnyElementsOf", "containsExactlyElementsOf", "containsOnlyElementsOf",
+            "isSubsetOf", "containsSequence", "containsSubsequence",
+            "doesNotContainSequence", "doesNotContainSubsequence", "doesNotContain",
+            "doesNotContainAnyElementsOf", "doesNotHaveDuplicates",
+            "startsWith", "endsWith", "containsNull", "doesNotContainNull",
+            "are", "areNot", "have", "doNotHave", "areAtLeastOne", "areAtLeast", "areAtMost", "areExactly",
+            "haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
+            "doesNotHave", "doesNotHaveSameClassAs",
+            "hasAtLeastOneElementOfType", "hasOnlyElementsOfType", "hasOnlyElementsOfTypes",
+            "doesNotHaveAnyElementsOfTypes",
+            "has", "doesNotHave",
+            "hasOnlyOneElementSatisfying", "hasSameElementsAs",
+            "allMatch", "allSatisfy", "anyMatch", "anySatisfy", "noneMatch", "noneSatisfy"
+        )!!
+
+        private val OBJECT_ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
+            AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
+            "containsOnlyNulls",
+            "startsWith", "endsWith", "containsNull",
+            "areAtLeastOne",
+            "haveAtLeastOne",
+            "hasAtLeastOneElementOfType",
+            "anyMatch", "anySatisfy"
+        )!!
+
+        private val ENUMERABLE_NON_NULL_ASSERTIONS = CallMatcher.instanceCall(
+            AssertJClassNames.ENUMERABLE_ASSERT_INTERFACE,
+            MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY,
+            MethodNames.HAS_SIZE, MethodNames.HAS_SIZE_GREATER_THAN, MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO,
+            MethodNames.HAS_SIZE_LESS_THAN, MethodNames.HAS_SIZE_LESS_THAN_OR_EQUAL_TO,
+            "hasSizeBetween", MethodNames.HAS_SAME_SIZE_AS
+        )!!
+
+        private val ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
+            AssertJClassNames.ENUMERABLE_ASSERT_INTERFACE,
+            MethodNames.HAS_SIZE, MethodNames.HAS_SIZE_GREATER_THAN,
+            MethodNames.HAS_SAME_SIZE_AS
+        )!!
+
+        private val NON_NULL_CORE_ASSERTIONS = CallMatcher.instanceCall(
+            AssertJClassNames.ASSERT_INTERFACE,
+            "isInstanceOf", "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
+            "isNotInstanceOf", "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
+            "hasSameClassAs", "doesNotHaveSameClassAs",
+            "hasToString", "hasSameHashCodeAs"
+        )!!
+
+        private val GUAVA_IS_PRESENT = CallMatcher.instanceCall(AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME, MethodNames.IS_PRESENT)
+            .parameterCount(0)!!
+        private val GUAVA_IS_ABSENT = CallMatcher.instanceCall(AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME, MethodNames.IS_ABSENT)
+            .parameterCount(0)!!
+        private val GUAVA_OPTIONAL_CONTAINS = CallMatcher.instanceCall(
+            AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME,
+            MethodNames.CONTAINS, "extractingValue", "extractingCharSequence"
+        )!!
+
+        private val MAPPINGS = listOf(
+            IS_NOT_NULL to CallMatcher.anyOf(
+                NON_NULL_CORE_ASSERTIONS,
+                ENUMERABLE_NON_NULL_ASSERTIONS,
+                OBJECT_ENUMERABLE_ANY_CONTENT_ASSERTIONS,
+                IS_PRESENT, IS_NOT_PRESENT, OPTIONAL_CONTAINS,
+                GUAVA_IS_PRESENT, GUAVA_IS_ABSENT, GUAVA_OPTIONAL_CONTAINS
+            )!!,
+
+            IS_NOT_EMPTY to CallMatcher.anyOf(
+                ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS,
+                OBJECT_ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS
+            )!!,
+
+            IS_PRESENT to OPTIONAL_CONTAINS,
+            GUAVA_IS_PRESENT to GUAVA_OPTIONAL_CONTAINS
+        )
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : JavaElementVisitor() {
+            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
+                super.visitMethodCallExpression(expression)
+                if (!expression.hasAssertThat()) {
+                    return
+                }
+                val mapping = MAPPINGS.firstOrNull { it.first.test(expression) } ?: return
+                val followupExpression = expression.findFluentCallTo(mapping.second) ?: return
+                val redundantName = getOriginalMethodName(expression) ?: return
+                val followupName = getOriginalMethodName(followupExpression) ?: return
+                val description = DELETE_IMPLICIT_DESCRIPTION_TEMPLATE.format(redundantName, followupName)
+                val quickFix = DeleteMethodCallQuickFix(description)
+
+                val textRange = TextRange(expression.qualifierExpression.textLength, expression.textLength)
+                holder.registerProblem(expression, textRange, SURPLUS_ASSERTION_MESSAGE.format(redundantName, followupName), quickFix)
+            }
+        }
+    }
+}
@@ -10,43 +10,44 @@ import com.siyeh.ig.callMatcher.CallMatcher.staticCall
 import de.platon42.intellij.plugins.cajon.AssertJClassNames
 import de.platon42.intellij.plugins.cajon.MethodNames
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssertMethodCallQuickFix
+import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssumeMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitDeltaAssertMethodCallQuickFix

 class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {

    companion object {
-        private const val DISPLAY_NAME = "Convert JUnit assertions to AssertJ"
+        private const val DISPLAY_NAME = "Convert JUnit assertions/assumptions to AssertJ"
        private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
-        private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to assertThat().%s()"
+        private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"

-        private val MAPPINGS = listOf(
+        private val ASSERT_MAPPINGS = listOf(
            Mapping(
                anyOf(
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
                ),
-                MethodNames.IS_TRUE, false
+                MethodNames.IS_TRUE, hasExpected = false
            ),
            Mapping(
                anyOf(
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
                ),
-                MethodNames.IS_FALSE, false
+                MethodNames.IS_FALSE, hasExpected = false
            ),
            Mapping(
                anyOf(
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                ),
-                MethodNames.IS_NULL, false
+                MethodNames.IS_NULL, hasExpected = false
            ),
            Mapping(
                anyOf(
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
                ),
-                MethodNames.IS_NOT_NULL, false
+                MethodNames.IS_NOT_NULL, hasExpected = false
            ),
            Mapping(
                anyOf(
@@ -111,6 +112,34 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
                MethodNames.CONTAINS_EXACTLY
            )
        )
+
+        private val ASSUME_MAPPINGS = listOf(
+            Mapping(
+                anyOf(
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes("boolean")
+                ),
+                MethodNames.IS_TRUE, hasExpected = false
+            ),
+            Mapping(
+                anyOf(
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes("boolean")
+                ),
+                MethodNames.IS_FALSE, hasExpected = false
+            ),
+            Mapping(
+                staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
+                MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
+            ),
+            Mapping(
+                anyOf(
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_THROWABLE),
+                    staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_THROWABLE)
+                ),
+                "doesNotThrowAnyException", hasExpected = false
+            )
+        )
    }

    override fun getDisplayName() = DISPLAY_NAME
@@ -119,21 +148,31 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
        return object : JavaElementVisitor() {
            override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                super.visitMethodCallExpression(expression)
-                val isJUnitAssertCall = expression.resolveMethod()?.containingClass?.qualifiedName == JUNIT_ASSERT_CLASSNAME
-                if (!isJUnitAssertCall) {
-                    return // early exit
-                }
+                when (expression.resolveMethod()?.containingClass?.qualifiedName) {
+                    JUNIT_ASSERT_CLASSNAME -> {
                        JavaPsiFacade.getInstance(expression.project)
                            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
                        if (mapping.hasDelta) {
-                    registerConvertMethod(holder, expression, mapping.replacement, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
                        } else {
-                    registerConvertMethod(holder, expression, mapping.replacement) { desc, method ->
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
                                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
                            }
                        }
                    }
+                    JUNIT_ASSUME_CLASSNAME -> {
+                        JavaPsiFacade.getInstance(expression.project)
+                            .findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                        val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                        if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
+                                ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
+                            }
+                        }
+                    }
+                }
+            }
        }
    }

@@ -141,10 +180,11 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
        holder: ProblemsHolder,
        expression: PsiMethodCallExpression,
        replacementMethod: String,
+        staticMethod: String,
        quickFixSupplier: (String, String) -> LocalQuickFix
    ) {
        val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, staticMethod, replacementMethod)
        val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
        val quickfix = quickFixSupplier(description, replacementMethod)
        holder.registerProblem(expression, message, quickfix)
@@ -154,6 +194,7 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
        val callMatcher: CallMatcher,
        val replacement: String,
        val hasExpected: Boolean = true,
-        val hasDelta: Boolean = false
+        val hasDelta: Boolean = false,
+        val singleArgument: Boolean = false
    )
 }
@@ -35,16 +35,9 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                        reset = (lastActualExpression == null)
                        actualExpression = assertThatCall.firstArg
                        if (!reset) {
-                            val isSame = when (actualExpression) {
-                                is PsiMethodCallExpression -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                                        // Note: replace with PsiTreeUtil.findChildrenOfAnyType(strict = false) for IDEA >= 2018.1
-                                        && !KNOWN_METHODS_WITH_SIDE_EFFECTS.test(actualExpression)
-                                        && PsiTreeUtil.findChildrenOfAnyType(
-                                    actualExpression,
-                                    PsiMethodCallExpression::class.java
-                                ).none { KNOWN_METHODS_WITH_SIDE_EFFECTS.test(it) }
-                                else -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                            }
+                            val isSame = equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
+                                    && !hasExpressionWithSideEffects(actualExpression)
+
                            if (isSame) {
                                sameCount++
                                lastStatement = statement
@@ -78,6 +71,25 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                }
                return null
            }
+
+            private fun hasExpressionWithSideEffects(actualExpression: PsiExpression): Boolean {
+                var result = false
+                PsiTreeUtil.processElements(actualExpression) { element ->
+                    val matched = when (element) {
+                        is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
+                                || (element.operationTokenType == JavaTokenType.MINUSMINUS)
+                        is PsiMethodCallExpression -> KNOWN_METHODS_WITH_SIDE_EFFECTS.test(element)
+                        else -> false
+                    }
+                    if (matched) {
+                        result = true
+                        false
+                    } else {
+                        true
+                    }
+                }
+                return result
+            }
        }
    }

@@ -0,0 +1,23 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.qualifierExpression
+
+class DeleteMethodCallQuickFix(description: String) : AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val DELETE_METHOD_DESCRIPTION = "Delete unnecessary method calls"
+    }
+
+    override fun getFamilyName(): String {
+        return DELETE_METHOD_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val methodCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+
+        methodCallExpression.replace(methodCallExpression.qualifierExpression)
+    }
+}
@@ -0,0 +1,37 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.*
+
+class HasHashCodeQuickFix :
+    AbstractCommonQuickFix(HASHCODE_DESCRIPTION) {
+
+    companion object {
+        private const val HASHCODE_DESCRIPTION = "Replace calls to hashCode() with hasSameHashCodeAs()"
+    }
+
+    override fun getFamilyName(): String {
+        return HASHCODE_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
+        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
+
+        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
+
+        val methodsToFix = assertThatMethodCall.gatherAssertionCalls()
+
+        assertExpression.replace(assertExpression.qualifierExpression)
+
+        methodsToFix
+            .forEach {
+                val innerHashCodeObject = (it.firstArg as PsiMethodCallExpression).qualifierExpression
+                val expectedExpression = createExpectedMethodCall(it, "hasSameHashCodeAs", innerHashCodeObject)
+                expectedExpression.replaceQualifierFromMethodCall(it)
+                it.replace(expectedExpression)
+            }
+    }
+}
@@ -5,7 +5,13 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*

-class MoveOutMethodCallExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
+class MoveOutMethodCallExpressionQuickFix(
+    description: String,
+    private val replacementMethod: String,
+    private val useNullNonNull: Boolean = false,
+    private val noExpectedExpression: Boolean = false
+) :
+    AbstractCommonQuickFix(description) {

    companion object {
        private const val REMOVE_ACTUAL_EXPRESSION_DESCRIPTION = "Move method calls in actual expressions out of assertThat()"
@@ -19,10 +25,10 @@ class MoveOutMethodCallExpressionQuickFix(description: String, private val repla
        val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
        val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
        val assertExpression = assertThatMethodCall.firstArg as? PsiMethodCallExpression ?: return
-        val assertExpressionArg = assertExpression.getArgOrNull(0)?.copy()
+        val assertExpressionArg = if (noExpectedExpression) null else assertExpression.getArgOrNull(0)?.copy()

        val methodsToFix = assertThatMethodCall.collectMethodCallsUpToStatement()
-            .filter { it.getExpectedBooleanResult() != null }
+            .filter { (if (useNullNonNull) it.getExpectedNullNonNullResult() else it.getExpectedBooleanResult()) != null }
            .toList()

        assertExpression.replace(assertExpression.qualifierExpression)
@@ -24,7 +24,7 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
        val args = methodCallExpression.argumentList
        val count = args.expressions.size
        val actualExpression = args.expressions[count - 1] ?: return
-        val (expectedExpression, messageExpression) = if (noExpectedExpression) {
+        val (expectedExpressions, messageExpression) = if (noExpectedExpression) {
            val message = args.expressions.getOrNull(count - 2)
            emptyArray<PsiExpression>() to message
        } else {
@@ -33,8 +33,15 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
            arrayOf(expected) to message
        }

-        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, *expectedExpression)
-        val newMethodCall = createAssertThat(element, actualExpression)
+        val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)
+                && (actualExpression.calculateConstantValue() != null))
+        val (expectedMethodCall, newMethodCall) = if (swapActualAndExpected) {
+            createExpectedMethodCall(element, replacementMethod, actualExpression) to
+                    createAssertThat(element, expectedExpressions.single())
+        } else {
+            createExpectedMethodCall(element, replacementMethod, *expectedExpressions) to
+                    createAssertThat(element, actualExpression)
+        }

        if (messageExpression != null) {
            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
@@ -0,0 +1,41 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.*
+
+class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
+    AbstractCommonQuickFix(description) {
+
+    companion object {
+        private const val CONVERT_DESCRIPTION = "Convert JUnit assumptions to assertJ"
+    }
+
+    override fun getFamilyName(): String {
+        return CONVERT_DESCRIPTION
+    }
+
+    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+        val element = descriptor.startElement
+        val methodCallExpression = element as? PsiMethodCallExpression ?: return
+        val args = methodCallExpression.argumentList
+        val count = args.expressions.size
+        val actualExpression = args.expressions[count - 1] ?: return
+        val messageExpression = args.expressions.getOrNull(count - 2)
+
+        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
+        val newMethodCall = createAssumeThat(element, actualExpression)
+
+        if (messageExpression != null) {
+            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
+            asExpression.replaceQualifier(newMethodCall)
+            expectedMethodCall.replaceQualifier(asExpression)
+        } else {
+            expectedMethodCall.replaceQualifier(newMethodCall)
+        }
+
+        newMethodCall.resolveMethod()?.addAsStaticImport(element)
+        element.replace(expectedMethodCall).shortenAndReformat()
+    }
+}
@@ -9,7 +9,7 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSE
 class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {

    companion object {
-        private const val CONVERT_DESCRIPTION = "Convert JUnit assertions to assertJ"
+        private const val CONVERT_DESCRIPTION = "Convert JUnit assertions with delta to assertJ"
    }

    override fun getFamilyName(): String {
@@ -27,8 +27,16 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
        val deltaExpression = args.expressions[count - 1] ?: return

        val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
-        val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall)
-        val newMethodCall = createAssertThat(element, actualExpression)
+
+        val swapActualAndExpected = ((expectedExpression.calculateConstantValue() == null)
+                && (actualExpression.calculateConstantValue() != null))
+        val (expectedMethodCall, newMethodCall) = if (swapActualAndExpected) {
+            createExpectedMethodCall(element, replacementMethod, actualExpression, offsetMethodCall) to
+                    createAssertThat(element, expectedExpression)
+        } else {
+            createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall) to
+                    createAssertThat(element, actualExpression)
+        }

        if (messageExpression != null) {
            val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
@@ -40,6 +40,8 @@

        <localInspection groupPath="Java" shortName="AssertThatBinaryExpression" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBinaryExpressionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatObjectExpression" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatObjectExpressionInspection"/>
        <localInspection groupPath="Java" shortName="AssertThatStringExpression" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringExpressionInspection"/>
        <localInspection groupPath="Java" shortName="AssertThatCollectionOrMapExpression" enabledByDefault="true" level="WARNING"
@@ -55,6 +57,9 @@
        <localInspection groupPath="Java" shortName="AssertThatGuavaOptional" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatGuavaOptionalInspection"/>

+        <localInspection groupPath="Java" shortName="ImplicitAssertion" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.ImplicitAssertionInspection"/>
+
        <localInspection groupPath="Java" shortName="JUnitAssertToAssertJ" enabledByDefault="true" level="WARNING"
                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.JUnitAssertToAssertJInspection"/>
    </extensions>
@@ -4,7 +4,6 @@ Turns a binary expression in the kind of assertThat(actual &lt;operator&gt; expe
 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>
@@ -0,0 +1,9 @@
+<html>
+<body>
+Tries to simplify Object method calls such as toString, hashCode() and equals().
+<!-- tooltip end -->
+<br>Turns assertThat(object.toString()).isEqualTo(expression) into assertThat(object).hasToString(expression).
+<br>Turns assertThat(object.hashCode()).isEqualTo(otherObject.hashCode()) into assertThat(object).hasSameHashCodeAs(otherObject).
+<br>Turns assertThat(object.equals(otherObject)).isEqualTo(true) into assertThat(object).isEqualTo(otherObject) (and variations).
+</body>
+</html>
@@ -0,0 +1,8 @@
+<html>
+<body>
+Finds assertion method calls that are already implicitly covered by prior assertions.
+<!-- tooltip end -->
+This works for isNotNull(), isNotEmpty() and isPresent(). It does not cover all edge cases, such as .isNotNull().isNullOrEmpty()
+or comparing against non-null literals and is conservative to not eliminate legitimate assertions.
+</body>
+</html>
@@ -1,9 +1,10 @@
 <html>
 <body>
-Tries to convert most of the JUnit 4 assertions to AssertJ format.
+Tries to convert most of the JUnit 4 assertions and assumptions to AssertJ format.
 <!-- tooltip end -->
 <br>Works for assertTrue(), assertFalse(), assertNull(), assertNotNull(), assertEquals(), assertNotEquals(), assertSame() assertNotSame(), assertArrayEquals().
 Copes with variants with message and without, handles special versions for double and float types (including arrays).
+Also converts assumeTrue(), assumeFalse(), assumeNotNull(), assumeNoException() to assumeThat().
 <p>
    Does not support Hamcrest-Matchers. If you need that kind of conversion, you might want to check out the Assertions2AssertJ plugin by Ric Emery.
 </p>
@@ -8,9 +8,8 @@ import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.PsiTestUtil;
-import com.intellij.testFramework.UsefulTestCase;
+import com.intellij.testFramework.*;
+import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
@@ -19,6 +18,7 @@ import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
 import org.junit.jupiter.api.extension.ExtensionContext.Store;

 import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.net.URISyntaxException;
 import java.nio.file.Path;
@@ -26,7 +26,7 @@ import java.nio.file.Paths;
 import java.util.logging.Logger;
 import java.util.stream.Stream;

-public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback {
+public class LightCodeInsightExtension implements ParameterResolver, AfterTestExecutionCallback, InvocationInterceptor {

    private static final Logger LOG = Logger.getLogger(LightCodeInsightExtension.class.getName());

@@ -77,6 +77,41 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
        return context.getStore(Namespace.create(LightCodeInsightExtension.class, context.getRequiredTestMethod()));
    }

+    @Override
+    public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
+        Throwable[] throwables = new Throwable[1];
+
+        Runnable runnable = () -> {
+            try {
+                TestLoggerFactory.onTestStarted();
+                invocation.proceed();
+                TestLoggerFactory.onTestFinished(true);
+            } catch (Throwable e) {
+                TestLoggerFactory.onTestFinished(false);
+                e.fillInStackTrace();
+                throwables[0] = e;
+            }
+        };
+
+        invokeTestRunnable(runnable);
+
+        if (throwables[0] != null) {
+            throw throwables[0];
+        }
+    }
+
+    private static void invokeTestRunnable(@NotNull Runnable runnable) {
+        IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
+        if (policy != null && !policy.runInDispatchThread()) {
+            runnable.run();
+        } else {
+            EdtTestUtilKt.runInEdtAndWait(() -> {
+                runnable.run();
+                return null;
+            });
+        }
+    }
+
    private static class LightCodeInsightFixtureTestCaseWrapper extends LightCodeInsightFixtureTestCase {
        private final ExtensionContext extensionContext;

@@ -1,44 +0,0 @@
-package de.platon42.intellij.jupiter;
-
-import com.intellij.testFramework.EdtTestUtilKt;
-import com.intellij.testFramework.TestLoggerFactory;
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
-import org.jetbrains.annotations.NotNull;
-
-// See https://github.com/junit-team/junit5/issues/157
-public class WorkaroundUntilJupiterGetsExecutorProvider {
-
-    protected static void runTest(Runnable test) throws Throwable {
-        Throwable[] throwables = new Throwable[1];
-
-        Runnable runnable = () -> {
-            try {
-                TestLoggerFactory.onTestStarted();
-                test.run();
-                TestLoggerFactory.onTestFinished(true);
-            } catch (Throwable e) {
-                TestLoggerFactory.onTestFinished(false);
-                e.fillInStackTrace();
-                throwables[0] = e;
-            }
-        };
-
-        invokeTestRunnable(runnable);
-
-        if (throwables[0] != null) {
-            throw throwables[0];
-        }
-    }
-
-    private static void invokeTestRunnable(@NotNull Runnable runnable) {
-        IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
-        if (policy != null && !policy.runInDispatchThread()) {
-            runnable.run();
-        } else {
-            EdtTestUtilKt.runInEdtAndWait(() -> {
-                runnable.run();
-                return null;
-            });
-        }
-    }
-}
@@ -1,10 +1,7 @@
 package de.platon42.intellij.plugins.cajon

 import com.intellij.pom.java.LanguageLevel
-import com.intellij.testFramework.TestLoggerFactory
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
-import com.intellij.testFramework.runInEdtAndWait
 import de.platon42.intellij.jupiter.AddLocalJarToModule
 import de.platon42.intellij.jupiter.LightCodeInsightExtension
 import de.platon42.intellij.jupiter.TestDataPath
@@ -14,7 +11,6 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.DisplayNameGeneration
 import org.junit.jupiter.api.DisplayNameGenerator
 import org.junit.jupiter.api.extension.ExtendWith
-import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Method

@ExtendWith(LightCodeInsightExtension::class)
@@ -24,45 +20,6 @@ import java.lang.reflect.Method
@DisplayNameGeneration(AbstractCajonTest.CutOffFixtureDisplayNameGenerator::class)
 abstract class AbstractCajonTest {

-    // See https://github.com/junit-team/junit5/issues/157, should be resolved with junit5 5.5 M2
-    protected fun runTest(body: () -> Unit) {
-        val throwables = arrayOfNulls<Throwable>(1)
-
-        invokeTestRunnable {
-            try {
-                TestLoggerFactory.onTestStarted()
-                body()
-                TestLoggerFactory.onTestFinished(true)
-            } catch (e: InvocationTargetException) {
-                TestLoggerFactory.onTestFinished(false)
-                e.fillInStackTrace()
-                throwables[0] = e.targetException
-            } catch (e: IllegalAccessException) {
-                TestLoggerFactory.onTestFinished(false)
-                e.fillInStackTrace()
-                throwables[0] = e
-            } catch (e: Throwable) {
-                TestLoggerFactory.onTestFinished(false)
-                throwables[0] = e
-            }
-        }
-
-        if (throwables[0] != null) {
-            throw throwables[0]!!
-        }
-    }
-
-    private fun invokeTestRunnable(runnable: () -> Unit) {
-        val policy = IdeaTestExecutionPolicy.current()
-        if (policy != null && !policy.runInDispatchThread()) {
-            runnable()
-        } else {
-            runInEdtAndWait {
-                runnable()
-            }
-        }
-    }
-
    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)
@@ -11,12 +11,9 @@ internal class AssertThatBinaryExpressionInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/BinaryExpression")
    internal fun assertThat_of_binary_expression_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatBinaryExpressionInspection::class.java)
        myFixture.configureByFile("BinaryExpressionBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 149)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 13)
        myFixture.checkResultByFile("BinaryExpressionAfter.java")
    }
-    }
 }
@@ -11,7 +11,6 @@ internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/BooleanCondition")
    internal fun assertThat_with_isEqualTo_true_or_false_can_use_isTrue_or_isFalse(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatBooleanConditionInspection::class.java)
        myFixture.configureByFile("BooleanConditionBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
@@ -20,5 +19,4 @@ internal class AssertThatBooleanConditionInspectionTest : AbstractCajonTest() {
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
        myFixture.checkResultByFile("BooleanConditionAfter.java")
    }
-    }
 }
@@ -11,7 +11,6 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
    @Test
    @TestDataSubPath("inspections/CollectionMapExpression")
    internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
        myFixture.configureByFile("CollectionMapExpressionBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
@@ -25,5 +24,4 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
    }
-    }
 }
@@ -11,11 +11,9 @@ internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/EnumerableIsEmpty")
    internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
        myFixture.configureByFile("EnumerableIsEmptyBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
        myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
    }
-    }
 }
@@ -14,33 +14,30 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {

    @Test
    internal fun assertThat_get_or_isPresent_for_Guava_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
        myFixture.configureByFile("GuavaOptionalBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
        myFixture.checkResultByFile("GuavaOptionalAfter.java")
    }
-    }

    @Test
    internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 4)
        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
    }
-    }

    @Test
    internal fun adds_missing_Guava_import_isAbsent_first(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
@@ -48,5 +45,4 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
    }
-    }
 }
@@ -11,12 +11,10 @@ internal class AssertThatInstanceOfInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/InstanceOf")
    internal fun assertThat_with_instanceof_can_be_moved_out(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatInstanceOfInspection::class.java)
        myFixture.configureByFile("InstanceOfBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isInstanceOf() instead"), 6)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
        myFixture.checkResultByFile("InstanceOfAfter.java")
    }
-    }
 }
@@ -11,11 +11,9 @@ internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonT
    @Test
    @TestDataSubPath("inspections/InvertedBooleanCondition")
    internal fun assertThat_with_inverted_boolean_condition_can_be_inverted(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
        myFixture.configureByFile("InvertedBooleanConditionBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
        myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
    }
-    }
 }
@@ -11,11 +11,12 @@ internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/Java8Optional")
    internal fun assertThat_get_or_isPresent_for_Java8_Optional_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatJava8OptionalInspection::class.java)
        myFixture.configureByFile("Java8OptionalBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isPresent() instead"), 6)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isPresent() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orElse() of actual expression and use assertThat().isNotPresent() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
@@ -23,5 +24,4 @@ internal class AssertThatJava8OptionalInspectionTest : AbstractCajonTest() {
        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
        myFixture.checkResultByFile("Java8OptionalAfter.java")
    }
-    }
 }
@@ -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 AssertThatObjectExpressionInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/ObjectExpression")
+    internal fun assertThat_with_certain_Object_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        myFixture.enableInspections(AssertThatObjectExpressionInspection::class.java)
+        myFixture.configureByFile("ObjectExpressionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace calls to hashCode() with hasSameHashCodeAs()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove toString() of actual expression and use assertThat().hasToString() instead"), 1)
+        myFixture.checkResultByFile("ObjectExpressionAfter.java")
+    }
+}
@@ -11,12 +11,10 @@ internal class AssertThatObjectIsNullOrNotNullInspectionTest : AbstractCajonTest
    @Test
    @TestDataSubPath("inspections/ObjectIsNullOrNotNull")
    internal fun assertThat_with_isEqualTo_null_can_use_isNull(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
        myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
        myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
    }
-    }
 }
@@ -13,7 +13,6 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/Size")
    internal fun assertThat_size_of_array_or_collection_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatSizeInspection::class.java)
        myFixture.configureByFile("SizeBefore.java")
        assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
@@ -34,5 +33,4 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14)
        myFixture.checkResultByFile("SizeAfter.java")
    }
-    }
 }
@@ -11,17 +11,16 @@ internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/StringExpression")
    internal fun assertThat_with_certain_String_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatStringExpressionInspection::class.java)
        myFixture.configureByFile("StringExpressionBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isEqualToIgnoringCase() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isEqualTo() instead"), 4)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 4)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWith() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
@@ -30,5 +29,4 @@ internal class AssertThatStringExpressionInspectionTest : AbstractCajonTest() {
        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
        myFixture.checkResultByFile("StringExpressionAfter.java")
    }
-    }
 }
@@ -13,7 +13,6 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/StringIsEmpty")
    internal fun assertThat_with_isEqualTo_emptyString_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssertThatStringIsEmptyInspection::class.java)
        myFixture.configureByFile("StringIsEmptyBefore.java")
        val highlights = myFixture.doHighlighting()
@@ -25,5 +24,4 @@ internal class AssertThatStringIsEmptyInspectionTest : AbstractCajonTest() {
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
        myFixture.checkResultByFile("StringIsEmptyAfter.java")
    }
-    }
 }
@@ -14,11 +14,9 @@ internal class AssumeThatInsteadOfReturnInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/AssumeThat")
    internal fun conditional_returns_can_be_replaced_by_assumeThat(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
        myFixture.configureByFile("AssumeThatBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
        myFixture.checkResultByFile("AssumeThatAfter.java")
    }
-    }
 }
@@ -0,0 +1,24 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
+import de.platon42.intellij.jupiter.AddLocalJarToModule
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.cajon.AbstractCajonTest
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+
+@AddLocalJarToModule(com.google.common.base.Optional::class, org.assertj.guava.api.Assertions::class, Assertions::class)
+internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/ImplicitAssertion")
+    internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        myFixture.enableInspections(ImplicitAssertionInspection::class.java)
+        myFixture.configureByFile("ImplicitAssertionBefore.java")
+        executeQuickFixes(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 101)
+        executeQuickFixes(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
+        executeQuickFixes(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
+        myFixture.checkResultByFile("ImplicitAssertionAfter.java")
+    }
+}
@@ -15,11 +15,10 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/JUnitAssertToAssertJ")
    internal fun junit_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
        myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-            executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 38)
+        executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+        executeQuickFixes(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
        myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
    }
-    }
 }
@@ -11,11 +11,9 @@ internal class JoinAssertThatStatementsInspectionTest : AbstractCajonTest() {
    @Test
    @TestDataSubPath("inspections/JoinStatements")
    internal fun assertThat_statements_can_be_joined_together(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.enableInspections(JoinAssertThatStatementsInspection::class.java)
        myFixture.configureByFile("JoinStatementsBefore.java")
        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
        myFixture.checkResultByFile("JoinStatementsAfter.java")
    }
-    }
 }
@@ -13,81 +13,61 @@ internal class ExtractorReferenceContributorTest : AbstractCajonTest() {

    @Test
    internal fun extractor_is_able_to_find_reference_for_field_extracting(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_for_first_part_of_a_path(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_for_second_part_of_a_path_and_both_getter_and_field(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_on_a_bare_method_call(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_with_only_Getter_on_second_part(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_using_byName_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_using_resultOf_extractor(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_for_field_extraction_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_for_field_flat_extraction_of_path_on_list(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
    }
-    }

    @Test
    internal fun extractor_is_able_to_find_reference_for_extraction_on_result_of_method(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
        myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
    }
-    }
 }
@@ -146,12 +146,12 @@ public class BinaryExpression {
        assertThat(numberObjAct).isGreaterThan(1);
        assertThat(numberObjAct).isGreaterThan(1);

-        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(true);

        assertThat(stringAct).as("doh!").isSameAs(stringExp);
        assertThat(stringAct).isSameAs(stringExp);
@@ -160,12 +160,12 @@ public class BinaryExpression {
        assertThat(stringAct).isNotSameAs(stringExp);
        assertThat(stringAct).isNotSameAs(stringExp);

-        assertThat(stringAct).as("doh!").isEqualTo(stringExp);
-        assertThat(stringAct).isEqualTo(stringExp);
-        assertThat(stringAct).isEqualTo(stringExp);
-        assertThat(stringAct).isNotEqualTo(stringExp);
-        assertThat(stringAct).isNotEqualTo(stringExp);
-        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct.equals(stringExp)).as("doh!").isTrue();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isFalse();
+        assertThat(stringAct.equals(stringExp)).isEqualTo(false);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(true);

        assertThat(stringAct).as("doh!").isNotSameAs(stringExp);
        assertThat(stringAct).isNotSameAs(stringExp);
@@ -194,6 +194,6 @@ public class BinaryExpression {
        assertThat(primAct).as("doh!").isEqualTo(primExp).isEqualTo(primExp);
        assertThat(primAct == primExp).isFalse().as("doh!").isEqualTo(true);

-        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp).isEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue().isEqualTo(true);
    }
 }
@@ -25,6 +25,11 @@ public class GuavaOptional {
        assertThat(opt.get()).isNotEqualTo("foo");
        assertThat(opt.get()).isNotSameAs("foo");

+        assertThat(opt).as("foo").isAbsent();
+        assertThat(opt).isAbsent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+
        assertThat(opt).as("foo").contains("foo");
        assertThat(opt).contains("foo");
        assertThat(opt).isNotEqualTo(Optional.of("foo"));
@@ -25,6 +25,11 @@ public class GuavaOptional {
        assertThat(opt.get()).isNotEqualTo("foo");
        assertThat(opt.get()).isNotSameAs("foo");

+        assertThat(opt.orNull()).as("foo").isEqualTo(null);
+        assertThat(opt.orNull()).isNull();
+        assertThat(opt.orNull()).isNotEqualTo(null);
+        assertThat(opt.orNull()).isNotNull();
+
        assertThat(opt).as("foo").isEqualTo(Optional.of("foo"));
        assertThat(opt).isEqualTo(Optional.fromNullable("foo"));
        assertThat(opt).isNotEqualTo(Optional.of("foo"));
@@ -0,0 +1,288 @@
+import org.assertj.core.api.Condition;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Consumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class ImplicitAssertion {
+
+    private void implicitAssertion() {
+        List<String> list = new ArrayList<>();
+        List<String> moreStrings = new ArrayList<>();
+        Condition<String> stringCondition = new Condition<>();
+        Condition<List<? extends String>> listCondition = new Condition<>();
+        Consumer<String> stringConsumer = (it) -> {
+        };
+
+        String string = "foo";
+
+        com.google.common.base.Optional<String> guavaOptional = com.google.common.base.Optional.absent();
+        Optional<String> java8Optional = Optional.empty();
+
+        assertThat(string).isNotNull().isNullOrEmpty(); // could be equal to .isEmpty()
+        assertThat(string).isEmpty();
+        assertThat(string).isNotEmpty();
+        assertThat(string).hasSize(1);
+        assertThat(string).hasSizeGreaterThan(1);
+        assertThat(string).hasSizeGreaterThanOrEqualTo(1);
+        assertThat(string).hasSizeLessThan(1);
+        assertThat(string).hasSizeLessThanOrEqualTo(1);
+        assertThat(string).hasSizeBetween(1, 2);
+        assertThat(string).hasSameSizeAs(moreStrings);
+        assertThat(string).isNotNull().isEqualTo("bar");
+        assertThat(string).isNotNull().isNotEqualTo("bar");
+        assertThat(string).isNotNull().isSameAs("bar");
+        assertThat(string).isNotNull().isNotSameAs("bar");
+        assertThat(string).isNotNull().contains(string);
+        assertThat(string).isNotNull().containsOnlyOnce(string);
+        assertThat(string).isNotNull().isIn(string, "bar");
+        assertThat(string).isNotNull().isNotIn(string, "bar");
+        assertThat(string).isNotNull().doesNotContain(string, "bar");
+        assertThat(string).isNotNull().startsWith("bar");
+        assertThat(string).isNotNull().endsWith("bar");
+        assertThat(string).isNotNull().containsSequence(moreStrings);
+        assertThat(string).isNotNull().containsSubsequence(moreStrings);
+        assertThat(string).isNotNull().has(stringCondition);
+        assertThat(string).isNotNull().doesNotHave(stringCondition);
+        assertThat(string).isNotNull().is(stringCondition);
+        assertThat(string).isNotNull().isNot(stringCondition);
+        assertThat(string).hasToString(string);
+        assertThat(string).isInstanceOf(String.class);
+        assertThat(string).isNotInstanceOf(String.class);
+        assertThat(string).isExactlyInstanceOf(String.class);
+        assertThat(string).isNotExactlyInstanceOf(String.class);
+        assertThat(string).isInstanceOfAny(String.class);
+        assertThat(string).isNotInstanceOfAny(String.class);
+        assertThat(string).isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(string).hasSameClassAs("bar");
+        assertThat(string).doesNotHaveSameClassAs("bar");
+        assertThat(string).isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(string).isNotOfAnyClassIn(String.class, CharSequence.class);
+
+        assertThat(string).isNotEmpty().isNullOrEmpty();
+        assertThat(string).isNotEmpty().isEmpty();
+        assertThat(string).isNotEmpty().isNotEmpty();
+        assertThat(string).hasSize(1);
+        assertThat(string).hasSizeGreaterThan(1);
+        assertThat(string).isNotEmpty().hasSizeGreaterThanOrEqualTo(1);
+        assertThat(string).isNotEmpty().hasSizeLessThan(1);
+        assertThat(string).isNotEmpty().hasSizeLessThanOrEqualTo(1);
+        assertThat(string).isNotEmpty().hasSizeBetween(1, 2);
+        assertThat(string).hasSameSizeAs(moreStrings);
+        assertThat(string).isNotEmpty().isEqualTo("bar");
+        assertThat(string).isNotEmpty().isNotEqualTo("bar");
+        assertThat(string).isNotEmpty().isSameAs("bar");
+        assertThat(string).isNotEmpty().isNotSameAs("bar");
+        assertThat(string).isNotEmpty().contains(string);
+        assertThat(string).isNotEmpty().containsOnlyOnce(string);
+        assertThat(string).isNotEmpty().isIn(string, "bar");
+        assertThat(string).isNotEmpty().isNotIn(string, "bar");
+        assertThat(string).isNotEmpty().doesNotContain(string, "bar");
+        assertThat(string).isNotEmpty().startsWith("bar");
+        assertThat(string).isNotEmpty().endsWith("bar");
+        assertThat(string).isNotEmpty().containsSequence(moreStrings);
+        assertThat(string).isNotEmpty().containsSubsequence(moreStrings);
+        assertThat(string).isNotEmpty().has(stringCondition);
+        assertThat(string).isNotEmpty().doesNotHave(stringCondition);
+        assertThat(string).isNotEmpty().is(stringCondition);
+        assertThat(string).isNotEmpty().isNot(stringCondition);
+        assertThat(string).isNotEmpty().hasToString(string);
+        assertThat(string).isNotEmpty().isInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isNotInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isExactlyInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isNotExactlyInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isInstanceOfAny(String.class);
+        assertThat(string).isNotEmpty().isNotInstanceOfAny(String.class);
+        assertThat(string).isNotEmpty().isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(string).isNotEmpty().hasSameClassAs("bar");
+        assertThat(string).isNotEmpty().doesNotHaveSameClassAs("bar");
+        assertThat(string).isNotEmpty().isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(string).isNotEmpty().isNotOfAnyClassIn(String.class, CharSequence.class);
+
+        assertThat(list).isNotNull().isNullOrEmpty();
+        assertThat(list).isEmpty();
+        assertThat(list).isNotEmpty();
+        assertThat(list).hasSize(1);
+        assertThat(list).hasSizeGreaterThan(1);
+        assertThat(list).hasSizeGreaterThanOrEqualTo(1);
+        assertThat(list).hasSizeLessThan(1);
+        assertThat(list).hasSizeLessThanOrEqualTo(1);
+        assertThat(list).hasSizeBetween(1, 2);
+        assertThat(list).hasSameSizeAs(moreStrings);
+        assertThat(list).isNotNull().isEqualTo(moreStrings);
+        assertThat(list).isNotNull().isNotEqualTo(moreStrings);
+        assertThat(list).isNotNull().isSameAs(moreStrings);
+        assertThat(list).isNotNull().isNotSameAs(moreStrings);
+        assertThat(list).contains(string);
+        assertThat(list).containsOnly(string);
+        assertThat(list).containsOnlyOnce(string);
+        assertThat(list).containsOnlyNulls();
+        assertThat(list).doesNotContainNull();
+        assertThat(list).containsExactly(string, "bar");
+        assertThat(list).containsExactlyInAnyOrder(string, "bar");
+        assertThat(list).containsAnyOf(string, "bar");
+        assertThat(list).containsAll(moreStrings);
+        assertThat(list).containsExactlyInAnyOrderElementsOf(moreStrings);
+        assertThat(list).isNotNull().isIn(string, "bar");
+        assertThat(list).isNotNull().isNotIn(string, "bar");
+        assertThat(list).doesNotContain(string, "bar");
+        assertThat(list).hasSameElementsAs(moreStrings);
+        assertThat(list).containsAnyElementsOf(moreStrings);
+        assertThat(list).containsExactlyElementsOf(moreStrings);
+        assertThat(list).containsOnlyElementsOf(moreStrings);
+        assertThat(list).doesNotContainAnyElementsOf(moreStrings);
+        assertThat(list).isSubsetOf(moreStrings);
+        assertThat(list).startsWith(string, "bar");
+        assertThat(list).endsWith(string, "bar");
+        assertThat(list).doesNotHaveDuplicates();
+        assertThat(list).containsSequence(moreStrings);
+        assertThat(list).containsSubsequence(moreStrings);
+        assertThat(list).doesNotContainSequence(moreStrings);
+        assertThat(list).doesNotContainSubsequence(moreStrings);
+        assertThat(list).are(stringCondition);
+        assertThat(list).areNot(stringCondition);
+        assertThat(list).have(stringCondition);
+        assertThat(list).doNotHave(stringCondition);
+        assertThat(list).areAtLeastOne(stringCondition);
+        assertThat(list).areAtLeast(1, stringCondition);
+        assertThat(list).areAtMost(1, stringCondition);
+        assertThat(list).areExactly(1, stringCondition);
+        assertThat(list).hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).haveAtLeastOne(stringCondition);
+        assertThat(list).haveAtLeast(1, stringCondition);
+        assertThat(list).haveAtMost(1, stringCondition);
+        assertThat(list).haveExactly(1, stringCondition);
+        assertThat(list).hasAtLeastOneElementOfType(String.class);
+        assertThat(list).hasOnlyElementsOfType(String.class);
+        assertThat(list).hasOnlyElementsOfTypes(String.class);
+        assertThat(list).doesNotHaveAnyElementsOfTypes(String.class);
+        assertThat(list).hasOnlyElementsOfTypes(String.class);
+        assertThat(list).has(listCondition);
+        assertThat(list).doesNotHave(listCondition);
+        assertThat(list).isNotNull().is(listCondition);
+        assertThat(list).isNotNull().isNot(listCondition);
+        assertThat(list).hasToString(string);
+        assertThat(list).isInstanceOf(String.class);
+        assertThat(list).isNotInstanceOf(String.class);
+        assertThat(list).isExactlyInstanceOf(String.class);
+        assertThat(list).isNotExactlyInstanceOf(String.class);
+        assertThat(list).isInstanceOfAny(String.class);
+        assertThat(list).isNotInstanceOfAny(String.class);
+        assertThat(list).noneMatch(it -> true);
+        assertThat(list).isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(list).hasSameClassAs("bar");
+        assertThat(list).doesNotHaveSameClassAs("bar");
+        assertThat(list).isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(list).isNotOfAnyClassIn(String.class, CharSequence.class);
+
+        assertThat(list).isNotEmpty().isNullOrEmpty();
+        assertThat(list).isNotEmpty().isEmpty();
+        assertThat(list).isNotEmpty().isNotEmpty();
+        assertThat(list).hasSize(1);
+        assertThat(list).hasSizeGreaterThan(1);
+        assertThat(list).isNotEmpty().hasSizeGreaterThanOrEqualTo(1);
+        assertThat(list).isNotEmpty().hasSizeLessThan(1);
+        assertThat(list).isNotEmpty().hasSizeLessThanOrEqualTo(1);
+        assertThat(list).isNotEmpty().hasSizeBetween(1, 2);
+        assertThat(list).hasSameSizeAs(moreStrings);
+        assertThat(list).isNotEmpty().isEqualTo(moreStrings);
+        assertThat(list).isNotEmpty().isNotEqualTo(moreStrings);
+        assertThat(list).isNotEmpty().isSameAs(moreStrings);
+        assertThat(list).isNotEmpty().isNotSameAs(moreStrings);
+        assertThat(list).isNotEmpty().contains(string);
+        assertThat(list).isNotEmpty().containsOnly(string);
+        assertThat(list).isNotEmpty().containsOnlyOnce(string);
+        assertThat(list).containsOnlyNulls();
+        assertThat(list).isNotEmpty().doesNotContainNull();
+        assertThat(list).isNotEmpty().containsExactly(string, "bar");
+        assertThat(list).isNotEmpty().containsExactlyInAnyOrder(string, "bar");
+        assertThat(list).isNotEmpty().containsAnyOf(string, "bar");
+        assertThat(list).isNotEmpty().containsAll(moreStrings);
+        assertThat(list).isNotEmpty().containsExactlyInAnyOrderElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().isIn(string, "bar");
+        assertThat(list).isNotEmpty().isNotIn(string, "bar");
+        assertThat(list).isNotEmpty().doesNotContain(string, "bar");
+        assertThat(list).isNotEmpty().hasSameElementsAs(moreStrings);
+        assertThat(list).isNotEmpty().containsAnyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().containsExactlyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().containsOnlyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().doesNotContainAnyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().isSubsetOf(moreStrings);
+        assertThat(list).startsWith(string, "bar");
+        assertThat(list).endsWith(string, "bar");
+        assertThat(list).isNotEmpty().doesNotHaveDuplicates();
+        assertThat(list).isNotEmpty().containsSequence(moreStrings);
+        assertThat(list).isNotEmpty().containsSubsequence(moreStrings);
+        assertThat(list).isNotEmpty().doesNotContainSequence(moreStrings);
+        assertThat(list).isNotEmpty().doesNotContainSubsequence(moreStrings);
+        assertThat(list).isNotEmpty().are(stringCondition);
+        assertThat(list).isNotEmpty().areNot(stringCondition);
+        assertThat(list).isNotEmpty().have(stringCondition);
+        assertThat(list).isNotEmpty().doNotHave(stringCondition);
+        assertThat(list).areAtLeastOne(stringCondition);
+        assertThat(list).isNotEmpty().areAtLeast(1, stringCondition);
+        assertThat(list).isNotEmpty().areAtMost(1, stringCondition);
+        assertThat(list).isNotEmpty().areExactly(1, stringCondition);
+        assertThat(list).isNotEmpty().hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).haveAtLeastOne(stringCondition);
+        assertThat(list).isNotEmpty().haveAtLeast(1, stringCondition);
+        assertThat(list).isNotEmpty().haveAtMost(1, stringCondition);
+        assertThat(list).isNotEmpty().haveExactly(1, stringCondition);
+        assertThat(list).hasAtLeastOneElementOfType(String.class);
+        assertThat(list).isNotEmpty().hasOnlyElementsOfType(String.class);
+        assertThat(list).isNotEmpty().hasOnlyElementsOfTypes(String.class);
+        assertThat(list).isNotEmpty().doesNotHaveAnyElementsOfTypes(String.class);
+        assertThat(list).isNotEmpty().hasOnlyElementsOfTypes(String.class);
+        assertThat(list).isNotEmpty().has(listCondition);
+        assertThat(list).isNotEmpty().doesNotHave(listCondition);
+        assertThat(list).isNotEmpty().is(listCondition);
+        assertThat(list).isNotEmpty().isNot(listCondition);
+        assertThat(list).isNotEmpty().hasToString(string);
+        assertThat(list).isNotEmpty().isInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isNotInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isExactlyInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isNotExactlyInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isInstanceOfAny(String.class);
+        assertThat(list).isNotEmpty().isNotInstanceOfAny(String.class);
+        assertThat(list).isNotEmpty().noneMatch(it -> true);
+        assertThat(list).isNotEmpty().isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(list).isNotEmpty().hasSameClassAs("bar");
+        assertThat(list).isNotEmpty().doesNotHaveSameClassAs("bar");
+        assertThat(list).isNotEmpty().isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(list).isNotEmpty().isNotOfAnyClassIn(String.class, CharSequence.class);
+
+
+        assertThat(java8Optional).isPresent();
+        assertThat(java8Optional).isNotPresent();
+        assertThat(java8Optional).isEmpty();
+        assertThat(java8Optional).isNotEmpty();
+        assertThat(java8Optional).contains("foo");
+        assertThat(java8Optional).containsSame("foo");
+        assertThat(java8Optional).hasValue("foo");
+        assertThat(java8Optional).containsInstanceOf(String.class);
+        assertThat(java8Optional).hasValueSatisfying(stringCondition);
+        assertThat(java8Optional).contains("foo");
+        assertThat(java8Optional).containsSame("foo");
+        assertThat(java8Optional).hasValue("foo");
+        assertThat(java8Optional).containsInstanceOf(String.class);
+        assertThat(java8Optional).hasValueSatisfying(stringCondition);
+        assertThat(java8Optional).contains("foo");
+        assertThat(java8Optional).containsSame("foo");
+        assertThat(java8Optional).hasValue("foo");
+        assertThat(java8Optional).containsInstanceOf(String.class);
+        assertThat(java8Optional).hasValueSatisfying(stringCondition);
+
+        assertThat(guavaOptional).isPresent();
+        assertThat(guavaOptional).isAbsent();
+        assertThat(guavaOptional).contains("foo");
+        assertThat(guavaOptional).extractingValue().isEqualTo("foo");
+        assertThat(guavaOptional).extractingCharSequence().isEqualTo("foo");
+        assertThat(guavaOptional).contains("foo");
+        assertThat(guavaOptional).extractingValue().isEqualTo("foo");
+        assertThat(guavaOptional).extractingCharSequence().isEqualTo("foo");
+    }
+}
@@ -0,0 +1,288 @@
+import org.assertj.core.api.Condition;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Consumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.assertThat;
+
+public class ImplicitAssertion {
+
+    private void implicitAssertion() {
+        List<String> list = new ArrayList<>();
+        List<String> moreStrings = new ArrayList<>();
+        Condition<String> stringCondition = new Condition<>();
+        Condition<List<? extends String>> listCondition = new Condition<>();
+        Consumer<String> stringConsumer = (it) -> {
+        };
+
+        String string = "foo";
+
+        com.google.common.base.Optional<String> guavaOptional = com.google.common.base.Optional.absent();
+        Optional<String> java8Optional = Optional.empty();
+
+        assertThat(string).isNotNull().isNullOrEmpty(); // could be equal to .isEmpty()
+        assertThat(string).isNotNull().isEmpty();
+        assertThat(string).isNotNull().isNotEmpty();
+        assertThat(string).isNotNull().hasSize(1);
+        assertThat(string).isNotNull().hasSizeGreaterThan(1);
+        assertThat(string).isNotNull().hasSizeGreaterThanOrEqualTo(1);
+        assertThat(string).isNotNull().hasSizeLessThan(1);
+        assertThat(string).isNotNull().hasSizeLessThanOrEqualTo(1);
+        assertThat(string).isNotNull().hasSizeBetween(1, 2);
+        assertThat(string).isNotNull().hasSameSizeAs(moreStrings);
+        assertThat(string).isNotNull().isEqualTo("bar");
+        assertThat(string).isNotNull().isNotEqualTo("bar");
+        assertThat(string).isNotNull().isSameAs("bar");
+        assertThat(string).isNotNull().isNotSameAs("bar");
+        assertThat(string).isNotNull().contains(string);
+        assertThat(string).isNotNull().containsOnlyOnce(string);
+        assertThat(string).isNotNull().isIn(string, "bar");
+        assertThat(string).isNotNull().isNotIn(string, "bar");
+        assertThat(string).isNotNull().doesNotContain(string, "bar");
+        assertThat(string).isNotNull().startsWith("bar");
+        assertThat(string).isNotNull().endsWith("bar");
+        assertThat(string).isNotNull().containsSequence(moreStrings);
+        assertThat(string).isNotNull().containsSubsequence(moreStrings);
+        assertThat(string).isNotNull().has(stringCondition);
+        assertThat(string).isNotNull().doesNotHave(stringCondition);
+        assertThat(string).isNotNull().is(stringCondition);
+        assertThat(string).isNotNull().isNot(stringCondition);
+        assertThat(string).isNotNull().hasToString(string);
+        assertThat(string).isNotNull().isInstanceOf(String.class);
+        assertThat(string).isNotNull().isNotInstanceOf(String.class);
+        assertThat(string).isNotNull().isExactlyInstanceOf(String.class);
+        assertThat(string).isNotNull().isNotExactlyInstanceOf(String.class);
+        assertThat(string).isNotNull().isInstanceOfAny(String.class);
+        assertThat(string).isNotNull().isNotInstanceOfAny(String.class);
+        assertThat(string).isNotNull().isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(string).isNotNull().hasSameClassAs("bar");
+        assertThat(string).isNotNull().doesNotHaveSameClassAs("bar");
+        assertThat(string).isNotNull().isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(string).isNotNull().isNotOfAnyClassIn(String.class, CharSequence.class);
+
+        assertThat(string).isNotEmpty().isNullOrEmpty();
+        assertThat(string).isNotEmpty().isEmpty();
+        assertThat(string).isNotEmpty().isNotEmpty();
+        assertThat(string).isNotEmpty().hasSize(1);
+        assertThat(string).isNotEmpty().hasSizeGreaterThan(1);
+        assertThat(string).isNotEmpty().hasSizeGreaterThanOrEqualTo(1);
+        assertThat(string).isNotEmpty().hasSizeLessThan(1);
+        assertThat(string).isNotEmpty().hasSizeLessThanOrEqualTo(1);
+        assertThat(string).isNotEmpty().hasSizeBetween(1, 2);
+        assertThat(string).isNotEmpty().hasSameSizeAs(moreStrings);
+        assertThat(string).isNotEmpty().isEqualTo("bar");
+        assertThat(string).isNotEmpty().isNotEqualTo("bar");
+        assertThat(string).isNotEmpty().isSameAs("bar");
+        assertThat(string).isNotEmpty().isNotSameAs("bar");
+        assertThat(string).isNotEmpty().contains(string);
+        assertThat(string).isNotEmpty().containsOnlyOnce(string);
+        assertThat(string).isNotEmpty().isIn(string, "bar");
+        assertThat(string).isNotEmpty().isNotIn(string, "bar");
+        assertThat(string).isNotEmpty().doesNotContain(string, "bar");
+        assertThat(string).isNotEmpty().startsWith("bar");
+        assertThat(string).isNotEmpty().endsWith("bar");
+        assertThat(string).isNotEmpty().containsSequence(moreStrings);
+        assertThat(string).isNotEmpty().containsSubsequence(moreStrings);
+        assertThat(string).isNotEmpty().has(stringCondition);
+        assertThat(string).isNotEmpty().doesNotHave(stringCondition);
+        assertThat(string).isNotEmpty().is(stringCondition);
+        assertThat(string).isNotEmpty().isNot(stringCondition);
+        assertThat(string).isNotEmpty().hasToString(string);
+        assertThat(string).isNotEmpty().isInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isNotInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isExactlyInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isNotExactlyInstanceOf(String.class);
+        assertThat(string).isNotEmpty().isInstanceOfAny(String.class);
+        assertThat(string).isNotEmpty().isNotInstanceOfAny(String.class);
+        assertThat(string).isNotEmpty().isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(string).isNotEmpty().hasSameClassAs("bar");
+        assertThat(string).isNotEmpty().doesNotHaveSameClassAs("bar");
+        assertThat(string).isNotEmpty().isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(string).isNotEmpty().isNotOfAnyClassIn(String.class, CharSequence.class);
+
+        assertThat(list).isNotNull().isNullOrEmpty();
+        assertThat(list).isNotNull().isEmpty();
+        assertThat(list).isNotNull().isNotEmpty();
+        assertThat(list).isNotNull().hasSize(1);
+        assertThat(list).isNotNull().hasSizeGreaterThan(1);
+        assertThat(list).isNotNull().hasSizeGreaterThanOrEqualTo(1);
+        assertThat(list).isNotNull().hasSizeLessThan(1);
+        assertThat(list).isNotNull().hasSizeLessThanOrEqualTo(1);
+        assertThat(list).isNotNull().hasSizeBetween(1, 2);
+        assertThat(list).isNotNull().hasSameSizeAs(moreStrings);
+        assertThat(list).isNotNull().isEqualTo(moreStrings);
+        assertThat(list).isNotNull().isNotEqualTo(moreStrings);
+        assertThat(list).isNotNull().isSameAs(moreStrings);
+        assertThat(list).isNotNull().isNotSameAs(moreStrings);
+        assertThat(list).isNotNull().contains(string);
+        assertThat(list).isNotNull().containsOnly(string);
+        assertThat(list).isNotNull().containsOnlyOnce(string);
+        assertThat(list).isNotNull().containsOnlyNulls();
+        assertThat(list).isNotNull().doesNotContainNull();
+        assertThat(list).isNotNull().containsExactly(string, "bar");
+        assertThat(list).isNotNull().containsExactlyInAnyOrder(string, "bar");
+        assertThat(list).isNotNull().containsAnyOf(string, "bar");
+        assertThat(list).isNotNull().containsAll(moreStrings);
+        assertThat(list).isNotNull().containsExactlyInAnyOrderElementsOf(moreStrings);
+        assertThat(list).isNotNull().isIn(string, "bar");
+        assertThat(list).isNotNull().isNotIn(string, "bar");
+        assertThat(list).isNotNull().doesNotContain(string, "bar");
+        assertThat(list).isNotNull().hasSameElementsAs(moreStrings);
+        assertThat(list).isNotNull().containsAnyElementsOf(moreStrings);
+        assertThat(list).isNotNull().containsExactlyElementsOf(moreStrings);
+        assertThat(list).isNotNull().containsOnlyElementsOf(moreStrings);
+        assertThat(list).isNotNull().doesNotContainAnyElementsOf(moreStrings);
+        assertThat(list).isNotNull().isSubsetOf(moreStrings);
+        assertThat(list).isNotNull().startsWith(string, "bar");
+        assertThat(list).isNotNull().endsWith(string, "bar");
+        assertThat(list).isNotNull().doesNotHaveDuplicates();
+        assertThat(list).isNotNull().containsSequence(moreStrings);
+        assertThat(list).isNotNull().containsSubsequence(moreStrings);
+        assertThat(list).isNotNull().doesNotContainSequence(moreStrings);
+        assertThat(list).isNotNull().doesNotContainSubsequence(moreStrings);
+        assertThat(list).isNotNull().are(stringCondition);
+        assertThat(list).isNotNull().areNot(stringCondition);
+        assertThat(list).isNotNull().have(stringCondition);
+        assertThat(list).isNotNull().doNotHave(stringCondition);
+        assertThat(list).isNotNull().areAtLeastOne(stringCondition);
+        assertThat(list).isNotNull().areAtLeast(1, stringCondition);
+        assertThat(list).isNotNull().areAtMost(1, stringCondition);
+        assertThat(list).isNotNull().areExactly(1, stringCondition);
+        assertThat(list).isNotNull().hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).isNotNull().haveAtLeastOne(stringCondition);
+        assertThat(list).isNotNull().haveAtLeast(1, stringCondition);
+        assertThat(list).isNotNull().haveAtMost(1, stringCondition);
+        assertThat(list).isNotNull().haveExactly(1, stringCondition);
+        assertThat(list).isNotNull().hasAtLeastOneElementOfType(String.class);
+        assertThat(list).isNotNull().hasOnlyElementsOfType(String.class);
+        assertThat(list).isNotNull().hasOnlyElementsOfTypes(String.class);
+        assertThat(list).isNotNull().doesNotHaveAnyElementsOfTypes(String.class);
+        assertThat(list).isNotNull().hasOnlyElementsOfTypes(String.class);
+        assertThat(list).isNotNull().has(listCondition);
+        assertThat(list).isNotNull().doesNotHave(listCondition);
+        assertThat(list).isNotNull().is(listCondition);
+        assertThat(list).isNotNull().isNot(listCondition);
+        assertThat(list).isNotNull().hasToString(string);
+        assertThat(list).isNotNull().isInstanceOf(String.class);
+        assertThat(list).isNotNull().isNotInstanceOf(String.class);
+        assertThat(list).isNotNull().isExactlyInstanceOf(String.class);
+        assertThat(list).isNotNull().isNotExactlyInstanceOf(String.class);
+        assertThat(list).isNotNull().isInstanceOfAny(String.class);
+        assertThat(list).isNotNull().isNotInstanceOfAny(String.class);
+        assertThat(list).isNotNull().noneMatch(it -> true);
+        assertThat(list).isNotNull().isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(list).isNotNull().hasSameClassAs("bar");
+        assertThat(list).isNotNull().doesNotHaveSameClassAs("bar");
+        assertThat(list).isNotNull().isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(list).isNotNull().isNotOfAnyClassIn(String.class, CharSequence.class);
+
+        assertThat(list).isNotEmpty().isNullOrEmpty();
+        assertThat(list).isNotEmpty().isEmpty();
+        assertThat(list).isNotEmpty().isNotEmpty();
+        assertThat(list).isNotEmpty().hasSize(1);
+        assertThat(list).isNotEmpty().hasSizeGreaterThan(1);
+        assertThat(list).isNotEmpty().hasSizeGreaterThanOrEqualTo(1);
+        assertThat(list).isNotEmpty().hasSizeLessThan(1);
+        assertThat(list).isNotEmpty().hasSizeLessThanOrEqualTo(1);
+        assertThat(list).isNotEmpty().hasSizeBetween(1, 2);
+        assertThat(list).isNotEmpty().hasSameSizeAs(moreStrings);
+        assertThat(list).isNotEmpty().isEqualTo(moreStrings);
+        assertThat(list).isNotEmpty().isNotEqualTo(moreStrings);
+        assertThat(list).isNotEmpty().isSameAs(moreStrings);
+        assertThat(list).isNotEmpty().isNotSameAs(moreStrings);
+        assertThat(list).isNotEmpty().contains(string);
+        assertThat(list).isNotEmpty().containsOnly(string);
+        assertThat(list).isNotEmpty().containsOnlyOnce(string);
+        assertThat(list).isNotEmpty().containsOnlyNulls();
+        assertThat(list).isNotEmpty().doesNotContainNull();
+        assertThat(list).isNotEmpty().containsExactly(string, "bar");
+        assertThat(list).isNotEmpty().containsExactlyInAnyOrder(string, "bar");
+        assertThat(list).isNotEmpty().containsAnyOf(string, "bar");
+        assertThat(list).isNotEmpty().containsAll(moreStrings);
+        assertThat(list).isNotEmpty().containsExactlyInAnyOrderElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().isIn(string, "bar");
+        assertThat(list).isNotEmpty().isNotIn(string, "bar");
+        assertThat(list).isNotEmpty().doesNotContain(string, "bar");
+        assertThat(list).isNotEmpty().hasSameElementsAs(moreStrings);
+        assertThat(list).isNotEmpty().containsAnyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().containsExactlyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().containsOnlyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().doesNotContainAnyElementsOf(moreStrings);
+        assertThat(list).isNotEmpty().isSubsetOf(moreStrings);
+        assertThat(list).isNotEmpty().startsWith(string, "bar");
+        assertThat(list).isNotEmpty().endsWith(string, "bar");
+        assertThat(list).isNotEmpty().doesNotHaveDuplicates();
+        assertThat(list).isNotEmpty().containsSequence(moreStrings);
+        assertThat(list).isNotEmpty().containsSubsequence(moreStrings);
+        assertThat(list).isNotEmpty().doesNotContainSequence(moreStrings);
+        assertThat(list).isNotEmpty().doesNotContainSubsequence(moreStrings);
+        assertThat(list).isNotEmpty().are(stringCondition);
+        assertThat(list).isNotEmpty().areNot(stringCondition);
+        assertThat(list).isNotEmpty().have(stringCondition);
+        assertThat(list).isNotEmpty().doNotHave(stringCondition);
+        assertThat(list).isNotEmpty().areAtLeastOne(stringCondition);
+        assertThat(list).isNotEmpty().areAtLeast(1, stringCondition);
+        assertThat(list).isNotEmpty().areAtMost(1, stringCondition);
+        assertThat(list).isNotEmpty().areExactly(1, stringCondition);
+        assertThat(list).isNotEmpty().hasOnlyOneElementSatisfying(stringConsumer);
+        assertThat(list).isNotEmpty().haveAtLeastOne(stringCondition);
+        assertThat(list).isNotEmpty().haveAtLeast(1, stringCondition);
+        assertThat(list).isNotEmpty().haveAtMost(1, stringCondition);
+        assertThat(list).isNotEmpty().haveExactly(1, stringCondition);
+        assertThat(list).isNotEmpty().hasAtLeastOneElementOfType(String.class);
+        assertThat(list).isNotEmpty().hasOnlyElementsOfType(String.class);
+        assertThat(list).isNotEmpty().hasOnlyElementsOfTypes(String.class);
+        assertThat(list).isNotEmpty().doesNotHaveAnyElementsOfTypes(String.class);
+        assertThat(list).isNotEmpty().hasOnlyElementsOfTypes(String.class);
+        assertThat(list).isNotEmpty().has(listCondition);
+        assertThat(list).isNotEmpty().doesNotHave(listCondition);
+        assertThat(list).isNotEmpty().is(listCondition);
+        assertThat(list).isNotEmpty().isNot(listCondition);
+        assertThat(list).isNotEmpty().hasToString(string);
+        assertThat(list).isNotEmpty().isInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isNotInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isExactlyInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isNotExactlyInstanceOf(String.class);
+        assertThat(list).isNotEmpty().isInstanceOfAny(String.class);
+        assertThat(list).isNotEmpty().isNotInstanceOfAny(String.class);
+        assertThat(list).isNotEmpty().noneMatch(it -> true);
+        assertThat(list).isNotEmpty().isInstanceOfSatisfying(String.class, stringConsumer);
+        assertThat(list).isNotEmpty().hasSameClassAs("bar");
+        assertThat(list).isNotEmpty().doesNotHaveSameClassAs("bar");
+        assertThat(list).isNotEmpty().isOfAnyClassIn(String.class, CharSequence.class);
+        assertThat(list).isNotEmpty().isNotOfAnyClassIn(String.class, CharSequence.class);
+
+
+        assertThat(java8Optional).isNotNull().isPresent();
+        assertThat(java8Optional).isNotNull().isNotPresent();
+        assertThat(java8Optional).isNotNull().isEmpty();
+        assertThat(java8Optional).isNotNull().isNotEmpty();
+        assertThat(java8Optional).isNotNull().contains("foo");
+        assertThat(java8Optional).isNotNull().containsSame("foo");
+        assertThat(java8Optional).isNotNull().hasValue("foo");
+        assertThat(java8Optional).isNotNull().containsInstanceOf(String.class);
+        assertThat(java8Optional).isNotNull().hasValueSatisfying(stringCondition);
+        assertThat(java8Optional).isPresent().contains("foo");
+        assertThat(java8Optional).isPresent().containsSame("foo");
+        assertThat(java8Optional).isPresent().hasValue("foo");
+        assertThat(java8Optional).isPresent().containsInstanceOf(String.class);
+        assertThat(java8Optional).isPresent().hasValueSatisfying(stringCondition);
+        assertThat(java8Optional).isNotEmpty().contains("foo");
+        assertThat(java8Optional).isNotEmpty().containsSame("foo");
+        assertThat(java8Optional).isNotEmpty().hasValue("foo");
+        assertThat(java8Optional).isNotEmpty().containsInstanceOf(String.class);
+        assertThat(java8Optional).isNotEmpty().hasValueSatisfying(stringCondition);
+
+        assertThat(guavaOptional).isNotNull().isPresent();
+        assertThat(guavaOptional).isNotNull().isAbsent();
+        assertThat(guavaOptional).isNotNull().contains("foo");
+        assertThat(guavaOptional).isNotNull().extractingValue().isEqualTo("foo");
+        assertThat(guavaOptional).isNotNull().extractingCharSequence().isEqualTo("foo");
+        assertThat(guavaOptional).isPresent().contains("foo");
+        assertThat(guavaOptional).isPresent().extractingValue().isEqualTo("foo");
+        assertThat(guavaOptional).isPresent().extractingCharSequence().isEqualTo("foo");
+    }
+}
@@ -1,12 +1,18 @@
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.data.Offset.offset;
 import static org.junit.Assert.*;
+import static org.junit.Assume.*;

 public class JUnitAssertToAssertJ {

    private void jUnitAssertToAssertJ() {
        String foo = "foo";
        String bar = "bar";
+        int someInt = 1;
+        double someDouble = 1.0;
+        float someFloat = 1.0f;
+
        assertThat(foo == "foo").isTrue();
        assertThat(foo == "foo").as("oh no!").isTrue();
        assertThat(foo == "bar").isFalse();
@@ -52,5 +58,35 @@ public class JUnitAssertToAssertJ {
        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(foo).isEqualTo("bar");
+        assertThat(bar).as("equals").isEqualTo("foo");
+        assertThat(bar).isNotEqualTo("foo");
+        assertThat(foo).as("equals").isNotEqualTo("bar");
+
+        assertThat(someInt).isEqualTo(2);
+        assertThat(someDouble).isCloseTo(2.0, offset(0.1));
+        assertThat(someDouble).as("equals").isEqualTo(1.0);
+        assertThat(someDouble).as("equals").isCloseTo(1.0, offset(0.1));
+        assertThat(someFloat).isEqualTo(1.0f);
+        assertThat(someFloat).isCloseTo(2.0f, offset(0.1f));
+
+        fail();
+        fail("oh no!")
+    }
+
+    private void jUnitAssumeToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        assumeThat(foo == "foo").isTrue();
+        assumeThat(foo == "foo").as("oh no!").isTrue();
+        assumeThat(foo == "bar").isFalse();
+        assumeThat(foo == "bar").as("boom!").isFalse();
+
+        assumeThat(foo).isNotNull();
+        assumeNotNull(foo, bar);
+
+        assumeThat(new IllegalArgumentException()).doesNotThrowAnyException();
+        assumeThat(new IllegalArgumentException()).as("oh no!").doesNotThrowAnyException();
    }
 }
@@ -1,10 +1,15 @@
 import static org.junit.Assert.*;
+import static org.junit.Assume.*;

 public class JUnitAssertToAssertJ {

    private void jUnitAssertToAssertJ() {
        String foo = "foo";
        String bar = "bar";
+        int someInt = 1;
+        double someDouble = 1.0;
+        float someFloat = 1.0f;
+
        assertTrue(foo == "foo");
        assertTrue("oh no!", foo == "foo");
        assertFalse(foo == "bar");
@@ -50,5 +55,35 @@ public class JUnitAssertToAssertJ {
        assertArrayEquals("array equals", new double[2], new double[1], 1.0);
        assertArrayEquals(new float[2], new float[1], 1.0f);
        assertArrayEquals("array equals", new float[2], new float[1], 1.0f);
+
+        assertEquals("bar", foo);
+        assertEquals("equals", bar, "foo");
+        assertNotEquals(bar, "foo");
+        assertNotEquals("equals", "bar", foo);
+
+        assertEquals(someInt, 2);
+        assertEquals(someDouble, 2.0, 0.1);
+        assertEquals("equals",1.0, someDouble);
+        assertEquals("equals",1.0, someDouble, 0.1);
+        assertEquals(1.0f, someFloat);
+        assertEquals(someFloat, 2.0f, 0.1f);
+
+        fail();
+        fail("oh no!")
+    }
+
+    private void jUnitAssumeToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        assumeTrue(foo == "foo");
+        assumeTrue("oh no!", foo == "foo");
+        assumeFalse(foo == "bar");
+        assumeFalse("boom!", foo == "bar");
+
+        assumeNotNull(foo);
+        assumeNotNull(foo, bar);
+
+        assumeNoException(new IllegalArgumentException());
+        assumeNoException("oh no!", new IllegalArgumentException());
    }
 }
@@ -24,6 +24,11 @@ public class Java8Optional {
        assertThat(opt.get()).isNotEqualTo("foo");
        assertThat(opt.get()).isNotSameAs("foo");

+        assertThat(opt).as("foo").isNotPresent();
+        assertThat(opt).isNotPresent();
+        assertThat(opt).isPresent();
+        assertThat(opt).isPresent();
+
        assertThat(opt).as("foo").contains("foo");
        assertThat(opt).contains("foo");
        assertThat(opt).isNotEqualTo(Optional.of("foo"));
@@ -36,5 +41,7 @@ public class Java8Optional {
        assertThat(opt.isPresent()).as("foo").isEqualTo(false).as("bar").isTrue();

        assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
+
+        assertThat(opt.orElse("foo")).as("foo").isEqualTo(null);
    }
 }
@@ -24,6 +24,11 @@ public class Java8Optional {
        assertThat(opt.get()).isNotEqualTo("foo");
        assertThat(opt.get()).isNotSameAs("foo");

+        assertThat(opt.orElse(null)).as("foo").isEqualTo(null);
+        assertThat(opt.orElse(null)).isNull();
+        assertThat(opt.orElse(null)).isNotEqualTo(null);
+        assertThat(opt.orElse(null)).isNotNull();
+
        assertThat(opt).as("foo").isEqualTo(Optional.of("foo"));
        assertThat(opt).isEqualTo(Optional.ofNullable("foo"));
        assertThat(opt).isNotEqualTo(Optional.of("foo"));
@@ -36,5 +41,7 @@ public class Java8Optional {
        assertThat(opt.isPresent()).as("foo").isEqualTo(false).as("bar").isTrue();

        assertThat(opt.get()).isEqualTo("foo").isSameAs("foo").isNotEqualTo("foo").isNotSameAs("foo");
+
+        assertThat(opt.orElse("foo")).as("foo").isEqualTo(null);
    }
 }
@@ -48,5 +48,14 @@ public class JoinStatements {
        assertThat(iterator.next()).isEqualTo("bar");
        assertThat(iterator.next().toLowerCase()).isEqualTo("foo");
        assertThat(iterator.next().toLowerCase()).isEqualTo("bar");
+        assertThat(iterator.next() + "bar").isEqualTo("foobar");
+        assertThat(iterator.next() + "bar").isEqualTo("barbar");
+        int i = 0;
+        assertThat(++i).isEqualTo(1);
+        assertThat(++i).isEqualTo(2);
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
    }
 }
@@ -50,5 +50,14 @@ public class JoinStatements {
        assertThat(iterator.next()).isEqualTo("bar");
        assertThat(iterator.next().toLowerCase()).isEqualTo("foo");
        assertThat(iterator.next().toLowerCase()).isEqualTo("bar");
+        assertThat(iterator.next() + "bar").isEqualTo("foobar");
+        assertThat(iterator.next() + "bar").isEqualTo("barbar");
+        int i = 0;
+        assertThat(++i).isEqualTo(1);
+        assertThat(++i).isEqualTo(2);
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
    }
 }
@@ -0,0 +1,27 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ObjectExpression {
+
+    private void objectExpression() {
+        Integer object = 1;
+        Integer otherObject = 1;
+        boolean foo = false;
+
+        assertThat(object).hasToString("foo");
+        assertThat(object.toString()).isNotEqualTo("foo");
+
+        assertThat(object).hasSameHashCodeAs(otherObject);
+        assertThat(object.hashCode()).isEqualTo(123);
+
+        assertThat(object).as("doh!").isEqualTo(otherObject);
+        assertThat(object).isEqualTo(otherObject);
+        assertThat(object).isEqualTo(otherObject);
+        assertThat(object).isNotEqualTo(otherObject);
+        assertThat(object).isNotEqualTo(otherObject);
+        assertThat(object).isNotEqualTo(otherObject);
+
+        assertThat(object.equals(otherObject)).isEqualTo(foo);
+
+        assertThat(object).as("doh!").isEqualTo(otherObject).isEqualTo(otherObject);
+    }
+}
@@ -0,0 +1,27 @@
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ObjectExpression {
+
+    private void objectExpression() {
+        Integer object = 1;
+        Integer otherObject = 1;
+        boolean foo = false;
+
+        assertThat(object.toString()).isEqualTo("foo");
+        assertThat(object.toString()).isNotEqualTo("foo");
+
+        assertThat(object.hashCode()).isEqualTo(otherObject.hashCode());
+        assertThat(object.hashCode()).isEqualTo(123);
+
+        assertThat(object.equals(otherObject)).as("doh!").isTrue();
+        assertThat(object.equals(otherObject)).isEqualTo(true);
+        assertThat(object.equals(otherObject)).isNotEqualTo(false);
+        assertThat(object.equals(otherObject)).isFalse();
+        assertThat(object.equals(otherObject)).isEqualTo(false);
+        assertThat(object.equals(otherObject)).isNotEqualTo(true);
+
+        assertThat(object.equals(otherObject)).isEqualTo(foo);
+
+        assertThat(object.equals(otherObject)).as("doh!").isTrue().isEqualTo(true);
+    }
+}
@@ -8,6 +8,7 @@ public class StringExpression {

        assertThat(string).as("foo").isEmpty();
        assertThat(string).isEmpty();
+        assertThat(string).isEmpty();
        assertThat(string).isEqualTo("foo");
        assertThat(string).isEqualTo("foo");
        assertThat(string).isEqualToIgnoringCase("foo");
@@ -27,6 +28,7 @@ public class StringExpression {

        assertThat(string).as("foo").isNotEmpty();
        assertThat(string).isNotEmpty();
+        assertThat(string).isNotEmpty();
        assertThat(string).isNotEqualTo("foo");
        assertThat(string).isNotEqualTo("foo");
        assertThat(string).isNotEqualToIgnoringCase("foo");
@@ -7,6 +7,7 @@ public class StringExpression {
        StringBuilder stringBuilder = new StringBuilder();

        assertThat(string.isEmpty()).as("foo").isEqualTo(true);
+        assertThat(string.isEmpty()).isNotEqualTo(false);
        assertThat(string.isEmpty()).isTrue();
        assertThat(string.equals("foo")).isEqualTo(true);
        assertThat(string.equals("foo")).isTrue();
@@ -26,6 +27,7 @@ public class StringExpression {
        assertThat(string.endsWith("foo")).isTrue();

        assertThat(string.isEmpty()).as("foo").isEqualTo(false);
+        assertThat(string.isEmpty()).isNotEqualTo(true);
        assertThat(string.isEmpty()).isFalse();
        assertThat(string.equals("foo")).isEqualTo(false);
        assertThat(string.equals("foo")).isFalse();
Author	SHA1	Message	Date
chrisly42	5c455c3ca9	Fix for multiple JUnit Conversions in batch mode with and without delta creating an exception. Added new AssertThatObjectExpression inspection for toString() and hashCode() and moved equals() from AssertThatBinaryExpression there.	2019-06-09 21:35:23 +02:00
chrisly42	6795622202	Finally was able to remove JUnit workaround for test invokation with availability of JUnit 5.5.0-RC1.	2019-06-09 14:17:44 +02:00
chrisly42	828e61a73b	New ImplicitAssertion inspection for implicit isNotNull(), isNotEmpty() and isPresent() assertions that will be covered by chained assertions.	2019-06-09 14:04:01 +02:00
chrisly42	178b7d368a	Extended JUnitAssertToAssertJ inspection to convert JUnit assume-Statements, too. Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.	2019-05-17 12:17:01 +02:00
chrisly42	e797dc2515	Extended documentation about assumeThat() preconditions.	2019-05-16 20:06:14 +02:00
chrisly42	7133c55710	Added Guava Optional opt.orNull() == null case. Added Java 8 Optional opt.orElse(null) == null case, too.	2019-05-15 20:50:30 +02:00
chrisly42	94c695617a	Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.	2019-05-11 13:40:37 +02:00