diff --git a/README.md b/README.md index 714ef22..cc8784c 100644 --- a/README.md +++ b/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()) - to: assertThat("string").hasSameSizeAs(collection); + from: assertThat("string".length()).isEqualTo(map.size()) + 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()```, diff --git a/build.gradle b/build.gradle index 0bedded..dbee7a8 100644 --- a/build.gradle +++ b/build.gradle @@ -46,6 +46,7 @@ patchPluginXml {

V1.4 (unreleased)

Full changelog available at Github project site.

""" diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt index d176a0f..6517d35 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt +++ b/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") diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt index 7f596c5..0e97284 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspection.kt +++ b/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)) || - isForString && (isCollectionSize(equalToExpression) || isArrayLength(equalToExpression) || isCharSequenceLength(equalToExpression)) + val equalsArrayCollectionOrMapSize = isArrayLength(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 diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt index aa0bb0c..64c1300 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceHasSizeMethodCallQuickFix.kt +++ b/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!! diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt b/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt index 1e866be..653259d 100644 --- a/src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceSizeMethodCallQuickFix.kt +++ b/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!! diff --git a/src/main/resources/inspectionDescriptions/AssertThatSize.html b/src/main/resources/inspectionDescriptions/AssertThatSize.html index 0cf0d0f..1200fff 100644 --- a/src/main/resources/inspectionDescriptions/AssertThatSize.html +++ b/src/main/resources/inspectionDescriptions/AssertThatSize.html @@ -1,6 +1,6 @@ -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().
Several more conversions are available with AssertJ 3.12.0 or later. diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt index 5a6cb7a..500b732 100644 --- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatSizeInspectionTest.kt +++ b/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 isZero() with isEmpty()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with isNotEmpty()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with isEmpty()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with isEmpty()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSameSizeAs()"), 12) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with hasSize()"), 8) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with hasSizeGreaterThan()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThanOrEqualTo() with hasSizeGreaterThanOrEqualTo()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThan() with hasSizeLessThan()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Replace isLessThanOrEqualTo() with hasSizeLessThanOrEqualTo()"), 4) - executeQuickFixes(myFixture, Regex.fromLiteral("Remove size determination of expected expression and replace hasSize() with hasSameSizeAs()"), 14) + executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isEmpty()"), 5) + executeQuickFixes(myFixture, Regex.fromLiteral("Replace isZero() with isEmpty()"), 5) + executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotZero() with isNotEmpty()"), 5) + executeQuickFixes(myFixture, Regex.fromLiteral("Replace isGreaterThan() with isNotEmpty()"), 5) + 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 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) myFixture.checkResultByFile("SizeAfter.java") } } \ No newline at end of file diff --git a/src/test/resources/inspections/Size/SizeAfter.java b/src/test/resources/inspections/Size/SizeAfter.java index 09561ec..dc1ebfa 100644 --- a/src/test/resources/inspections/Size/SizeAfter.java +++ b/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 map = new HashMap<>(); + Map 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); diff --git a/src/test/resources/inspections/Size/SizeBefore.java b/src/test/resources/inspections/Size/SizeBefore.java index c708f3e..546bc56 100644 --- a/src/test/resources/inspections/Size/SizeBefore.java +++ b/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 map = new HashMap<>(); + Map 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()).isGreaterThanOrEqualTo(otherArray.length + 1); - assertThat(string.length()).isLessThan(otherArray.length - 3); - assertThat(string.length()).isLessThanOrEqualTo(1 - otherArray.length); - assertThat(string).hasSize(otherList.size()); + assertThat(string.length()).isGreaterThan(array.length - 1); + assertThat(string.length()).isGreaterThanOrEqualTo(array.length + 1); + assertThat(string.length()).isLessThan(array.length - 3); + assertThat(string.length()).isLessThanOrEqualTo(1 - array.length); + 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()).isGreaterThanOrEqualTo(otherArray.length + 1); - assertThat(stringBuilder.length()).isLessThan(otherArray.length - 3); - assertThat(stringBuilder.length()).isLessThanOrEqualTo(1 - otherArray.length); - assertThat(stringBuilder).hasSize(otherList.size()); + assertThat(stringBuilder.length()).isGreaterThan(array.length - 1); + assertThat(stringBuilder.length()).isGreaterThanOrEqualTo(array.length + 1); + assertThat(stringBuilder.length()).isLessThan(array.length - 3); + assertThat(stringBuilder.length()).isLessThanOrEqualTo(1 - array.length); + 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);