Fixes to AssertThatSize inspection after extending it for Maps in previous release as not all combinations for .hasSameSizeAs() are supported.

Bumped to IntelliJ IDEA 2019.2.3.

README.md

@@ -247,6 +247,16 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat(map.get(key)).isNull();
     to: assertThat(map).doesNotContainKey(key);
   ```
+  
+  The last transformation is the default, but may not be 100% equivalent depending whether the map
+  is a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
+  but ```containsKey(key)``` is ```true```.
+  For that special case (which usually is the result of a bad design decision!)
+  the quickfix should rather generate ```assertThat(map).containsEntry(key, null)```.
+  Therefore, the behavior can be configured in the settings for this inspection to either
+  create the default case (```doesNotContainKey```), the degenerated case (```containsEntry```),
+  choosing between both fixes (does not work well for batch processing), or ignore this edge case
+  altogether (just to be sure to not break any code).
 
 - AssertThatEnumerableIsEmpty
 
@@ -302,8 +312,8 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat("string".length()).isLessThan(1);
     to: assertThat("string").isEmpty();
 
-  from: assertThat("string".length()).isEqualTo(map.size())
-    to: assertThat("string").hasSameSizeAs(map);
+  from: assertThat(map.size()).isEqualTo(anotherMap.size())
+    to: assertThat(map).hasSameSizeAs(anotherMap);
     
   from: assertThat("string".length()).hasSize("strong".length())
     to: assertThat("string").hasSameSizeAs("strong");
@@ -554,10 +564,20 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 ## Changelog
 
+#### V1.5 (24-Sep-19)
+- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception.
+- AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
+  for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
+- Added an settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with ```null``` values.
+  It is now possible to change the behavior for ```map.get(key) == null```, so it can offer either ```.doesNotContainKey()``` (default)
+  or ```.containsEntry(key, null)```, or even both.
+- Fixes to AssertThatSize inspection after extending it for Maps in previous release as not all
+  combinations for ```.hasSameSizeAs()``` are supported.
+
 #### V1.4 (25-Aug-19)
 - Minor fix for highlighting of JoinVarArgsContains inspection.
 - Extended AssertThatSize inspection to Maps, too.
-- Extended AssertThatCollectionOrMap inspection for several ```assertThat(map.get())``` cases as suggested by Stefan H.
+- Extended AssertThatCollectionOrMap inspection for several ```assertThat(map.get())``` cases as suggested by Georgij G.
 
 #### V1.3 (03-Aug-19)
 - New JoinVarArgsContains inspection that will detect multiple ```.contains()```, ```.doesNotContain()```,

build.gradle

@@ -7,7 +7,7 @@ plugins {
 }
 
 group 'de.platon42'
-version '1.4'
+version '1.5'
 
 repositories {
     mavenCentral()
@@ -22,8 +22,8 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     testCompile "org.assertj:assertj-core:3.13.2"
     testCompile "org.assertj:assertj-guava:3.2.1"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.1'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
 }
@@ -35,7 +35,7 @@ compileTestKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
 intellij {
-    version '2019.2.1'
+    version '2019.2.3'
 //    pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
     updateSinceUntilBuild false
     plugins = ['java']
@@ -43,11 +43,16 @@ intellij {
 
 patchPluginXml {
     changeNotes """
-  <h4>V1.4 (25-Aug-19)</h4>
+  <h4>V1.5 (24-Sep-19)</h4>
     <ul>
-      <li>Minor fix for highlighting of JoinVarArgsContains inspection.
-      <li>Extended AssertThatSize inspection to Maps, too.
-      <li>Extended AssertThatCollectionOrMap inspection for several assertThat(map.get()) cases as suggested by Stefan H.
+      <li>Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception.
+      <li>AssertThatGuavaOptional inspections will now avoid conversions from .get() to .contains()
+          for array types (currently not correctly supported by AssertJ-Guava).
+      <li>Added an settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with null values.
+          It is now possible to change the behavior for map.get(key) == null, so it can offer either .doesNotContainKey() (default)
+          or .containsEntry(key, null), or even both.
+      <li>Fixes to AssertThatSize inspection after extending it for Maps in previous release as not all
+          combinations for .hasSameSizeAs() are supported.
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
 """

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

@@ -42,6 +42,8 @@ class AssertJClassNames {
         @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_ITERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractIterableAssert"
         @NonNls
         const val ABSTRACT_OPTIONAL_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractOptionalAssert"

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

@@ -102,6 +102,10 @@ class MethodNames {
         @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"

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

@@ -227,6 +227,20 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         holder.registerProblem(expression, message, quickfix)
     }
 
+    protected fun registerMoveOutMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldActualExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String) -> List<LocalQuickFix>
+    ) {
+        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
+        val description = MOVE_ACTUAL_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
+        val quickfixes = quickFixSupplier(description)
+        holder.registerProblem(expression, message, *quickfixes.toTypedArray())
+    }
+
     protected fun registerReplaceMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,

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

@@ -1,15 +1,22 @@
 package de.platon42.intellij.plugins.cajon.inspections
 
 import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.openapi.ui.ComboBox
 import com.intellij.psi.*
+import com.intellij.util.ui.FormBuilder
 import com.siyeh.ig.callMatcher.CallMatcher
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.quickfixes.MoveOutMethodCallExpressionQuickFix
+import java.awt.BorderLayout
+import javax.swing.JComponent
+import javax.swing.JPanel
+
 
 class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting a collection or map specific expression"
+        private const val DEFAULT_MAP_VALUES_NEVER_NULL = 2
 
         private val MAP_GET_MATCHER = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "get").parameterCount(1)
 
@@ -34,25 +41,25 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
         private val MAPPINGS = listOf(
             Mapping(
                 CallMatcher.anyOf(
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "isEmpty").parameterCount(0),
-                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "isEmpty").parameterCount(0)
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.IS_EMPTY).parameterCount(0),
+                    CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.IS_EMPTY).parameterCount(0)
                 ),
                 MethodNames.IS_EMPTY, MethodNames.IS_NOT_EMPTY
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "contains").parameterCount(1),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS).parameterCount(1),
                 MethodNames.CONTAINS, MethodNames.DOES_NOT_CONTAIN
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "containsAll").parameterCount(1),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, MethodNames.CONTAINS_ALL).parameterCount(1),
                 MethodNames.CONTAINS_ALL, null
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "containsKey").parameterCount(1),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_KEY).parameterCount(1),
                 MethodNames.CONTAINS_KEY, MethodNames.DOES_NOT_CONTAIN_KEY
             ),
             Mapping(
-                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "containsValue").parameterCount(1),
+                CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, MethodNames.CONTAINS_VALUE).parameterCount(1),
                 MethodNames.CONTAINS_VALUE, MethodNames.DOES_NOT_CONTAIN_VALUE
             )
         )
@@ -60,6 +67,9 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
 
     override fun getDisplayName() = DISPLAY_NAME
 
+    @JvmField
+    var behaviorForMapValueEqualsNull: Int = DEFAULT_MAP_VALUES_NEVER_NULL
+
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : JavaElementVisitor() {
             override fun visitExpressionStatement(statement: PsiExpressionStatement) {
@@ -67,22 +77,60 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
                 if (!statement.hasAssertThat()) return
                 val staticMethodCall = statement.findStaticMethodCall() ?: return
 
-                val assertThatArgument = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
+                val assertThatArgument = staticMethodCall.getArgOrNull(0) as? PsiMethodCallExpression ?: return
                 val expectedCallExpression = statement.findOutmostMethodCall() ?: return
                 if (MAP_GET_MATCHER.test(assertThatArgument)) {
                     val nullOrNotNull = expectedCallExpression.getAllTheSameNullNotNullConstants()
-                    if (nullOrNotNull != null) {
-                        val replacementMethod = nullOrNotNull.map("containsKey", "doesNotContainKey")
-                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, replacementMethod) { desc, method ->
+                    if (nullOrNotNull == true) {
+                        registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_KEY) { desc, method ->
                             MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
                         }
+                    } else if (nullOrNotNull == false) {
+                        when (behaviorForMapValueEqualsNull) {
+                            1 -> // warning only
+                                registerMoveOutMethod(
+                                    holder,
+                                    expectedCallExpression,
+                                    assertThatArgument,
+                                    ""
+                                ) { _ -> emptyList() }
+                            2 -> // as doesNotContainKey(key)
+                                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.DOES_NOT_CONTAIN_KEY) { desc, method ->
+                                    MoveOutMethodCallExpressionQuickFix(desc, method, useNullNonNull = true)
+                                }
+                            3 -> // as containsEntry(key, null)
+                                registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_ENTRY) { desc, method ->
+                                    MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true, useNullNonNull = true)
+                                }
+                            4 -> // both
+                                registerMoveOutMethod(
+                                    holder,
+                                    expectedCallExpression,
+                                    assertThatArgument,
+                                    MethodNames.DOES_NOT_CONTAIN_KEY + "/" + MethodNames.CONTAINS_ENTRY
+                                ) { desc ->
+                                    listOf(
+                                        MoveOutMethodCallExpressionQuickFix(
+                                            "Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)",
+                                            MethodNames.DOES_NOT_CONTAIN_KEY,
+                                            useNullNonNull = true
+                                        ),
+                                        MoveOutMethodCallExpressionQuickFix(
+                                            "Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)",
+                                            MethodNames.CONTAINS_ENTRY,
+                                            keepExpectedAsSecondArgument = true,
+                                            useNullNonNull = true
+                                        )
+                                    )
+                                }
+                        }
                     } else {
                         if (ANY_IS_EQUAL_TO_MATCHER.test(expectedCallExpression)) {
-                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, "containsEntry") { desc, method ->
+                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.CONTAINS_ENTRY) { desc, method ->
                                 MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true)
                             }
                         } else if (ANY_IS_NOT_EQUAL_TO_MATCHER.test(expectedCallExpression)) {
-                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, "doesNotContainEntry") { desc, method ->
+                            registerMoveOutMethod(holder, expectedCallExpression, assertThatArgument, MethodNames.DOES_NOT_CONTAIN_ENTRY) { desc, method ->
                                 MoveOutMethodCallExpressionQuickFix(desc, method, keepExpectedAsSecondArgument = true)
                             }
                         }
@@ -102,6 +150,20 @@ class AssertThatCollectionOrMapExpressionInspection : AbstractAssertJInspection(
         }
     }
 
+    override fun createOptionsPanel(): JComponent {
+        val comboBox = ComboBox(
+            arrayOf("ignore", "warning only, no fixes", "as doesNotContainKey(key)", "as containsEntry(key, null)", "both choices")
+        )
+        comboBox.selectedIndex = behaviorForMapValueEqualsNull
+        comboBox.addActionListener { behaviorForMapValueEqualsNull = comboBox.selectedIndex }
+        val panel = JPanel(BorderLayout())
+        panel.add(
+            FormBuilder.createFormBuilder().addLabeledComponent("Fix get() on maps expecting null values:", comboBox).panel,
+            BorderLayout.NORTH
+        )
+        return panel
+    }
+
     private class Mapping(
         val callMatcher: CallMatcher,
         val replacementForTrue: String,

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

@@ -29,6 +29,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
                 val actualExpression = staticMethodCall.firstArg as? PsiMethodCallExpression ?: return
                 val outmostMethodCall = statement.findOutmostMethodCall() ?: return
                 if (GUAVA_OPTIONAL_GET.test(actualExpression)) {
+                    if (actualExpression.resolveMethod()?.returnType is PsiArrayType) return
                     val expectedCallExpression = staticMethodCall.gatherAssertionCalls().singleOrNull() ?: return
                     if (CallMatcher.anyOf(IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_STRING).test(expectedCallExpression)) {
                         registerMoveOutMethod(holder, outmostMethodCall, actualExpression, MethodNames.CONTAINS) { desc, method ->

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

@@ -5,6 +5,7 @@ import com.intellij.psi.*
 import de.platon42.intellij.plugins.cajon.*
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_ITERABLE_ASSERT_CLASSNAME
+import de.platon42.intellij.plugins.cajon.AssertJClassNames.Companion.ABSTRACT_MAP_ASSERT_CLASSNAME
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceHasSizeMethodCallQuickFix
 import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickFix
 
@@ -34,7 +35,7 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                     && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
         }
 
-        fun getMatch(expression: PsiMethodCallExpression, isForArrayCollectionOrMap: Boolean, isForString: Boolean): Match? {
+        fun getMatch(expression: PsiMethodCallExpression, isForArrayOrCollection: Boolean, isForMap: Boolean, isForString: Boolean): Match? {
             val isLastExpression = expression.parent is PsiStatement
             val constValue = expression.calculateConstantParameterValue(0)
             if (IS_EQUAL_TO_INT.test(expression)) {
@@ -42,10 +43,11 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                     Match(expression, MethodNames.IS_EMPTY, noExpectedExpression = true)
                 } else {
                     val equalToExpression = expression.firstArg
-                    val equalsArrayCollectionOrMapSize = isArrayLength(equalToExpression) ||
-                            isCollectionSize(equalToExpression) || isMapSize(equalToExpression)
-                    if (isForArrayCollectionOrMap && equalsArrayCollectionOrMapSize ||
-                        isForString && (equalsArrayCollectionOrMapSize || isCharSequenceLength(equalToExpression))
+                    val equalsArrayOrCollectionSize = isArrayLength(equalToExpression) ||
+                            isCollectionSize(equalToExpression)
+                    if ((isForArrayOrCollection && equalsArrayOrCollectionSize)
+                        || (isForMap && (equalsArrayOrCollectionSize || isMapSize(equalToExpression)))
+                        || (isForString && (equalsArrayOrCollectionSize || isCharSequenceLength(equalToExpression)))
                     ) {
                         Match(expression, MethodNames.HAS_SAME_SIZE_AS, expectedIsCollection = true)
                     } else {
@@ -83,12 +85,13 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!ASSERT_THAT_INT.test(staticMethodCall)) return
 
                 val actualExpression = staticMethodCall.firstArg
-                val isForArrayCollectionOrMap = isArrayLength(actualExpression) || isCollectionSize(actualExpression) || isMapSize(actualExpression)
+                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForMap = isMapSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (!(isForArrayCollectionOrMap || isForString)) return
+                if (!(isForArrayOrCollection || isForMap || isForString)) return
 
                 val matches = staticMethodCall.collectMethodCallsUpToStatement()
-                    .mapNotNull { getMatch(it, isForArrayCollectionOrMap, isForString) }
+                    .mapNotNull { getMatch(it, isForArrayOrCollection, isForMap, isForString) }
                     .toList()
                 if (matches.isNotEmpty()) {
                     if (matches.size == 1) {
@@ -116,9 +119,11 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!HAS_SIZE.test(expression)) return
                 val actualExpression = expression.firstArg
 
-                val isForArrayCollectionOrMap = isArrayLength(actualExpression) || isCollectionSize(actualExpression) || isMapSize(actualExpression)
+                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForMap = isMapSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (!(isForArrayCollectionOrMap
+                if (!(isForArrayOrCollection
+                            || (isForMap && checkAssertedType(expression, ABSTRACT_MAP_ASSERT_CLASSNAME))
                             || (isForString && checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)))
                 ) return
 

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

@@ -2,6 +2,7 @@ package de.platon42.intellij.plugins.cajon.quickfixes
 
 import com.intellij.codeInspection.ProblemDescriptor
 import com.intellij.openapi.project.Project
+import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiMethodCallExpression
 import de.platon42.intellij.plugins.cajon.*
 
@@ -30,7 +31,8 @@ class MoveOutMethodCallExpressionQuickFix(
 
         if (keepExpectedAsSecondArgument) {
             assertExpressionArg ?: return
-            val secondArg = outmostCallExpression.getArgOrNull(0)?.copy() ?: return
+            val secondArg =
+                if (useNullNonNull) JavaPsiFacade.getElementFactory(project).createExpressionFromText("null", null) else outmostCallExpression.getArgOrNull(0)?.copy() ?: return
 
             assertExpression.replace(assertExpression.qualifierExpression)
 

src/main/resources/inspectionDescriptions/AssertThatCollectionOrMapExpression.html

@@ -6,5 +6,13 @@ assertThat(map.get(key)).isEqualTo/isNotEqualTo(value) into assertThat(map).cont
 <br>someMethod() can be isEmpty(), contains(), and containsAll() for collections and
 isEmpty(), containsKey(), and containsValue() for maps.
 get() may be transformed into containsKey(), doesNotContainKey(), containsEntry() or doesNotContainEntry().
+<br>
+If you are using degenerated maps in your project that may contain null values (i.e.
+map.contains(key) == true AND map.get(key) == null
+is valid for some entries in your map), the default behavior of the quickfix
+assertThat(map.get(key)).isNull() turning into assertThat(map).doesNotContainKey(key)
+is not an equivalent transformation. The settings below can change this behavior to instead transform it into
+assertThat(map).containsEntry(key, null) for those cases, create both quickfix choices or simply ignore this
+case altogether (if in doubt).
 </body>
 </html>

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

@@ -1,5 +1,6 @@
 package de.platon42.intellij.plugins.cajon
 
+import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.pom.java.LanguageLevel
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import de.platon42.intellij.jupiter.AddLocalJarToModule
@@ -21,10 +22,20 @@ import java.lang.reflect.Method
 abstract class AbstractCajonTest {
 
     protected fun executeQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
+        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
+        assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
+        quickfixes.forEach(myFixture::launchAction)
+    }
+
+    protected fun executeQuickFixesNoFamilyNameCheck(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
+        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
+        quickfixes.forEach(myFixture::launchAction)
+    }
+
+    protected fun getQuickFixes(myFixture: JavaCodeInsightTestFixture, regex: Regex, expectedFixes: Int): List<IntentionAction> {
         val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
         assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
-        quickfixes.forEach { it.familyName }
-        quickfixes.forEach(myFixture::launchAction)
+        return quickfixes
     }
 
     class CutOffFixtureDisplayNameGenerator : DisplayNameGenerator.ReplaceUnderscores() {

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

@@ -4,12 +4,13 @@ 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.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 
+@TestDataSubPath("inspections/CollectionMapExpression")
 internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajonTest() {
 
     @Test
-    @TestDataSubPath("inspections/CollectionMapExpression")
     internal fun assertThat_with_certain_Collection_and_Map_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(AssertThatCollectionOrMapExpressionInspection::class.java)
         myFixture.configureByFile("CollectionMapExpressionBefore.java")
@@ -28,4 +29,76 @@ internal class AssertThatCollectionOrMapExpressionInspectionTest : AbstractCajon
         executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 4)
         myFixture.checkResultByFile("CollectionMapExpressionAfter.java")
     }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_Null_values(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 3
+        myFixture.enableInspections(inspection)
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isEmpty() instead"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().contains() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsAll() of actual expression and use assertThat().containsAll() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().containsKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().containsValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove isEmpty() of actual expression and use assertThat().isNotEmpty() instead"), 5)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove contains() of actual expression and use assertThat().doesNotContain() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsKey() of actual expression and use assertThat().doesNotContainKey() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove containsValue() of actual expression and use assertThat().doesNotContainValue() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 6)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+        myFixture.checkResultByFile("CollectionMapExpressionWithNullValuesAfter.java")
+    }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_no_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 0
+
+        myFixture.enableInspections(inspection)
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+    }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_only_warnings_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 1
+
+        myFixture.enableInspections(inspection)
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        val highlights = myFixture.doHighlighting()
+            .asSequence()
+            .filter { it.description == "Moving get() expression out of assertThat() would be more concise" }
+            .filter {
+                it.quickFixActionRanges?.any { innerit -> innerit.first.action.text.contains("Inspection 'Asserting a collection or map specific expression") } ?: true
+            }
+            .toList()
+        assertThat(highlights).hasSize(4)
+
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+    }
+
+    @Test
+    internal fun assertThat_with_certain_Collection_and_Map_methods_with_both_quickfixes_for_get_equals_null(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+        val inspection = AssertThatCollectionOrMapExpressionInspection()
+        inspection.behaviorForMapValueEqualsNull = 4
+
+        myFixture.enableInspections(inspection)
+        myFixture.configureByFile("CollectionMapExpressionBefore.java")
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead (regular map)"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsEntry(key, null) instead (degenerated map)"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainEntry() instead"), 2)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().containsKey() instead"), 4)
+        getQuickFixes(myFixture, Regex.fromLiteral("Remove get() of actual expression and use assertThat().doesNotContainKey() instead"), 0)
+    }
 }

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

@@ -31,8 +31,8 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
     internal fun adds_missing_Guava_import_any_order(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
         myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 4)
-        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 4)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
         myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
 
@@ -41,8 +41,8 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
         myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
         myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
-        executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 3)
-        executeQuickFixes(myFixture, Regex("Remove .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex(".*eplace .* with .*"), 3)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Remove .*"), 3)
         myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
     }
 }

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

@@ -24,13 +24,13 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 19)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 11)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 15)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 15)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
         executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 21)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 17)
         myFixture.checkResultByFile("SizeAfter.java")
     }
 }

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

@@ -16,9 +16,9 @@ internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
     internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(ImplicitAssertionInspection::class.java)
         myFixture.configureByFile("ImplicitAssertionBefore.java")
-        executeQuickFixes(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 101)
-        executeQuickFixes(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
-        executeQuickFixes(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 101)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
         myFixture.checkResultByFile("ImplicitAssertionAfter.java")
     }
 }

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

@@ -17,8 +17,8 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
     internal fun junit_Assertions_can_be_converted_into_AssertJ(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
         myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-        executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
-        executeQuickFixes(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+        executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
         myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
     }
 }

src/test/resources/inspections/CollectionMapExpression/CollectionMapExpressionWithNullValuesAfter.java

@@ -0,0 +1,63 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+import java.util.*;
+
+public class CollectionMapExpression {
+
+    private void collectionMapExpression() {
+        List<String> stringList = new ArrayList<>();
+        List<String> anotherList = new ArrayList<>();
+        Map<String, Integer> keyValueMap = new HashMap<>();
+
+        assertThat(stringList).as("foo").isEmpty();
+        assertThat(stringList).isEmpty();
+        assertThat(stringList).contains("foo");
+        assertThat(stringList).contains("foo");
+        assertThat(stringList).containsAll(anotherList);
+        assertThat(stringList).containsAll(anotherList);
+
+        assertThat(stringList).as("foo").isNotEmpty();
+        assertThat(stringList).isNotEmpty();
+        assertThat(stringList).doesNotContain("foo");
+        assertThat(stringList).doesNotContain("foo");
+        assertThat(stringList.containsAll(anotherList)).isEqualTo(false);
+        assertThat(stringList.containsAll(anotherList)).isFalse();
+
+        assertThat(keyValueMap).as("foo").isEmpty();
+        assertThat(keyValueMap).isEmpty();
+        assertThat(keyValueMap).containsKey("foo");
+        assertThat(keyValueMap).containsKey("foo");
+        assertThat(keyValueMap).containsValue(2);
+        assertThat(keyValueMap).containsValue(2);
+
+        assertThat(keyValueMap).as("foo").isNotEmpty();
+        assertThat(keyValueMap).isNotEmpty();
+        assertThat(keyValueMap).doesNotContainKey("foo");
+        assertThat(keyValueMap).doesNotContainKey("foo");
+        assertThat(keyValueMap).doesNotContainValue(2);
+        assertThat(keyValueMap).doesNotContainValue(2);
+
+        assertThat(keyValueMap).containsEntry("foo", 2);
+        assertThat(keyValueMap).doesNotContainEntry("foo", 3);
+        assertThat(keyValueMap).containsEntry("foo", null);
+        assertThat(keyValueMap).containsEntry("foo", null);
+        assertThat(keyValueMap).containsKey("foo");
+        assertThat(keyValueMap).containsKey("foo");
+
+        Map<String, String> stringStringMap = new HashMap<>();
+        assertThat(stringStringMap).containsEntry("foo", "bar");
+        assertThat(stringStringMap).doesNotContainEntry("foo", "bar");
+        assertThat(stringStringMap).containsEntry("foo", null);
+        assertThat(stringStringMap).containsEntry("foo", null);
+        assertThat(stringStringMap).containsKey("foo");
+        assertThat(stringStringMap).containsKey("foo");
+
+        assertThat(stringList).as("foo").isNotEmpty().as("bar").isNotEmpty();
+        assertThat(stringList.isEmpty()).as("foo").isEqualTo(false).as("bar").isTrue();
+        assertThat(stringList.isEmpty()).as("foo").satisfies(it -> it.booleanValue()).as("bar").isFalse();
+
+        org.junit.Assert.assertThat(stringList, null);
+        fail("oh no!");
+    }
+}

src/test/resources/inspections/Size/SizeAfter.java

@@ -26,9 +26,9 @@ public class Size {
         assertThat(list).isEmpty();
         assertThat(list).hasSameSizeAs(otherList);
         assertThat(list).hasSameSizeAs(array);
-        assertThat(list).hasSize(string.length());
-        assertThat(list).hasSize(stringBuilder.length());
-        assertThat(list).hasSameSizeAs(map);
+        assertThat(list).hasSize(string.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(list).hasSize(stringBuilder.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(list).hasSize(map.size()); // does currently not support hasSameSizeAs() in assertj
         assertThat(list).hasSize(1);
         assertThat(list).hasSizeGreaterThan(otherList.size() * 2);
         assertThat(list).hasSizeGreaterThanOrEqualTo(otherList.size() * 2);
@@ -36,9 +36,9 @@ public class Size {
         assertThat(list).hasSizeLessThanOrEqualTo(otherList.size() * 2);
         assertThat(list).hasSameSizeAs(otherList);
         assertThat(list).hasSameSizeAs(array);
-        assertThat(list).hasSize(string.length());
-        assertThat(list).hasSize(stringBuilder.length());
-        assertThat(list).hasSameSizeAs(map);
+        assertThat(list).hasSize(string.length()); // currently unsupported in assertj
+        assertThat(list).hasSize(stringBuilder.length()); // currently unsupported in assertj
+        assertThat(list).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(array).isEmpty();
         assertThat(array).isEmpty();
@@ -49,9 +49,9 @@ public class Size {
         assertThat(array).isEmpty();
         assertThat(array).hasSameSizeAs(list);
         assertThat(array).hasSameSizeAs(otherArray);
-        assertThat(array).hasSize(string.length());
-        assertThat(array).hasSize(stringBuilder.length());
-        assertThat(array).hasSameSizeAs(map);
+        assertThat(array).hasSize(string.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(array).hasSize(stringBuilder.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(array).hasSize(map.size()); // does currently not support hasSameSizeAs() in assertj
         assertThat(array).hasSize(1);
         assertThat(array).hasSizeGreaterThan(otherArray.length - 1);
         assertThat(array).hasSizeGreaterThanOrEqualTo(otherArray.length + 1);
@@ -59,9 +59,9 @@ public class Size {
         assertThat(array).hasSizeLessThanOrEqualTo(1 - otherArray.length);
         assertThat(array).hasSameSizeAs(list);
         assertThat(array).hasSameSizeAs(otherArray);
-        assertThat(array).hasSize(string.length());
-        assertThat(array).hasSize(stringBuilder.length());
-        assertThat(array).hasSameSizeAs(map);
+        assertThat(array).hasSize(string.length()); // currently unsupported in assertj
+        assertThat(array).hasSize(stringBuilder.length()); // currently unsupported in assertj
+        assertThat(array).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(string).isEmpty();
         assertThat(string).isEmpty();
@@ -74,7 +74,7 @@ public class Size {
         assertThat(string).hasSameSizeAs(array);
         assertThat(string).hasSameSizeAs(string);
         assertThat(string).hasSameSizeAs(stringBuilder);
-        assertThat(string).hasSameSizeAs(map);
+        assertThat(string).hasSize(map.size()); // currently unsupported in assertj
         assertThat(string).hasSize(1);
         assertThat(string).hasSizeGreaterThan(array.length - 1);
         assertThat(string).hasSizeGreaterThanOrEqualTo(array.length + 1);
@@ -84,7 +84,7 @@ public class Size {
         assertThat(string).hasSameSizeAs(array);
         assertThat(string).hasSameSizeAs(string);
         assertThat(string).hasSameSizeAs(stringBuilder);
-        assertThat(string).hasSameSizeAs(map);
+        assertThat(string).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(stringBuilder).isEmpty();
         assertThat(stringBuilder).isEmpty();
@@ -97,7 +97,7 @@ public class Size {
         assertThat(stringBuilder).hasSameSizeAs(array);
         assertThat(stringBuilder).hasSameSizeAs(string);
         assertThat(stringBuilder).hasSameSizeAs(stringBuilder);
-        assertThat(stringBuilder).hasSameSizeAs(map);
+        assertThat(stringBuilder).hasSize(map.size()); // does currently not support hasSameSizeAs() in assertj
         assertThat(stringBuilder).hasSize(1);
         assertThat(stringBuilder).hasSizeGreaterThan(array.length - 1);
         assertThat(stringBuilder).hasSizeGreaterThanOrEqualTo(array.length + 1);
@@ -107,7 +107,7 @@ public class Size {
         assertThat(stringBuilder).hasSameSizeAs(array);
         assertThat(stringBuilder).hasSameSizeAs(string);
         assertThat(stringBuilder).hasSameSizeAs(stringBuilder);
-        assertThat(stringBuilder).hasSameSizeAs(map);
+        assertThat(stringBuilder).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(map).isEmpty();
         assertThat(map).isEmpty();
@@ -118,8 +118,8 @@ public class Size {
         assertThat(map).isEmpty();
         assertThat(map).hasSameSizeAs(list);
         assertThat(map).hasSameSizeAs(array);
-        assertThat(map).hasSize(string.length());
-        assertThat(map).hasSize(stringBuilder.length());
+        assertThat(map).hasSize(string.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(map).hasSize(stringBuilder.length()); // does currently not support hasSameSizeAs() in assertj
         assertThat(map).hasSameSizeAs(otherMap);
         assertThat(map).hasSize(1);
         assertThat(map).hasSizeGreaterThan(array.length - 1);
@@ -128,8 +128,8 @@ public class Size {
         assertThat(map).hasSizeLessThanOrEqualTo(1 - array.length);
         assertThat(map).hasSameSizeAs(list);
         assertThat(map).hasSameSizeAs(array);
-        assertThat(map).hasSize(string.length());
-        assertThat(map).hasSize(stringBuilder.length());
+        assertThat(map).hasSize(string.length()); // currently unsupported in assertj
+        assertThat(map).hasSize(stringBuilder.length()); // currently unsupported in assertj
         assertThat(map).hasSameSizeAs(otherMap);
 
         assertThat(stringBuilder.length()).as("foo").isEqualTo(0).isZero().as("bar").isNotZero().isEqualTo(10);

src/test/resources/inspections/Size/SizeBefore.java

@@ -26,9 +26,9 @@ public class Size {
         assertThat(list.size()).isLessThanOrEqualTo(0);
         assertThat(list.size()).isEqualTo(otherList.size());
         assertThat(list.size()).isEqualTo(array.length);
-        assertThat(list.size()).isEqualTo(string.length());
-        assertThat(list.size()).isEqualTo(stringBuilder.length());
-        assertThat(list.size()).isEqualTo(map.size());
+        assertThat(list.size()).isEqualTo(string.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(list.size()).isEqualTo(stringBuilder.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(list.size()).isEqualTo(map.size()); // does currently not support hasSameSizeAs() in assertj
         assertThat(list.size()).isEqualTo(1);
         assertThat(list.size()).isGreaterThan(otherList.size() * 2);
         assertThat(list.size()).isGreaterThanOrEqualTo(otherList.size() * 2);
@@ -36,9 +36,9 @@ public class Size {
         assertThat(list.size()).isLessThanOrEqualTo(otherList.size() * 2);
         assertThat(list).hasSize(otherList.size());
         assertThat(list).hasSize(array.length);
-        assertThat(list).hasSize(string.length());
-        assertThat(list).hasSize(stringBuilder.length());
-        assertThat(list).hasSize(map.size());
+        assertThat(list).hasSize(string.length()); // currently unsupported in assertj
+        assertThat(list).hasSize(stringBuilder.length()); // currently unsupported in assertj
+        assertThat(list).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(array.length).isEqualTo(0);
         assertThat(array.length).isZero();
@@ -49,9 +49,9 @@ public class Size {
         assertThat(array.length).isLessThanOrEqualTo(0);
         assertThat(array.length).isEqualTo(list.size());
         assertThat(array.length).isEqualTo(otherArray.length);
-        assertThat(array.length).isEqualTo(string.length());
-        assertThat(array.length).isEqualTo(stringBuilder.length());
-        assertThat(array.length).isEqualTo(map.size());
+        assertThat(array.length).isEqualTo(string.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(array.length).isEqualTo(stringBuilder.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(array.length).isEqualTo(map.size()); // does currently not support hasSameSizeAs() in assertj
         assertThat(array.length).isEqualTo(1);
         assertThat(array.length).isGreaterThan(otherArray.length - 1);
         assertThat(array.length).isGreaterThanOrEqualTo(otherArray.length + 1);
@@ -59,9 +59,9 @@ public class Size {
         assertThat(array.length).isLessThanOrEqualTo(1 - otherArray.length);
         assertThat(array).hasSize(list.size());
         assertThat(array).hasSize(otherArray.length);
-        assertThat(array).hasSize(string.length());
-        assertThat(array).hasSize(stringBuilder.length());
-        assertThat(array).hasSize(map.size());
+        assertThat(array).hasSize(string.length()); // currently unsupported in assertj
+        assertThat(array).hasSize(stringBuilder.length()); // currently unsupported in assertj
+        assertThat(array).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(string.length()).isEqualTo(0);
         assertThat(string.length()).isZero();
@@ -74,7 +74,7 @@ public class Size {
         assertThat(string.length()).isEqualTo(array.length);
         assertThat(string.length()).isEqualTo(string.length());
         assertThat(string.length()).isEqualTo(stringBuilder.length());
-        assertThat(string.length()).isEqualTo(map.size());
+        assertThat(string.length()).isEqualTo(map.size()); // currently unsupported in assertj
         assertThat(string.length()).isEqualTo(1);
         assertThat(string.length()).isGreaterThan(array.length - 1);
         assertThat(string.length()).isGreaterThanOrEqualTo(array.length + 1);
@@ -84,7 +84,7 @@ public class Size {
         assertThat(string).hasSize(array.length);
         assertThat(string).hasSize(string.length());
         assertThat(string).hasSize(stringBuilder.length());
-        assertThat(string).hasSize(map.size());
+        assertThat(string).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(stringBuilder.length()).isEqualTo(0);
         assertThat(stringBuilder.length()).isZero();
@@ -97,7 +97,7 @@ public class Size {
         assertThat(stringBuilder.length()).isEqualTo(array.length);
         assertThat(stringBuilder.length()).isEqualTo(string.length());
         assertThat(stringBuilder.length()).isEqualTo(stringBuilder.length());
-        assertThat(stringBuilder.length()).isEqualTo(map.size());
+        assertThat(stringBuilder.length()).isEqualTo(map.size()); // does currently not support hasSameSizeAs() in assertj
         assertThat(stringBuilder.length()).isEqualTo(1);
         assertThat(stringBuilder.length()).isGreaterThan(array.length - 1);
         assertThat(stringBuilder.length()).isGreaterThanOrEqualTo(array.length + 1);
@@ -107,7 +107,7 @@ public class Size {
         assertThat(stringBuilder).hasSize(array.length);
         assertThat(stringBuilder).hasSize(string.length());
         assertThat(stringBuilder).hasSize(stringBuilder.length());
-        assertThat(stringBuilder).hasSize(map.size());
+        assertThat(stringBuilder).hasSize(map.size()); // currently unsupported in assertj
 
         assertThat(map.size()).isEqualTo(0);
         assertThat(map.size()).isZero();
@@ -118,8 +118,8 @@ public class Size {
         assertThat(map.size()).isLessThanOrEqualTo(0);
         assertThat(map.size()).isEqualTo(list.size());
         assertThat(map.size()).isEqualTo(array.length);
-        assertThat(map.size()).isEqualTo(string.length());
-        assertThat(map.size()).isEqualTo(stringBuilder.length());
+        assertThat(map.size()).isEqualTo(string.length()); // does currently not support hasSameSizeAs() in assertj
+        assertThat(map.size()).isEqualTo(stringBuilder.length()); // does currently not support hasSameSizeAs() in assertj
         assertThat(map.size()).isEqualTo(otherMap.size());
         assertThat(map.size()).isEqualTo(1);
         assertThat(map.size()).isGreaterThan(array.length - 1);
@@ -128,8 +128,8 @@ public class Size {
         assertThat(map.size()).isLessThanOrEqualTo(1 - array.length);
         assertThat(map).hasSize(list.size());
         assertThat(map).hasSize(array.length);
-        assertThat(map).hasSize(string.length());
-        assertThat(map).hasSize(stringBuilder.length());
+        assertThat(map).hasSize(string.length()); // currently unsupported in assertj
+        assertThat(map).hasSize(stringBuilder.length()); // currently unsupported in assertj
         assertThat(map).hasSize(otherMap.size());
 
         assertThat(stringBuilder.length()).as("foo").isEqualTo(0).isZero().as("bar").isNotZero().isEqualTo(10);