chrisly42/cajon-plugin
1
0
Fork 0
Code Issues 4 Pull Requests 1 Packages Projects Releases Wiki Activity

Extended AssertThatSize inspection to Maps, too.

Browse Source
This commit is contained in:
Chris Hodges 2019-08-23 18:21:08 +02:00
parent 36f63d26d2
commit 315b93d90d
10 changed files with 142 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
README.md
View File

@ -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()```,

1
build.gradle
View File

@ -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>
"""

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

@ -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")

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

@ -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

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

@ -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!!

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

@ -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!!

2
src/main/resources/inspectionDescriptions/AssertThatSize.html
View File

@ -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>

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

@ -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")
}
}

71
src/test/resources/inspections/Size/SizeAfter.java
View File

@ -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);

59
src/test/resources/inspections/Size/SizeBefore.java
View File

@ -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()).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);