Updated readme for release. Typofix.

Added PluginVerifier to build.gradle.

LICENSE.TXT

@@ -1,4 +1,4 @@
-Copyright 2019 Chris Hodges <chrisly@platon42.de>
+Copyright 2019-2022 Chris Hodges <chrisly@platon42.de>
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

README.md

@@ -32,7 +32,7 @@ Then AssertJ would tell you the _actual contents_ of the collection on failure.
 
 ## Conversion of JUnit assertions to AssertJ
 
-The plugin also supports the conversion of the most common JUnit 4 and JUnit 5 assertions to AssertJ.
+The plugin also supports the conversion of the most common JUnit 4 assertions to AssertJ.
 
 ## Wrong use of AssertJ
 
@@ -171,6 +171,23 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
     to: assertThat(object).isNotInstanceOf(classname.class);
   ```
 
+- AssertThatIsZeroOne
+
+  Uses ```isZero()```, ```isNotZero()``` and ```isOne()``` instead.
+  Works with shorts, integers, longs, floats and doubles, and tries to evaluate
+  constant expressions, too.
+
+  ```
+  from: assertThat(numeric).isEqualTo(0);
+    to: assertThat(numeric).isZero();
+
+  from: assertThat(numeric).isNotEqualTo(0);
+    to: assertThat(numeric).isNotZero();
+
+  from: assertThat(numeric).isEqualTo(1);
+    to: assertThat(numeric).isOne();
+  ```
+
 - AssertThatStringIsEmpty
 
   Uses ```isEmpty()``` for empty string assertions.
@@ -694,7 +711,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   However, this suggests that the test has actually been run and passed instead of showing the test
   as being skipped.
 
-  Return statements in ```if``` statements in main test methods (must be annotated with JUnit 4 or JUnit 5 or
+  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.
   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.
@@ -731,7 +748,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 - JUnitAssertToAssertJ
 
-  Tries to convert most of the JUnit 4 and JUnit 5 assertions and assumptions 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.
@@ -798,7 +815,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 ## Development notice
 
-Cajon is written in Kotlin 1.4.
+Cajon is written in Kotlin 1.7.
 
 Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one 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.
@@ -814,12 +831,17 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
   from: assertThat(object).extracting("propOne", "propNoGetter", "propTwo.innerProp")...
     to: assertThat(object).extracting(type::getPropOne, it -> it.propNoGetter, it -> it.getPropTwo().getInnerProp())...
   ```
+- Support primitives in assertThat(map.containsKey(1)).isTrue();
 
 ## Changelog
 
-#### V1.13 (unreleased)
+### V1.13 (15-Aug-22)
 
-- Added support for converting JUnit 5 tests to AssertJ
+- Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
+- Tried to fix unreproducible issue #9.
+- Added workaround for upcoming API change in IntelliJ breaking older releases.
+- Added AssertThatIsZeroOne inspection demanded by issue #5.
+- Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
 
 ### V1.12 (06-May-21)
 

build.gradle

@@ -1,13 +1,13 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '1.1.3'
-    id 'org.jetbrains.kotlin.jvm' version '1.5.21'
+    id 'org.jetbrains.intellij' version '1.8.0'
+    id 'org.jetbrains.kotlin.jvm' version '1.7.10'
     id 'jacoco'
-    id 'com.github.kt3k.coveralls' version '2.11.0'
+    id 'com.github.kt3k.coveralls' version '2.12.0'
 }
 
 group 'de.platon42'
-version '1.12.1'
+version '1.13'
 sourceCompatibility = "1.8"
 targetCompatibility = "1.8"
 
@@ -22,10 +22,10 @@ repositories {
 
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testImplementation "org.assertj:assertj-core:3.20.2"
-    testImplementation "org.assertj:assertj-guava:3.4.0"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
+    testImplementation "org.assertj:assertj-core:3.23.1"
+    testImplementation "org.assertj:assertj-guava:3.5.0"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
     testImplementation "org.jetbrains.kotlin:kotlin-reflect"
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
@@ -40,17 +40,26 @@ compileTestKotlin {
 }
 
 intellij {
-    setVersion("2021.1.3") // LATEST-EAP-SNAPSHOT
+    setVersion("2022.2") // LATEST-EAP-SNAPSHOT
     //pluginName.set(provider { 'Concise AssertJ Optimizing Nitpicker (Cajon)' })
     setUpdateSinceUntilBuild(false)
     setPlugins(["com.intellij.java"])
 }
 
+runPluginVerifier {
+    ideVersions = ["IC-193.5662.53", "IC-222.3345.118"] // 2020.3 - 2022.2
+    downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
+}
+
 patchPluginXml {
     setChangeNotes("""
-  <h4>V1.13 (unreleased)</h4>
+  <h4>V1.13 (15-Aug-22)</h4>
     <ul>
-      <li>Added support for converting JUnit 5 tests to AssertJ
+      <li>Maintenance. Updated various dependencies (Kotlin 1.7.10) and AssertJ 3.23.1 and AssertJ-Guava 3.5.0.
+      <li>Tried to fix unreproducible issue #9.
+      <li>Added workaround for upcoming API change in IntelliJ breaking older releases.
+      <li>Added AssertThatIsZeroOne inspection demanded by issue #5.
+      <li>Fix for wrongly joining statements that cannot be trivially joined (e.g. with filteredOn). Fixes issue #6.
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """)
@@ -63,8 +72,12 @@ test {
     }
 }
 
+tasks.test {
+    systemProperty("idea.force.use.core.classloader", "true")
+}
+
 jacoco {
-    toolVersion = '0.8.7'
+    toolVersion = '0.8.8'
 }
 
 jacocoTestReport {

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -12,68 +12,100 @@ class AssertJClassNames {
 
         @NonNls
         const val DESCRIPTABLE_INTERFACE = "org.assertj.core.api.Descriptable"
+
         @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
         const val ASSERT_INTERFACE = "org.assertj.core.api.Assert"
+
         @NonNls
         const val ABSTRACT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractAssert"
+
         @NonNls
         const val ABSTRACT_OBJECT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectAssert"
+
         @NonNls
         const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
+
+        @NonNls
+        const val ABSTRACT_SHORT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortAssert"
+
         @NonNls
         const val ABSTRACT_INTEGER_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntegerAssert"
+
         @NonNls
         const val ABSTRACT_LONG_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongAssert"
+
         @NonNls
         const val ABSTRACT_FLOAT_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatAssert"
+
         @NonNls
         const val ABSTRACT_DOUBLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleAssert"
+
         @NonNls
         const val ABSTRACT_COMPARABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractComparableAssert"
+
         @NonNls
         const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
+
         @NonNls
         const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
+
         @NonNls
         const val ABSTRACT_MAP_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractMapAssert"
+
         @NonNls
         const val ABSTRACT_BOOLEAN_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanArrayAssert"
+
         @NonNls
         const val ABSTRACT_BYTE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractByteArrayAssert"
+
         @NonNls
         const val ABSTRACT_SHORT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractShortArrayAssert"
+
         @NonNls
         const val ABSTRACT_INT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIntArrayAssert"
+
         @NonNls
         const val ABSTRACT_LONG_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractLongArrayAssert"
+
         @NonNls
         const val ABSTRACT_FLOAT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFloatArrayAssert"
+
         @NonNls
         const val ABSTRACT_DOUBLE_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractDoubleArrayAssert"
+
         @NonNls
         const val ABSTRACT_CHAR_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharArrayAssert"
+
         @NonNls
         const val ABSTRACT_OBJECT_ARRAY_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractObjectArrayAssert"
+
         @NonNls
         const val ABSTRACT_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
+
         @NonNls
         const val ABSTRACT_FILE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractFileAssert"
+
         @NonNls
         const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"
+
         @NonNls
         const val EXTRACTORS_CLASSNAME = "org.assertj.core.extractor.Extractors"
 
         @NonNls
         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/CommonMatchers.kt

@@ -50,9 +50,21 @@ val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
     "singleElement", "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
 )!!
 
+val FILTERED_ON = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ITERABLE_ASSERT_CLASSNAME, "filteredOn", "filteredOnNull", "filteredOnAssertions")!!
+
 val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
+    EXTRACTING_CALL_MATCHERS,
     DESCRIBED_AS,
     WITH_REPRESENTATION_AND_SUCH,
+    FILTERED_ON,
+    USING_COMPARATOR,
+    IN_HEXADECIMAL_OR_BINARY
+)!!
+
+val COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE = CallMatcher.anyOf(
+    EXTRACTING_CALL_MATCHERS,
+    WITH_REPRESENTATION_AND_SUCH,
+    FILTERED_ON,
     USING_COMPARATOR,
     IN_HEXADECIMAL_OR_BINARY
 )!!

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

@@ -115,8 +115,7 @@ fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
 }
 
 fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
-    if (argIndex >= argumentList.expressions.size) return null
-    return getArg(argIndex).calculateConstantValue()
+    return getArgOrNull(argIndex)?.calculateConstantValue()
 }
 
 fun PsiExpression.calculateConstantValue(): Any? {

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

@@ -17,19 +17,25 @@ class MethodNames {
 
         @NonNls
         const val AS = "as"
+
         @NonNls
         const val DESCRIBED_AS = "describedAs"
+
         @NonNls
         const val IN_HEXADECIMAL = "inHexadecimal"
+
         @NonNls
         const val IN_BINARY = "inBinary"
 
         @NonNls
         const val IS_EQUAL_TO = "isEqualTo"
+
         @NonNls
         const val IS_NOT_EQUAL_TO = "isNotEqualTo"
+
         @NonNls
         const val IS_SAME_AS = "isSameAs"
+
         @NonNls
         const val IS_NOT_SAME_AS = "isNotSameAs"
 
@@ -38,89 +44,133 @@ class MethodNames {
 
         @NonNls
         const val IS_GREATER_THAN = "isGreaterThan"
+
         @NonNls
         const val IS_GREATER_THAN_OR_EQUAL_TO = "isGreaterThanOrEqualTo"
+
         @NonNls
         const val IS_LESS_THAN = "isLessThan"
+
         @NonNls
         const val IS_LESS_THAN_OR_EQUAL_TO = "isLessThanOrEqualTo"
+
         @NonNls
         const val IS_ZERO = "isZero"
+
         @NonNls
         const val IS_NOT_ZERO = "isNotZero"
+
+        @NonNls
+        const val IS_ONE = "isOne"
+
         @NonNls
         const val IS_TRUE = "isTrue"
+
         @NonNls
         const val IS_FALSE = "isFalse"
+
         @NonNls
         const val IS_NULL = "isNull" // terminal, returns void
+
         @NonNls
         const val IS_NOT_NULL = "isNotNull"
+
         @NonNls
         const val IS_CLOSE_TO = "isCloseTo"
+
         @NonNls
         const val IS_NOT_CLOSE_TO = "isNotCloseTo"
+
         @NonNls
         const val IS_INSTANCE_OF = "isInstanceOf"
+
         @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
         const val IS_NOT_EMPTY = "isNotEmpty"
+
         @NonNls
         const val HAS_SIZE = "hasSize"
+
         @NonNls
         const val HAS_SIZE_LESS_THAN = "hasSizeLessThan"
+
         @NonNls
         const val HAS_SIZE_LESS_THAN_OR_EQUAL_TO = "hasSizeLessThanOrEqualTo"
+
         @NonNls
         const val HAS_SIZE_GREATER_THAN = "hasSizeGreaterThan"
+
         @NonNls
         const val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO = "hasSizeGreaterThanOrEqualTo"
+
         @NonNls
         const val HAS_SAME_SIZE_AS = "hasSameSizeAs"
+
         @NonNls
         const val CONTAINS = "contains"
+
         @NonNls
         const val CONTAINS_ONLY_ONCE = "containsOnlyOnce"
+
         @NonNls
         const val DOES_NOT_CONTAIN = "doesNotContain"
+
         @NonNls
         const val CONTAINS_EXACTLY = "containsExactly"
+
         @NonNls
         const val CONTAINS_ALL = "containsAll"
+
         @NonNls
         const val CONTAINS_KEY = "containsKey"
+
         @NonNls
         const val DOES_NOT_CONTAIN_KEY = "doesNotContainKey"
+
         @NonNls
         const val CONTAINS_VALUE = "containsValue"
+
         @NonNls
         const val DOES_NOT_CONTAIN_VALUE = "doesNotContainValue"
+
         @NonNls
         const val CONTAINS_ENTRY = "containsEntry"
+
         @NonNls
         const val DOES_NOT_CONTAIN_ENTRY = "doesNotContainEntry"
+
         @NonNls
         const val IS_EQUAL_TO_IC = "isEqualToIgnoringCase"
+
         @NonNls
         const val IS_NOT_EQUAL_TO_IC = "isNotEqualToIgnoringCase"
+
         @NonNls
         const val STARTS_WITH = "startsWith"
+
         @NonNls
         const val ENDS_WITH = "endsWith"
+
         @NonNls
         const val DOES_NOT_START_WITH = "doesNotStartWith"
+
         @NonNls
         const val DOES_NOT_END_WITH = "doesNotEndWith"
+
         @NonNls
         const val CONTAINS_SAME = "containsSame"
+
         @NonNls
         const val IS_PRESENT = "isPresent"
+
         @NonNls
         const val IS_NOT_PRESENT = "isNotPresent"
 

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

@@ -15,6 +15,7 @@ import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_D
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_FLOAT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_INTEGER_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_LONG_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_SHORT_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_STRING_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERTIONS_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ASSERT_INTERFACE
@@ -88,6 +89,8 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_EQUAL_TO_STRING = CallMatcher.instanceCall(ABSTRACT_STRING_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes(CommonClassNames.JAVA_LANG_STRING)!!
+        val IS_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
+            .parameterTypes("short")!!
         val IS_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
             .parameterTypes("int")!!
         val IS_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_EQUAL_TO)
@@ -103,6 +106,8 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
         val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes("boolean")!!
+        val IS_NOT_EQUAL_TO_SHORT = CallMatcher.instanceCall(ABSTRACT_SHORT_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
+            .parameterTypes("short")!!
         val IS_NOT_EQUAL_TO_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
             .parameterTypes("int")!!
         val IS_NOT_EQUAL_TO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_EQUAL_TO)
@@ -155,15 +160,15 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterCount(0)!!
         val IS_NOT_ZERO_LONG = CallMatcher.instanceCall(ABSTRACT_LONG_ASSERT_CLASSNAME, MethodNames.IS_NOT_ZERO)
             .parameterCount(0)!!
-        val IS_ONE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
+        val IS_ONE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isOne")
             .parameterCount(0)!!
-        val IS_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
+        val IS_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNegative")
             .parameterCount(0)!!
-        val IS_NOT_NEGATIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
+        val IS_NOT_NEGATIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotNegative")
             .parameterCount(0)!!
-        val IS_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
+        val IS_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isPositive")
             .parameterCount(0)!!
-        val IS_NOT_POSITIVE = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
+        val IS_NOT_POSITIVE_INT = CallMatcher.instanceCall(ABSTRACT_INTEGER_ASSERT_CLASSNAME, "isNotPositive")
             .parameterCount(0)!!
 
         val IS_TRUE = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, MethodNames.IS_TRUE)

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

@@ -8,16 +8,10 @@ abstract class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTo
 
     companion object {
         @NonNls
-        const val JUNIT4_ASSERT_CLASSNAME = "org.junit.Assert"
+        const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
 
         @NonNls
-        const val JUNIT5_ASSERT_CLASSNAME = "org.junit.jupiter.api.Assertions"
-
-        @NonNls
-        const val JUNIT4_ASSUME_CLASSNAME = "org.junit.Assume"
-
-        @NonNls
-        const val JUNIT5_ASSUME_CLASSNAME = "org.junit.jupiter.api.Assumptions"
+        const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
 
         @NonNls
         const val ASSERT_TRUE_METHOD = "assertTrue"

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

@@ -52,7 +52,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
+                MethodNames.IS_GREATER_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
             ),
 
             MoveOutMapping(
@@ -67,7 +67,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE, IS_ONE), replaceFromOriginalMethod = true
+                MethodNames.IS_GREATER_THAN, expectedMatcher = CallMatcher.anyOf(IS_POSITIVE_INT, IS_ONE_INT), replaceFromOriginalMethod = true
             ),
 
             MoveOutMapping(
@@ -82,7 +82,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE, replaceFromOriginalMethod = true
+                MethodNames.IS_LESS_THAN_OR_EQUAL_TO, expectedMatcher = IS_NOT_POSITIVE_INT, replaceFromOriginalMethod = true
             ),
 
             MoveOutMapping(
@@ -97,7 +97,7 @@ class AssertThatComparableInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 COMPARABLE_COMPARE_TO,
-                MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
+                MethodNames.IS_LESS_THAN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
             )
         )
     }

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

@@ -0,0 +1,81 @@
+package de.platon42.intellij.plugins.cajon.inspections
+
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.JavaElementVisitor
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiMethodCallExpression
+import com.intellij.psi.util.TypeConversionUtil
+import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.*
+
+class AssertThatIsZeroOneInspection : AbstractAssertJInspection() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Asserting a zero or one value"
+    }
+
+    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 isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_SHORT, IS_EQUAL_TO_INT, IS_EQUAL_TO_LONG, IS_EQUAL_TO_FLOAT, IS_EQUAL_TO_DOUBLE).test(expression)
+                val isNotEqualTo =
+                    CallMatcher.anyOf(IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_SHORT, IS_NOT_EQUAL_TO_INT, IS_NOT_EQUAL_TO_LONG, IS_NOT_EQUAL_TO_FLOAT, IS_NOT_EQUAL_TO_DOUBLE)
+                        .test(expression)
+
+                if (!(isEqualTo || isNotEqualTo)) return
+
+                val expectedExpression = expression.firstArg
+                if (!TypeConversionUtil.isNumericType(expectedExpression.type)) return
+
+                val expectedResult = expression.calculateConstantParameterValue(0) ?: return
+                var isZero = false
+                var isOne = false
+                when (expectedResult) {
+                    is Short -> {
+                        isZero = (expectedResult == 0.toShort())
+                        isOne = (expectedResult == 1.toShort())
+                    }
+
+                    is Int -> {
+                        isZero = (expectedResult == 0)
+                        isOne = (expectedResult == 1)
+                    }
+
+                    is Long -> {
+                        isZero = (expectedResult == 0L)
+                        isOne = (expectedResult == 1L)
+                    }
+
+                    is Float -> {
+                        isZero = (expectedResult == 0.0f)
+                        isOne = (expectedResult == 1.0f)
+                    }
+
+                    is Double -> {
+                        isZero = (expectedResult == 0.0)
+                        isOne = (expectedResult == 1.0)
+                    }
+                }
+                if (isZero || isOne) {
+                    val numericBaseClass = listOf(
+                        AssertJClassNames.ABSTRACT_SHORT_ASSERT_CLASSNAME,
+                        AssertJClassNames.ABSTRACT_INTEGER_ASSERT_CLASSNAME,
+                        AssertJClassNames.ABSTRACT_LONG_ASSERT_CLASSNAME,
+                        AssertJClassNames.ABSTRACT_FLOAT_ASSERT_CLASSNAME,
+                        AssertJClassNames.ABSTRACT_DOUBLE_ASSERT_CLASSNAME
+                    ).any { checkAssertedType(expression, it) }
+                    if (!numericBaseClass) return
+                }
+                if (isZero) {
+                    registerSimplifyMethod(holder, expression, isEqualTo.map(MethodNames.IS_ZERO, MethodNames.IS_NOT_ZERO))
+                } else if (isOne && isEqualTo) {
+                    registerSimplifyMethod(holder, expression, MethodNames.IS_ONE)
+                }
+            }
+        }
+    }
+}

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

@@ -94,7 +94,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
 
             MoveOutMapping(
                 STRING_INDEX_OF,
-                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE, replaceFromOriginalMethod = true
+                MethodNames.CONTAINS, expectedMatcher = IS_NOT_NEGATIVE_INT, replaceFromOriginalMethod = true
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,
@@ -119,7 +119,7 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,
-                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE, replaceFromOriginalMethod = true
+                MethodNames.DOES_NOT_CONTAIN, expectedMatcher = IS_NEGATIVE_INT, replaceFromOriginalMethod = true
             ),
             MoveOutMapping(
                 STRING_INDEX_OF,

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

@@ -3,8 +3,6 @@ package de.platon42.intellij.plugins.cajon.inspections
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.*
-import com.intellij.psi.CommonClassNames.*
-import com.intellij.psi.PsiKeyword.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.siyeh.ig.callMatcher.CallMatcher
 import com.siyeh.ig.callMatcher.CallMatcher.anyOf
@@ -22,127 +20,94 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
         private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"
 
-        private const val DOUBLE_ARR = "$DOUBLE[]"
-        private const val FLOAT_ARR = "$FLOAT[]"
-
         private val ASSERT_MAPPINGS = listOf(
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(BOOLEAN),
+                    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, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(BOOLEAN),
+                    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, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
+                    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, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_OBJECT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(JAVA_LANG_OBJECT),
+                    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, hasExpected = false
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterTypes("float", "float", "float")
                 ),
                 MethodNames.IS_CLOSE_TO, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_EQUALS_METHOD).parameterCount(2)
                 ),
                 MethodNames.IS_EQUAL_TO
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE, DOUBLE, DOUBLE),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(DOUBLE, DOUBLE, DOUBLE),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT, FLOAT, FLOAT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(FLOAT, FLOAT, FLOAT),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("double", "double", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float", "float", "float"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterTypes("float", "float", "float")
                 ),
                 MethodNames.IS_NOT_CLOSE_TO, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_EQUALS_METHOD).parameterCount(2)
                 ),
                 MethodNames.IS_NOT_EQUAL_TO
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_SAME_METHOD).parameterCount(2)
                 ),
                 MethodNames.IS_SAME_AS
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_SAME_METHOD).parameterCount(2)
                 ),
                 MethodNames.IS_NOT_SAME_AS
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(DOUBLE_ARR, DOUBLE_ARR, DOUBLE),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(JAVA_LANG_STRING, FLOAT_ARR, FLOAT_ARR, FLOAT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(FLOAT_ARR, FLOAT_ARR, FLOAT),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "double[]", "double[]", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("double[]", "double[]", "double"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "float[]", "float[]", "float"),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterTypes("float[]", "float[]", "float")
                 ),
                 MethodNames.CONTAINS_EXACTLY, hasDelta = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
-                    staticCall(JUNIT4_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
-                    staticCall(JUNIT5_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(2),
+                    staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_ARRAY_EQUALS_METHOD).parameterCount(3)
                 ),
                 MethodNames.CONTAINS_EXACTLY
             )
@@ -151,35 +116,26 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
         private val ASSUME_MAPPINGS = listOf(
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(BOOLEAN),
+                    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(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(JAVA_LANG_STRING, BOOLEAN),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(BOOLEAN),
+                    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(
-                anyOf(
-                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
-                ),
+                staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
                 MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
             ),
             Mapping(
                 anyOf(
-                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_STRING, JAVA_LANG_THROWABLE),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE, JAVA_LANG_STRING),
-                    staticCall(JUNIT4_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
-                    staticCall(JUNIT5_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(JAVA_LANG_THROWABLE),
+                    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
             )
@@ -193,41 +149,33 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
             override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
                 super.visitMethodCallExpression(expression)
                 when (expression.resolveMethod()?.containingClass?.qualifiedName) {
-                    JUNIT4_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, false)
-                    JUNIT5_ASSERT_CLASSNAME -> visitMethodCallExpressionAssert(holder, expression, true)
-                    JUNIT4_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, false)
-                    JUNIT5_ASSUME_CLASSNAME -> visitMethodCallExpressionAssume(holder, expression, true)
+                    JUNIT_ASSERT_CLASSNAME -> {
+                        JavaPsiFacade.getInstance(expression.project)
+                            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                        if (mapping.hasDelta) {
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
+                        } else {
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
+                                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
+                            }
+                        }
+                    }
+                    JUNIT_ASSUME_CLASSNAME -> {
+                        JavaPsiFacade.getInstance(expression.project)
+                            .findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
+                        val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
+                        if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
+                            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
+                                ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
+                            }
+                        }
+                    }
                 }
             }
         }
     }
 
-    private fun visitMethodCallExpressionAssert(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
-        JavaPsiFacade.getInstance(expression.project)
-            .findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
-        val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
-        if (mapping.hasDelta) {
-            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
-                ReplaceJUnitDeltaAssertMethodCallQuickFix(desc, method, junit5)
-            }
-        } else {
-            registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
-                ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected, junit5)
-            }
-        }
-    }
-
-    private fun visitMethodCallExpressionAssume(holder: ProblemsHolder, expression: PsiMethodCallExpression, junit5: Boolean) {
-        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, junit5)
-            }
-        }
-    }
-
     private fun registerConvertMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,

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

@@ -72,7 +72,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                     if (!statement.hasAssertThat()) return null
 
                     val assertThatCall = PsiTreeUtil.findChildrenOfType(statement, PsiMethodCallExpression::class.java).find { ALL_ASSERT_THAT_MATCHERS.test(it) }
-                    return assertThatCall?.takeIf { it.findFluentCallTo(EXTRACTING_CALL_MATCHERS) == null }
+                    return assertThatCall?.takeIf { it.findFluentCallTo(COMPLEX_STUFF_THAT_MAKES_JOINING_IMPOSSIBLE) == null }
                 }
                 return null
             }
@@ -83,6 +83,7 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                     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
                     }

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

@@ -56,9 +56,14 @@ class JoinStatementsQuickFix(private val separateLineLimit: Int) : AbstractCommo
     }
 
     private fun addLineBreak(project: Project, lastElementBeforeConcat: PsiElement) {
-        val newLineNode =
+        val newLineNode = try {
+            PsiParserFacade.getInstance(project).createWhiteSpaceFromText("\n\t")
+        } catch (ex: NoSuchMethodError) {
+            // scheduled for removal, but alternate version not even available in 2020.3.
+            // So keep it here until we run into a problem.
+            // Changing the min version from 2017.3 to 2021.x is a major thing.
             PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n\t")
-
+        }
         lastElementBeforeConcat.addAfter(newLineNode, lastElementBeforeConcat.firstChild)
     }
 

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

@@ -7,7 +7,7 @@ import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 
-class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean, private val junit5: Boolean) :
+class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val noExpectedExpression: Boolean) :
     AbstractCommonQuickFix(description) {
 
     companion object {
@@ -23,20 +23,14 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
         val count = args.expressions.size
-        val hasMessage = if (noExpectedExpression) count == 1 else count == 2;
-
-        val actualExpression: PsiExpression
-        val expectedExpressions: Array<PsiExpression>
-        val messageExpression: PsiExpression?
-
-        if (junit5) {
-            actualExpression = args.expressions[if (noExpectedExpression) 0 else 1] ?: return
-            messageExpression = if (hasMessage) null else args.expressions[count - 1]
-            expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[0])
+        val actualExpression = args.expressions[count - 1] ?: return
+        val (expectedExpressions, messageExpression) = if (noExpectedExpression) {
+            val message = args.expressions.getOrNull(count - 2)
+            emptyArray<PsiExpression>() to message
         } else {
-            actualExpression = args.expressions[count - 1] ?: return
-            messageExpression = if (hasMessage) null else args.expressions[0]
-            expectedExpressions = if (noExpectedExpression) emptyArray() else arrayOf(args.expressions[count - 2])
+            val expected = args.expressions[count - 2] ?: return
+            val message = args.expressions.getOrNull(count - 3)
+            arrayOf(expected) to message
         }
 
         val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)

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

@@ -5,7 +5,7 @@ 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, private val junit5: Boolean) :
+class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
     AbstractCommonQuickFix(description) {
 
     companion object {
@@ -21,8 +21,8 @@ class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val repl
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
         val count = args.expressions.size
-        val actualExpression = args.expressions[if (junit5) 0 else count - 1] ?: return
-        val messageExpression = args.expressions.getOrNull(if (junit5) 1 else count - 2)
+        val actualExpression = args.expressions[count - 1] ?: return
+        val messageExpression = args.expressions.getOrNull(count - 2)
 
         val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
         val newMethodCall = createAssumeThat(element, actualExpression)

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

@@ -6,7 +6,7 @@ import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.GUAVA_ASSERTIONS_CLASSNAME
 
-class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String, private val junit5: Boolean) : AbstractCommonQuickFix(description) {
+class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
 
     companion object {
         private const val CONVERT_DESCRIPTION = "Convert JUnit assertions with delta to assertJ"
@@ -21,10 +21,10 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
         val methodCallExpression = element as? PsiMethodCallExpression ?: return
         val args = methodCallExpression.argumentList
         val count = args.expressions.size
-        val messageExpression = args.expressions.getOrNull(if (junit5) 3 else count - 4)
-        val expectedExpression = args.expressions[if (junit5) 0 else count - 3] ?: return
-        val actualExpression = args.expressions[if (junit5) 1 else count - 2] ?: return
-        val deltaExpression = args.expressions[if (junit5) 2 else count - 1] ?: return
+        val messageExpression = args.expressions.getOrNull(count - 4)
+        val expectedExpression = args.expressions[count - 3] ?: return
+        val actualExpression = args.expressions[count - 2] ?: return
+        val deltaExpression = args.expressions[count - 1] ?: return
 
         val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
 

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

@@ -28,6 +28,8 @@
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanConditionInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatInvertedBooleanCondition" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInvertedBooleanConditionInspection"/>
+        <localInspection groupPath="Java" shortName="AssertThatIsZeroOne" enabledByDefault="true" level="WARNING"
+                         implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatIsZeroOneInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatInstanceOf" enabledByDefault="true" level="WARNING"
                          implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatInstanceOfInspection"/>
         <localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"

src/main/resources/inspectionDescriptions/AssertThatIsZeroOne.html

@@ -0,0 +1,8 @@
+<html>
+<body>
+Turns assertThat(numeric).isEqualTo(0/1) into assertThat(numeric).isZero()/isOne()
+or assertThat(numeric).isNotEqualTo(0) into assertThat(numeric).isNotZero().
+<!-- tooltip end -->
+<br>Also works with constant expressions.
+</body>
+</html>

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

@@ -8,6 +8,7 @@ import de.platon42.intellij.jupiter.LightCodeInsightExtension
 import de.platon42.intellij.jupiter.TestDataPath
 import de.platon42.intellij.jupiter.TestJdk
 import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Condition
 import org.junit.jupiter.api.DisplayNameGeneration
 import org.junit.jupiter.api.DisplayNameGenerator
 import org.junit.jupiter.api.extension.ExtendWith
@@ -39,11 +40,8 @@ abstract class AbstractCajonTest {
     }
 
     protected fun assertHighlightings(myFixture: JavaCodeInsightTestFixture, count: Int, snippet: String) {
-        val highlights = myFixture.doHighlighting()
-            .asSequence()
-            .filter { it.description?.contains(snippet) ?: false }
-            .toList()
-        assertThat(highlights).hasSize(count)
+        assertThat(myFixture.doHighlighting())
+            .areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
     }
 
     class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {

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

@@ -0,0 +1,21 @@
+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 AssertThatIsZeroOneInspectionTest : AbstractCajonTest() {
+
+    @Test
+    @TestDataSubPath("inspections/IsZeroOne")
+    internal fun assertThat_with_isEqualTo_zero_or_one_can_use_isZero_or_isOne_plus_isNotZero(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        myFixture.enableInspections(AssertThatIsZeroOneInspection::class.java)
+        myFixture.configureByFile("IsZeroOneBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isZero()"), 10)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isOne()"), 10)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isNotZero()"), 10)
+        myFixture.checkResultByFile("IsZeroOneAfter.java")
+    }
+}

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

@@ -1,23 +0,0 @@
-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(org.junit.jupiter.api.Assertions::class, Assertions::class)
-internal class JUnit5AssertToAssertJInspectionTest : AbstractCajonTest() {
-
-    @Test
-    @TestDataSubPath("inspections/JUnit5AssertToAssertJ")
-    internal fun junit5_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
-        myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
-        myFixture.configureByFile("JUnit5AssertToAssertJInspectionBefore.java")
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
-        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 4)
-        myFixture.checkResultByFile("JUnit5AssertToAssertJInspectionAfter.java")
-    }
-}

src/test/resources/inspections/IsZeroOne/IsZeroOneAfter.java

@@ -0,0 +1,67 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class IsZeroOne {
+
+    private void isZeroOne() {
+        short shortValue = 0;
+        int intValue = 0;
+        long longValue = 0L;
+        float floatValue = 0.0f;
+        double doubleValue = 0.0;
+
+        assertThat(shortValue).as("foo").isZero();
+        assertThat(shortValue).isZero();
+        assertThat(shortValue).as("foo").isOne();
+        assertThat(shortValue).isOne();
+
+        assertThat(shortValue).as("foo").isNotZero();
+        assertThat(shortValue).isNotZero();
+        assertThat(shortValue).as("foo").isNotEqualTo(1);
+        assertThat(shortValue).isNotEqualTo(0 + 1);
+
+        assertThat(intValue).as("foo").isZero();
+        assertThat(intValue).isZero();
+        assertThat(intValue).as("foo").isOne();
+        assertThat(intValue).isOne();
+
+        assertThat(intValue).as("foo").isNotZero();
+        assertThat(intValue).isNotZero();
+        assertThat(intValue).as("foo").isNotEqualTo(1);
+        assertThat(intValue).isNotEqualTo(0 + 1);
+
+        assertThat(longValue).as("foo").isZero();
+        assertThat(longValue).isZero();
+        assertThat(longValue).as("foo").isOne();
+        assertThat(longValue).isOne();
+
+        assertThat(longValue).as("foo").isNotZero();
+        assertThat(longValue).isNotZero();
+        assertThat(longValue).as("foo").isNotEqualTo(1L);
+        assertThat(longValue).isNotEqualTo(0L + 1L);
+
+        assertThat(floatValue).as("foo").isZero();
+        assertThat(floatValue).isZero();
+        assertThat(floatValue).as("foo").isOne();
+        assertThat(floatValue).isOne();
+
+        assertThat(floatValue).as("foo").isNotZero();
+        assertThat(floatValue).isNotZero();
+        assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
+        assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
+
+        assertThat(doubleValue).as("foo").isZero();
+        assertThat(doubleValue).isZero();
+        assertThat(doubleValue).as("foo").isOne();
+        assertThat(doubleValue).isOne();
+
+        assertThat(doubleValue).as("foo").isNotZero();
+        assertThat(doubleValue).isNotZero();
+        assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
+        assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
+
+        assertThat(intValue).as("foo").isEqualTo(2);
+
+        fail("oh no!");
+    }
+}

src/test/resources/inspections/IsZeroOne/IsZeroOneBefore.java

@@ -0,0 +1,67 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class IsZeroOne {
+
+    private void isZeroOne() {
+        short shortValue = 0;
+        int intValue = 0;
+        long longValue = 0L;
+        float floatValue = 0.0f;
+        double doubleValue = 0.0;
+
+        assertThat(shortValue).as("foo").isEqualTo(0);
+        assertThat(shortValue).isEqualTo(1 - 1);
+        assertThat(shortValue).as("foo").isEqualTo(1);
+        assertThat(shortValue).isEqualTo(0 + 1);
+
+        assertThat(shortValue).as("foo").isNotEqualTo(0);
+        assertThat(shortValue).isNotEqualTo(1 - 1);
+        assertThat(shortValue).as("foo").isNotEqualTo(1);
+        assertThat(shortValue).isNotEqualTo(0 + 1);
+
+        assertThat(intValue).as("foo").isEqualTo(0);
+        assertThat(intValue).isEqualTo(1 - 1);
+        assertThat(intValue).as("foo").isEqualTo(1);
+        assertThat(intValue).isEqualTo(0 + 1);
+
+        assertThat(intValue).as("foo").isNotEqualTo(0);
+        assertThat(intValue).isNotEqualTo(1 - 1);
+        assertThat(intValue).as("foo").isNotEqualTo(1);
+        assertThat(intValue).isNotEqualTo(0 + 1);
+
+        assertThat(longValue).as("foo").isEqualTo(0L);
+        assertThat(longValue).isEqualTo(1L - 1L);
+        assertThat(longValue).as("foo").isEqualTo(1L);
+        assertThat(longValue).isEqualTo(0L + 1L);
+
+        assertThat(longValue).as("foo").isNotEqualTo(0L);
+        assertThat(longValue).isNotEqualTo(1L - 1L);
+        assertThat(longValue).as("foo").isNotEqualTo(1L);
+        assertThat(longValue).isNotEqualTo(0L + 1L);
+
+        assertThat(floatValue).as("foo").isEqualTo(0.0f);
+        assertThat(floatValue).isEqualTo(1.0f - 1.0f);
+        assertThat(floatValue).as("foo").isEqualTo(1.0f);
+        assertThat(floatValue).isEqualTo(0.0f + 1.0f);
+
+        assertThat(floatValue).as("foo").isNotEqualTo(0.0f);
+        assertThat(floatValue).isNotEqualTo(1.0f - 1.0f);
+        assertThat(floatValue).as("foo").isNotEqualTo(1.0f);
+        assertThat(floatValue).isNotEqualTo(0.0f + 1.0f);
+
+        assertThat(doubleValue).as("foo").isEqualTo(0.0);
+        assertThat(doubleValue).isEqualTo(1.0 - 1.0);
+        assertThat(doubleValue).as("foo").isEqualTo(1.0);
+        assertThat(doubleValue).isEqualTo(0.0 + 1.0);
+
+        assertThat(doubleValue).as("foo").isNotEqualTo(0.0);
+        assertThat(doubleValue).isNotEqualTo(1.0 - 1.0);
+        assertThat(doubleValue).as("foo").isNotEqualTo(1.0);
+        assertThat(doubleValue).isNotEqualTo(0.0 + 1.0);
+
+        assertThat(intValue).as("foo").isEqualTo(2);
+
+        fail("oh no!");
+    }
+}

src/test/resources/inspections/JUnit5AssertToAssertJ/JUnit5AssertToAssertJInspectionAfter.java

@@ -1,86 +0,0 @@
-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.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assumptions.*;
-
-public class JUnit5AssertToAssertJ {
-
-    private void jUnit5AssertToAssertJ() {
-        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();
-        assertThat(foo == "bar").as("boom!").isFalse();
-
-        assertThat(foo).isNull();
-        assertThat(foo).as("oh no!").isNull();
-        assertThat(foo).isNotNull();
-        assertThat(foo).as("oh no!").isNotNull();
-
-        assertThat(foo).isEqualTo(bar);
-        assertThat(foo).as("equals").isEqualTo(bar);
-        assertThat(foo).isNotEqualTo(bar);
-        assertThat(foo).as("equals").isNotEqualTo(bar);
-
-        assertThat(foo).isSameAs(bar);
-        assertThat(foo).as("same").isSameAs(bar);
-        assertThat(foo).isNotSameAs(bar);
-        assertThat(foo).as("same").isNotSameAs(bar);
-
-        assertThat(2.0).isEqualTo(1.0);
-        assertThat(2.0).isCloseTo(1.0, offset(0.1));
-        assertThat(2.0).as("equals").isEqualTo(1.0);
-        assertThat(2.0).as("equals").isCloseTo(1.0, offset(0.1));
-        assertThat(2.0f).isEqualTo(1.0f);
-        assertThat(2.0f).isCloseTo(1.0f, offset(0.1f));
-        assertThat(2.0f).as("equals").isEqualTo(1.0f);
-        assertThat(2.0f).as("equals").isCloseTo(1.0f, offset(0.1f));
-
-        assertThat(2.0).isNotEqualTo(1.0);
-        assertThat(2.0).isNotCloseTo(1.0, offset(0.1));
-        assertThat(2.0).as("equals").isNotEqualTo(1.0);
-        assertThat(2.0).as("equals").isNotCloseTo(1.0, offset(0.1));
-        assertThat(2.0f).isNotEqualTo(1.0f);
-        assertThat(2.0f).isNotCloseTo(1.0f, offset(0.1f));
-        assertThat(2.0f).as("equals").isNotEqualTo(1.0f);
-        assertThat(2.0f).as("equals").isNotCloseTo(1.0f, offset(0.1f));
-
-        assertThat(new int[1]).containsExactly(new int[2]);
-        assertThat(new int[1]).as("array equals").containsExactly(new int[2]);
-
-        assertThat(new double[1]).containsExactly(new double[2], offset(1.0));
-        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 jUnit5AssumeToAssertJ() {
-        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();
-    }
-}

src/test/resources/inspections/JUnit5AssertToAssertJ/JUnit5AssertToAssertJInspectionBefore.java

@@ -1,83 +0,0 @@
-import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assumptions.*;
-
-public class JUnit5AssertToAssertJ {
-
-    private void jUnit5AssertToAssertJ() {
-        String foo = "foo";
-        String bar = "bar";
-        int someInt = 1;
-        double someDouble = 1.0;
-        float someFloat = 1.0f;
-
-        assertTrue(foo == "foo");
-        assertTrue(foo == "foo", "oh no!");
-        assertFalse(foo == "bar");
-        assertFalse(foo == "bar", "boom!");
-
-        assertNull(foo);
-        assertNull(foo, "oh no!");
-        assertNotNull(foo);
-        assertNotNull(foo, "oh no!");
-
-        assertEquals(bar, foo);
-        assertEquals(bar, foo, "equals");
-        assertNotEquals(bar, foo);
-        assertNotEquals(bar, foo, "equals");
-
-        assertSame(bar, foo);
-        assertSame(bar, foo, "same");
-        assertNotSame(bar, foo);
-        assertNotSame(bar, foo, "same");
-
-        assertEquals(1.0, 2.0);
-        assertEquals(1.0, 2.0, 0.1);
-        assertEquals(1.0, 2.0, "equals");
-        assertEquals(1.0, 2.0, 0.1, "equals");
-        assertEquals(1.0f, 2.0f);
-        assertEquals(1.0f, 2.0f, 0.1f);
-        assertEquals(1.0f, 2.0f, "equals");
-        assertEquals(1.0f, 2.0f, 0.1f, "equals");
-
-        assertNotEquals(1.0, 2.0);
-        assertNotEquals(1.0, 2.0, 0.1);
-        assertNotEquals(1.0, 2.0, "equals");
-        assertNotEquals(1.0, 2.0, 0.1, "equals");
-        assertNotEquals(1.0f, 2.0f);
-        assertNotEquals(1.0f, 2.0f, 0.1f);
-        assertNotEquals(1.0f, 2.0f, "equals");
-        assertNotEquals(1.0f, 2.0f, 0.1f, "equals");
-
-        assertArrayEquals(new int[2], new int[1]);
-        assertArrayEquals(new int[2], new int[1], "array equals");
-
-        assertArrayEquals(new double[2], new double[1], 1.0);
-        assertArrayEquals(new double[2], new double[1], 1.0, "array equals");
-        assertArrayEquals(new float[2], new float[1], 1.0f);
-        assertArrayEquals(new float[2], new float[1], 1.0f, "array equals");
-
-        assertEquals("bar", foo);
-        assertEquals(bar, "foo", "equals");
-        assertNotEquals(bar, "foo");
-        assertNotEquals("bar", foo, "equals");
-
-        assertEquals(someInt, 2);
-        assertEquals(someDouble, 2.0, 0.1);
-        assertEquals(1.0, someDouble, "equals");
-        assertEquals(1.0, someDouble, 0.1, "equals");
-        assertEquals(1.0f, someFloat);
-        assertEquals(someFloat, 2.0f, 0.1f);
-
-        fail();
-        fail("oh no!")
-    }
-
-    private void jUnit5AssumeToAssertJ() {
-        String foo = "foo";
-        String bar = "bar";
-        assumeTrue(foo == "foo");
-        assumeTrue(foo == "foo", "oh no!");
-        assumeFalse(foo == "bar");
-        assumeFalse(foo == "bar", "boom!");
-    }
-}

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

@@ -66,6 +66,9 @@ public class JoinStatements {
         assertThat(list.get(--i)).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
 
+        assertThat(list).filteredOn("foo", "foo").contains("narf");
+        assertThat(list).filteredOn("bar", "bar").contains("puit");
+
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");
     }

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

@@ -63,6 +63,9 @@ public class JoinStatements {
         assertThat(list.get(--i)).isEqualTo("foo");
         assertThat(list.get(--i)).isEqualTo("foo");
 
+        assertThat(list).filteredOn("foo", "foo").contains("narf");
+        assertThat(list).filteredOn("bar", "bar").contains("puit");
+
         org.junit.Assert.assertThat(list, null);
         fail("oh no!");
     }