Updated readme for release. Typofix.

Added PluginVerifier to build.gradle.

.idea/saveactions_settings.xml

@@ -18,6 +18,7 @@
     <option name="configurationPath" value="" />
     <option name="exclusions">
       <set>
+        <option value=".*\.md" />
         <option value="src/test/resources/.*" />
       </set>
     </option>

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

@@ -1,4 +1,4 @@
-# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://travis-ci.org/chrisly42/cajon-plugin.svg?branch=master)](https://travis-ci.org/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
+# Cajon - Concise AssertJ Optimizing Nitpicker [![Build Status](https://travis-ci.com/chrisly42/cajon-plugin.svg?branch=master)](https://travis-ci.com/chrisly42/cajon-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/cajon-plugin/badge.svg?branch=master)](https://coveralls.io/github/chrisly42/cajon-plugin?branch=master)
 
 Cajon is an IntelliJ IDEA Plugin for shortening and optimizing [AssertJ](https://assertj.github.io/doc/) assertions.
 
@@ -160,7 +160,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 - AssertThatInstanceOf
 
   Moves ```instanceof``` expressions out of ```assertThat()```.
-  
+
   ```
   from: assertThat(object instanceof classname).isEqualTo(true);
   from: assertThat(object instanceof classname).isTrue();
@@ -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.
@@ -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.3.
+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,16 +831,33 @@ 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 (15-Aug-22)
+
+- 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)
+
+- Maintenance. Updated various dependencies (Kotlin 1.50.0) and AssertJ 3.19.0
+- Fixed issue#3 reported by hankem where usingRecursiveComparison() was not considered a complex transformation.
+
 #### V1.11 (03-Oct-20) Day of German Unity Edition
+
 - Now is being built with JDK 11 (with Java 8 target).
 - Updated various dependencies (Kotlin 1.40.10) and AssertJ 3.17.2.
-- Fixed the ImplicitAssertion inspection that broke the plugin with IntelliJ 2020.3 EAP as reported by Frédéric Thomas. Thanks!
+- Fixed the ImplicitAssertion inspection that broke the plugin with IntelliJ 2020.3 EAP as reported by Frédéric Thomas.
+  Thanks!
 - Added new singleElement() from AssertJ >= 3.17.0 to ImplicitAssertionInspection.
 - Added several cases for ```hasSizeGreaterThan/LessThan/OrEqualTo()``` for EnumerablesEmpty inspection.
-- Added inversion of boolean conditions inside ```isEqualTo()``` and ```isNotEqualTo()``` for InvertedBooleanCondition inspection.
+- Added inversion of boolean conditions inside ```isEqualTo()``` and ```isNotEqualTo()``` for InvertedBooleanCondition
+  inspection.
 
 #### V1.10 (31-Jul-20) Friday the 31st Edition
 - Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).

build.gradle

@@ -1,13 +1,13 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '0.4.26'
-    id 'org.jetbrains.kotlin.jvm' version '1.4.10'
+    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.10.2'
+    id 'com.github.kt3k.coveralls' version '2.12.0'
 }
 
 group 'de.platon42'
-version '1.11'
+version '1.13'
 sourceCompatibility = "1.8"
 targetCompatibility = "1.8"
 
@@ -22,11 +22,12 @@ repositories {
 
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    testImplementation "org.assertj:assertj-core:3.17.2"
-    testImplementation "org.assertj:assertj-guava:3.4.0"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
+    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"
 }
 
@@ -39,25 +40,29 @@ compileTestKotlin {
 }
 
 intellij {
-    version '2020.2.2' // LATEST-EAP-SNAPSHOT
-//    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
-    updateSinceUntilBuild false
-    plugins = ['java']
+    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 {
-    changeNotes """
-  <h4>V1.11 (03-Oct-20) Day of German Unity Edition</h4>
+    setChangeNotes("""
+  <h4>V1.13 (15-Aug-22)</h4>
     <ul>
-      <li>Now is being built with JDK 11 (with Java 8 target).
-      <li>Updated various dependencies (Kotlin 1.40.10) and AssertJ 3.17.2.
-      <li>Fixed the ImplicitAssertion inspection that broke the plugin with IntelliJ 2020.3 EAP as reported by Frédéric Thomas. Thanks!
-      <li>Added new singleElement() from AssertJ >= 3.17.0 to ImplicitAssertionInspection.
-      <li>Added several cases for hasSizeGreaterThan/LessThan/OrEqualTo() for EnumerablesEmpty inspection.
-      <li>Added inversion of boolean conditions inside isEqualTo() and isNotEqualTo() for InvertedBooleanCondition inspection.
+      <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>
-"""
+""")
 }
 
 test {
@@ -67,17 +72,21 @@ test {
     }
 }
 
+tasks.test {
+    systemProperty("idea.force.use.core.classloader", "true")
+}
+
 jacoco {
-    toolVersion = '0.8.6'
+    toolVersion = '0.8.8'
 }
 
 jacocoTestReport {
     reports {
-        xml.enabled true
-        csv.enabled false
+        xml.required.set(true)
+        csv.required.set(false)
     }
 }
 
 publishPlugin {
-    token intellijPublishToken
+    setToken(intellijPublishToken)
 }

gradle.properties

@@ -1,3 +1,4 @@
 kotlin.code.style=official
 kotlin.incremental=true
-intellijPublishToken=perm:dummy
+intellijPublishToken=perm:dummy
+systemProp.jdk.tls.client.protocols="TLSv1,TLSv1.1,TLSv1.2"

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -72,7 +72,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MINGW* )
+  MSYS* | MINGW* )
     msys=true
     ;;
   NONSTOP* )
@@ -130,7 +130,7 @@ fi
 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    
+
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath

gradlew.bat

@@ -40,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,21 +64,6 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
@@ -86,7 +71,7 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

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

@@ -21,13 +21,27 @@ val EXTRACTING_CALL_MATCHERS = CallMatcher.anyOf(
 
 val DESCRIBED_AS = CallMatcher.instanceCall(AssertJClassNames.DESCRIPTABLE_INTERFACE, MethodNames.DESCRIBED_AS, MethodNames.AS)!!
 val WITH_REPRESENTATION_AND_SUCH = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "withRepresentation", "withThreadDumpOnError")!!
-val USING_COMPARATOR = CallMatcher.instanceCall(AssertJClassNames.ASSERT_INTERFACE, "usingComparator", "usingDefaultComparator")!!
+val USING_COMPARATOR = CallMatcher.anyOf(
+    CallMatcher.instanceCall(
+        AssertJClassNames.ASSERT_INTERFACE,
+        "usingComparator",
+        "usingDefaultComparator"
+    ),
+    CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ASSERT_CLASSNAME, "usingRecursiveComparison"),
+    CallMatcher.instanceCall(
+        AssertJClassNames.ABSTRACT_OBJECT_ASSERT_CLASSNAME,
+        "usingComparatorForFields",
+        "usingComparatorForType"
+    )
+)!!
+
 val IN_HEXADECIMAL_OR_BINARY = CallMatcher.instanceCall(AssertJClassNames.ABSTRACT_ASSERT_CLASSNAME, MethodNames.IN_HEXADECIMAL, MethodNames.IN_BINARY)!!
 val EXTENSION_POINTS = CallMatcher.instanceCall(
     AssertJClassNames.EXTENSION_POINTS_INTERFACE,
     "is", "isNot", "has", "doesNotHave",
     "satisfies"
 )!!
+
 val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
     AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
     "are", "areNot", "have", "doNotHave",
@@ -36,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)
@@ -177,12 +182,12 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
             .parameterCount(0)!!
         val CHAR_SEQUENCE_LENGTH = CallMatcher.instanceCall("java.lang.CharSequence", "length")
             .parameterCount(0)!!
-        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "equals")
+        val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, MethodNames.EQUALS)
             .parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
 
         val OPTIONAL_GET = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "get")
             .parameterCount(0)!!
-        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "isPresent")
+        val OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, MethodNames.IS_PRESENT)
             .parameterCount(0)!!
         val OPTIONAL_OR_ELSE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_OPTIONAL, "orElse")
             .parameterCount(1)!!
@@ -196,7 +201,7 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
 
         val GUAVA_OPTIONAL_GET = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "get")
             .parameterCount(0)!!
-        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "isPresent")
+        val GUAVA_OPTIONAL_IS_PRESENT = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, MethodNames.IS_PRESENT)
             .parameterCount(0)!!
         val GUAVA_OPTIONAL_OR_NULL = CallMatcher.instanceCall(GUAVA_OPTIONAL_CLASSNAME, "orNull")
             .parameterCount(0)!!

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

@@ -4,39 +4,51 @@ import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool
 import com.intellij.psi.PsiMethodCallExpression
 import org.jetbrains.annotations.NonNls
 
-open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool() {
+abstract 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"
+
         @NonNls
         const val ASSERT_FALSE_METHOD = "assertFalse"
+
         @NonNls
         const val ASSERT_NULL_METHOD = "assertNull"
+
         @NonNls
         const val ASSERT_NOT_NULL_METHOD = "assertNotNull"
+
         @NonNls
         const val ASSERT_EQUALS_METHOD = "assertEquals"
+
         @NonNls
         const val ASSERT_NOT_EQUALS_METHOD = "assertNotEquals"
+
         @NonNls
         const val ASSERT_SAME_METHOD = "assertSame"
+
         @NonNls
         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"
 

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/AssertThatEnumerableIsEmptyInspection.kt

@@ -27,9 +27,9 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
                 val value = expression.calculateConstantParameterValue(0) ?: return
 
                 val isEmpty = (CallMatcher.anyOf(HAS_SIZE, HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT).test(expression) && (value == 0)) ||
-                        (HAS_SIZE_LESS_THAN_INT.test(expression) && (value == 1));
+                        (HAS_SIZE_LESS_THAN_INT.test(expression) && (value == 1))
                 val isNotEmpty = (HAS_SIZE_GREATER_THAN_INT.test(expression) && (value == 0)) ||
-                        (HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (value == 1));
+                        (HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (value == 1))
 
                 if (isEmpty && isLastExpression) {
                     registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)

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

@@ -79,25 +79,25 @@ class AssertThatFileExpressionInspection : AbstractMoveOutInspection() {
         private val MAPPINGS_SINCE_ASSERTJ_3_14_0 = listOf(
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isEmpty", expectedMatcher = IS_ZERO_LONG, noExpectedExpression = true
+                MethodNames.IS_EMPTY, expectedMatcher = IS_ZERO_LONG, noExpectedExpression = true
             ),
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isEmpty", expectedMatcher = IS_EQUAL_TO_LONG, noExpectedExpression = true,
+                MethodNames.IS_EMPTY, expectedMatcher = IS_EQUAL_TO_LONG, noExpectedExpression = true,
                 additionalCondition = ARG_IS_ZERO_CONST
             ),
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isNotEmpty", expectedMatcher = IS_NOT_ZERO_LONG, noExpectedExpression = true
+                MethodNames.IS_NOT_EMPTY, expectedMatcher = IS_NOT_ZERO_LONG, noExpectedExpression = true
             ),
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "isNotEmpty", expectedMatcher = IS_NOT_EQUAL_TO_LONG, noExpectedExpression = true,
+                MethodNames.IS_NOT_EMPTY, expectedMatcher = IS_NOT_EQUAL_TO_LONG, noExpectedExpression = true,
                 additionalCondition = ARG_IS_ZERO_CONST
             ),
             MoveOutMapping(
                 CallMatcher.instanceCall(CommonClassNames.JAVA_IO_FILE, "length").parameterCount(0),
-                "hasSize", expectedMatcher = IS_EQUAL_TO_LONG,
+                MethodNames.HAS_SIZE, expectedMatcher = IS_EQUAL_TO_LONG,
                 additionalCondition = ARG_IS_NOT_ZERO_CONST
             )
         )

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/AssertThatPathExpressionInspection.kt

@@ -5,6 +5,7 @@ import com.intellij.psi.JavaElementVisitor
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiExpressionStatement
 import com.siyeh.ig.callMatcher.CallMatcher
+import de.platon42.intellij.plugins.cajon.MethodNames
 
 
 class AssertThatPathExpressionInspection : AbstractMoveOutInspection() {
@@ -19,11 +20,11 @@ class AssertThatPathExpressionInspection : AbstractMoveOutInspection() {
                 "isAbsolute", "isRelative", expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "startsWith").parameterTypes(JAVA_NIO_PATH),
+                CallMatcher.instanceCall(JAVA_NIO_PATH, MethodNames.STARTS_WITH).parameterTypes(JAVA_NIO_PATH),
                 "startsWithRaw", expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(JAVA_NIO_PATH, "endsWith").parameterTypes(JAVA_NIO_PATH),
+                CallMatcher.instanceCall(JAVA_NIO_PATH, MethodNames.ENDS_WITH).parameterTypes(JAVA_NIO_PATH),
                 "endsWithRaw", expectBoolean = true
             ),
             MoveOutMapping(

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

@@ -22,12 +22,12 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
 
         private val MAPPINGS = listOf(
             MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "isEmpty").parameterCount(0),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.IS_EMPTY).parameterCount(0),
                 MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY, expectBoolean = true
             ),
             MoveOutMapping(
                 CallMatcher.anyOf(
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "equals").parameterCount(1),
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.EQUALS).parameterCount(1),
                     CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contentEquals").parameterCount(1)
                 ),
                 MethodNames.IS_EQUAL_TO, MethodNames.IS_NOT_EQUAL_TO, expectBoolean = true
@@ -37,15 +37,15 @@ class AssertThatStringExpressionInspection : AbstractMoveOutInspection() {
                 MethodNames.IS_EQUAL_TO_IC, MethodNames.IS_NOT_EQUAL_TO_IC, expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "contains").parameterCount(1),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.CONTAINS).parameterCount(1),
                 MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN, expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "startsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.STARTS_WITH).parameterTypes(CommonClassNames.JAVA_LANG_STRING),
                 MethodNames.STARTS_WITH, MethodNames.DOES_NOT_START_WITH, expectBoolean = true
             ),
             MoveOutMapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "endsWith").parameterTypes(CommonClassNames.JAVA_LANG_STRING),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, MethodNames.ENDS_WITH).parameterTypes(CommonClassNames.JAVA_LANG_STRING),
                 MethodNames.ENDS_WITH, MethodNames.DOES_NOT_END_WITH, expectBoolean = true
             ),
             MoveOutMapping(
@@ -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/BogusAssertionInspection.kt

@@ -25,16 +25,16 @@ class BogusAssertionInspection : AbstractAssertJInspection() {
             ).parameterCount(1)
 
         private val ARRAY_METHODS = arrayOf(
-            "hasSameSizeAs",
+            MethodNames.HAS_SAME_SIZE_AS,
             MethodNames.CONTAINS,
             "containsAnyOf",
-            "containsExactly",
+            MethodNames.CONTAINS_EXACTLY,
             "containsExactlyInAnyOrder",
             "containsOnly",
             "containsSequence",
             "containsSubsequence",
-            "startsWith",
-            "endsWith"
+            MethodNames.STARTS_WITH,
+            MethodNames.ENDS_WITH
         )
 
         private val SAME_BOOLEAN_ARRAY_CONTENTS =

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

@@ -30,13 +30,13 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
         private val OBJECT_ENUMERABLE_ANY_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
             AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
             MethodNames.CONTAINS, "containsOnly", "containsOnlyNulls", MethodNames.CONTAINS_ONLY_ONCE,
-            "containsExactly", "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
-            "containsAll", "containsAnyOf",
+            MethodNames.CONTAINS_EXACTLY, "containsExactlyInAnyOrder", "containsExactlyInAnyOrderElementsOf",
+            MethodNames.CONTAINS_ALL, "containsAnyOf",
             "containsAnyElementsOf", "containsExactlyElementsOf", "containsOnlyElementsOf",
             "isSubsetOf", "containsSequence", "containsSubsequence",
-            "doesNotContainSequence", "doesNotContainSubsequence", "doesNotContain",
+            "doesNotContainSequence", "doesNotContainSubsequence", MethodNames.DOES_NOT_CONTAIN,
             "doesNotContainAnyElementsOf", "doesNotHaveDuplicates",
-            "startsWith", "endsWith", "containsNull", "doesNotContainNull",
+            MethodNames.STARTS_WITH, MethodNames.ENDS_WITH, "containsNull", "doesNotContainNull",
             "are", "areNot", "have", "doNotHave", "areAtLeastOne", "areAtLeast", "areAtMost", "areExactly",
             "haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
             "hasAtLeastOneElementOfType", "hasOnlyElementsOfType", "hasOnlyElementsOfTypes",
@@ -49,7 +49,7 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
         private val OBJECT_ENUMERABLE_AT_LEAST_ONE_CONTENT_ASSERTIONS = CallMatcher.instanceCall(
             AssertJClassNames.OBJECT_ENUMERABLE_ASSERT_INTERFACE,
             "containsOnlyNulls",
-            "startsWith", "endsWith", "containsNull",
+            MethodNames.STARTS_WITH, MethodNames.ENDS_WITH, "containsNull",
             "areAtLeastOne",
             "haveAtLeastOne",
             "hasAtLeastOneElementOfType",
@@ -72,10 +72,10 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
 
         private val NON_NULL_CORE_ASSERTIONS = CallMatcher.instanceCall(
             AssertJClassNames.ASSERT_INTERFACE,
-            "isInstanceOf", "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
-            "isNotInstanceOf", "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
+            MethodNames.IS_INSTANCE_OF, "isInstanceOfSatisfying", "isInstanceOfAny", "isExactlyInstanceOf", "isOfAnyClassIn",
+            MethodNames.IS_NOT_INSTANCE_OF, "isNotInstanceOfAny", "isNotExactlyInstanceOf", "isNotOfAnyClassIn",
             "hasSameClassAs", "doesNotHaveSameClassAs",
-            "hasToString", "hasSameHashCodeAs"
+            MethodNames.HAS_TO_STRING, "hasSameHashCodeAs"
         )!!
 
         private val GUAVA_IS_PRESENT = CallMatcher.instanceCall(AssertJClassNames.GUAVA_OPTIONAL_ASSERTIONS_CLASSNAME, MethodNames.IS_PRESENT)

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/references/ExtractorReferenceContributor.kt

@@ -70,7 +70,7 @@ class ExtractorReferenceContributor : PsiReferenceContributor() {
     class ExtractorReference(literal: PsiLiteralExpression, range: TextRange, private val targets: List<PsiElement>) :
         PsiPolyVariantReferenceBase<PsiLiteralExpression>(literal, range, true) {
 
-        // Do not remove due to compatiblity issue with IDEA <= 2018.2
+        // Do not remove due to compatibility issue with IDEA <= 2018.2
         override fun getVariants(): Array<Any> {
             return ArrayUtil.EMPTY_OBJECT_ARRAY
         }

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/jupiter/AddLocalJarToModule.java

@@ -6,5 +6,5 @@ import java.lang.annotation.*;
 @Retention(RetentionPolicy.RUNTIME)
 @Inherited
 public @interface AddLocalJarToModule {
-    Class[] value();
+    Class<?>[] value();
 }

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

@@ -2,6 +2,7 @@ package de.platon42.intellij.jupiter;
 
 import com.intellij.jarRepository.JarRepositoryManager;
 import com.intellij.jarRepository.RemoteRepositoryDescription;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
@@ -15,7 +16,10 @@ import com.intellij.openapi.roots.libraries.ui.OrderRoot;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.testFramework.*;
+import com.intellij.testFramework.EdtTestUtilKt;
+import com.intellij.testFramework.LightProjectDescriptor;
+import com.intellij.testFramework.PsiTestUtil;
+import com.intellij.testFramework.TestLoggerFactory;
 import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture;
 import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
@@ -133,15 +137,19 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
         @Override
         public void setUp() throws Exception {
             super.setUp();
+            Store store = getStore(extensionContext);
+            store.put("disposable", Disposer.newDisposable("LightCodeInsightFixtureTestCaseWrapper"));
         }
 
         @Override
         public void tearDown() throws Exception {
-            super.tearDown();
-            UsefulTestCase.clearFields(this);
-            if (myFixture != null && getProject() != null && !getProject().isDisposed()) {
-                Disposer.dispose(getProject());
+            Store store = getStore(extensionContext);
+            Disposable disposable = (Disposable) store.get("disposable");
+            if (myFixture != null && disposable != null) {
+                Disposer.dispose(disposable);
+                store.remove("disposable");
             }
+            super.tearDown();
         }
 
         @NotNull
@@ -172,7 +180,7 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
             };
         }
 
-        void addJarContaining(ModifiableRootModel model, Class clazz) {
+        void addJarContaining(ModifiableRootModel model, Class<?> clazz) {
             try {
                 Path jarPath = Paths.get(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
 

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/TwistedAssertionInspectionTest.kt

@@ -13,7 +13,7 @@ internal class TwistedAssertionInspectionTest : AbstractCajonTest() {
     internal fun hint_twisted_actual_and_expected_and_provide_quickfix_where_possible(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(TwistedAssertionInspection::class.java)
         myFixture.configureByFile("TwistedAssertionBefore.java")
-        assertHighlightings(myFixture, 5, "Actual expression in assertThat() is a constant")
+        assertHighlightings(myFixture, 9, "Actual expression in assertThat() is a constant")
         assertHighlightings(myFixture, 10, "Twisted actual and expected expressions")
 
         executeQuickFixes(myFixture, Regex.fromLiteral("Swap actual and expected expressions in assertion"), 6)

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

src/test/resources/inspections/TwistedAssertion/TwistedAssertionAfter.java

@@ -31,7 +31,11 @@ public class TwistedAssertions {
         assertThat(bar).isEqualTo(foo);
 
         assertThat(4).isEqualTo(number).isNotEqualTo(number * 2);
+        assertThat(4).usingDefaultComparator().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingRecursiveComparison().isGreaterThanOrEqualTo(number);
         assertThat(4).usingComparator(Comparator.reverseOrder()).isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForFields().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForType(Integer::compare).isGreaterThanOrEqualTo(number);
 
         assertThat(String.class).isEqualTo(Class.forName("java.lang.String"));
         assertThat("XX").matches(Pattern.compile(".."));

src/test/resources/inspections/TwistedAssertion/TwistedAssertionBefore.java

@@ -31,7 +31,11 @@ public class TwistedAssertions {
         assertThat(bar).isEqualTo(foo);
 
         assertThat(4).isEqualTo(number).isNotEqualTo(number * 2);
+        assertThat(4).usingDefaultComparator().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingRecursiveComparison().isGreaterThanOrEqualTo(number);
         assertThat(4).usingComparator(Comparator.reverseOrder()).isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForFields().isGreaterThanOrEqualTo(number);
+        assertThat(4).usingComparatorForType(Integer::compare).isGreaterThanOrEqualTo(number);
 
         assertThat(String.class).isEqualTo(Class.forName("java.lang.String"));
         assertThat("XX").matches(Pattern.compile(".."));