How to use Array.shouldBeStrictlyIncreasingWith method of io.kotest.matchers.collections.increasing class

Best Kotest code snippet using io.kotest.matchers.collections.increasing.Array.shouldBeStrictlyIncreasingWith

TraceIteratorTest.kt

Source:TraceIteratorTest.kt

1/*2 * This file is part of OMJ.3 *4 * OMJ is free software: you can redistribute it and/or modify5 * it under the terms of the GNU General Public License as published by6 * the Free Software Foundation, either version 3 of the License, or7 * (at your option) any later version.8 *9 * OMJ is distributed in the hope that it will be useful,10 * but WITHOUT ANY WARRANTY; without even the implied warranty of11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12 * GNU General Public License for more details.13 *14 * You should have received a copy of the GNU General Public License15 * along with OMJ. If not, see <https://www.gnu.org/licenses/>.16 */17package com.octogonapus.omj.ui.model18import com.octogonapus.omj.testutil.CompileUtil19import io.kotest.assertions.throwables.shouldThrow20import io.kotest.matchers.collections.shouldBeStrictlyIncreasingWith21import io.kotest.matchers.collections.shouldExist22import io.kotest.matchers.collections.shouldExistInOrder23import io.kotest.matchers.collections.shouldHaveSize24import mu.KotlinLogging25import org.junit.jupiter.api.Nested26import org.junit.jupiter.api.Test27import org.junit.jupiter.api.io.TempDir28import java.io.BufferedInputStream29import java.io.File30import java.io.FileInputStream31internal class TraceIteratorTest {32 @Nested33 inner class MethodTraceTests {34 @Test35 fun `parse method call with no args`(@TempDir tempDir: File) {36 val traces = generateTraces(tempDir, "agent-test_noargs.jar")37 traces.shouldExistInOrder(38 {39 it.constructorCall(40 receiverType = "com.agenttest.noargs.Foo",41 callerClass = "com.agenttest.noargs.Main"42 )43 },44 {45 it.virtualMethodCall(46 receiverType = "com.agenttest.noargs.Foo",47 callerClass = "com.agenttest.noargs.Main",48 methodName = "with"49 )50 }51 )52 }53 @Test54 fun `parse method call with args byte 3C`(@TempDir tempDir: File) {55 val traces = generateTraces(tempDir, "agent-test_byte3c.jar")56 traces.shouldExistInOrder(57 {58 it.constructorCall(59 receiverType = "com.agenttest.byte3c.Foo",60 callerClass = "com.agenttest.byte3c.Main"61 )62 },63 {64 it.virtualMethodCall(65 receiverType = "com.agenttest.byte3c.Foo",66 methodName = "with",67 callerClass = "com.agenttest.byte3c.Main",68 args = listOf("byte" to "60")69 )70 }71 )72 }73 @Test74 fun `parse method call with args char Q`(@TempDir tempDir: File) {75 val traces = generateTraces(tempDir, "agent-test_charQ.jar")76 traces.shouldExistInOrder(77 {78 it.constructorCall(79 receiverType = "com.agenttest.charQ.Foo",80 callerClass = "com.agenttest.charQ.Main"81 )82 },83 {84 it.virtualMethodCall(85 receiverType = "com.agenttest.charQ.Foo",86 methodName = "with",87 callerClass = "com.agenttest.charQ.Main",88 args = listOf("char" to "Q")89 )90 }91 )92 }93 @Test94 fun `parse method call with args double 1p2`(@TempDir tempDir: File) {95 val traces = generateTraces(tempDir, "agent-test_double1p2.jar")96 traces.shouldExistInOrder(97 {98 it.constructorCall(99 receiverType = "com.agenttest.double1p2.Foo",100 callerClass = "com.agenttest.double1p2.Main"101 )102 },103 {104 it.virtualMethodCall(105 receiverType = "com.agenttest.double1p2.Foo",106 methodName = "with",107 callerClass = "com.agenttest.double1p2.Main",108 args = listOf("double" to "1.2")109 )110 }111 )112 }113 @Test114 fun `parse method call with args float 4p3`(@TempDir tempDir: File) {115 val traces = generateTraces(tempDir, "agent-test_float4p3.jar")116 traces.shouldExistInOrder(117 {118 it.constructorCall(119 receiverType = "com.agenttest.float4p3.Foo",120 callerClass = "com.agenttest.float4p3.Main"121 )122 },123 {124 it.virtualMethodCall(125 receiverType = "com.agenttest.float4p3.Foo",126 methodName = "with",127 callerClass = "com.agenttest.float4p3.Main",128 args = listOf("float" to "4.3")129 )130 }131 )132 }133 @Test134 fun `parse method call with args int 42`(@TempDir tempDir: File) {135 val traces = generateTraces(tempDir, "agent-test_int42.jar")136 traces.shouldExistInOrder(137 {138 it.constructorCall(139 receiverType = "com.agenttest.int42.Foo",140 callerClass = "com.agenttest.int42.Main"141 )142 },143 {144 it.virtualMethodCall(145 receiverType = "com.agenttest.int42.Foo",146 methodName = "with",147 callerClass = "com.agenttest.int42.Main",148 args = listOf("int" to "42")149 )150 }151 )152 }153 @Test154 fun `parse method call with args long 123456789123456789`(@TempDir tempDir: File) {155 val traces = generateTraces(tempDir, "agent-test_long123456789123456789.jar")156 traces.shouldExistInOrder(157 {158 it.constructorCall(159 receiverType = "com.agenttest.long123456789123456789.Foo",160 callerClass = "com.agenttest.long123456789123456789.Main"161 )162 },163 {164 it.virtualMethodCall(165 receiverType = "com.agenttest.long123456789123456789.Foo",166 methodName = "with",167 callerClass = "com.agenttest.long123456789123456789.Main",168 args = listOf("long" to "123456789123456789")169 )170 }171 )172 }173 @Test174 fun `parse method call with args string hello`(@TempDir tempDir: File) {175 val traces = generateTraces(tempDir, "agent-test_stringHello.jar")176 traces.shouldExistInOrder(177 {178 it.constructorCall(179 receiverType = "com.agenttest.stringHello.Foo",180 callerClass = "com.agenttest.stringHello.Main"181 )182 },183 {184 it.virtualMethodCall(185 receiverType = "com.agenttest.stringHello.Foo",186 methodName = "with",187 callerClass = "com.agenttest.stringHello.Main",188 args = listOf("java.lang.String" to "Hello")189 )190 }191 )192 }193 @Test194 fun `parse method call with args string hello with null byte`(@TempDir tempDir: File) {195 val traces = generateTraces(tempDir, "agent-test_stringHelloNull1.jar")196 traces.shouldExistInOrder(197 {198 it.constructorCall(199 receiverType = "com.agenttest.stringHelloNull1.Foo",200 callerClass = "com.agenttest.stringHelloNull1.Main"201 )202 },203 {204 it.virtualMethodCall(205 receiverType = "com.agenttest.stringHelloNull1.Foo",206 methodName = "with",207 callerClass = "com.agenttest.stringHelloNull1.Main",208 args = listOf("java.lang.String" to "Hello\u0000 1")209 )210 }211 )212 }213 @Test214 fun `parse method call with args object`(@TempDir tempDir: File) {215 val traces = generateTraces(tempDir, "agent-test_objectStringArray.jar")216 traces.shouldExistInOrder(217 {218 it.constructorCall(219 receiverType = "com.agenttest.objectStringArray.Foo",220 callerClass = "com.agenttest.objectStringArray.Main"221 )222 },223 {224 it.virtualMethodCall(225 receiverType = "com.agenttest.objectStringArray.Foo",226 methodName = "with",227 callerClass = "com.agenttest.objectStringArray.Main",228 args = listOf("[Ljava.lang.String;" to null)229 )230 }231 )232 }233 @Test234 fun `parse method call with args short 12345`(@TempDir tempDir: File) {235 val traces = generateTraces(tempDir, "agent-test_short12345.jar")236 traces.shouldExistInOrder(237 {238 it.constructorCall(239 receiverType = "com.agenttest.short12345.Foo",240 callerClass = "com.agenttest.short12345.Main"241 )242 },243 {244 it.virtualMethodCall(245 receiverType = "com.agenttest.short12345.Foo",246 methodName = "with",247 callerClass = "com.agenttest.short12345.Main",248 args = listOf("short" to "12345")249 )250 }251 )252 }253 @Test254 fun `parse method call with args boolean true`(@TempDir tempDir: File) {255 val traces = generateTraces(tempDir, "agent-test_booleanTrue.jar")256 traces.shouldExistInOrder(257 {258 it.constructorCall(259 receiverType = "com.agenttest.booleanTrue.Foo",260 callerClass = "com.agenttest.booleanTrue.Main"261 )262 },263 {264 it.virtualMethodCall(265 receiverType = "com.agenttest.booleanTrue.Foo",266 methodName = "with",267 callerClass = "com.agenttest.booleanTrue.Main",268 args = listOf("boolean" to "true")269 )270 }271 )272 }273 @Test274 fun `parse method call with args object MyDataClass`(@TempDir tempDir: File) {275 val traces = generateTraces(tempDir, "agent-test_objectTestDataClass.jar")276 traces.shouldExistInOrder(277 {278 it.constructorCall(279 receiverType = "com.agenttest.objectTestDataClass.Foo",280 callerClass = "com.agenttest.objectTestDataClass.Main"281 )282 },283 {284 it.virtualMethodCall(285 receiverType = "com.agenttest.objectTestDataClass.Foo",286 methodName = "with",287 callerClass = "com.agenttest.objectTestDataClass.Main",288 args = listOf("com.agenttest.objectTestDataClass.TestDataClass" to null)289 )290 }291 )292 }293 @Test294 fun `parse constructor call with int 6`(@TempDir tempDir: File) {295 val traces = generateTraces(tempDir, "agent-test_constructorInt6.jar")296 traces.shouldExistInOrder(297 {298 it.constructorCall(299 receiverType = "com.agenttest.constructorInt6.Foo",300 callerClass = "com.agenttest.constructorInt6.Main",301 args = listOf("int" to "6")302 )303 }304 )305 }306 @Test307 fun `parse a static method call in a static block`(@TempDir tempDir: File) {308 val traces = generateTraces(tempDir, "agent-test_staticBlockCallStaticMethod.jar")309 traces.shouldExistInOrder(310 {311 it.staticMethodCall(312 methodName = "callMe",313 callerClass = "com.agenttest.staticBlockCallStaticMethod.Foo"314 )315 }316 )317 }318 @Test319 fun `parse a static method call with an int after a double`(@TempDir tempDir: File) {320 val traces = generateTraces(tempDir, "agent-test_methodCallIntAfterDouble.jar")321 traces.shouldExistInOrder(322 {323 it.staticMethodCall(324 methodName = "callMe",325 callerClass = "com.agenttest.methodCallIntAfterDouble.Main",326 args = listOf("double" to "4.2", "int" to "1")327 )328 }329 )330 }331 }332 @Nested333 inner class LocalVariableStoreTraceTests {334 @Test335 fun `test boolean store`(@TempDir tempDir: File) {336 val traces = generateTraces(tempDir, "agent-test_storeBoolean.jar")337 traces.shouldExist {338 it.storeVar("com.agenttest.storeBoolean.Main", "boolean", "b", "true")339 }340 }341 @Test342 fun `test byte store`(@TempDir tempDir: File) {343 val traces = generateTraces(tempDir, "agent-test_storeByte.jar")344 traces.shouldExist {345 it.storeVar("com.agenttest.storeByte.Main", "byte", "b", "250")346 }347 }348 @Test349 fun `test char store`(@TempDir tempDir: File) {350 val traces = generateTraces(tempDir, "agent-test_storeChar.jar")351 traces.shouldExist {352 it.storeVar("com.agenttest.storeChar.Main", "char", "c", "Q")353 }354 }355 @Test356 fun `test double store`(@TempDir tempDir: File) {357 val traces = generateTraces(tempDir, "agent-test_storeDouble.jar")358 traces.shouldExist {359 it.storeVar("com.agenttest.storeDouble.Main", "double", "d", "4.2")360 }361 }362 @Test363 fun `test float store`(@TempDir tempDir: File) {364 val traces = generateTraces(tempDir, "agent-test_storeFloat.jar")365 traces.shouldExist {366 it.storeVar("com.agenttest.storeFloat.Main", "float", "f", "2.3")367 }368 }369 @Test370 fun `test int store`(@TempDir tempDir: File) {371 val traces = generateTraces(tempDir, "agent-test_storeInt.jar")372 traces.shouldExist {373 it.storeVar("com.agenttest.storeInt.Main", "int", "i", "123456")374 }375 }376 @Test377 fun `test long store`(@TempDir tempDir: File) {378 val traces = generateTraces(tempDir, "agent-test_storeLong.jar")379 traces.shouldExist {380 it.storeVar("com.agenttest.storeLong.Main", "long", "l", "123456789123456789")381 }382 }383 @Test384 fun `test ref store`(@TempDir tempDir: File) {385 val traces = generateTraces(tempDir, "agent-test_storeRef.jar")386 traces.shouldExist {387 it.storeVar("com.agenttest.storeRef.Main", "java.lang.Object", "o", null)388 }389 }390 @Test391 fun `test short store`(@TempDir tempDir: File) {392 val traces = generateTraces(tempDir, "agent-test_storeShort.jar")393 traces.shouldExist {394 it.storeVar("com.agenttest.storeShort.Main", "short", "s", "12345")395 }396 }397 @Test398 fun `test string store`(@TempDir tempDir: File) {399 val traces = generateTraces(tempDir, "agent-test_storeString.jar")400 traces.shouldExist {401 it.storeVar("com.agenttest.storeString.Main", "java.lang.String", "s", "My String")402 }403 }404 @Test405 fun `test int increment`(@TempDir tempDir: File) {406 val traces = generateTraces(tempDir, "agent-test_storeIncrementInt.jar")407 traces.shouldExist {408 // Started at 3 and was incremented to 4409 it.storeVar("com.agenttest.storeIncrementInt.Main", "int", "i", "4")410 }411 }412 @Test413 fun `test int array store`(@TempDir tempDir: File) {414 val traces = generateTraces(tempDir, "agent-test_storeIntArray.jar")415 traces.shouldExistInOrder(416 {417 it.storeVar("com.agenttest.storeIntArray.Main", "[I", "i", null)418 },419 {420 it.storeArray(421 containingClass = "com.agenttest.storeIntArray.Main",422 varType = "int",423 arrayIndex = 0,424 value = "6"425 )426 }427 )428 }429 @Test430 fun `test int array store one-liner`(@TempDir tempDir: File) {431 val traces = generateTraces(tempDir, "agent-test_storeIntArrayOneLiner.jar")432 traces.shouldExistInOrder(433 {434 it.storeArray(435 containingClass = "com.agenttest.storeIntArrayOneLiner.Main",436 varType = "int",437 arrayIndex = 0,438 value = "6"439 )440 },441 {442 it.storeVar("com.agenttest.storeIntArrayOneLiner.Main", "[I", "i", null)443 }444 )445 }446 @Test447 fun `test double array store`(@TempDir tempDir: File) {448 val traces = generateTraces(tempDir, "agent-test_storeDoubleArray.jar")449 traces.shouldExistInOrder(450 {451 it.storeVar("com.agenttest.storeDoubleArray.Main", "[D", "d", null)452 },453 {454 it.storeArray(455 containingClass = "com.agenttest.storeDoubleArray.Main",456 varType = "double",457 arrayIndex = 0,458 value = "4.2"459 )460 }461 )462 }463 @Test464 fun `test double array store one-liner`(@TempDir tempDir: File) {465 val traces = generateTraces(tempDir, "agent-test_storeDoubleArrayOneLiner.jar")466 traces.shouldExistInOrder(467 {468 it.storeArray(469 containingClass = "com.agenttest.storeDoubleArrayOneLiner.Main",470 varType = "double",471 arrayIndex = 0,472 value = "4.2"473 )474 },475 {476 it.storeVar("com.agenttest.storeDoubleArrayOneLiner.Main", "[D", "d", null)477 }478 )479 }480 @Test481 fun `test object array store`(@TempDir tempDir: File) {482 val traces = generateTraces(tempDir, "agent-test_storeObjectArray.jar")483 traces.shouldExistInOrder(484 {485 it.storeVar(486 "com.agenttest.storeObjectArray.Main",487 "[Ljava.lang.Object;",488 "o",489 null490 )491 },492 {493 it.storeArray(494 containingClass = "com.agenttest.storeObjectArray.Main",495 varType = "java.lang.Object",496 arrayIndex = 0,497 value = null498 )499 }500 )501 }502 @Test503 fun `test object array store one-liner`(@TempDir tempDir: File) {504 val traces = generateTraces(tempDir, "agent-test_storeObjectArrayOneLiner.jar")505 traces.shouldExistInOrder(506 {507 it.storeArray(508 containingClass = "com.agenttest.storeObjectArrayOneLiner.Main",509 varType = "java.lang.Object",510 arrayIndex = 0,511 value = null512 )513 },514 {515 it.storeVar(516 "com.agenttest.storeObjectArrayOneLiner.Main",517 "[Ljava.lang.Object;",518 "o",519 null520 )521 }522 )523 }524 @Test525 fun `test string array store`(@TempDir tempDir: File) {526 val traces = generateTraces(tempDir, "agent-test_storeStringArray.jar")527 traces.shouldExistInOrder(528 {529 it.storeVar(530 "com.agenttest.storeStringArray.Main",531 "[Ljava.lang.String;",532 "o",533 null534 )535 },536 {537 it.storeArray(538 containingClass = "com.agenttest.storeStringArray.Main",539 varType = "java.lang.String",540 arrayIndex = 0,541 value = "Hello"542 )543 }544 )545 }546 @Test547 fun `test string array store one-liner`(@TempDir tempDir: File) {548 val traces = generateTraces(tempDir, "agent-test_storeStringArrayOneLiner.jar")549 traces.shouldExistInOrder(550 {551 it.storeArray(552 containingClass = "com.agenttest.storeStringArrayOneLiner.Main",553 varType = "java.lang.String",554 arrayIndex = 0,555 value = "Hello"556 )557 },558 {559 it.storeVar(560 "com.agenttest.storeStringArrayOneLiner.Main",561 "[Ljava.lang.String;",562 "o",563 null564 )565 }566 )567 }568 @Test569 fun `test 2D int array store`(@TempDir tempDir: File) {570 val traces = generateTraces(tempDir, "agent-test_storeMultiIntArray.jar")571 traces.shouldExistInOrder(572 {573 it.storeVar("com.agenttest.storeMultiIntArray.Main", "[[I", "i", null)574 },575 {576 it.storeArray(577 "com.agenttest.storeMultiIntArray.Main",578 "int",579 0,580 "6"581 )582 }583 )584 }585 @Test586 fun `test 3D int array store`(@TempDir tempDir: File) {587 val traces = generateTraces(tempDir, "agent-test_storeMultiIntArray3.jar")588 traces.shouldExistInOrder(589 {590 it.storeVar("com.agenttest.storeMultiIntArray3.Main", "[[[I", "i", null)591 },592 {593 it.storeArray(594 "com.agenttest.storeMultiIntArray3.Main",595 "int",596 0,597 "6"598 )599 }600 )601 }602 @Test603 fun `test boolean array store`(@TempDir tempDir: File) {604 val traces = generateTraces(tempDir, "agent-test_storeBooleanArray.jar")605 traces.shouldExistInOrder(606 {607 it.storeVar("com.agenttest.storeBooleanArray.Main", "[Z", "b", null)608 },609 {610 it.storeArray(611 containingClass = "com.agenttest.storeBooleanArray.Main",612 varType = "boolean",613 arrayIndex = 0,614 value = "true"615 )616 }617 )618 }619 @Test620 fun `test byte array store`(@TempDir tempDir: File) {621 val traces = generateTraces(tempDir, "agent-test_storeByteArray.jar")622 traces.shouldExistInOrder(623 {624 it.storeVar("com.agenttest.storeByteArray.Main", "[B", "b", null)625 },626 {627 it.storeArray(628 containingClass = "com.agenttest.storeByteArray.Main",629 varType = "byte",630 arrayIndex = 0,631 value = "250"632 )633 }634 )635 }636 @Test637 fun `test char array store`(@TempDir tempDir: File) {638 val traces = generateTraces(tempDir, "agent-test_storeCharArray.jar")639 traces.shouldExistInOrder(640 {641 it.storeVar("com.agenttest.storeCharArray.Main", "[C", "c", null)642 },643 {644 it.storeArray(645 containingClass = "com.agenttest.storeCharArray.Main",646 varType = "char",647 arrayIndex = 0,648 value = "Q"649 )650 }651 )652 }653 @Test654 fun `test float array store`(@TempDir tempDir: File) {655 val traces = generateTraces(tempDir, "agent-test_storeFloatArray.jar")656 traces.shouldExistInOrder(657 {658 it.storeVar("com.agenttest.storeFloatArray.Main", "[F", "f", null)659 },660 {661 it.storeArray(662 containingClass = "com.agenttest.storeFloatArray.Main",663 varType = "float",664 arrayIndex = 0,665 value = "2.3"666 )667 }668 )669 }670 @Test671 fun `test long array store`(@TempDir tempDir: File) {672 val traces = generateTraces(tempDir, "agent-test_storeLongArray.jar")673 traces.shouldExistInOrder(674 {675 it.storeVar("com.agenttest.storeLongArray.Main", "[J", "l", null)676 },677 {678 it.storeArray(679 containingClass = "com.agenttest.storeLongArray.Main",680 varType = "long",681 arrayIndex = 0,682 value = "123456789123456789"683 )684 }685 )686 }687 @Test688 fun `test short array store`(@TempDir tempDir: File) {689 val traces = generateTraces(tempDir, "agent-test_storeShortArray.jar")690 traces.shouldExistInOrder(691 {692 it.storeVar("com.agenttest.storeShortArray.Main", "[S", "s", null)693 },694 {695 it.storeArray(696 containingClass = "com.agenttest.storeShortArray.Main",697 varType = "short",698 arrayIndex = 0,699 value = "12345"700 )701 }702 )703 }704 @Test705 fun `test multithreaded int array store`(@TempDir tempDir: File) {706 val traces = generateTraces(tempDir, "agent-test_storeIntMultithreaded.jar")707 // One thread writes even numbers and the other writes odd numbers. Both use a lock so708 // all numbers should be traced.709 repeat(20) { number ->710 traces.shouldExist {711 it.storeVar(712 "com.agenttest.storeIntMultithreaded.Main",713 "int",714 "com.agenttest.storeIntMultithreaded.Main.i",715 "$number"716 )717 }718 }719 // All traces should be in order720 traces.shouldBeStrictlyIncreasingWith(Comparator { t1, t2 -> (t1.index - t2.index).toInt() })721 }722 }723 @Nested724 inner class FormalMethodParameterStoreTraceTests {725 @Test726 fun `mutate both method params`(@TempDir tempDir: File) {727 val traces = generateTraces(tempDir, "agent-test_storeTwoMethodParams.jar")728 traces.shouldExist {729 it.storeVar(730 "com.agenttest.storeTwoMethodParams.Main",731 "java.lang.String",732 "s",733 "Second"734 )735 it.storeVar("com.agenttest.storeTwoMethodParams.Main", "int", "i", "2")736 }737 }738 }739 @Nested740 inner class PutFieldTraceTests {741 @Test742 fun `test put boolean`(@TempDir tempDir: File) {743 val traces = generateTraces(tempDir, "agent-test_putBooleanField.jar")744 traces.shouldExist {745 it.storeVar(746 "com.agenttest.putBooleanField.Main",747 "boolean",748 "com.agenttest.putBooleanField.Main.b",749 "true"750 )751 }752 }753 @Test754 fun `test put byte`(@TempDir tempDir: File) {755 val traces = generateTraces(tempDir, "agent-test_putByteField.jar")756 traces.shouldExist {757 it.storeVar(758 "com.agenttest.putByteField.Main",759 "byte",760 "com.agenttest.putByteField.Main.b",761 "250"762 )763 }764 }765 @Test766 fun `test put char`(@TempDir tempDir: File) {767 val traces = generateTraces(tempDir, "agent-test_putCharField.jar")768 traces.shouldExist {769 it.storeVar(770 "com.agenttest.putCharField.Main",771 "char",772 "com.agenttest.putCharField.Main.c",773 "Q"774 )775 }776 }777 @Test778 fun `test put double`(@TempDir tempDir: File) {779 val traces = generateTraces(tempDir, "agent-test_putDoubleField.jar")780 traces.shouldExist {781 it.storeVar(782 "com.agenttest.putDoubleField.Main",783 "double",784 "com.agenttest.putDoubleField.Main.d",785 "4.2"786 )787 }788 }789 @Test790 fun `test put float`(@TempDir tempDir: File) {791 val traces = generateTraces(tempDir, "agent-test_putFloatField.jar")792 traces.shouldExist {793 it.storeVar(794 "com.agenttest.putFloatField.Main",795 "float",796 "com.agenttest.putFloatField.Main.f",797 "2.3"798 )799 }800 }801 @Test802 fun `test put int`(@TempDir tempDir: File) {803 val traces = generateTraces(tempDir, "agent-test_putIntField.jar")804 traces.shouldExist {805 it.storeVar(806 "com.agenttest.putIntField.Main",807 "int",808 "com.agenttest.putIntField.Main.i",809 "7"810 )811 }812 }813 @Test814 fun `test put long`(@TempDir tempDir: File) {815 val traces = generateTraces(tempDir, "agent-test_putLongField.jar")816 traces.shouldExist {817 it.storeVar(818 "com.agenttest.putLongField.Main",819 "long",820 "com.agenttest.putLongField.Main.l",821 "123456789123456789"822 )823 }824 }825 @Test826 fun `test put object`(@TempDir tempDir: File) {827 val traces = generateTraces(tempDir, "agent-test_putObjectField.jar")828 traces.shouldExist {829 it.storeVar(830 "com.agenttest.putObjectField.Main",831 "java.lang.Object",832 "com.agenttest.putObjectField.Main.o",833 null834 )835 }836 }837 @Test838 fun `test put short`(@TempDir tempDir: File) {839 val traces = generateTraces(tempDir, "agent-test_putShortField.jar")840 traces.shouldExist {841 it.storeVar(842 "com.agenttest.putShortField.Main",843 "short",844 "com.agenttest.putShortField.Main.s",845 "12345"846 )847 }848 }849 @Test850 fun `test put string`(@TempDir tempDir: File) {851 val traces = generateTraces(tempDir, "agent-test_putStringField.jar")852 traces.shouldExist {853 it.storeVar(854 "com.agenttest.putStringField.Main",855 "java.lang.String",856 "com.agenttest.putStringField.Main.s",857 "Hello"858 )859 }860 }861 }862 @Nested863 inner class PutStaticFieldTraceTests {864 @Test865 fun `test put boolean`(@TempDir tempDir: File) {866 val traces = generateTraces(tempDir, "agent-test_putBooleanStaticField.jar")867 traces.shouldExist {868 it.storeVar(869 "com.agenttest.putBooleanStaticField.Main",870 "boolean",871 "com.agenttest.putBooleanStaticField.Main.b",872 "true"873 )874 }875 }876 @Test877 fun `test put byte`(@TempDir tempDir: File) {878 val traces = generateTraces(tempDir, "agent-test_putByteStaticField.jar")879 traces.shouldExist {880 it.storeVar(881 "com.agenttest.putByteStaticField.Main",882 "byte",883 "com.agenttest.putByteStaticField.Main.b",884 "250"885 )886 }887 }888 @Test889 fun `test put char`(@TempDir tempDir: File) {890 val traces = generateTraces(tempDir, "agent-test_putCharStaticField.jar")891 traces.shouldExist {892 it.storeVar(893 "com.agenttest.putCharStaticField.Main",894 "char",895 "com.agenttest.putCharStaticField.Main.c",896 "Q"897 )898 }899 }900 @Test901 fun `test put double`(@TempDir tempDir: File) {902 val traces = generateTraces(tempDir, "agent-test_putDoubleStaticField.jar")903 traces.shouldExist {904 it.storeVar(905 "com.agenttest.putDoubleStaticField.Main",906 "double",907 "com.agenttest.putDoubleStaticField.Main.d",908 "4.2"909 )910 }911 }912 @Test913 fun `test put float`(@TempDir tempDir: File) {914 val traces = generateTraces(tempDir, "agent-test_putFloatStaticField.jar")915 traces.shouldExist {916 it.storeVar(917 "com.agenttest.putFloatStaticField.Main",918 "float",919 "com.agenttest.putFloatStaticField.Main.f",920 "2.3"921 )922 }923 }924 @Test925 fun `test put int`(@TempDir tempDir: File) {926 val traces = generateTraces(tempDir, "agent-test_putIntStaticField.jar")927 traces.shouldExist {928 it.storeVar(929 "com.agenttest.putIntStaticField.Main",930 "int",931 "com.agenttest.putIntStaticField.Main.i",932 "7"933 )934 }935 }936 @Test937 fun `test put long`(@TempDir tempDir: File) {938 val traces = generateTraces(tempDir, "agent-test_putLongStaticField.jar")939 traces.shouldExist {940 it.storeVar(941 "com.agenttest.putLongStaticField.Main",942 "long",943 "com.agenttest.putLongStaticField.Main.l",944 "123456789123456789"945 )946 }947 }948 @Test949 fun `test put object`(@TempDir tempDir: File) {950 val traces = generateTraces(tempDir, "agent-test_putObjectStaticField.jar")951 traces.shouldExist {952 it.storeVar(953 "com.agenttest.putObjectStaticField.Main",954 "java.lang.Object",955 "com.agenttest.putObjectStaticField.Main.o",956 null957 )958 }959 }960 @Test961 fun `test put short`(@TempDir tempDir: File) {962 val traces = generateTraces(tempDir, "agent-test_putShortStaticField.jar")963 traces.shouldExist {964 it.storeVar(965 "com.agenttest.putShortStaticField.Main",966 "short",967 "com.agenttest.putShortStaticField.Main.s",968 "12345"969 )970 }971 }972 @Test973 fun `test put string`(@TempDir tempDir: File) {974 val traces = generateTraces(tempDir, "agent-test_putStringStaticField.jar")975 traces.shouldExist {976 it.storeVar(977 "com.agenttest.putStringStaticField.Main",978 "java.lang.String",979 "com.agenttest.putStringStaticField.Main.s",980 "Hello"981 )982 }983 }984 }985 @Test986 fun `read past end of trace`(@TempDir tempDir: File) {987 CompileUtil.checkForAgentTestErrors(988 CompileUtil.runAgentTest("agent-test_noargs.jar", tempDir.toPath())989 )990 val traceFiles = tempDir.listFiles()!!.toList().filter { it.extension == "trace" }991 traceFiles.shouldHaveSize(1)992 TraceIterator(BufferedInputStream(FileInputStream(traceFiles[0]))).use {993 // Go to the end994 while (it.hasNext()) {995 it.next()996 }997 // Past the end998 shouldThrow<NoSuchElementException> { it.next() }999 }1000 }1001 companion object {1002 private val logger = KotlinLogging.logger { }1003 /**1004 * Generate traces by running the Jar under the agent. Asserts that there is only one trace1005 * file.1006 *1007 * @param tempDir The dir to save the trace file into.1008 * @param jarFilename The filename of the Jar to load from1009 * `rootProject/build/agent-test-jars`.1010 * @return The traces.1011 */1012 private fun generateTraces(tempDir: File, jarFilename: String): List<Trace> {1013 CompileUtil.checkForAgentTestErrors(1014 CompileUtil.runAgentTest(jarFilename, tempDir.toPath())1015 )1016 logger.debug {1017 """1018 |Files in temp dir:1019 |${tempDir.walkTopDown().joinToString("\n")}1020 """.trimMargin()1021 }1022 val traceFiles = tempDir.listFiles()!!.filter { it.extension == "trace" }1023 traceFiles.shouldHaveSize(1)1024 return TraceIterator(BufferedInputStream(FileInputStream(traceFiles[0]))).use {1025 it.asSequence().toList()1026 }1027 }1028 /**1029 * Assumes there is a virtual method call and asserts about its receiver type and arguments.1030 * Excludes instance and class initialization methods.1031 *1032 * @param receiverType The expected receiver type.1033 * @param methodName The expected method name.1034 * @param callerClass The class that the method is expected to be called from.1035 * @param args The expected (type, value) pairs for each argument in order.1036 */1037 private fun Trace.virtualMethodCall(1038 receiverType: String,1039 methodName: String,1040 callerClass: String,1041 args: List<Pair<String, String?>> = emptyList()1042 ) = this is MethodTrace &&1043 !isStatic &&1044 methodName != "<init>" &&1045 methodName != "<clinit>" &&1046 hasArguments(listOf(receiverType to null) + args) &&1047 this.methodName == methodName &&1048 this.callerClass == callerClass1049 /**1050 * Assumes there is a static method call and asserts about its arguments. Excludes instance1051 * and class initialization methods.1052 *1053 * @param methodName The expected method name.1054 * @param callerClass The class that the method is expected to be called from.1055 * @param args The expected (type, value) pairs for each argument in order.1056 */1057 private fun Trace.staticMethodCall(1058 methodName: String,1059 callerClass: String,1060 args: List<Pair<String, String?>> = emptyList()1061 ) = this is MethodTrace &&1062 isStatic &&1063 methodName != "<init>" &&1064 methodName != "<clinit>" &&1065 hasArguments(args) &&1066 this.methodName == methodName &&1067 this.callerClass == callerClass1068 /**1069 * Assumes there is an instance initializer method call and asserts about its arguments.1070 *1071 * @param receiverType The expected receiver type.1072 * @param callerClass The class that the method is expected to be called from.1073 * @param args The expected (type, value) pairs for each argument in order.1074 */1075 private fun Trace.constructorCall(1076 receiverType: String,1077 callerClass: String,1078 args: List<Pair<String, String?>> = emptyList()1079 ) = this is MethodTrace &&1080 !isStatic &&1081 methodName == "<init>" &&1082 hasArguments(listOf(receiverType to null) + args) &&1083 this.callerClass == callerClass1084 /**1085 * Checks there is a store with a value of [value] into a variable of type [varType].1086 *1087 * @param containingClass The class the store happens in.1088 * @param varType The type of the variable the value was stored in.1089 * @param name The name of the variable.1090 * @param value The value that was stored. Set to null if you don't care about the value.1091 */1092 private fun Trace.storeVar(1093 containingClass: String,1094 varType: String,1095 name: String,1096 value: String?1097 ) = this is StoreTrace &&1098 callerClass == containingClass &&1099 typeValuePair.type == varType &&1100 variableName == name &&1101 value?.let { typeValuePair.value == it } ?: true1102 /**1103 * Checks there is a store with a value of [value] into an array of type [varType] at index1104 * [arrayIndex].1105 *1106 * @param containingClass The class the store happens in.1107 * @param varType The type of the variable the value was stored in.1108 * @param arrayIndex The index in the array the value was stored in.1109 * @param value The value that was stored. Set to null if you don't care about the value.1110 */1111 private fun Trace.storeArray(1112 containingClass: String,1113 varType: String,1114 arrayIndex: Int,1115 value: String?1116 ) = this is ArrayStoreTrace &&1117 callerClass == containingClass &&1118 this.arrayIndex == arrayIndex &&1119 typeValuePair.type == varType &&1120 value?.let { typeValuePair.value == it } ?: true1121 private fun MethodTrace.hasArguments(args: List<Pair<String, String?>>) =1122 args.foldIndexed(true) { index, acc, (type, value) ->1123 if (value == null) {1124 // Null means we don't care about the value1125 acc && hasArgumentType(index, type)1126 } else {1127 acc && hasArgument(index, type, value)1128 }1129 }1130 private fun MethodTrace.hasArgumentType(index: Int, type: String) =1131 arguments[index].type == type1132 private fun MethodTrace.hasArgument(index: Int, type: String, value: String) =1133 arguments[index].type == type && arguments[index].value == value1134 }1135}...

CollectionMatchersTest.kt

Source:CollectionMatchersTest.kt

1package com.sksamuel.kotest.matchers.collections2import io.kotest.assertions.shouldFail3import io.kotest.assertions.throwables.shouldNotThrow4import io.kotest.assertions.throwables.shouldThrow5import io.kotest.assertions.withClue6import io.kotest.core.spec.style.WordSpec7import io.kotest.equals.Equality8import io.kotest.equals.types.byObjectEquality9import io.kotest.matchers.collections.atLeastSize10import io.kotest.matchers.collections.atMostSize11import io.kotest.matchers.collections.beLargerThan12import io.kotest.matchers.collections.beSameSizeAs13import io.kotest.matchers.collections.beSmallerThan14import io.kotest.matchers.collections.contain15import io.kotest.matchers.collections.containDuplicates16import io.kotest.matchers.collections.containNoNulls17import io.kotest.matchers.collections.containNull18import io.kotest.matchers.collections.containOnlyNulls19import io.kotest.matchers.collections.matchInOrder20import io.kotest.matchers.collections.existInOrder21import io.kotest.matchers.collections.haveElementAt22import io.kotest.matchers.collections.haveSize23import io.kotest.matchers.collections.matchEach24import io.kotest.matchers.collections.matchInOrderSubset25import io.kotest.matchers.collections.monotonicallyDecreasing26import io.kotest.matchers.collections.monotonicallyDecreasingWith27import io.kotest.matchers.collections.monotonicallyIncreasing28import io.kotest.matchers.collections.monotonicallyIncreasingWith29import io.kotest.matchers.collections.shouldBeIn30import io.kotest.matchers.collections.shouldBeLargerThan31import io.kotest.matchers.collections.shouldBeMonotonicallyDecreasing32import io.kotest.matchers.collections.shouldBeMonotonicallyDecreasingWith33import io.kotest.matchers.collections.shouldBeMonotonicallyIncreasing34import io.kotest.matchers.collections.shouldBeMonotonicallyIncreasingWith35import io.kotest.matchers.collections.shouldBeSameSizeAs36import io.kotest.matchers.collections.shouldBeSingleton37import io.kotest.matchers.collections.shouldBeSmallerThan38import io.kotest.matchers.collections.shouldBeSorted39import io.kotest.matchers.collections.shouldBeSortedBy40import io.kotest.matchers.collections.shouldBeSortedWith41import io.kotest.matchers.collections.shouldBeStrictlyDecreasing42import io.kotest.matchers.collections.shouldBeStrictlyDecreasingWith43import io.kotest.matchers.collections.shouldBeStrictlyIncreasing44import io.kotest.matchers.collections.shouldBeStrictlyIncreasingWith45import io.kotest.matchers.collections.shouldContainAnyOf46import io.kotest.matchers.collections.shouldContainDuplicates47import io.kotest.matchers.collections.shouldContainNoNulls48import io.kotest.matchers.collections.shouldContainNull49import io.kotest.matchers.collections.shouldContainOnlyNulls50import io.kotest.matchers.collections.shouldExist51import io.kotest.matchers.collections.shouldHaveAtLeastSize52import io.kotest.matchers.collections.shouldHaveAtMostSize53import io.kotest.matchers.collections.shouldHaveElementAt54import io.kotest.matchers.collections.shouldHaveSingleElement55import io.kotest.matchers.collections.shouldHaveSize56import io.kotest.matchers.collections.shouldMatchInOrder57import io.kotest.matchers.collections.shouldMatchInOrderSubset58import io.kotest.matchers.collections.shouldNotBeIn59import io.kotest.matchers.collections.shouldNotBeMonotonicallyDecreasing60import io.kotest.matchers.collections.shouldNotBeMonotonicallyDecreasingWith61import io.kotest.matchers.collections.shouldNotBeMonotonicallyIncreasing62import io.kotest.matchers.collections.shouldNotBeMonotonicallyIncreasingWith63import io.kotest.matchers.collections.shouldNotBeSingleton64import io.kotest.matchers.collections.shouldNotBeSorted65import io.kotest.matchers.collections.shouldNotBeSortedBy66import io.kotest.matchers.collections.shouldNotBeSortedWith67import io.kotest.matchers.collections.shouldNotBeStrictlyDecreasing68import io.kotest.matchers.collections.shouldNotBeStrictlyDecreasingWith69import io.kotest.matchers.collections.shouldNotBeStrictlyIncreasing70import io.kotest.matchers.collections.shouldNotBeStrictlyIncreasingWith71import io.kotest.matchers.collections.shouldNotContainAnyOf72import io.kotest.matchers.collections.shouldNotContainDuplicates73import io.kotest.matchers.collections.shouldNotContainNoNulls74import io.kotest.matchers.collections.shouldNotContainNull75import io.kotest.matchers.collections.shouldNotContainOnlyNulls76import io.kotest.matchers.collections.shouldNotHaveElementAt77import io.kotest.matchers.collections.shouldNotHaveSize78import io.kotest.matchers.collections.shouldNotMatchEach79import io.kotest.matchers.collections.shouldNotMatchInOrder80import io.kotest.matchers.collections.shouldNotMatchInOrderSubset81import io.kotest.matchers.collections.singleElement82import io.kotest.matchers.collections.sorted83import io.kotest.matchers.collections.strictlyDecreasing84import io.kotest.matchers.collections.strictlyDecreasingWith85import io.kotest.matchers.collections.strictlyIncreasing86import io.kotest.matchers.collections.strictlyIncreasingWith87import io.kotest.matchers.ints.shouldBeGreaterThan88import io.kotest.matchers.ints.shouldBeInRange89import io.kotest.matchers.should90import io.kotest.matchers.shouldBe91import io.kotest.matchers.shouldHave92import io.kotest.matchers.shouldNot93import io.kotest.matchers.shouldNotBe94import io.kotest.matchers.shouldNotHave95import io.kotest.matchers.throwable.shouldHaveMessage96class CollectionMatchersTest : WordSpec() {97 private val countdown = (10 downTo 0).toList()98 private val asc = { a: Int, b: Int -> a - b }99 private val desc = { a: Int, b: Int -> b - a }100 init {101 "a descending non-empty list" should {102 "fail to ascend" {103 shouldFail {104 countdown.shouldBeSortedWith(asc)105 }106 }107 "descend" {108 countdown.shouldBeSortedWith(desc)109 }110 "not ascend" {111 countdown.shouldNotBeSortedWith(asc)112 }113 "fail not to descend" {114 shouldFail {115 countdown.shouldNotBeSortedWith(desc)116 }117 }118 }119 "sortedWith" should {120 val items = listOf(121 1 to "I",122 2 to "II",123 4 to "IV",124 5 to "V",125 6 to "VI",126 9 to "IX",127 10 to "X"128 )129 "work on non-Comparable given a Comparator" {130 items.shouldBeSortedWith(Comparator { a, b -> asc(a.first, b.first) })131 }132 "work on non-Comparable given a compare function" {133 items.shouldBeSortedWith { a, b -> asc(a.first, b.first) }134 }135 }136 "haveElementAt" should {137 "test that a collection contains the specified element at the given index" {138 listOf("a", "b", "c") should haveElementAt(1, "b")139 listOf("a", "b", "c") shouldNot haveElementAt(1, "c")140 listOf("a", "b", null) should haveElementAt(2, null)141 listOf("a", "b", null) shouldNot haveElementAt(3, null)142 listOf("a", "b", "c").shouldHaveElementAt(1, "b")143 listOf("a", "b", "c").shouldNotHaveElementAt(1, "c")144 listOf("a", "b", null).shouldHaveElementAt(2, null)145 }146 "support type inference for subtypes of collection" {147 val tests = listOf(148 TestSealed.Test1("test1"),149 TestSealed.Test2(2)150 )151 tests should haveElementAt(0, TestSealed.Test1("test1"))152 tests.shouldHaveElementAt(1, TestSealed.Test2(2))153 }154 }155 "containNull()" should {156 "test that a collection contains at least one null" {157 listOf(1, 2, null) should containNull()158 listOf(null) should containNull()159 listOf(1, 2) shouldNot containNull()160 listOf(1, 2, null).shouldContainNull()161 listOf(null).shouldContainNull()162 listOf(1, 2).shouldNotContainNull()163 }164 }165 "sorted" should {166 "test that a collection is sorted" {167 emptyList<Int>() shouldBe sorted<Int>()168 listOf(1) shouldBe sorted<Int>()169 listOf(1, 2, 3, 4) shouldBe sorted<Int>()170 shouldThrow<AssertionError> {171 listOf(2, 1) shouldBe sorted<Int>()172 }.shouldHaveMessage("List [2, 1] should be sorted. Element 2 at index 0 was greater than element 1")173 listOf(1, 2, 6, 9).shouldBeSorted()174 shouldThrow<AssertionError> {175 listOf(2, 1).shouldBeSorted()176 }.shouldHaveMessage("List [2, 1] should be sorted. Element 2 at index 0 was greater than element 1")177 shouldThrow<AssertionError> {178 listOf(1, 2, 3).shouldNotBeSorted()179 }.shouldHaveMessage("List [1, 2, 3] should not be sorted")180 }181 "restrict items at the error message" {182 val longList = (1..1000).toList()183 shouldThrow<AssertionError> {184 longList.shouldNotBeSorted()185 }.shouldHaveMessage("List [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...and 980 more (set the 'kotest.assertions.collection.print.size' JVM property to see more / less items)] should not be sorted")186 }187 }188 "sortedBy" should {189 val items = listOf(190 1 to "I",191 2 to "II",192 4 to "IV",193 5 to "V",194 6 to "VI",195 9 to "IX",196 10 to "X"197 )198 "compare by the tranformed value" {199 items.shouldBeSortedBy { it.first }200 items.shouldNotBeSortedBy { it.second }201 }202 }203 "shouldBeIncreasing" should {204 "test that a collection is monotonically increasing" {205 listOf(1, 2, 2, 3) shouldBe monotonicallyIncreasing<Int>()206 listOf(6, 5) shouldNotBe monotonicallyIncreasing<Int>()207 listOf(1, 2, 2, 3).shouldBeMonotonicallyIncreasing()208 listOf(6, 5).shouldNotBeMonotonicallyIncreasing()209 }210 "test that a collection is monotonically increasing according to comparator" {211 val comparator = Comparator(desc)212 listOf(3, 2, 2, 1) shouldBe monotonicallyIncreasingWith(comparator)213 listOf(5, 6) shouldNotBe monotonicallyIncreasingWith(comparator)214 listOf(3, 2, 2, 1).shouldBeMonotonicallyIncreasingWith(comparator)215 listOf(5, 6).shouldNotBeMonotonicallyIncreasingWith(comparator)216 }217 "test that a collection is strictly increasing" {218 listOf(1, 2, 3) shouldBe strictlyIncreasing<Int>()219 listOf(1, 2, 2, 3) shouldNotBe strictlyIncreasing<Int>()220 listOf(6, 5) shouldNotBe strictlyIncreasing<Int>()221 listOf(1, 2, 3).shouldBeStrictlyIncreasing()222 listOf(1, 2, 2, 3).shouldNotBeStrictlyIncreasing()223 listOf(6, 5).shouldNotBeStrictlyIncreasing()224 }225 "test that a collection is strictly increasing according to comparator" {226 val comparator = Comparator(desc)227 listOf(3, 2, 1) shouldBe strictlyIncreasingWith(comparator)228 listOf(3, 2, 2, 1) shouldNotBe strictlyIncreasingWith(comparator)229 listOf(5, 6) shouldNotBe strictlyIncreasingWith(comparator)230 listOf(3, 2, 1).shouldBeStrictlyIncreasingWith(comparator)231 listOf(3, 2, 2, 1).shouldNotBeStrictlyIncreasingWith(comparator)232 listOf(5, 6).shouldNotBeStrictlyIncreasingWith(comparator)233 }234 }235 "shouldBeDecreasing" should {236 "test that a collection is monotonically decreasing" {237 listOf(3, 2, 2, -4) shouldBe monotonicallyDecreasing<Int>()238 listOf(5, 6) shouldNotBe monotonicallyDecreasing<Int>()239 listOf(3, 2, 2, -4).shouldBeMonotonicallyDecreasing()240 listOf(5, 6).shouldNotBeMonotonicallyDecreasing()241 }242 "test that a collection is monotonically decreasing according to comparator" {243 val comparator = Comparator(desc)244 listOf(-4, 2, 2, 3) shouldBe monotonicallyDecreasingWith(comparator)245 listOf(6, 5) shouldNotBe monotonicallyDecreasingWith(comparator)246 listOf(-4, 2, 2, 3).shouldBeMonotonicallyDecreasingWith(comparator)247 listOf(6, 5).shouldNotBeMonotonicallyDecreasingWith(comparator)248 }249 "test that a collection is strictly decreasing" {250 listOf(3, 2, -4) shouldBe strictlyDecreasing<Int>()251 listOf(3, 2, 2, -4) shouldNotBe strictlyDecreasing<Int>()252 listOf(5, 6) shouldNotBe strictlyDecreasing<Int>()253 listOf(3, 2, -4).shouldBeStrictlyDecreasing()254 listOf(3, 2, 2, -4).shouldNotBeStrictlyDecreasing()255 listOf(5, 6).shouldNotBeStrictlyDecreasing()256 }257 "test that a collection is strictly decreasing according to comparator" {258 val comparator = Comparator(desc)259 listOf(-4, 2, 3) shouldBe strictlyDecreasingWith(comparator)260 listOf(-4, 2, 2, 3) shouldNotBe strictlyDecreasingWith(comparator)261 listOf(6, 5) shouldNotBe strictlyDecreasingWith(comparator)262 listOf(-4, 2, 3).shouldBeStrictlyDecreasingWith(comparator)263 listOf(-4, 2, 2, 3).shouldNotBeStrictlyDecreasingWith(comparator)264 listOf(6, 5).shouldNotBeStrictlyDecreasingWith(comparator)265 }266 }267 "haveDuplicates" should {268 "test that a collection is unique" {269 listOf(1, 2, 3, 3) should containDuplicates()270 listOf(1, 2, 3, 4) shouldNot containDuplicates()271 listOf(1, 2, 3, 3).shouldContainDuplicates()272 listOf(1, 2, 3, 4).shouldNotContainDuplicates()273 }274 }275 "singleElement" should {276 "test that a collection contains a single given element" {277 listOf(1) shouldBe singleElement(1)278 listOf(1).shouldHaveSingleElement(1)279 shouldThrow<AssertionError> {280 listOf(1) shouldBe singleElement(2)281 }.shouldHaveMessage("Collection should be a single element of 2 but has 1 elements: [1]")282 shouldThrow<AssertionError> {283 listOf(1, 2) shouldBe singleElement(2)284 }.shouldHaveMessage("Collection should be a single element of 2 but has 2 elements: [1, 2]")285 }286 }287 "singleElement with predicate" should {288 "test that a collection contains a single element by given predicate" {289 listOf(1) shouldHave singleElement { e -> e == 1 }290 listOf(1).shouldHaveSingleElement { e -> e == 1 }291 shouldThrow<AssertionError> {292 listOf(1) shouldHave singleElement { e -> e == 2 }293 }.shouldHaveMessage("Collection should have a single element by a given predicate but has 0 elements: [1]")294 shouldThrow<AssertionError> {295 listOf(2, 2) shouldHave singleElement { e -> e == 2 }296 }.shouldHaveMessage("Collection should have a single element by a given predicate but has 2 elements: [2, 2]")297 }298 }299 "should contain element" should {300 "test that a collection contains an element" {301 val col = listOf(1, 2, 3)302 col should contain(2)303 col should contain(2.0) // uses strict num equality = false304 shouldThrow<AssertionError> {305 col should contain(4)306 }.shouldHaveMessage("Collection should contain element 4 based on object equality; but the collection is [1, 2, 3]")307 }308 }309 "should contain element based on a custom equality object" should {310 "test that a collection contains an element" {311 val col = listOf(1, 2, 3.0)312 val verifier = Equality.byObjectEquality<Number>(strictNumberEquality = true)313 col should contain(2, verifier)314 col should contain(3.0, verifier)315 shouldThrow<AssertionError> {316 col should contain(3, verifier)317 }.shouldHaveMessage("Collection should contain element 3 based on object equality; but the collection is [1, 2, 3.0]")318 }319 }320 "shouldBeLargerThan" should {321 "test that a collection is larger than another collection" {322 val col1 = listOf(1, 2, 3)323 val col2 = setOf(1, 2, 3, 4)324 col2.shouldBeLargerThan(col1)325 col2 should beLargerThan(col1)326 col1 shouldNot beLargerThan(col2)327 shouldThrow<AssertionError> {328 col1.shouldBeLargerThan(col2)329 }.shouldHaveMessage("Collection of size 3 should be larger than collection of size 4")330 }331 }332 "shouldBeSmallerThan" should {333 "test that a collection is smaller than another collection" {334 val col1 = listOf(1, 2, 3)335 val col2 = setOf(1, 2, 3, 4)336 col1.shouldBeSmallerThan(col2)337 col1 should beSmallerThan(col2)338 col2 shouldNot beSmallerThan(col1)339 shouldThrow<AssertionError> {340 col2.shouldBeSmallerThan(col1)341 }.shouldHaveMessage("Collection of size 4 should be smaller than collection of size 3")342 }343 }344 "shouldBeSameSizeAs" should {345 "test that a collection is the same size as another collection" {346 val col1 = listOf(1, 2, 3)347 val col2 = setOf(1, 2, 3)348 val col3 = listOf(1, 2, 3, 4)349 col1.shouldBeSameSizeAs(col2)350 col1 should beSameSizeAs(col2)351 col1 shouldNot beSameSizeAs(col3)352 shouldThrow<AssertionError> {353 col1.shouldBeSameSizeAs(col3)354 }.shouldHaveMessage("Collection of size 3 should be the same size as collection of size 4")355 }356 }357 "haveSize" should {358 "test that a collection has a certain size" {359 val col1 = listOf(1, 2, 3)360 col1 should haveSize(3)361 col1.shouldHaveSize(3)362 shouldThrow<AssertionError> {363 col1 should haveSize(2)364 }365 val col2 = emptyList<String>()366 col2 should haveSize(0)367 shouldThrow<AssertionError> {368 col2 should haveSize(1)369 }370 listOf(1, 2, 3).shouldNotHaveSize(1)371 listOf(1, 2, 3).shouldNotHaveSize(4)372 shouldThrow<AssertionError> {373 listOf(1, 2, 3).shouldNotHaveSize(3)374 }.shouldHaveMessage("Collection should not have size 3. Values: [1, 2, 3]")375 }376 }377 "should be singleton" should {378 "pass for collection with a single element" {379 listOf(1).shouldBeSingleton()380 }381 "fail for collection with 0 elements" {382 shouldThrow<AssertionError> {383 listOf<Int>().shouldBeSingleton()384 }.shouldHaveMessage("Collection should have size 1 but has size 0. Values: []")385 }386 "fail for collection with 2+ elements" {387 shouldThrow<AssertionError> {388 listOf(1, 2).shouldBeSingleton()389 }.shouldHaveMessage("Collection should have size 1 but has size 2. Values: [1, 2]")390 shouldThrow<AssertionError> {391 listOf(1, 2, 3, 4).shouldBeSingleton()392 }.shouldHaveMessage("Collection should have size 1 but has size 4. Values: [1, 2, 3, 4]")393 }394 }395 "should be singleton with block" should {396 "pass for collection with a single element" {397 listOf(1).shouldBeSingleton { it shouldBe 1 }398 }399 "fail for collection with 0 elements" {400 shouldThrow<AssertionError> {401 listOf<Int>().shouldBeSingleton { it shouldBe 1 }402 }.shouldHaveMessage("Collection should have size 1 but has size 0. Values: []")403 }404 "fail for collection with a single incorrect elements" {405 shouldThrow<AssertionError> {406 listOf(2).shouldBeSingleton { it shouldBe 1 }407 }.shouldHaveMessage("expected:<1> but was:<2>")408 }409 "fail for collection with 2+ elements" {410 shouldThrow<AssertionError> {411 listOf(1, 2).shouldBeSingleton { it shouldBe 1 }412 }.shouldHaveMessage("Collection should have size 1 but has size 2. Values: [1, 2]")413 shouldThrow<AssertionError> {414 listOf(1, 2, 3, 4).shouldBeSingleton { it shouldBe 1 }415 }.shouldHaveMessage("Collection should have size 1 but has size 4. Values: [1, 2, 3, 4]")416 }417 }418 "should not be singleton" should {419 "pass for collection with 0 elements" {420 listOf<Int>().shouldNotBeSingleton()421 }422 "pass for collection with 2+ elements" {423 listOf(1, 2).shouldNotBeSingleton()424 listOf(1, 2, 3, 4).shouldNotBeSingleton()425 }426 "fail for collection with a single element" {427 shouldThrow<AssertionError> {428 listOf(1).shouldNotBeSingleton()429 }.shouldHaveMessage("Collection should not have size 1. Values: [1]")430 }431 }432 "shouldExist" should {433 "test that a collection contains at least one element that matches a predicate" {434 val list = listOf(1, 2, 3)435 list.shouldExist { it == 2 }436 }437 }438 "shouldHaveAtLeastSize" should {439 "test that a collection has at least a certain number of elements" {440 val list = listOf(1, 2, 3)441 list.shouldHaveAtLeastSize(2)442 list shouldHave atLeastSize(2)443 val set = setOf(1, 2, 3)444 set.shouldHaveAtLeastSize(3)445 set shouldHave atLeastSize(3)446 shouldThrow<AssertionError> {447 list.shouldHaveAtLeastSize(4)448 }.shouldHaveMessage("Collection [1, 2, 3] should contain at least 4 elements")449 shouldThrow<AssertionError> {450 list shouldHave atLeastSize(4)451 }.shouldHaveMessage("Collection [1, 2, 3] should contain at least 4 elements")452 shouldThrow<AssertionError> {453 list shouldNotHave atLeastSize(2)454 }.shouldHaveMessage("Collection [1, 2, 3] should contain less than 2 elements")455 }456 }457 "shouldHaveAtMostSize" should {458 "test that a collection has at least a certain number of elements" {459 val list = listOf(1, 2, 3)460 list.shouldHaveAtMostSize(3)461 list shouldHave atMostSize(3)462 list.shouldHaveAtMostSize(4)463 list shouldHave atMostSize(4)464 val set = setOf(1, 2, 3)465 set.shouldHaveAtMostSize(3)466 set shouldHave atMostSize(3)467 set.shouldHaveAtMostSize(4)468 set shouldHave atMostSize(4)469 shouldThrow<AssertionError> {470 list.shouldHaveAtMostSize(2)471 }.shouldHaveMessage("Collection [1, 2, 3] should contain at most 2 elements")472 shouldThrow<AssertionError> {473 list shouldHave atMostSize(2)474 }.shouldHaveMessage("Collection [1, 2, 3] should contain at most 2 elements")475 shouldThrow<AssertionError> {476 list shouldNotHave atMostSize(4)477 }.shouldHaveMessage("Collection [1, 2, 3] should contain more than 4 elements")478 }479 }480 "containNoNulls" should {481 "test that a collection contains zero nulls" {482 emptyList<String>() should containNoNulls()483 listOf(1, 2, 3) should containNoNulls()484 listOf(null, null, null) shouldNot containNoNulls()485 listOf(1, null, null) shouldNot containNoNulls()486 emptyList<String>().shouldContainNoNulls()487 listOf(1, 2, 3).shouldContainNoNulls()488 listOf(null, null, null).shouldNotContainNoNulls()489 listOf(1, null, null).shouldNotContainNoNulls()490 shouldThrow<AssertionError> {491 listOf(null, null, null).shouldContainNoNulls()492 }.shouldHaveMessage("Collection should not contain nulls")493 shouldThrow<AssertionError> {494 listOf(1, 2, 3).shouldNotContainNoNulls()495 }.shouldHaveMessage("Collection should have at least one null")496 }497 "support type inference for subtypes of collection" {498 val tests = listOf(499 TestSealed.Test1("test1"),500 TestSealed.Test2(2)501 )502 tests should containNoNulls()503 tests.shouldContainNoNulls()504 }505 }506 "containOnlyNulls" should {507 "test that a collection contains only nulls" {508 emptyList<String>() should containOnlyNulls()509 listOf(null, null, null) should containOnlyNulls()510 listOf(1, null, null) shouldNot containOnlyNulls()511 listOf(1, 2, 3) shouldNot containOnlyNulls()512 listOf(null, 1, 2, 3).shouldNotContainOnlyNulls()513 listOf(1, 2, 3).shouldNotContainOnlyNulls()514 listOf(null, null, null).shouldContainOnlyNulls()515 }516 }517 "matchInOrder" should {518 "test that a collection matches the assertions in the given order, duplicates permitted" {519 withClue("Gaps not allowed") {520 shouldFail {521 listOf(1, 2, 2, 3) should matchInOrder(522 { it shouldBe 1 },523 { it shouldBe 2 },524 { it shouldBe 3 }525 )526 }527 }528 arrayOf(2, 2, 3).shouldMatchInOrder(529 { it shouldBe 2 },530 { it shouldBe 2 },531 { it shouldBe 3 },532 )533 }534 "failure shows best result" {535 shouldFail {536 listOf(1, 2, 3, 1, 2, 1, 2).shouldMatchInOrder(537 { it shouldBe 1 },538 { it shouldBe 2 },539 { it shouldBe 1 },540 { it shouldBe 3 },541 )542 }.message shouldBe """543 Expected a sequence of elements to pass the assertions, but failed to match all assertions544 Best result when comparing from index [3], where 3 elements passed, but the following elements failed:545 6 => expected:<3> but was:<2>546 """.trimIndent()547 }548 "Non existing element causes error" {549 shouldThrow<AssertionError> {550 listOf(1, 2, 3).shouldMatchInOrder(551 { it shouldBe 1 },552 { it shouldBe 2 },553 { it shouldBe 6 }554 )555 }556 }557 "out-of-order elements cause error" {558 shouldThrow<AssertionError> {559 listOf(1, 2, 3) should matchInOrder(560 { it shouldBe 2 },561 { it shouldBe 1 },562 { it shouldBe 3 }563 )564 }565 }566 "work with unsorted collections" {567 val actual = listOf(5, 3, 1, 2, 4, 2)568 withClue("should match 4th, 5th and 6th elements ([.., 2, 4, 2])") {569 actual should matchInOrder(570 { it shouldBe 2 },571 { it shouldBeGreaterThan 3 },572 { it shouldBeInRange 2..2 }573 )574 }575 }576 "negation should work" {577 shouldFail {578 listOf(1, 2, 3, 4).shouldNotMatchInOrder(579 { it shouldBe 2 },580 { it shouldBe 3 },581 )582 }.message shouldBe """583 Expected some assertion to fail but all passed584 """.trimIndent()585 listOf(1, 2, 3, 4).shouldNotMatchInOrder(586 { it shouldBe 2 },587 { it shouldBe 4 }588 )589 }590 }591 "matchInOrderSubset" should {592 "test that a collection matches the assertions in the given order without gaps" {593 listOf(1, 1, 2, 2, 3, 3) should matchInOrderSubset(594 { it shouldBe 1 },595 { it shouldBe 2 },596 { it shouldBe 2 },597 { it shouldBe 3 }598 )599 arrayOf(1, 1, 1).shouldMatchInOrderSubset(600 { it shouldBe 1 }601 )602 }603 "Negation should work" {604 shouldFail {605 listOf(1, 2, 3, 4).shouldNotMatchInOrderSubset(606 { it shouldBe 2 },607 { it shouldBe 4 },608 )609 }.message shouldBe """610 Expected some assertion to fail but all passed611 """.trimIndent()612 arrayOf(1, 2, 3, 4).shouldNotMatchInOrder(613 { it shouldBe 4 },614 { it shouldBe 1 }615 )616 }617 "Non existing element causes error" {618 shouldThrow<AssertionError> {619 listOf(1, 1, 2, 2, 3, 3) should matchInOrderSubset(620 { it shouldBe 1 },621 { it shouldBe 2 },622 { it shouldBe 6 }623 )624 }.message shouldBe """625 Expected a sequence of elements to pass the assertions, possibly with gaps between but failed to match all assertions626 Best result when comparing from index [0], where 2 elements passed, but the following elements failed:627 3 => expected:<6> but was:<2>628 4 => expected:<6> but was:<3>629 5 => expected:<6> but was:<3>630 """.trimIndent()631 }632 "out-of-order elements cause error" {633 shouldThrow<AssertionError> {634 listOf(1, 2, 3) should matchInOrderSubset(635 { it shouldBe 2 },636 { it shouldBe 1 },637 { it shouldBe 3 }638 )639 }640 }641 "gaps should be ok" {642 listOf(1, 1, 2, 2, 3, 3) should matchInOrderSubset(643 { it shouldBe 1 },644 { it shouldBe 2 },645 { it shouldBe 3 }646 )647 }648 "work with unsorted collections" {649 val actual = listOf(5, 3, 1, 2, 4, 2)650 withClue("should match 4th, 5th and 6th elements ([.., 2, 4, 2])") {651 actual should matchInOrderSubset(652 { it shouldBe 2 },653 { it shouldBeGreaterThan 3 },654 { it shouldBeInRange 2..2 }655 )656 }657 }658 }659 "matchEach" should {660 "test that a collection matches the assertions in the given order without gaps" {661 listOf(1, 3, 7) should matchEach(662 { it shouldBe 1 },663 { it shouldBeInRange 2..4 },664 { it shouldBeGreaterThan 2 }665 )666 }667 "Negation should work" {668 shouldFail{669 listOf(1, 2).shouldNotMatchEach(670 { it shouldBe 1 },671 { it shouldBe 2 },672 )673 }.message shouldBe """674 Expected some element to fail its assertion, but all passed.675 """.trimIndent()676 arrayOf(1, 2).shouldNotMatchEach(677 { it shouldBe 2 },678 { it shouldBe 1 }679 )680 }681 "No assertion exists for each element" {682 shouldFail {683 listOf(1, -1, 999) should matchEach(684 { it shouldBe 1 }685 )686 }.message shouldBe """687 Expected each element to pass its assertion, but found issues at indexes: [1, 2]688 1 => Element has no corresponding assertion. Only 1 assertions provided689 2 => Element has no corresponding assertion. Only 1 assertions provided690 """.trimIndent()691 }692 "Too many assertions cause error" {693 shouldFail {694 listOf(1, 3, 7) should matchEach(695 { it shouldBe 1 },696 { it shouldBe 3 },697 { it shouldBe 7 },698 { it shouldBe 7 },699 { it shouldBe 7 },700 )701 }.message shouldBe """702 Expected each element to pass its assertion, but found issues at indexes: [3, 4]703 3 => No actual element for assertion at index 3704 4 => No actual element for assertion at index 4705 """.trimIndent()706 }707 "Non matching element causes error" {708 shouldFail {709 listOf(1, 3, 7) should matchEach(710 { it shouldBe 1 },711 { it shouldBeInRange 2..4 },712 { it shouldBeGreaterThan 7 }713 )714 }.message shouldBe """715 Expected each element to pass its assertion, but found issues at indexes: [2]716 2 => 7 should be > 7717 """.trimIndent()718 }719 "out-of-order elements cause error" {720 shouldThrow<AssertionError> {721 setOf(2, 3, 1) should matchEach(722 { it shouldBe 2 },723 { it shouldBe 1 },724 { it shouldBe 3 }725 )726 }.message shouldBe """727 Expected each element to pass its assertion, but found issues at indexes: [1, 2]728 1 => expected:<1> but was:<3>729 2 => expected:<3> but was:<1>730 """.trimIndent()731 }732 "gaps cause errors" {733 shouldThrow<AssertionError> {734 listOf(1, 1, 2, 2, 3, 3) should matchEach(735 { it shouldBe 1 },736 { it shouldBe 2 },737 { it shouldBe 3 }738 )739 }.message shouldBe """740 Expected each element to pass its assertion, but found issues at indexes: [1, 2, 3, 4, 5]741 1 => expected:<2> but was:<1>742 2 => expected:<3> but was:<2>743 3 => Element has no corresponding assertion. Only 3 assertions provided744 4 => Element has no corresponding assertion. Only 3 assertions provided745 5 => Element has no corresponding assertion. Only 3 assertions provided746 """.trimIndent()747 }748 }749 "existInOrder" should {750 "test that a collection matches the predicates in the given order, duplicates permitted" {751 val col = listOf(1, 1, 2, 2, 3, 3)752 col should existInOrder(753 { it == 1 },754 { it == 2 },755 { it == 3 }756 )757 col should existInOrder({ it == 1 })758 shouldThrow<AssertionError> {759 col should existInOrder(760 { it == 1 },761 { it == 2 },762 { it == 6 }763 )764 }765 shouldThrow<AssertionError> {766 col should existInOrder({ it == 4 })767 }768 shouldThrow<AssertionError> {769 col should existInOrder(770 { it == 2 },771 { it == 1 },772 { it == 3 }773 )774 }775 }776 "work with unsorted collections" {777 val actual = listOf(5, 3, 1, 2, 4, 2)778 actual should existInOrder(779 { it == 3 },780 { it == 2 },781 { it == 2 }782 )783 }784 }785 "Contain any" should {786 "Fail when the list is empty" {787 shouldThrow<AssertionError> {788 listOf(1, 2, 3).shouldContainAnyOf(emptyList())789 }.shouldHaveMessage("Asserting content on empty collection. Use Collection.shouldBeEmpty() instead.")790 }791 "Pass when one element is in the list" {792 listOf(1, 2, 3).shouldContainAnyOf(1)793 }794 "Pass when all elements are in the list" {795 listOf(1, 2, 3).shouldContainAnyOf(1, 2, 3)796 }797 "Fail when no element is in the list" {798 shouldThrow<AssertionError> {799 listOf(1, 2, 3).shouldContainAnyOf(4)800 }.shouldHaveMessage("Collection [1, 2, 3] should contain any of [4]")801 }802 }803 "Contain any (negative)" should {804 "Fail when the list is empty" {805 shouldThrow<AssertionError> {806 listOf(1, 2, 3).shouldNotContainAnyOf(emptyList())807 }.shouldHaveMessage("Asserting content on empty collection. Use Collection.shouldBeEmpty() instead.")808 }809 "Pass when no element is present in the list" {810 listOf(1, 2, 3).shouldNotContainAnyOf(4)811 }812 "Fail when one element is in the list" {813 shouldThrow<AssertionError> {814 listOf(1, 2, 3).shouldNotContainAnyOf(1)815 }.shouldHaveMessage("Collection [1, 2, 3] should not contain any of [1]")816 }817 "Fail when all elements are in the list" {818 shouldThrow<AssertionError> {819 listOf(1, 2, 3).shouldNotContainAnyOf(1, 2, 3)820 }.shouldHaveMessage("Collection [1, 2, 3] should not contain any of [1, 2, 3]")821 }822 }823 "Be in" should {824 "Pass when the element is in the list" {825 val foo = Foo("Bar")826 val list = listOf(foo)827 foo shouldBeIn list828 }829 "Fail when the element is not in the list" {830 val foo1 = Foo("Bar")831 val foo2 = Foo("Booz")832 val list = listOf(foo1)833 shouldThrow<AssertionError> {834 foo2.shouldBeIn(list)835 }.shouldHaveMessage("Collection should contain Foo(bar=Booz), but doesn't. Possible values: [Foo(bar=Bar)]")836 }837 "Pass when there's an equal element, but not the same instance in the list" {838 val foo1 = Foo("Bar")839 val foo2 = Foo("Bar")840 val list = listOf(foo1)841 shouldNotThrow<AssertionError> { foo2 shouldBeIn list }842 }843 "Pass when there's an equal element, but not the same instance in the array" {844 val foo1 = Foo("Bar")845 val foo2 = Foo("Bar")846 val list = arrayOf(foo1)847 shouldNotThrow<AssertionError> { foo2 shouldBeIn list }848 }849 "Fail when the list is empty" {850 val foo = Foo("Bar")851 val list = emptyList<Foo>()852 shouldThrow<AssertionError> {853 foo shouldBeIn list854 }.shouldHaveMessage("Asserting content on empty collection. Use Collection.shouldBeEmpty() instead.")855 }856 }857 "Be in (negative)" should {858 "Fail when the element is in the list" {859 val foo = Foo("Bar")860 val list = listOf(foo)861 shouldThrow<AssertionError> {862 foo shouldNotBeIn list863 }.shouldHaveMessage("Collection should not contain Foo(bar=Bar), but does. Forbidden values: [Foo(bar=Bar)]")864 }865 "Pass when the element is not in the list" {866 val foo1 = Foo("Bar")867 val foo2 = Foo("Booz")868 val list = listOf(foo1)869 shouldNotThrow<AssertionError> {870 foo2.shouldNotBeIn(list)871 }872 }873 "Fail when there's an equal element, but not the same instance in the list" {874 val foo1 = Foo("Bar")875 val foo2 = Foo("Bar")876 val list = listOf(foo1)877 shouldThrow<AssertionError> {878 foo2 shouldNotBeIn list879 }.shouldHaveMessage("Collection should not contain Foo(bar=Bar), but does. Forbidden values: [Foo(bar=Bar)]")880 }881 "Fail when the list is empty" {882 val foo = Foo("Bar")883 val list = emptyList<Foo>()884 shouldThrow<AssertionError> {885 foo shouldNotBeIn list886 }.shouldHaveMessage("Asserting content on empty collection. Use Collection.shouldBeEmpty() instead.")887 }888 }889 }890}891private data class Foo(val bar: String)892sealed class TestSealed {893 data class Test1(val value: String) : TestSealed()894 data class Test2(val value: Int) : TestSealed()895}...

matchers.kt

Source:matchers.kt

1package io.kotest.matchers.collections2import io.kotest.assertions.show.show3import io.kotest.matchers.Matcher4import io.kotest.matchers.MatcherResult5import io.kotest.matchers.neverNullMatcher6import io.kotest.matchers.should7import io.kotest.matchers.shouldHave8import io.kotest.matchers.shouldNot9import kotlin.jvm.JvmName10fun <T> Iterable<T>.shouldContainOnlyNulls() = toList().shouldContainOnlyNulls()11fun <T> Array<T>.shouldContainOnlyNulls() = asList().shouldContainOnlyNulls()12fun <T> Collection<T>.shouldContainOnlyNulls() = this should containOnlyNulls()13fun <T> Iterable<T>.shouldNotContainOnlyNulls() = toList().shouldNotContainOnlyNulls()14fun <T> Array<T>.shouldNotContainOnlyNulls() = asList().shouldNotContainOnlyNulls()15fun <T> Collection<T>.shouldNotContainOnlyNulls() = this shouldNot containOnlyNulls()16fun <T> containOnlyNulls() = object : Matcher<Collection<T>> {17 override fun test(value: Collection<T>) =18 MatcherResult(19 value.all { it == null },20 "Collection should contain only nulls",21 "Collection should not contain only nulls"22 )23}24fun <T> Iterable<T>.shouldContainNull() = toList().shouldContainNull()25fun <T> Array<T>.shouldContainNull() = asList().shouldContainNull()26fun <T> Collection<T>.shouldContainNull() = this should containNull()27fun <T> Iterable<T>.shouldNotContainNull() = toList().shouldNotContainNull()28fun <T> Array<T>.shouldNotContainNull() = asList().shouldNotContainNull()29fun <T> Collection<T>.shouldNotContainNull() = this shouldNot containNull()30fun <T> containNull() = object : Matcher<Collection<T>> {31 override fun test(value: Collection<T>) =32 MatcherResult(33 value.any { it == null },34 "Collection should contain at least one null",35 "Collection should not contain any nulls"36 )37}38fun <T> Iterable<T>.shouldHaveElementAt(index: Int, element: T) = toList().shouldHaveElementAt(index, element)39fun <T> Array<T>.shouldHaveElementAt(index: Int, element: T) = asList().shouldHaveElementAt(index, element)40fun <T> List<T>.shouldHaveElementAt(index: Int, element: T) = this should haveElementAt(index, element)41fun <T> Iterable<T>.shouldNotHaveElementAt(index: Int, element: T) = toList().shouldNotHaveElementAt(index, element)42fun <T> Array<T>.shouldNotHaveElementAt(index: Int, element: T) = asList().shouldNotHaveElementAt(index, element)43fun <T> List<T>.shouldNotHaveElementAt(index: Int, element: T) = this shouldNot haveElementAt(index, element)44fun <T, L : List<T>> haveElementAt(index: Int, element: T) = object : Matcher<L> {45 override fun test(value: L) =46 MatcherResult(47 value[index] == element,48 { "Collection should contain ${element.show().value} at index $index" },49 { "Collection should not contain ${element.show().value} at index $index" }50 )51}52fun <T> Iterable<T>.shouldContainNoNulls() = toList().shouldContainNoNulls()53fun <T> Array<T>.shouldContainNoNulls() = asList().shouldContainNoNulls()54fun <T> Collection<T>.shouldContainNoNulls() = this should containNoNulls()55fun <T> Iterable<T>.shouldNotContainNoNulls() = toList().shouldNotContainNoNulls()56fun <T> Array<T>.shouldNotContainNoNulls() = asList().shouldNotContainNoNulls()57fun <T> Collection<T>.shouldNotContainNoNulls() = this shouldNot containNoNulls()58fun <T> containNoNulls() = object : Matcher<Collection<T>> {59 override fun test(value: Collection<T>) =60 MatcherResult(61 value.all { it != null },62 { "Collection should not contain nulls" },63 { "Collection should have at least one null" }64 )65}66infix fun <T> Array<T>.shouldNotContainExactlyInAnyOrder(expected: Array<T>) =67 asList().shouldNotContainExactlyInAnyOrder(expected.asList())68infix fun <T, C : Collection<T>> C?.shouldNotContainExactlyInAnyOrder(expected: C) =69 this shouldNot containExactlyInAnyOrder(expected)70fun <T, C : Collection<T>> C?.shouldNotContainExactlyInAnyOrder(vararg expected: T) =71 this shouldNot containExactlyInAnyOrder(*expected)72infix fun <T> Array<T>.shouldContainExactlyInAnyOrder(expected: Array<T>) =73 asList().shouldContainExactlyInAnyOrder(expected.asList())74infix fun <T, C : Collection<T>> C?.shouldContainExactlyInAnyOrder(expected: C) =75 this should containExactlyInAnyOrder(expected)76fun <T, C : Collection<T>> C?.shouldContainExactlyInAnyOrder(vararg expected: T) =77 this should containExactlyInAnyOrder(*expected)78fun <T> containExactlyInAnyOrder(vararg expected: T): Matcher<Collection<T>?> =79 containExactlyInAnyOrder(expected.asList())80/** Assert that a collection contains exactly the given values and nothing else, in any order. */81fun <T, C : Collection<T>> containExactlyInAnyOrder(expected: C): Matcher<C?> = neverNullMatcher { value ->82 val valueGroupedCounts: Map<T, Int> = value.groupBy { it }.mapValues { it.value.size }83 val expectedGroupedCounts: Map<T, Int> = expected.groupBy { it }.mapValues { it.value.size }84 val passed = expectedGroupedCounts.size == valueGroupedCounts.size85 && expectedGroupedCounts.all { valueGroupedCounts[it.key] == it.value }86 MatcherResult(87 passed,88 "Collection should contain ${expected.show().value} in any order, but was ${value.show().value}",89 "Collection should not contain exactly ${expected.show().value} in any order"90 )91}92infix fun <T : Comparable<T>> Iterable<T>.shouldHaveUpperBound(t: T) = toList().shouldHaveUpperBound(t)93infix fun <T : Comparable<T>> Array<T>.shouldHaveUpperBound(t: T) = asList().shouldHaveUpperBound(t)94infix fun <T : Comparable<T>, C : Collection<T>> C.shouldHaveUpperBound(t: T) = this should haveUpperBound(t)95fun <T : Comparable<T>, C : Collection<T>> haveUpperBound(t: T) = object : Matcher<C> {96 override fun test(value: C) = MatcherResult(97 value.all { it <= t },98 "Collection should have upper bound $t",99 "Collection should not have upper bound $t"100 )101}102infix fun <T : Comparable<T>> Iterable<T>.shouldHaveLowerBound(t: T) = toList().shouldHaveLowerBound(t)103infix fun <T : Comparable<T>> Array<T>.shouldHaveLowerBound(t: T) = asList().shouldHaveLowerBound(t)104infix fun <T : Comparable<T>, C : Collection<T>> C.shouldHaveLowerBound(t: T) = this should haveLowerBound(t)105fun <T : Comparable<T>, C : Collection<T>> haveLowerBound(t: T) = object : Matcher<C> {106 override fun test(value: C) = MatcherResult(107 value.all { t <= it },108 "Collection should have lower bound $t",109 "Collection should not have lower bound $t"110 )111}112fun <T> Iterable<T>.shouldBeUnique() = toList().shouldBeUnique()113fun <T> Array<T>.shouldBeUnique() = asList().shouldBeUnique()114fun <T> Collection<T>.shouldBeUnique() = this should beUnique()115fun <T> Iterable<T>.shouldNotBeUnique() = toList().shouldNotBeUnique()116fun <T> Array<T>.shouldNotBeUnique() = asList().shouldNotBeUnique()117fun <T> Collection<T>.shouldNotBeUnique() = this shouldNot beUnique()118fun <T> beUnique() = object : Matcher<Collection<T>> {119 override fun test(value: Collection<T>) = MatcherResult(120 value.toSet().size == value.size,121 "Collection should be Unique",122 "Collection should contain at least one duplicate element"123 )124}125fun <T> Iterable<T>.shouldContainDuplicates() = toList().shouldContainDuplicates()126fun <T> Array<T>.shouldContainDuplicates() = asList().shouldContainDuplicates()127fun <T> Collection<T>.shouldContainDuplicates() = this should containDuplicates()128fun <T> Iterable<T>.shouldNotContainDuplicates() = toList().shouldNotContainDuplicates()129fun <T> Array<T>.shouldNotContainDuplicates() = asList().shouldNotContainDuplicates()130fun <T> Collection<T>.shouldNotContainDuplicates() = this shouldNot containDuplicates()131fun <T> containDuplicates() = object : Matcher<Collection<T>> {132 override fun test(value: Collection<T>) = MatcherResult(133 value.toSet().size < value.size,134 "Collection should contain duplicates",135 "Collection should not contain duplicates"136 )137}138fun <T> beSortedWith(comparator: Comparator<in T>): Matcher<List<T>> = sortedWith(comparator)139fun <T> beSortedWith(cmp: (T, T) -> Int): Matcher<List<T>> = sortedWith(cmp)140fun <T> sortedWith(comparator: Comparator<in T>): Matcher<List<T>> = sortedWith { a, b ->141 comparator.compare(a, b)142}143fun <T> sortedWith(cmp: (T, T) -> Int): Matcher<List<T>> = object : Matcher<List<T>> {144 override fun test(value: List<T>): MatcherResult {145 val failure = value.withIndex().firstOrNull { (i, it) -> i != value.lastIndex && cmp(it, value[i + 1]) > 0 }146 val snippet = value.joinToString(",", limit = 10)147 val elementMessage = when (failure) {148 null -> ""149 else -> ". Element ${failure.value} at index ${failure.index} shouldn't precede element ${value[failure.index + 1]}"150 }151 return MatcherResult(152 failure == null,153 "List [$snippet] should be sorted$elementMessage",154 "List [$snippet] should not be sorted"155 )156 }157}158fun <T : Comparable<T>> Iterable<T>.shouldBeSorted() = toList().shouldBeSorted()159fun <T : Comparable<T>> Array<T>.shouldBeSorted() = asList().shouldBeSorted()160fun <T : Comparable<T>> List<T>.shouldBeSorted() = this should beSorted<T>()161fun <T : Comparable<T>> Iterable<T>.shouldNotBeSorted() = toList().shouldNotBeSorted()162fun <T : Comparable<T>> Array<T>.shouldNotBeSorted() = asList().shouldNotBeSorted()163fun <T : Comparable<T>> List<T>.shouldNotBeSorted() = this shouldNot beSorted<T>()164infix fun <T> Iterable<T>.shouldBeSortedWith(comparator: Comparator<in T>) = toList().shouldBeSortedWith(comparator)165infix fun <T> Array<T>.shouldBeSortedWith(comparator: Comparator<in T>) = asList().shouldBeSortedWith(comparator)166infix fun <T> List<T>.shouldBeSortedWith(comparator: Comparator<in T>) = this should beSortedWith(comparator)167infix fun <T> Iterable<T>.shouldNotBeSortedWith(comparator: Comparator<in T>) = toList().shouldNotBeSortedWith(comparator)168infix fun <T> Array<T>.shouldNotBeSortedWith(comparator: Comparator<in T>) = asList().shouldNotBeSortedWith(comparator)169infix fun <T> List<T>.shouldNotBeSortedWith(comparator: Comparator<in T>) = this shouldNot beSortedWith(comparator)170infix fun <T> Iterable<T>.shouldBeSortedWith(cmp: (T, T) -> Int) = toList().shouldBeSortedWith(cmp)171infix fun <T> Array<T>.shouldBeSortedWith(cmp: (T, T) -> Int) = asList().shouldBeSortedWith(cmp)172infix fun <T> List<T>.shouldBeSortedWith(cmp: (T, T) -> Int) = this should beSortedWith(cmp)173infix fun <T> Iterable<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int) = toList().shouldNotBeSortedWith(cmp)174infix fun <T> Array<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int) = asList().shouldNotBeSortedWith(cmp)175infix fun <T> List<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int) = this shouldNot beSortedWith(cmp)176fun <T : Comparable<T>> Iterable<T>.shouldBeMonotonicallyIncreasing() = toList().shouldBeMonotonicallyIncreasing()177fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyIncreasing() = asList().shouldBeMonotonicallyIncreasing()178fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyIncreasing() = this should beMonotonicallyIncreasing<T>()179fun <T : Comparable<T>> Iterable<T>.shouldNotBeMonotonicallyIncreasing() = toList().shouldNotBeMonotonicallyIncreasing()180fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyIncreasing() = asList().shouldNotBeMonotonicallyIncreasing()181fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyIncreasing() = this shouldNot beMonotonicallyIncreasing<T>()182fun <T> List<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>) =183 this should beMonotonicallyIncreasingWith(comparator)184fun <T> Iterable<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>) =185 toList().shouldBeMonotonicallyIncreasingWith(comparator)186fun <T> Array<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>) =187 asList().shouldBeMonotonicallyIncreasingWith(comparator)188fun <T> List<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>) =189 this shouldNot beMonotonicallyIncreasingWith(comparator)190fun <T> Iterable<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>) =191 toList().shouldNotBeMonotonicallyIncreasingWith(comparator)192fun <T> Array<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>) =193 asList().shouldNotBeMonotonicallyIncreasingWith(comparator)194fun <T : Comparable<T>> Iterable<T>.shouldBeMonotonicallyDecreasing() = toList().shouldBeMonotonicallyDecreasing()195fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyDecreasing() = asList().shouldBeMonotonicallyDecreasing()196fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyDecreasing() = this should beMonotonicallyDecreasing<T>()197fun <T : Comparable<T>> Iterable<T>.shouldNotBeMonotonicallyDecreasing() = toList().shouldNotBeMonotonicallyDecreasing()198fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyDecreasing() = asList().shouldNotBeMonotonicallyDecreasing()199fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyDecreasing() = this shouldNot beMonotonicallyDecreasing<T>()200fun <T> List<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>) =201 this should beMonotonicallyDecreasingWith(comparator)202fun <T> Iterable<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>) =203 toList().shouldBeMonotonicallyDecreasingWith(comparator)204fun <T> Array<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>) =205 asList().shouldBeMonotonicallyDecreasingWith(comparator)206fun <T> List<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>) =207 this shouldNot beMonotonicallyDecreasingWith(comparator)208fun <T> Iterable<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>) =209 toList().shouldNotBeMonotonicallyDecreasingWith(comparator)210fun <T> Array<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>) =211 asList().shouldNotBeMonotonicallyDecreasingWith(comparator)212fun <T : Comparable<T>> Iterable<T>.shouldBeStrictlyIncreasing() = toList().shouldBeStrictlyIncreasing()213fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasing() = asList().shouldBeStrictlyIncreasing()214fun <T : Comparable<T>> List<T>.shouldBeStrictlyIncreasing() = this should beStrictlyIncreasing<T>()215fun <T : Comparable<T>> Iterable<T>.shouldNotBeStrictlyIncreasing() = toList().shouldNotBeStrictlyIncreasing()216fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyIncreasing() = asList().shouldNotBeStrictlyIncreasing()217fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyIncreasing() = this shouldNot beStrictlyIncreasing<T>()218fun <T> List<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>) =219 this should beStrictlyIncreasingWith(comparator)220fun <T> Iterable<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>) =221 toList().shouldBeStrictlyIncreasingWith(comparator)222fun <T> Array<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>) =223 asList().shouldBeStrictlyIncreasingWith(comparator)224fun <T> List<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>) =225 this shouldNot beStrictlyIncreasingWith(comparator)226fun <T> Iterable<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>) =227 toList().shouldNotBeStrictlyIncreasingWith(comparator)228fun <T> Array<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>) =229 asList().shouldNotBeStrictlyIncreasingWith(comparator)230fun <T : Comparable<T>> Iterable<T>.shouldBeStrictlyDecreasing() = toList().shouldBeStrictlyDecreasing()231fun <T : Comparable<T>> List<T>.shouldBeStrictlyDecreasing() = this should beStrictlyDecreasing<T>()232fun <T : Comparable<T>> Iterable<T>.shouldNotBeStrictlyDecreasing() = toList().shouldNotBeStrictlyDecreasing()233fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyDecreasing() = this shouldNot beStrictlyDecreasing<T>()234fun <T> List<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>) =235 this should beStrictlyDecreasingWith(comparator)236fun <T> Iterable<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>) =237 toList().shouldBeStrictlyDecreasingWith(comparator)238fun <T> Array<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>) =239 asList().shouldBeStrictlyDecreasingWith(comparator)240fun <T> List<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>) =241 this shouldNot beStrictlyDecreasingWith(comparator)242fun <T> Iterable<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>) =243 toList().shouldNotBeStrictlyDecreasingWith(comparator)244fun <T> Array<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>) =245 asList().shouldNotBeStrictlyDecreasingWith(comparator)246infix fun <T> Iterable<T>.shouldHaveSingleElement(t: T) = toList().shouldHaveSingleElement(t)247infix fun <T> Array<T>.shouldHaveSingleElement(t: T) = asList().shouldHaveSingleElement(t)248infix fun <T> Iterable<T>.shouldHaveSingleElement(p: (T) -> Boolean) = toList().shouldHaveSingleElement(p)249infix fun <T> Array<T>.shouldHaveSingleElement(p: (T) -> Boolean) = asList().shouldHaveSingleElement(p)250infix fun <T> Collection<T>.shouldHaveSingleElement(t: T) = this should singleElement(t)251infix fun <T> Collection<T>.shouldHaveSingleElement(p: (T) -> Boolean) = this should singleElement(p)252infix fun <T> Iterable<T>.shouldNotHaveSingleElement(t: T) = toList().shouldNotHaveSingleElement(t)253infix fun <T> Array<T>.shouldNotHaveSingleElement(t: T) = asList().shouldNotHaveSingleElement(t)254infix fun <T> Collection<T>.shouldNotHaveSingleElement(t: T) = this shouldNot singleElement(t)255infix fun <T> Iterable<T>.shouldHaveSize(size: Int) = toList().shouldHaveSize(size)256infix fun <T> Array<T>.shouldHaveSize(size: Int) = asList().shouldHaveSize(size)257infix fun <T> Collection<T>.shouldHaveSize(size: Int) = this should haveSize(size = size)258infix fun <T> Iterable<T>.shouldNotHaveSize(size: Int) = toList().shouldNotHaveSize(size)259infix fun <T> Array<T>.shouldNotHaveSize(size: Int) = asList().shouldNotHaveSize(size)260infix fun <T> Collection<T>.shouldNotHaveSize(size: Int) = this shouldNot haveSize(size)261/**262 * Verifies this collection contains only one element263 *264 * This assertion is an alias to `collection shouldHaveSize 1`. This will pass if the collection have exactly one element265 * (definition of a Singleton Collection)266 *267 * ```268 * listOf(1).shouldBeSingleton() // Assertion passes269 * listOf(1, 2).shouldBeSingleton() // Assertion fails270 * ```271 *272 * @see [shouldHaveSize]273 * @see [shouldNotBeSingleton]274 * @see [shouldHaveSingleElement]275 */276fun <T> Collection<T>.shouldBeSingleton() = this shouldHaveSize 1277fun <T> Iterable<T>.shouldBeSingleton() = toList().shouldBeSingleton()278fun <T> Array<T>.shouldBeSingleton() = asList().shouldBeSingleton()279inline fun <T> Collection<T>.shouldBeSingleton(fn: (T) -> Unit) {280 this.shouldBeSingleton()281 fn(this.first())282}283inline fun <T> Iterable<T>.shouldBeSingleton(fn: (T) -> Unit) {284 toList().shouldBeSingleton(fn)285}286inline fun <T> Array<T>.shouldBeSingleton(fn: (T) -> Unit) {287 asList().shouldBeSingleton(fn)288}289/**290 * Verifies this collection doesn't contain only one element291 *292 * This assertion is an alias to `collection shouldNotHaveSize 1`. This will pass if the collection doesn't have exactly one element293 * (definition of a Singleton Collection)294 *295 * ```296 * listOf(1, 2).shouldNotBeSingleton() // Assertion passes297 * listOf<Int>().shouldNotBeSingleton() // Assertion passes298 * listOf(1).shouldNotBeSingleton() // Assertion fails299 * ```300 *301 * @see [shouldNotHaveSize]302 * @see [shouldBeSingleton]303 * @see [shouldNotHaveSingleElement]304 */305fun <T> Collection<T>.shouldNotBeSingleton() = this shouldNotHaveSize 1306fun <T> Iterable<T>.shouldNotBeSingleton() = toList().shouldNotBeSingleton()307fun <T> Array<T>.shouldNotBeSingleton() = asList().shouldNotBeSingleton()308infix fun <T, U> Iterable<T>.shouldBeLargerThan(other: Collection<U>) = toList().shouldBeLargerThan(other)309infix fun <T, U> Array<T>.shouldBeLargerThan(other: Collection<U>) = asList().shouldBeLargerThan(other)310infix fun <T, U> Iterable<T>.shouldBeLargerThan(other: Iterable<U>) = toList().shouldBeLargerThan(other.toList())311infix fun <T, U> Array<T>.shouldBeLargerThan(other: Array<U>) = asList().shouldBeLargerThan(other.asList())312infix fun <T, U> Collection<T>.shouldBeLargerThan(other: Collection<U>) = this should beLargerThan(other)313fun <T, U> beLargerThan(other: Collection<U>) = object : Matcher<Collection<T>> {314 override fun test(value: Collection<T>) = MatcherResult(315 value.size > other.size,316 "Collection of size ${value.size} should be larger than collection of size ${other.size}",317 "Collection of size ${value.size} should not be larger than collection of size ${other.size}"318 )319}320infix fun <T, U> Iterable<T>.shouldBeSmallerThan(other: Collection<U>) = toList().shouldBeSmallerThan(other)321infix fun <T, U> Array<T>.shouldBeSmallerThan(other: Collection<U>) = asList().shouldBeSmallerThan(other)322infix fun <T, U> Iterable<T>.shouldBeSmallerThan(other: Iterable<U>) = toList().shouldBeSmallerThan(other.toList())323infix fun <T, U> Array<T>.shouldBeSmallerThan(other: Array<U>) = asList().shouldBeSmallerThan(other.asList())324infix fun <T, U> Collection<T>.shouldBeSmallerThan(other: Collection<U>) = this should beSmallerThan(other)325fun <T, U> beSmallerThan(other: Collection<U>) = object : Matcher<Collection<T>> {326 override fun test(value: Collection<T>) = MatcherResult(327 value.size < other.size,328 "Collection of size ${value.size} should be smaller than collection of size ${other.size}",329 "Collection of size ${value.size} should not be smaller than collection of size ${other.size}"330 )331}332infix fun <T, U> Iterable<T>.shouldBeSameSizeAs(other: Collection<U>) = toList().shouldBeSameSizeAs(other)333infix fun <T, U> Array<T>.shouldBeSameSizeAs(other: Collection<U>) = asList().shouldBeSameSizeAs(other)334infix fun <T, U> Iterable<T>.shouldBeSameSizeAs(other: Iterable<U>) = toList().shouldBeSameSizeAs(other.toList())335infix fun <T, U> Array<T>.shouldBeSameSizeAs(other: Array<U>) = asList().shouldBeSameSizeAs(other.asList())336infix fun <T, U> Collection<T>.shouldBeSameSizeAs(other: Collection<U>) = this should beSameSizeAs(other)337fun <T, U> beSameSizeAs(other: Collection<U>) = object : Matcher<Collection<T>> {338 override fun test(value: Collection<T>) = MatcherResult(339 value.size == other.size,340 "Collection of size ${value.size} should be the same size as collection of size ${other.size}",341 "Collection of size ${value.size} should not be the same size as collection of size ${other.size}"342 )343}344infix fun <T> Iterable<T>.shouldHaveAtLeastSize(n: Int) = toList().shouldHaveAtLeastSize(n)345infix fun <T> Array<T>.shouldHaveAtLeastSize(n: Int) = asList().shouldHaveAtLeastSize(n)346infix fun <T> Collection<T>.shouldHaveAtLeastSize(n: Int) = this shouldHave atLeastSize(n)347fun <T> atLeastSize(n: Int) = object : Matcher<Collection<T>> {348 override fun test(value: Collection<T>) = MatcherResult(349 value.size >= n,350 "Collection should contain at least $n elements",351 "Collection should contain less than $n elements"352 )353}354infix fun <T> Iterable<T>.shouldHaveAtMostSize(n: Int) = toList().shouldHaveAtMostSize(n)355infix fun <T> Array<T>.shouldHaveAtMostSize(n: Int) = asList().shouldHaveAtMostSize(n)356infix fun <T> Collection<T>.shouldHaveAtMostSize(n: Int) = this shouldHave atMostSize(n)357fun <T> atMostSize(n: Int) = object : Matcher<Collection<T>> {358 override fun test(value: Collection<T>) = MatcherResult(359 value.size <= n,360 "Collection should contain at most $n elements",361 "Collection should contain more than $n elements"362 )363}364infix fun <T> Iterable<T>.shouldExist(p: (T) -> Boolean) = toList().shouldExist(p)365infix fun <T> Array<T>.shouldExist(p: (T) -> Boolean) = asList().shouldExist(p)366infix fun <T> Collection<T>.shouldExist(p: (T) -> Boolean) = this should exist(p)367fun <T> exist(p: (T) -> Boolean) = object : Matcher<Collection<T>> {368 override fun test(value: Collection<T>) = MatcherResult(369 value.any { p(it) },370 "Collection should contain an element that matches the predicate $p",371 "Collection should not contain an element that matches the predicate $p"372 )373}374fun <T> Iterable<T>.shouldExistInOrder(vararg ps: (T) -> Boolean) = toList().shouldExistInOrder(ps.toList())375fun <T> Array<T>.shouldExistInOrder(vararg ps: (T) -> Boolean) = asList().shouldExistInOrder(ps.toList())376fun <T> List<T>.shouldExistInOrder(vararg ps: (T) -> Boolean) = this.shouldExistInOrder(ps.toList())377infix fun <T> Iterable<T>.shouldExistInOrder(expected: List<(T) -> Boolean>) = toList().shouldExistInOrder(expected)378infix fun <T> Array<T>.shouldExistInOrder(expected: List<(T) -> Boolean>) = asList().shouldExistInOrder(expected)379infix fun <T> List<T>.shouldExistInOrder(expected: List<(T) -> Boolean>) = this should existInOrder(expected)380infix fun <T> Iterable<T>.shouldNotExistInOrder(expected: Iterable<(T) -> Boolean>) = toList().shouldNotExistInOrder(expected.toList())381infix fun <T> Array<T>.shouldNotExistInOrder(expected: Array<(T) -> Boolean>) = asList().shouldNotExistInOrder(expected.asList())382infix fun <T> Iterable<T>.shouldNotExistInOrder(expected: List<(T) -> Boolean>) = toList().shouldNotExistInOrder(expected)383infix fun <T> Array<T>.shouldNotExistInOrder(expected: List<(T) -> Boolean>) = asList().shouldNotExistInOrder(expected)384infix fun <T> List<T>.shouldNotExistInOrder(expected: List<(T) -> Boolean>) = this shouldNot existInOrder(expected)385fun <T> Iterable<T>.shouldBeEmpty() = toList().shouldBeEmpty()386fun <T> Array<T>.shouldBeEmpty() = asList().shouldBeEmpty()387fun <T> Collection<T>.shouldBeEmpty() = this should beEmpty()388fun <T> Iterable<T>.shouldNotBeEmpty() = toList().shouldNotBeEmpty()389fun <T> Array<T>.shouldNotBeEmpty() = asList().shouldNotBeEmpty()390fun <T> Collection<T>.shouldNotBeEmpty() = this shouldNot beEmpty()391fun <T> Iterable<T>.shouldContainAnyOf(vararg ts: T) = toList().shouldContainAnyOf(ts)392fun <T> Array<T>.shouldContainAnyOf(vararg ts: T) = asList().shouldContainAnyOf(ts)393fun <T> Collection<T>.shouldContainAnyOf(vararg ts: T) = this should containAnyOf(ts.asList())394fun <T> Iterable<T>.shouldNotContainAnyOf(vararg ts: T) = toList().shouldNotContainAnyOf(ts)395fun <T> Array<T>.shouldNotContainAnyOf(vararg ts: T) = asList().shouldNotContainAnyOf(ts)396fun <T> Collection<T>.shouldNotContainAnyOf(vararg ts: T) = this shouldNot containAnyOf(ts.asList())397infix fun <T> Iterable<T>.shouldContainAnyOf(ts: Collection<T>) = toList().shouldContainAnyOf(ts)398infix fun <T> Array<T>.shouldContainAnyOf(ts: Collection<T>) = asList().shouldContainAnyOf(ts)399infix fun <T> Collection<T>.shouldContainAnyOf(ts: Collection<T>) = this should containAnyOf(ts)400infix fun <T> Iterable<T>.shouldNotContainAnyOf(ts: Collection<T>) = toList().shouldNotContainAnyOf(ts)401infix fun <T> Array<T>.shouldNotContainAnyOf(ts: Collection<T>) = asList().shouldNotContainAnyOf(ts)402infix fun <T> Collection<T>.shouldNotContainAnyOf(ts: Collection<T>) = this shouldNot containAnyOf(ts)403fun <T> containAnyOf(ts: Collection<T>) = object : Matcher<Collection<T>> {404 override fun test(value: Collection<T>): MatcherResult {405 if (ts.isEmpty()) throwEmptyCollectionError()406 return MatcherResult(407 ts.any { it in value },408 { "Collection should contain any of ${ts.joinToString(separator = ", ", limit = 10) { it.show().value }}" },409 { "Collection should not contain any of ${ts.joinToString(separator = ", ", limit = 10) { it.show().value }}" }410 )411 }412}413/**414 * Verifies that this instance is in [collection]415 *416 * Assertion to check that this instance is in [collection]. This assertion checks by reference, and not by value,417 * therefore the exact instance must be in [collection], or this will fail.418 *419 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]420 *421 * @see [shouldNotBeOneOf]422 * @see [beOneOf]423 */424infix fun <T> T.shouldBeOneOf(collection: Collection<T>) = this should beOneOf(collection)425/**426 * Verifies that this instance is NOT in [collection]427 *428 * Assertion to check that this instance is not in [collection]. This assertion checks by reference, and not by value,429 * therefore the exact instance must not be in [collection], or this will fail.430 *431 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]432 *433 * @see [shouldBeOneOf]434 * @see [beOneOf]435 */436infix fun <T> T.shouldNotBeOneOf(collection: Collection<T>) = this shouldNot beOneOf(collection)437/**438 * Verifies that this instance is any of [any]439 *440 * Assertion to check that this instance is any of [any]. This assertion checks by reference, and not by value,441 * therefore the exact instance must be in [any], or this will fail.442 *443 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]444 *445 * @see [shouldNotBeOneOf]446 * @see [beOneOf]447 */448fun <T> T.shouldBeOneOf(vararg any: T) = this should beOneOf(any.toList())449/**450 * Verifies that this instance is NOT any of [any]451 *452 * Assertion to check that this instance is not any of [any]. This assertion checks by reference, and not by value,453 * therefore the exact instance must not be in [any], or this will fail.454 *455 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]456 *457 * @see [shouldNotBeOneOf]458 * @see [beOneOf]459 */460fun <T> T.shouldNotBeOneOf(vararg any: T) = this shouldNot beOneOf(any.toList())461/**462 * Matcher that verifies that this instance is in [collection]463 *464 * Assertion to check that this instance is in [collection]. This matcher checks by reference, and not by value,465 * therefore the exact instance must be in [collection], or this will fail.466 *467 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]468 *469 * @see [shouldBeOneOf]470 * @see [shouldNotBeOneOf]471 */472fun <T> beOneOf(collection: Collection<T>) = object : Matcher<T> {473 override fun test(value: T): MatcherResult {474 if (collection.isEmpty()) throwEmptyCollectionError()475 val match = collection.any { it === value }476 return MatcherResult(477 match,478 "Collection should contain the instance of value, but doesn't.",479 "Collection should not contain the instance of value, but does."480 )481 }482}483/**484 * Verifies that this element is in [collection] by comparing value485 *486 * Assertion to check that this element is in [collection]. This assertion checks by value, and not by reference,487 * therefore even if the exact instance is not in [collection] but another instance with same value is present, the488 * test will pass.489 *490 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]491 *492 * @see [shouldNotBeIn]493 * @see [beIn]494 */495infix fun <T> T.shouldBeIn(collection: Collection<T>) = this should beIn(collection)496/**497 * Verifies that this element is NOT any of [collection]498 *499 * Assertion to check that this element is not any of [collection]. This assertion checks by value, and not by reference,500 * therefore any instance with same value must not be in [collection], or this will fail.501 *502 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]503 *504 * @see [shouldNotBeIn]505 * @see [beIn]506 */507infix fun <T> T.shouldNotBeIn(collection: Collection<T>) = this shouldNot beIn(collection.toList())508/**509 * Verifies that this element is any of [any] by comparing value510 *511 * Assertion to check that this element is any of [any]. This assertion checks by value, and not by reference,512 * therefore even if the exact instance is not any of [any] but another instance with same value is present, the513 * test will pass.514 *515 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]516 *517 * @see [shouldNotBeIn]518 * @see [beIn]519 */520fun <T> T.shouldBeIn(vararg any: T) = this should beIn(any.toList())521/**522 * Verifies that this element is NOT any of [any]523 *524 * Assertion to check that this element is not any of [any]. This assertion checks by value, and not by reference,525 * therefore any instance with same value must not be in [any], or this will fail.526 *527 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]528 *529 * @see [shouldNotBeIn]530 * @see [beIn]531 */532fun <T> T.shouldNotBeIn(vararg any: T) = this shouldNot beIn(any.toList())533/**534 * Verifies that this element is in [array] by comparing value535 *536 * Assertion to check that this element is in [array]. This assertion checks by value, and not by reference,537 * therefore even if the exact instance is not in [array] but another instance with same value is present, the538 * test will pass.539 *540 * An empty array will always fail. If you need to check for empty array, use [Array.shouldBeEmpty]541 *542 * @see [shouldNotBeIn]543 * @see [beIn]544 */545@JvmName("shouldBeInArray")546infix fun <T> T.shouldBeIn(array: Array<T>) = this should beIn(array.toList())547/**548 * Verifies that this element is NOT any of [array]549 *550 * Assertion to check that this element is not any of [array]. This assertion checks by value, and not by reference,551 * therefore any instance with same value must not be in [array], or this will fail.552 *553 * An empty array will always fail. If you need to check for empty array, use [Array.shouldBeEmpty]554 *555 * @see [shouldNotBeIn]556 * @see [beIn]557 */558@JvmName("shouldNotBeInArray")559infix fun <T> T.shouldNotBeIn(array: Array<T>) = this shouldNot beIn(array.toList())560/**561 * Matcher that verifies that this element is in [collection] by comparing value562 *563 * Assertion to check that this element is in [collection]. This assertion checks by value, and not by reference,564 * therefore even if the exact instance is not in [collection] but another instance with same value is present, the565 * test will pass.566 *567 * An empty collection will always fail. If you need to check for empty collection, use [Collection.shouldBeEmpty]568 *569 * @see [shouldBeOneOf]570 * @see [shouldNotBeOneOf]571 */572fun <T> beIn(collection: Collection<T>) = object : Matcher<T> {573 override fun test(value: T): MatcherResult {574 if (collection.isEmpty()) throwEmptyCollectionError()575 val match = value in collection576 return MatcherResult(577 match,578 "Collection should contain ${value.show().value}, but doesn't. Possible values: ${collection.show().value}",579 "Collection should not contain ${value.show().value}, but does. Forbidden values: ${collection.show().value}"580 )581 }582}583private fun throwEmptyCollectionError(): Nothing {584 throw AssertionError("Asserting content on empty collection. Use Collection.shouldBeEmpty() instead.")585}...

increasing.kt

Source:increasing.kt

1package io.kotest.matchers.collections2import io.kotest.assertions.print.print3import io.kotest.matchers.Matcher4import io.kotest.matchers.MatcherResult5import io.kotest.matchers.should6import io.kotest.matchers.shouldNot7fun <T : Comparable<T>> Iterable<T>.shouldBeStrictlyIncreasing(): Iterable<T> {8 toList().shouldBeStrictlyIncreasing()9 return this10}11fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasing(): Array<T> {12 asList().shouldBeStrictlyIncreasing()13 return this14}15fun <T : Comparable<T>> List<T>.shouldBeStrictlyIncreasing(): List<T> {16 this should beStrictlyIncreasing()17 return this18}19fun <T : Comparable<T>> Iterable<T>.shouldNotBeStrictlyIncreasing(): Iterable<T> {20 toList().shouldNotBeStrictlyIncreasing()21 return this22}23fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyIncreasing(): Array<T> {24 asList().shouldNotBeStrictlyIncreasing()25 return this26}27fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyIncreasing(): List<T> {28 this shouldNot beStrictlyIncreasing()29 return this30}31fun <T : Comparable<T>> Iterable<T>.shouldBeMonotonicallyIncreasing(): Iterable<T> {32 toList().shouldBeMonotonicallyIncreasing()33 return this34}35fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyIncreasing(): Array<T> {36 asList().shouldBeMonotonicallyIncreasing()37 return this38}39fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyIncreasing(): List<T> {40 this should beMonotonicallyIncreasing()41 return this42}43fun <T : Comparable<T>> Iterable<T>.shouldNotBeMonotonicallyIncreasing(): Iterable<T> {44 toList().shouldNotBeMonotonicallyIncreasing()45 return this46}47fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyIncreasing(): Array<T> {48 asList().shouldNotBeMonotonicallyIncreasing()49 return this50}51fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyIncreasing(): List<T> {52 this shouldNot beMonotonicallyIncreasing()53 return this54}55fun <T> List<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): List<T> {56 this should beMonotonicallyIncreasingWith(comparator)57 return this58}59fun <T> Iterable<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Iterable<T> {60 toList().shouldBeMonotonicallyIncreasingWith(comparator)61 return this62}63fun <T> Array<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Array<T> {64 asList().shouldBeMonotonicallyIncreasingWith(comparator)65 return this66}67fun <T> List<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): List<T> {68 this shouldNot beMonotonicallyIncreasingWith(comparator)69 return this70}71fun <T> Iterable<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Iterable<T> {72 toList().shouldNotBeMonotonicallyIncreasingWith(comparator)73 return this74}75fun <T> Array<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Array<T> {76 asList().shouldNotBeMonotonicallyIncreasingWith(comparator)77 return this78}79fun <T> List<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>) =80 this should beStrictlyIncreasingWith(comparator)81fun <T> Iterable<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>) =82 toList().shouldBeStrictlyIncreasingWith(comparator)83fun <T> Array<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>) =84 asList().shouldBeStrictlyIncreasingWith(comparator)85fun <T> List<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>) =86 this shouldNot beStrictlyIncreasingWith(comparator)87fun <T> Iterable<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>) =88 toList().shouldNotBeStrictlyIncreasingWith(comparator)89fun <T> Array<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>) =90 asList().shouldNotBeStrictlyIncreasingWith(comparator)91fun <T : Comparable<T>> beStrictlyIncreasing(): Matcher<List<T>> = strictlyIncreasing()92fun <T : Comparable<T>> strictlyIncreasing(): Matcher<List<T>> = object : Matcher<List<T>> {93 override fun test(value: List<T>): MatcherResult {94 return testStrictlyIncreasingWith(value) { a, b -> a.compareTo(b) }95 }96}97fun <T> beStrictlyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>> = strictlyIncreasingWith(comparator)98fun <T> strictlyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>> = object : Matcher<List<T>> {99 override fun test(value: List<T>): MatcherResult {100 return testStrictlyIncreasingWith(value, comparator)101 }102}103private fun <T> testStrictlyIncreasingWith(value: List<T>, comparator: Comparator<in T>): MatcherResult {104 val failure = value.zipWithNext().withIndex().find { (_, pair) -> comparator.compare(pair.first, pair.second) >= 0 }105 val snippet = value.print().value106 val elementMessage = when (failure) {107 null -> ""108 else -> ". Element ${failure.value.second} at index ${failure.index + 1} was not strictly increased from previous element."109 }110 return MatcherResult(111 failure == null,112 { "List [$snippet] should be strictly increasing$elementMessage" },113 { "List [$snippet] should not be strictly increasing" }114 )115}116fun <T : Comparable<T>> beMonotonicallyIncreasing(): Matcher<List<T>> = monotonicallyIncreasing()117fun <T : Comparable<T>> monotonicallyIncreasing(): Matcher<List<T>> = object : Matcher<List<T>> {118 override fun test(value: List<T>): MatcherResult {119 return testMonotonicallyIncreasingWith(value) { a, b -> a.compareTo(b) }120 }121}122fun <T> beMonotonicallyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>> =123 monotonicallyIncreasingWith(comparator)124fun <T> monotonicallyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>> = object : Matcher<List<T>> {125 override fun test(value: List<T>): MatcherResult {126 return testMonotonicallyIncreasingWith(value, comparator)127 }128}129private fun <T> testMonotonicallyIncreasingWith(value: List<T>, comparator: Comparator<in T>): MatcherResult {130 val failure = value.zipWithNext().withIndex().find { (_, pair) -> comparator.compare(pair.first, pair.second) > 0 }131 val snippet = value.print().value132 val elementMessage = when (failure) {133 null -> ""134 else -> ". Element ${failure.value.second} at index ${failure.index + 1} was not monotonically increased from previous element."135 }136 return MatcherResult(137 failure == null,138 { "List [$snippet] should be monotonically increasing$elementMessage" },139 { "List [$snippet] should not be monotonically increasing" }140 )141}...

Array.shouldBeStrictlyIncreasingWith

Using AI Code Generation

1fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasingWith ( comparator : Comparator<T> ) : Unit2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.should5import io.kotest.matchers.shouldNot6fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasing() = this should strictlyIncreasing()7fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyIncreasing() = this shouldNot strictlyIncreasing()8fun <T : Comparable<T>> strictlyIncreasing() = object : Matcher<Array<T>> {9 override fun test(value: Array<T>): MatcherResult {10 return MatcherResult(11 value.isStrictlyIncreasing(),12 }13}14fun <T> Array<T>.isStrictlyIncreasing(): Boolean {15 for (i in 1 until this.size) {16 if (this[i - 1] >= this[i]) {17 }18 }19}20fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<T>) =21 this should strictlyIncreasingWith(comparator)22fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<T>) =23 this shouldNot strictlyIncreasingWith(comparator)24fun <T : Comparable<T>> strictlyIncreasingWith(comparator: Comparator<T>) = object : Matcher<Array<T>> {25 override fun test(value: Array<T>): MatcherResult {26 return MatcherResult(27 value.isStrictlyIncreasingWith(comparator

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

• JUnit Tutorial
• TestNG Tutorial
• Webdriver Tutorial
• WebDriverIO Tutorial
• Protractor Tutorial
• Selenium 4 Tutorial
• Jenkins Tutorial
• NUnit Tutorial
• Jest Tutorial
• Playwright Tutorial
• Cypress Tutorial
• PyTest Tutorial

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Kotest automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo View DocumentationSign up Free

›

_

Most used method in increasing

• List.shouldBeMonotonicallyIncreasingWith
• Iterable.shouldBeMonotonicallyIncreasingWith
• Array.shouldBeMonotonicallyIncreasingWith
• List.shouldNotBeMonotonicallyIncreasingWith
• Iterable.shouldNotBeMonotonicallyIncreasingWith
• Array.shouldNotBeMonotonicallyIncreasingWith
• List.shouldBeStrictlyIncreasingWith
• Iterable.shouldBeStrictlyIncreasingWith
• Array.shouldBeStrictlyIncreasingWith
• List.shouldNotBeStrictlyIncreasingWith
• Iterable.shouldNotBeStrictlyIncreasingWith
• Array.shouldNotBeStrictlyIncreasingWith
• test
• beStrictlyIncreasingWith
• strictlyIncreasingWith
• testStrictlyIncreasingWith
• beMonotonicallyIncreasingWith
• monotonicallyIncreasingWith
• testMonotonicallyIncreasingWith