Extended AssertThatSize inspection to Maps, too.

README.md

@@ -243,7 +243,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
 
 - AssertThatSize
 
-  Makes assertions on sizes of arrays, collections, strings, 
+  Makes assertions on sizes of arrays, collections, maps, strings, 
   or ```CharSequence```s more concise.
 
   ```
@@ -280,14 +280,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
   from: assertThat(array.length).isGreaterThanOrEqualTo(expression);
     to: assertThat(array).hasSizeGreaterThanOrEqualTo(expression);
   ```
-  and analogously for collections, strings and CharSequences, e.g:
+  and analogously for collections, maps, strings and CharSequences, e.g:
 
   ```
   from: assertThat("string".length()).isLessThan(1);
     to: assertThat("string").isEmpty();
 
-  from: assertThat("string".length()).isEqualTo(collection.size())
+  from: assertThat("string".length()).isEqualTo(map.size())
-    to: assertThat("string").hasSameSizeAs(collection);
+    to: assertThat("string").hasSameSizeAs(map);
     
   from: assertThat("string".length()).hasSize("strong".length())
     to: assertThat("string").hasSameSizeAs("strong");
@@ -539,6 +539,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
 
 #### V1.4 (unreleased)
 - Minor fix for highlighting of JoinVarArgsContains inspection.
+- Extended AssertThatSize inspection to Maps, too.
 
 #### V1.3 (03-Aug-19)
 - New JoinVarArgsContains inspection that will detect multiple ```.contains()```, ```.doesNotContain()```,

build.gradle

@@ -46,6 +46,7 @@ patchPluginXml {
   <h4>V1.4 (unreleased)</h4>
     <ul>
       <li>Minor fix for highlighting of JoinVarArgsContains inspection.
+      <li>Extended AssertThatSize inspection to Maps, too.
     </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/inspections/AbstractAssertJInspection.kt

@@ -130,6 +130,8 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
 
         val COLLECTION_SIZE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_COLLECTION, "size")
             .parameterCount(0)!!
+        val MAP_SIZE = CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "size")
+            .parameterCount(0)!!
         val CHAR_SEQUENCE_LENGTH = CallMatcher.instanceCall("java.lang.CharSequence", "length")
             .parameterCount(0)!!
         val OBJECT_EQUALS = CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_OBJECT, "equals")

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

@@ -11,7 +11,7 @@ import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceSizeMethodCallQuickF
 class AssertThatSizeInspection : AbstractAssertJInspection() {
 
     companion object {
-        private const val DISPLAY_NAME = "Asserting the size of an collection, array or string"
+        private const val DISPLAY_NAME = "Asserting the size of an collection, map, array or string"
         private const val REMOVE_SIZE_DESCRIPTION_TEMPLATE = "Remove size determination of expected expression and replace %s() with %s()"
         private const val REMOVE_ALL_MESSAGE = "Try to operate on the iterable itself rather than its size"
 
@@ -26,13 +26,15 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
 
         private fun isCollectionSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && COLLECTION_SIZE.test(expression)
 
+        private fun isMapSize(expression: PsiExpression) = (expression is PsiMethodCallExpression) && MAP_SIZE.test(expression)
+
         private fun isArrayLength(expression: PsiExpression): Boolean {
             val psiReferenceExpression = expression as? PsiReferenceExpression ?: return false
             return ((psiReferenceExpression.qualifierExpression?.type is PsiArrayType)
                     && ((psiReferenceExpression.resolve() as? PsiField)?.name == "length"))
         }
 
-        fun getMatch(expression: PsiMethodCallExpression, isForArrayOrCollection: Boolean, isForString: Boolean): Match? {
+        fun getMatch(expression: PsiMethodCallExpression, isForArrayCollectionOrMap: Boolean, isForString: Boolean): Match? {
             val isLastExpression = expression.parent is PsiStatement
             val constValue = expression.calculateConstantParameterValue(0)
             if (IS_EQUAL_TO_INT.test(expression)) {
@@ -40,8 +42,10 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                     Match(expression, MethodNames.IS_EMPTY, noExpectedExpression = true)
                 } else {
                     val equalToExpression = expression.firstArg
-                    if (isForArrayOrCollection && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression)) ||
+                    val equalsArrayCollectionOrMapSize = isArrayLength(equalToExpression) ||
-                        isForString && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression) || isCharSequenceLength(equalToExpression))
+                            isCollectionSize(equalToExpression) || isMapSize(equalToExpression)
+                    if (isForArrayCollectionOrMap && equalsArrayCollectionOrMapSize ||
+                        isForString && (equalsArrayCollectionOrMapSize || isCharSequenceLength(equalToExpression))
                     ) {
                         Match(expression, MethodNames.HAS_SAME_SIZE_AS, expectedIsCollection = true)
                     } else {
@@ -79,12 +83,12 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!ASSERT_THAT_INT.test(staticMethodCall)) return
 
                 val actualExpression = staticMethodCall.firstArg
-                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForArrayCollectionOrMap = isArrayLength(actualExpression) || isCollectionSize(actualExpression) || isMapSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (!(isForArrayOrCollection || isForString)) return
+                if (!(isForArrayCollectionOrMap || isForString)) return
 
                 val matches = staticMethodCall.collectMethodCallsUpToStatement()
-                    .mapNotNull { getMatch(it, isForArrayOrCollection, isForString) }
+                    .mapNotNull { getMatch(it, isForArrayCollectionOrMap, isForString) }
                     .toList()
                 if (matches.isNotEmpty()) {
                     if (matches.size == 1) {
@@ -112,9 +116,9 @@ class AssertThatSizeInspection : AbstractAssertJInspection() {
                 if (!HAS_SIZE.test(expression)) return
                 val actualExpression = expression.firstArg
 
-                val isForArrayOrCollection = isArrayLength(actualExpression) || isCollectionSize(actualExpression)
+                val isForArrayCollectionOrMap = isArrayLength(actualExpression) || isCollectionSize(actualExpression) || isMapSize(actualExpression)
                 val isForString = isCharSequenceLength(actualExpression)
-                if (!(isForArrayOrCollection
+                if (!(isForArrayCollectionOrMap
                             || (isForString && checkAssertedType(expression, ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME)))
                 ) return
 

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

@@ -15,7 +15,7 @@ class ReplaceHasSizeMethodCallQuickFix(description: String, private val replacem
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val methodCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
 
-        replaceCollectionSizeOrArrayLength(methodCallExpression.firstArg)
+        replaceCollectionAndMapSizeOrArrayLength(methodCallExpression.firstArg)
 
         val expectedExpression = createExpectedMethodCall(methodCallExpression, replacementMethod, methodCallExpression.firstArg)
 
@@ -23,7 +23,7 @@ class ReplaceHasSizeMethodCallQuickFix(description: String, private val replacem
         methodCallExpression.replace(expectedExpression)
     }
 
-    private fun replaceCollectionSizeOrArrayLength(assertExpression: PsiExpression) {
+    private fun replaceCollectionAndMapSizeOrArrayLength(assertExpression: PsiExpression) {
         assertExpression.replace(
             when (assertExpression) {
                 is PsiReferenceExpression -> assertExpression.qualifierExpression!!

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

@@ -26,10 +26,10 @@ class ReplaceSizeMethodCallQuickFix(
         val outmostCallExpression = descriptor.startElement as? PsiMethodCallExpression ?: return
         val assertThatMethodCall = outmostCallExpression.findStaticMethodCall() ?: return
         val assertExpression = assertThatMethodCall.firstArg
-        replaceCollectionSizeOrArrayLength(assertExpression)
+        replaceCollectionAndMapSizeOrArrayLength(assertExpression)
 
         if (expectedIsCollection) {
-            replaceCollectionSizeOrArrayLength(outmostCallExpression.firstArg)
+            replaceCollectionAndMapSizeOrArrayLength(outmostCallExpression.firstArg)
         }
 
         val args = if (noExpectedExpression) emptyArray() else arrayOf(outmostCallExpression.firstArg)
@@ -39,7 +39,7 @@ class ReplaceSizeMethodCallQuickFix(
         outmostCallExpression.replace(expectedExpression)
     }
 
-    private fun replaceCollectionSizeOrArrayLength(assertExpression: PsiExpression) {
+    private fun replaceCollectionAndMapSizeOrArrayLength(assertExpression: PsiExpression) {
         assertExpression.replace(
             when (assertExpression) {
                 is PsiReferenceExpression -> assertExpression.qualifierExpression!!

src/main/resources/inspectionDescriptions/AssertThatSize.html

@@ -1,6 +1,6 @@
 <html>
 <body>
-Makes assertions on sizes of arrays, collections, strings, or CharSequences more concise by replacing them with isEmpty(), isNotEmpty(), hasSize(), or hasSameSizeAs().
+Makes assertions on sizes of arrays, collections, maps, strings, or CharSequences more concise by replacing them with isEmpty(), isNotEmpty(), hasSize(), or hasSameSizeAs().
 <!-- tooltip end -->
 <br>Several more conversions are available with AssertJ 3.12.0 or later.
 </body>

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

@@ -12,25 +12,25 @@ internal class AssertThatSizeInspectionTest : AbstractCajonTest() {
 
     @Test
     @TestDataSubPath("inspections/Size")
-    internal fun assertThat_size_of_array_or_collection_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
+    internal fun assertThat_size_of_array_collection_or_map_can_be_simplified(@MyFixture myFixture: JavaCodeInsightTestFixture) {
         myFixture.enableInspections(AssertThatSizeInspection::class.java)
         myFixture.configureByFile("SizeBefore.java")
         assertThat(myFixture.doHighlighting()).extrakting { it.description }.containsOnlyOnce("Try to operate on the iterable itself rather than its size")
 
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 12)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 19)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 8)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 11)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 4)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 5)
-        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14)
+        executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 21)
         myFixture.checkResultByFile("SizeAfter.java")
     }
 }

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

@@ -1,4 +1,6 @@
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
@@ -12,6 +14,8 @@ public class Size {
         long[] otherArray = new long[4];
         String string = "string";
         StringBuilder stringBuilder = new StringBuilder();
+        Map<String, Integer> map = new HashMap<>();
+        Map<String, Integer> otherMap = new HashMap<>();
 
         assertThat(list).isEmpty();
         assertThat(list).isEmpty();
@@ -24,6 +28,7 @@ public class Size {
         assertThat(list).hasSameSizeAs(array);
         assertThat(list).hasSize(string.length());
         assertThat(list).hasSize(stringBuilder.length());
+        assertThat(list).hasSameSizeAs(map);
         assertThat(list).hasSize(1);
         assertThat(list).hasSizeGreaterThan(otherList.size() * 2);
         assertThat(list).hasSizeGreaterThanOrEqualTo(otherList.size() * 2);
@@ -33,6 +38,7 @@ public class Size {
         assertThat(list).hasSameSizeAs(array);
         assertThat(list).hasSize(string.length());
         assertThat(list).hasSize(stringBuilder.length());
+        assertThat(list).hasSameSizeAs(map);
 
         assertThat(array).isEmpty();
         assertThat(array).isEmpty();
@@ -45,6 +51,7 @@ public class Size {
         assertThat(array).hasSameSizeAs(otherArray);
         assertThat(array).hasSize(string.length());
         assertThat(array).hasSize(stringBuilder.length());
+        assertThat(array).hasSameSizeAs(map);
         assertThat(array).hasSize(1);
         assertThat(array).hasSizeGreaterThan(otherArray.length - 1);
         assertThat(array).hasSizeGreaterThanOrEqualTo(otherArray.length + 1);
@@ -54,6 +61,7 @@ public class Size {
         assertThat(array).hasSameSizeAs(otherArray);
         assertThat(array).hasSize(string.length());
         assertThat(array).hasSize(stringBuilder.length());
+        assertThat(array).hasSameSizeAs(map);
 
         assertThat(string).isEmpty();
         assertThat(string).isEmpty();
@@ -63,18 +71,20 @@ public class Size {
         assertThat(string).isEmpty();
         assertThat(string).isEmpty();
         assertThat(string).hasSameSizeAs(list);
-        assertThat(string).hasSameSizeAs(otherArray);
-        assertThat(string).hasSameSizeAs(string);
-        assertThat(string).hasSameSizeAs(stringBuilder);
-        assertThat(string).hasSize(1);
-        assertThat(string).hasSizeGreaterThan(otherArray.length - 1);
-        assertThat(string).hasSizeGreaterThanOrEqualTo(otherArray.length + 1);
-        assertThat(string).hasSizeLessThan(otherArray.length - 3);
-        assertThat(string).hasSizeLessThanOrEqualTo(1 - otherArray.length);
-        assertThat(string).hasSameSizeAs(otherList);
         assertThat(string).hasSameSizeAs(array);
         assertThat(string).hasSameSizeAs(string);
         assertThat(string).hasSameSizeAs(stringBuilder);
+        assertThat(string).hasSameSizeAs(map);
+        assertThat(string).hasSize(1);
+        assertThat(string).hasSizeGreaterThan(array.length - 1);
+        assertThat(string).hasSizeGreaterThanOrEqualTo(array.length + 1);
+        assertThat(string).hasSizeLessThan(array.length - 3);
+        assertThat(string).hasSizeLessThanOrEqualTo(1 - array.length);
+        assertThat(string).hasSameSizeAs(list);
+        assertThat(string).hasSameSizeAs(array);
+        assertThat(string).hasSameSizeAs(string);
+        assertThat(string).hasSameSizeAs(stringBuilder);
+        assertThat(string).hasSameSizeAs(map);
 
         assertThat(stringBuilder).isEmpty();
         assertThat(stringBuilder).isEmpty();
@@ -84,18 +94,43 @@ public class Size {
         assertThat(stringBuilder).isEmpty();
         assertThat(stringBuilder).isEmpty();
         assertThat(stringBuilder).hasSameSizeAs(list);
-        assertThat(stringBuilder).hasSameSizeAs(otherArray);
-        assertThat(stringBuilder).hasSameSizeAs(string);
-        assertThat(stringBuilder).hasSameSizeAs(stringBuilder);
-        assertThat(stringBuilder).hasSize(1);
-        assertThat(stringBuilder).hasSizeGreaterThan(otherArray.length - 1);
-        assertThat(stringBuilder).hasSizeGreaterThanOrEqualTo(otherArray.length + 1);
-        assertThat(stringBuilder).hasSizeLessThan(otherArray.length - 3);
-        assertThat(stringBuilder).hasSizeLessThanOrEqualTo(1 - otherArray.length);
-        assertThat(stringBuilder).hasSameSizeAs(otherList);
         assertThat(stringBuilder).hasSameSizeAs(array);
         assertThat(stringBuilder).hasSameSizeAs(string);
         assertThat(stringBuilder).hasSameSizeAs(stringBuilder);
+        assertThat(stringBuilder).hasSameSizeAs(map);
+        assertThat(stringBuilder).hasSize(1);
+        assertThat(stringBuilder).hasSizeGreaterThan(array.length - 1);
+        assertThat(stringBuilder).hasSizeGreaterThanOrEqualTo(array.length + 1);
+        assertThat(stringBuilder).hasSizeLessThan(array.length - 3);
+        assertThat(stringBuilder).hasSizeLessThanOrEqualTo(1 - array.length);
+        assertThat(stringBuilder).hasSameSizeAs(list);
+        assertThat(stringBuilder).hasSameSizeAs(array);
+        assertThat(stringBuilder).hasSameSizeAs(string);
+        assertThat(stringBuilder).hasSameSizeAs(stringBuilder);
+        assertThat(stringBuilder).hasSameSizeAs(map);
+
+        assertThat(map).isEmpty();
+        assertThat(map).isEmpty();
+        assertThat(map).isNotEmpty();
+        assertThat(map).as("hi").isNotEmpty();
+        assertThat(map).isNotEmpty();
+        assertThat(map).isEmpty();
+        assertThat(map).isEmpty();
+        assertThat(map).hasSameSizeAs(list);
+        assertThat(map).hasSameSizeAs(array);
+        assertThat(map).hasSize(string.length());
+        assertThat(map).hasSize(stringBuilder.length());
+        assertThat(map).hasSameSizeAs(otherMap);
+        assertThat(map).hasSize(1);
+        assertThat(map).hasSizeGreaterThan(array.length - 1);
+        assertThat(map).hasSizeGreaterThanOrEqualTo(array.length + 1);
+        assertThat(map).hasSizeLessThan(array.length - 3);
+        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).hasSameSizeAs(otherMap);
 
         assertThat(stringBuilder.length()).as("foo").isEqualTo(0).isZero().as("bar").isNotZero().isEqualTo(10);
 

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

@@ -1,4 +1,6 @@
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
@@ -12,6 +14,8 @@ public class Size {
         long[] otherArray = new long[4];
         String string = "string";
         StringBuilder stringBuilder = new StringBuilder();
+        Map<String, Integer> map = new HashMap<>();
+        Map<String, Integer> otherMap = new HashMap<>();
 
         assertThat(list.size()).isEqualTo(0);
         assertThat(list.size()).isZero();
@@ -24,6 +28,7 @@ public class 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(1);
         assertThat(list.size()).isGreaterThan(otherList.size() * 2);
         assertThat(list.size()).isGreaterThanOrEqualTo(otherList.size() * 2);
@@ -33,6 +38,7 @@ public class Size {
         assertThat(list).hasSize(array.length);
         assertThat(list).hasSize(string.length());
         assertThat(list).hasSize(stringBuilder.length());
+        assertThat(list).hasSize(map.size());
 
         assertThat(array.length).isEqualTo(0);
         assertThat(array.length).isZero();
@@ -45,6 +51,7 @@ public class 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(1);
         assertThat(array.length).isGreaterThan(otherArray.length - 1);
         assertThat(array.length).isGreaterThanOrEqualTo(otherArray.length + 1);
@@ -54,6 +61,7 @@ public class Size {
         assertThat(array).hasSize(otherArray.length);
         assertThat(array).hasSize(string.length());
         assertThat(array).hasSize(stringBuilder.length());
+        assertThat(array).hasSize(map.size());
 
         assertThat(string.length()).isEqualTo(0);
         assertThat(string.length()).isZero();
@@ -63,18 +71,20 @@ public class Size {
         assertThat(string.length()).isLessThan(1);
         assertThat(string.length()).isLessThanOrEqualTo(0);
         assertThat(string.length()).isEqualTo(list.size());
-        assertThat(string.length()).isEqualTo(otherArray.length);
+        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(1);
-        assertThat(string.length()).isGreaterThan(otherArray.length - 1);
+        assertThat(string.length()).isGreaterThan(array.length - 1);
-        assertThat(string.length()).isGreaterThanOrEqualTo(otherArray.length + 1);
+        assertThat(string.length()).isGreaterThanOrEqualTo(array.length + 1);
-        assertThat(string.length()).isLessThan(otherArray.length - 3);
+        assertThat(string.length()).isLessThan(array.length - 3);
-        assertThat(string.length()).isLessThanOrEqualTo(1 - otherArray.length);
+        assertThat(string.length()).isLessThanOrEqualTo(1 - array.length);
-        assertThat(string).hasSize(otherList.size());
+        assertThat(string).hasSize(list.size());
         assertThat(string).hasSize(array.length);
         assertThat(string).hasSize(string.length());
         assertThat(string).hasSize(stringBuilder.length());
+        assertThat(string).hasSize(map.size());
 
         assertThat(stringBuilder.length()).isEqualTo(0);
         assertThat(stringBuilder.length()).isZero();
@@ -84,18 +94,43 @@ public class Size {
         assertThat(stringBuilder.length()).isLessThan(1);
         assertThat(stringBuilder.length()).isLessThanOrEqualTo(0);
         assertThat(stringBuilder.length()).isEqualTo(list.size());
-        assertThat(stringBuilder.length()).isEqualTo(otherArray.length);
+        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(1);
-        assertThat(stringBuilder.length()).isGreaterThan(otherArray.length - 1);
+        assertThat(stringBuilder.length()).isGreaterThan(array.length - 1);
-        assertThat(stringBuilder.length()).isGreaterThanOrEqualTo(otherArray.length + 1);
+        assertThat(stringBuilder.length()).isGreaterThanOrEqualTo(array.length + 1);
-        assertThat(stringBuilder.length()).isLessThan(otherArray.length - 3);
+        assertThat(stringBuilder.length()).isLessThan(array.length - 3);
-        assertThat(stringBuilder.length()).isLessThanOrEqualTo(1 - otherArray.length);
+        assertThat(stringBuilder.length()).isLessThanOrEqualTo(1 - array.length);
-        assertThat(stringBuilder).hasSize(otherList.size());
+        assertThat(stringBuilder).hasSize(list.size());
         assertThat(stringBuilder).hasSize(array.length);
         assertThat(stringBuilder).hasSize(string.length());
         assertThat(stringBuilder).hasSize(stringBuilder.length());
+        assertThat(stringBuilder).hasSize(map.size());
+
+        assertThat(map.size()).isEqualTo(0);
+        assertThat(map.size()).isZero();
+        assertThat(map.size()).isNotZero();
+        assertThat(map.size()).as("hi").isGreaterThan(0);
+        assertThat(map.size()).isGreaterThanOrEqualTo(1);
+        assertThat(map.size()).isLessThan(1);
+        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(otherMap.size());
+        assertThat(map.size()).isEqualTo(1);
+        assertThat(map.size()).isGreaterThan(array.length - 1);
+        assertThat(map.size()).isGreaterThanOrEqualTo(array.length + 1);
+        assertThat(map.size()).isLessThan(array.length - 3);
+        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(otherMap.size());
 
         assertThat(stringBuilder.length()).as("foo").isEqualTo(0).isZero().as("bar").isNotZero().isEqualTo(10);