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.

README.md

@@ -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,
+  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.
+  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);
+  assertNotNull(object);
-  assertNonNull(message, 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.
+  Implementation is very basic though and does not work with fancy cascaded ```.extracting()``` sequences.
-  If there's demand, I will add it.
+  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).

build.gradle

@@ -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'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.0-RC1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.0'
+    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>Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.
-      <li>Fixed a NPE in AssumeThatInsteadOfReturn inspection quickfix for empty else branches.
+      <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>Fixed missing description for AssumeThatInsteadOfReturn inspection.
+      <li>Added Java 8 Optional opt.orElse(null) == null case, too.
-      <li>Added new AssertThatCollectionOrMapExpression inspection that tries to pull out methods such as isEmpty() or contains() out of an actual assertThat() expression.
+      <li>Extended JUnitAssertToAssertJ inspection to convert JUnit assume statements, too.
-    </ul>
+      <li>Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.
-  <h4>V0.8 (05-May-19)</h4>
+      <li>New ImplicitAssertion inspection for implicit isNotNull(), isNotEmpty() and isPresent() assertions that will be covered by chained assertions.
-    <ul>
+      <li>Fix for multiple JUnit Conversions in batch mode with and without delta creating an exception.
-      <li>Fixed missing description for JoinAssertThatStatements and detection of equivalent expressions (sorry, released it too hastily).
+      <li>Added new AssertThatObjectExpression inspection for toString() and hashCode() and moved equals() from AssertThatBinaryExpression there.
-      <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.
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """

src/main/java/de/platon42/intellij/plugins/cajon/AssertJClassNames.kt

@@ -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"
     }
 }

src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt

@@ -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
@@ -145,4 +163,31 @@ 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
 }

src/main/java/de/platon42/intellij/plugins/cajon/Helper.kt

@@ -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)
 }

src/main/java/de/platon42/intellij/plugins/cajon/MethodNames.kt

@@ -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

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt

@@ -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)!!

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt

@@ -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 {

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt

@@ -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 SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE = "Split binary expression out of assertThat()"
-        private const val MORE_MEANINGFUL_MESSAGE_TEMPLATE = "Moving %s expression out of assertThat() would be more meaningful"
+        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
+                val binaryExpression = staticMethodCall.firstArg as? PsiBinaryExpression ?: return
-                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 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 quickfix = quickFixSupplier(SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE, replacementMethod)
-        val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
+        holder.registerProblem(expression, MORE_MEANINGFUL_MESSAGE_TEMPLATE, quickfix)
-        val quickfix = quickFixSupplier(description, replacementMethod)
-        holder.registerProblem(expression, message, quickfix)
     }
 }

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspection.kt

@@ -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)
+                }
             }
         }
     }

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt

@@ -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
+                        )
+                    }
                 }
             }
 

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspection.kt

@@ -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.*
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiExpressionStatement
-import com.intellij.psi.PsiMethodCallExpression
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
 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)
+                    }
                 }
             }
 

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspection.kt

@@ -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())
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt

@@ -115,8 +115,7 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!expression.hasAssertThat()) {
                     return
                 }
-                val isHasSize = HAS_SIZE.test(expression)
+                if (!HAS_SIZE.test(expression)) {
-                if (!(isHasSize)) {
                     return
                 }
                 val actualExpression = expression.firstArg

src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt

@@ -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)
+                }
             }
         }
     }

src/main/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspection.kt

@@ -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)
+            }
+        }
+    }
+}

src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt

@@ -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,18 +148,28 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         return object : JavaElementVisitor() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
-                val isJUnitAssertCall = expression.resolveMethod()?.containingClass?.qualifiedName == JUNIT_ASSERT_CLASSNAME
+                when (expression.resolveMethod()?.containingClass?.qualifiedName) {
-                if (!isJUnitAssertCall) {
+                    JUNIT_ASSERT_CLASSNAME -> {
-                    return // early exit
+                        JavaPsiFacade.getInstance(expression.project)
-                }
+                            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-                JavaPsiFacade.getInstance(expression.project)
+                        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
-                    .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                        if (mapping.hasDelta) {
-                val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
-                if (mapping.hasDelta) {
+                        } else {
-                    registerConvertMethod(holder, expression, mapping.replacement, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
-                } else {
+                                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
-                    registerConvertMethod(holder, expression, mapping.replacement) { 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
     )
 }

src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt

@@ -35,16 +35,9 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                         reset = (lastActualExpression == null)
                         actualExpression = assertThatCall.firstArg
                         if (!reset) {
-                            val isSame = when (actualExpression) {
+                            val isSame = equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                                is PsiMethodCallExpression -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
+                                    && !hasExpressionWithSideEffects(actualExpression)
-                                        // 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)
-                            }
                             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
+            }
         }
     }
 

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/DeleteMethodCallQuickFix.kt

@@ -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)
+    }
+}

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/HasHashCodeQuickFix.kt

@@ -0,0 +1,37 @@
+package de.platon42.intellij.plugins.cajon.quickfixes
+
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethodCallExpression
+import de.platon42.intellij.plugins.cajon.*
+
+class 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)
+            }
+    }
+}

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/MoveOutMethodCallExpressionQuickFix.kt

@@ -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)

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt

@@ -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 swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)
-        val newMethodCall = createAssertThat(element, actualExpression)
+                && (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)

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssumeMethodCallQuickFix.kt

@@ -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()
+    }
+}

src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt

@@ -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)

src/main/resources/META-INF/plugin.xml

@@ -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>

src/main/resources/inspectionDescriptions/AssertThatBinaryExpression.html

@@ -4,7 +4,6 @@ Turns a binary expression in the kind of assertThat(actual <operator> expe
 into assertThat(actual).is<operator>(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>

src/main/resources/inspectionDescriptions/AssertThatObjectExpression.html

@@ -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>

src/main/resources/inspectionDescriptions/ImplicitAssertion.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>

src/main/resources/inspectionDescriptions/JUnitAssertToAssertJ.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>

src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java

@@ -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.*;
-import com.intellij.testFramework.PsiTestUtil;
+import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
-import com.intellij.testFramework.UsefulTestCase;
 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;
 

src/test/java/de/platon42/intellij/jupiter/WorkaroundUntilJupiterGetsExecutorProvider.java

@@ -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;
-            });
-        }
-    }
-}

src/test/java/de/platon42/intellij/plugins/cajon/AbstractCajonTest.kt

@@ -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)

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspectionTest.kt

@@ -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.enableInspections(AssertThatBinaryExpressionInspection::class.java)
+        myFixture.configureByFile("BinaryExpressionBefore.java")
-            myFixture.configureByFile("BinaryExpressionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 149)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split binary expression out of assertThat()"), 149)
+        myFixture.checkResultByFile("BinaryExpressionAfter.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Split equals() expression out of assertThat()"), 13)
-            myFixture.checkResultByFile("BinaryExpressionAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanConditionInspectionTest.kt

@@ -11,14 +11,12 @@ 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.enableInspections(AssertThatBooleanConditionInspection::class.java)
+        myFixture.configureByFile("BooleanConditionBefore.java")
-            myFixture.configureByFile("BooleanConditionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isTrue()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isFalse()"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isTrue()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isFalse()"), 4)
+        myFixture.checkResultByFile("BooleanConditionAfter.java")
-            myFixture.checkResultByFile("BooleanConditionAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatCollectionOrMapExpressionInspectionTest.kt

@@ -11,19 +11,17 @@ 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.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
-            myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
-            myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt

@@ -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.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
+        myFixture.configureByFile("EnumerableIsEmptyBefore.java")
-            myFixture.configureByFile("EnumerableIsEmptyBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
+        myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
-            myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt

@@ -14,39 +14,35 @@ 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.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        myFixture.configureByFile("GuavaOptionalBefore.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().isPresent() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isAbsent() instead"), 5)
-            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 get() of actual expression and use assertThat().contains() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove orNull() of actual expression and use assertThat().isAbsent() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 6)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 3)
-            myFixture.checkResultByFile("GuavaOptionalAfter.java")
+        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.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-            myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 4)
-            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 4)
+        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
-            executeQuickFixes(myFixture, Regex("Remove .*"), 3)
+        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
-            myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
-        }
     }
 
     @Test
     internal fun adds_missing_Guava_import_isAbsent_first(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        runTest {
+        myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
-            myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
+        myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-            myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
+        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 3)
-            executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 3)
+        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
-            executeQuickFixes(myFixture, Regex("Remove .*"), 3)
+        myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
-            myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspectionTest.kt

@@ -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.enableInspections(AssertThatInstanceOfInspection::class.java)
+        myFixture.configureByFile("InstanceOfBefore.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().isInstanceOf() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove instanceof in actual expression and use assertThat().isNotInstanceOf() instead"), 6)
+        myFixture.checkResultByFile("InstanceOfAfter.java")
-            myFixture.checkResultByFile("InstanceOfAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspectionTest.kt

@@ -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.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
+        myFixture.configureByFile("InvertedBooleanConditionBefore.java")
-            myFixture.configureByFile("InvertedBooleanConditionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
+        myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
-            myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatJava8OptionalInspectionTest.kt

@@ -11,17 +11,17 @@ 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.enableInspections(AssertThatJava8OptionalInspection::class.java)
+        myFixture.configureByFile("Java8OptionalBefore.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().isPresent() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isPresent() of actual expression and use assertThat().isNotPresent() instead"), 5)
-            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 get() of actual expression and use assertThat().contains() instead"), 1)
+        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().containsSame() instead"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().contains() instead"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsSame() instead"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNotPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 1)
-            myFixture.checkResultByFile("Java8OptionalAfter.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap expected expression and replace isEqualTo() with contains()"), 2)
-        }
+        myFixture.checkResultByFile("Java8OptionalAfter.java")
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectExpressionInspectionTest.kt

@@ -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")
+    }
+}

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatObjectIsNullOrNotNullInspectionTest.kt

@@ -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.enableInspections(AssertThatObjectIsNullOrNotNullInspection::class.java)
+        myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
-            myFixture.configureByFile("ObjectIsNullOrNotNullBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isNull()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotNull()"), 5)
+        myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
-            myFixture.checkResultByFile("ObjectIsNullOrNotNullAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt

@@ -13,26 +13,24 @@ 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.enableInspections(AssertThatSizeInspection::class.java)
+        myFixture.configureByFile("SizeBefore.java")
-            myFixture.configureByFile("SizeBefore.java")
+        assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
-            assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
 
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 12)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 12)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 8)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 8)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14)
-            myFixture.checkResultByFile("SizeAfter.java")
+        myFixture.checkResultByFile("SizeAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspectionTest.kt

@@ -11,24 +11,22 @@ 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.enableInspections(AssertThatStringExpressionInspection::class.java)
+        myFixture.configureByFile("StringExpressionBefore.java")
-            myFixture.configureByFile("StringExpressionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isEqualTo() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove 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 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 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 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 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 endsWith() of actual expression and use assertThat().endsWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove equals() of actual expression and use assertThat().isNotEqualTo() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove 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 equalsIgnoreCase() of actual expression and use assertThat().isNotEqualToIgnoringCase() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contentEquals() of actual expression and use assertThat().isNotEqualTo() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().doesNotStartWith() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().doesNotEndWith() instead"), 3)
+        myFixture.checkResultByFile("StringExpressionAfter.java")
-            myFixture.checkResultByFile("StringExpressionAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspectionTest.kt

@@ -13,17 +13,15 @@ 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.enableInspections(AssertThatStringIsEmptyInspection::class.java)
+        myFixture.configureByFile("StringIsEmptyBefore.java")
-            myFixture.configureByFile("StringIsEmptyBefore.java")
+        val highlights = myFixture.doHighlighting()
-            val highlights = myFixture.doHighlighting()
+            .asSequence()
-                .asSequence()
+            .filter { it.description?.contains(" can be simplified to") ?: false }
-                .filter { it.description?.contains(" can be simplified to") ?: false }
+            .toList()
-                .toList()
+        assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
-            assertThat(highlights).hasSize(6).extrakting { it.text }.doesNotContain("assertThat")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 3)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 3)
+        myFixture.checkResultByFile("StringIsEmptyAfter.java")
-            myFixture.checkResultByFile("StringIsEmptyAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssumeThatInsteadOfReturnInspectionTest.kt

@@ -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.enableInspections(AssumeThatInsteadOfReturnInspection::class.java)
+        myFixture.configureByFile("AssumeThatBefore.java")
-            myFixture.configureByFile("AssumeThatBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace if statement by assumeTrue()"), 5)
+        myFixture.checkResultByFile("AssumeThatAfter.java")
-            myFixture.checkResultByFile("AssumeThatAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/ImplicitAssertionInspectionTest.kt

@@ -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")
+    }
+}

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt

@@ -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.enableInspections(JUnitAssertToAssertJInspection::class.java)
+        myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-            myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
+        executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
-            executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 38)
+        executeQuickFixes(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
-            myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
+        myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspectionTest.kt

@@ -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.enableInspections(JoinAssertThatStatementsInspection::class.java)
+        myFixture.configureByFile("JoinStatementsBefore.java")
-            myFixture.configureByFile("JoinStatementsBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Join assertThat() statements"), 5)
+        myFixture.checkResultByFile("JoinStatementsAfter.java")
-            myFixture.checkResultByFile("JoinStatementsAfter.java")
-        }
     }
 }

src/test/java/de/platon42/intellij/plugins/cajon/references/ExtractorReferenceContributorTest.kt

@@ -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")
-            myFixture.configureByFiles("FindReference1.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
-            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")
-            myFixture.configureByFiles("FindReference2.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("protected Address address;")
-            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")
-            myFixture.configureByFiles("FindReference3.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
-            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")
-            myFixture.configureByFiles("FindReference4.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public Boolean getREALLYnoMAILINGS()")
-            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")
-            myFixture.configureByFiles("FindReference5.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public boolean isNoMailings()")
-            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")
-            myFixture.configureByFiles("FindReference6.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
-            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")
-            myFixture.configureByFiles("FindReference7.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
-            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")
-            myFixture.configureByFiles("FindReference8.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).isEqualTo("private String name;")
-            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")
-            myFixture.configureByFiles("FindReference9.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).startsWith("private String street;")
-            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")
-            myFixture.configureByFiles("FindReference10.java", "Address.java", "Contact.java")
+        assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
-            assertThat(myFixture.elementAtCaret.text).startsWith("public String getStreetName()")
-        }
     }
 }

src/test/resources/inspections/BinaryExpression/BinaryExpressionAfter.java

@@ -146,12 +146,12 @@ public class BinaryExpression {
         assertThat(numberObjAct).isGreaterThan(1);
         assertThat(numberObjAct).isGreaterThan(1);
 
-        assertThat(numberObjAct).as("doh!").isEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).as("doh!").isTrue();
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(true);
-        assertThat(numberObjAct).isEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).isNotEqualTo(false);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).isFalse();
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        assertThat(numberObjAct.equals(numberObjExp)).isEqualTo(false);
-        assertThat(numberObjAct).isNotEqualTo(numberObjExp);
+        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.equals(stringExp)).as("doh!").isTrue();
-        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct.equals(stringExp)).isEqualTo(true);
-        assertThat(stringAct).isEqualTo(stringExp);
+        assertThat(stringAct.equals(stringExp)).isNotEqualTo(false);
-        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct.equals(stringExp)).isFalse();
-        assertThat(stringAct).isNotEqualTo(stringExp);
+        assertThat(stringAct.equals(stringExp)).isEqualTo(false);
-        assertThat(stringAct).isNotEqualTo(stringExp);
+        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);
     }
 }

src/test/resources/inspections/GuavaOptional/GuavaOptionalAfter.java

@@ -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"));

src/test/resources/inspections/GuavaOptional/GuavaOptionalBefore.java

@@ -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"));

src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionAfter.java

@@ -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");
+    }
+}

src/test/resources/inspections/ImplicitAssertion/ImplicitAssertionBefore.java

@@ -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");
+    }
+}

src/test/resources/inspections/JUnitAssertToAssertJ/JUnitAssertToAssertJInspectionAfter.java

@@ -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();
     }
 }

src/test/resources/inspections/JUnitAssertToAssertJ/JUnitAssertToAssertJInspectionBefore.java

@@ -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());
     }
 }

src/test/resources/inspections/Java8Optional/Java8OptionalAfter.java

@@ -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);
     }
 }

src/test/resources/inspections/Java8Optional/Java8OptionalBefore.java

@@ -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);
     }
 }

src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java

@@ -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");
     }
 }

src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java

@@ -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");
     }
 }

src/test/resources/inspections/ObjectExpression/ObjectExpressionAfter.java

@@ -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);
+    }
+}

src/test/resources/inspections/ObjectExpression/ObjectExpressionBefore.java

@@ -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);
+    }
+}

src/test/resources/inspections/StringExpression/StringExpressionAfter.java

@@ -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");

src/test/resources/inspections/StringExpression/StringExpressionBefore.java

@@ -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();