From 16b021ce9c5b2cef3212eb48b430ea0426003559 Mon Sep 17 00:00:00 2001 From: T45K Date: Wed, 13 Mar 2024 23:11:59 +0900 Subject: [PATCH 1/8] add `verifyCount` implementation --- .../src/commonMain/kotlin/io/mockk/API.kt | 21 +++++++++++++++++++ .../src/commonMain/kotlin/io/mockk/MockK.kt | 17 +++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt b/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt index 299282ee4..8ead568c5 100644 --- a/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt +++ b/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt @@ -2182,6 +2182,27 @@ class MockKVerificationScope( } } +/** + * Part of DSL. Additional operations for call count verification scope. + */ +class MockKCallCountVerificationScope { + operator fun Int.times(verifyBlock: MockKVerificationScope.() -> Unit) { + MockKGateway.implementation().verifier.verify( + VerificationParameters(Ordering.UNORDERED, min = this, max = this, inverse = false, timeout = 0), + verifyBlock, + null + ) + } + + operator fun IntRange.times(verifyBlock: MockKVerificationScope.() -> Unit) { + MockKGateway.implementation().verifier.verify( + VerificationParameters(Ordering.UNORDERED, min = this.first, max = this.last, inverse = false, timeout = 0), + verifyBlock, + null + ) + } +} + /** * Part of DSL. Object to represent phrase "wasNot Called" */ diff --git a/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt b/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt index 6f7c20334..e3ab35364 100644 --- a/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt +++ b/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt @@ -261,6 +261,7 @@ fun coVerify( * @see verify * @see verifyOrder * @see verifySequence + * @see verifyCount * * @param inverse when true, the verification will check that the behaviour specified did **not** happen */ @@ -278,6 +279,7 @@ fun verifyAll( * @see verify * @see verifyAll * @see verifySequence + * @see verifyCount * * @param inverse when true, the verification will check that the behaviour specified did **not** happen */ @@ -295,6 +297,7 @@ fun verifyOrder( * @see verify * @see verifyOrder * @see verifyAll + * @see verifyCount * * @param inverse when true, the verification will check that the behaviour specified did **not** happen */ @@ -305,6 +308,20 @@ fun verifySequence( MockKDsl.internalVerifySequence(inverse, verifyBlock) } +/** + * Verifies that calls and their count + * + * @see coVerifyCount Coroutine version + * @see verify + * @see verifyOrder + * @see verifyAll + * @see verifySequence + * + */ +fun verifyCount(verifyBlock: MockKCallCountVerificationScope.() -> Unit) = MockK.useImpl { + MockKCallCountVerificationScope().verifyBlock() +} + /** * Verifies that all calls inside [verifyBlock] happened. **Does not** verify any order. Coroutine version * From 075c7cefe5fc796494e22d0be46fc92c312518e4 Mon Sep 17 00:00:00 2001 From: T45K Date: Wed, 13 Mar 2024 23:16:04 +0900 Subject: [PATCH 2/8] add test for verifyCount --- .../it/CaptureSubclassVerificationTest.kt | 19 +++++++ .../io/mockk/it/VerificationErrorsTest.kt | 2 +- .../it/VerifyAtLeastAtMostExactlyTest.kt | 27 ++++++---- .../kotlin/io/mockk/it/VerifyTest.kt | 17 ++++++- .../mockk/it/VerificationAcknowledgeTest.kt | 50 ++++++++++++++++--- 5 files changed, 98 insertions(+), 17 deletions(-) diff --git a/modules/mockk/src/commonTest/kotlin/io/mockk/it/CaptureSubclassVerificationTest.kt b/modules/mockk/src/commonTest/kotlin/io/mockk/it/CaptureSubclassVerificationTest.kt index 714de0e6b..937fff0af 100644 --- a/modules/mockk/src/commonTest/kotlin/io/mockk/it/CaptureSubclassVerificationTest.kt +++ b/modules/mockk/src/commonTest/kotlin/io/mockk/it/CaptureSubclassVerificationTest.kt @@ -6,6 +6,7 @@ import io.mockk.just import io.mockk.mockk import io.mockk.slot import io.mockk.verify +import io.mockk.verifyCount import io.mockk.verifyOrder import io.mockk.verifySequence import kotlin.test.Test @@ -77,4 +78,22 @@ class CaptureSubclassVerificationTest { assertTrue(slot.isCaptured) assertIs(slot.captured) } + + @Test + fun `test count`() { + val service = mockk { + every { method(any()) } just Runs + } + + service.method(Subclass1()) + service.method(Subclass2()) + + val slot = slot() + verifyCount { + 2 * { service.method(any()) } + 1 * { service.method(capture(slot)) } + } + assertTrue(slot.isCaptured) + assertIs(slot.captured) + } } diff --git a/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerificationErrorsTest.kt b/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerificationErrorsTest.kt index 2d5633aaa..72c1cee0e 100644 --- a/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerificationErrorsTest.kt +++ b/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerificationErrorsTest.kt @@ -135,7 +135,7 @@ class VerificationErrorsTest { } @Test - fun callsNotMatchinVerificationSequence() { + fun callsNotMatchingVerificationSequence() { expectVerificationError("calls are not exactly matching verification sequence", "MockCls.otherOp") { every { mock.otherOp(1, any()) } answers { 2 + firstArg() } diff --git a/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyAtLeastAtMostExactlyTest.kt b/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyAtLeastAtMostExactlyTest.kt index f7682da29..caa5bf206 100644 --- a/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyAtLeastAtMostExactlyTest.kt +++ b/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyAtLeastAtMostExactlyTest.kt @@ -5,6 +5,7 @@ import io.mockk.clearAllMocks import io.mockk.every import io.mockk.mockk import io.mockk.verify +import io.mockk.verifyCount import io.mockk.verifyOrder import io.mockk.verifySequence import kotlin.test.Test @@ -193,6 +194,17 @@ class VerifyAtLeastAtMostExactlyTest { } } + @Test + fun count() { + doCalls() + + verifyCount { + 1 * { mock.op(0) } + 4 * { mock.op(1) } + 0 * { mock.op(2) } + } + } + @Test fun atLeastNeverAtAll() { every { mock.op(0) } returns 1 @@ -225,7 +237,7 @@ class VerifyAtLeastAtMostExactlyTest { } } - fun doCalls() { + private fun doCalls() { every { mock.op(0) } throws RuntimeException("test") every { mock.op(1) } returnsMany listOf(1, 2, 3) @@ -239,7 +251,7 @@ class VerifyAtLeastAtMostExactlyTest { assertEquals(3, mock.op(1)) } - fun doCalls2() { + private fun doCalls2() { every { mock.op(0) } throws RuntimeException("test") every { mock.op(1) } returnsMany listOf(1, 2, 3) andThen 5 every { mock.op2(2, 1) } returns 3 @@ -255,17 +267,14 @@ class VerifyAtLeastAtMostExactlyTest { assertEquals(3, mock.op2(2, 1)) } - fun doCalls3() { + private fun doCalls3() { if (doCalls4()) { - mock.op2(3,4) + mock.op2(3, 4) } } - fun doCalls4(): Boolean { - if (mock.op(0) == 0 || mock.op(1) == 1) { - return true - } - return false + private fun doCalls4(): Boolean { + return mock.op(0) == 0 || mock.op(1) == 1 } class MockCls { diff --git a/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyTest.kt b/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyTest.kt index e1448d45c..f7d7d8327 100644 --- a/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyTest.kt +++ b/modules/mockk/src/commonTest/kotlin/io/mockk/it/VerifyTest.kt @@ -5,6 +5,7 @@ import io.mockk.just import io.mockk.mockk import io.mockk.runs import io.mockk.verify +import io.mockk.verifyCount import io.mockk.verifyOrder import io.mockk.verifySequence import kotlin.test.Test @@ -14,7 +15,7 @@ class VerifyTest { val mock = mockk() - fun doCalls() { + private fun doCalls() { every { mock.op(5) } returns 1 every { mock.op(6) } returns 2 every { mock.op(7) } returns 3 @@ -157,6 +158,20 @@ class VerifyTest { } } + @Test + fun verifyCount() { + doCalls() + + verifyCount { + 0 * { mock.op(4) } // not called + 1 * { mock.op(5) } // called + (0..Int.MAX_VALUE) * { mock.op(6) } // called + (1..1) * { mock.op(7) } // called + (0..0) * { mock.op(8) } // not called + (0..1) * { mock.op(9) } // not called + } + } + /** * See issue #109 */ diff --git a/modules/mockk/src/jvmTest/kotlin/io/mockk/it/VerificationAcknowledgeTest.kt b/modules/mockk/src/jvmTest/kotlin/io/mockk/it/VerificationAcknowledgeTest.kt index 5e5510202..1e0886b73 100644 --- a/modules/mockk/src/jvmTest/kotlin/io/mockk/it/VerificationAcknowledgeTest.kt +++ b/modules/mockk/src/jvmTest/kotlin/io/mockk/it/VerificationAcknowledgeTest.kt @@ -1,12 +1,23 @@ package io.mockk.it -import io.mockk.* -import org.hamcrest.CoreMatchers.equalTo -import org.hamcrest.MatcherAssert.assertThat -import org.junit.jupiter.api.Test +import io.mockk.Called +import io.mockk.checkUnnecessaryStub +import io.mockk.clearAllMocks +import io.mockk.clearMocks +import io.mockk.confirmVerified +import io.mockk.every +import io.mockk.excludeRecords +import io.mockk.mockk +import io.mockk.verify +import io.mockk.verifyCount +import io.mockk.verifyOrder +import io.mockk.verifySequence import kotlin.test.assertEquals import kotlin.test.assertFails import kotlin.test.assertFailsWith +import org.hamcrest.CoreMatchers.equalTo +import org.hamcrest.MatcherAssert.assertThat +import org.junit.jupiter.api.Test class VerificationAcknowledgeTest { class MockCls { @@ -15,7 +26,7 @@ class VerificationAcknowledgeTest { val mock = mockk() - fun doCalls1() { + private fun doCalls1() { every { mock.op(5) } returns 1 every { mock.op(6) } returns 2 every { mock.op(7) } returns 3 @@ -26,7 +37,7 @@ class VerificationAcknowledgeTest { } - fun doCalls2() { + private fun doCalls2() { every { mock.op(0) } throws RuntimeException("test") every { mock.op(1) } returnsMany listOf(1, 2, 3) @@ -319,6 +330,33 @@ class VerificationAcknowledgeTest { } } + @Test + fun verifyCount() { + doCalls1() + + verifyCount { + 1 * { mock.op(6) } + 1 * { mock.op(5) } + 1 * { mock.op(7) } + } + + confirmVerified(mock) + } + + @Test + fun verifyCount2() { + doCalls1() + + verifyCount { + 1 * { mock.op(6) } + 1 * { mock.op(5) } + } + + assertFails { + confirmVerified(mock) + } + } + @Test fun atLeast() { doCalls2() From d33a024b3e49c850f95844ede26d3ce52136dd04 Mon Sep 17 00:00:00 2001 From: T45K Date: Wed, 13 Mar 2024 23:18:27 +0900 Subject: [PATCH 3/8] add coVerifyCount --- .../src/commonMain/kotlin/io/mockk/API.kt | 40 +++++++++++++++++-- .../src/commonMain/kotlin/io/mockk/MockK.kt | 14 +++++++ 2 files changed, 50 insertions(+), 4 deletions(-) diff --git a/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt b/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt index 8ead568c5..7bf260dee 100644 --- a/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt +++ b/modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt @@ -690,9 +690,10 @@ open class MockKMatcherScope( val lambda: CapturingSlot> ) { - fun match(matcher: Matcher, kclass: KClass): T { + fun match(matcher: Matcher, kclass: KClass): T { return callRecorder.matcher(matcher, kclass) } + inline fun match(matcher: Matcher): T { return callRecorder.matcher(matcher, T::class) } @@ -720,6 +721,7 @@ open class MockKMatcherScope( */ inline fun eq(value: T, inverse: Boolean = false): T = match(EqMatcher(value, inverse = inverse)) + /** * Matches if the value is not equal to the provided [value] via the `deepEquals` function. */ @@ -730,6 +732,7 @@ open class MockKMatcherScope( */ inline fun refEq(value: T, inverse: Boolean = false): T = match(EqMatcher(value, ref = true, inverse = inverse)) + /** * Matches if the value is not equal to the provided [value] via reference comparison. */ @@ -738,13 +741,15 @@ open class MockKMatcherScope( /** * Matches any argument given a [KClass] */ - fun any(classifier: KClass): T = match(ConstantMatcher(true), classifier) + fun any(classifier: KClass): T = match(ConstantMatcher(true), classifier) + /** * Matches any argument. */ inline fun any(): T = match(ConstantMatcher(true)) inline fun capture(lst: MutableList): T = match(CaptureMatcher(lst, T::class)) + /** * Captures a non-nullable value to a [CapturingSlot]. * @@ -782,7 +787,8 @@ open class MockKMatcherScope( * network.download("testfile") * // slot.captured is now "testfile" */ - inline fun captureNullable(lst: CapturingSlot): T? = match(CapturingNullableSlotMatcher(lst, T::class)) + inline fun captureNullable(lst: CapturingSlot): T? = + match(CapturingNullableSlotMatcher(lst, T::class)) /** * Captures a nullable value to a [MutableList]. @@ -797,12 +803,14 @@ open class MockKMatcherScope( * Matches if the value is equal to the provided [value] via the `compareTo` function. */ inline fun > cmpEq(value: T): T = match(ComparingMatcher(value, 0, T::class)) + /** * Matches if the value is more than the provided [value] via the `compareTo` function. * @param andEquals matches more than or equal to */ inline fun > more(value: T, andEquals: Boolean = false): T = match(ComparingMatcher(value, if (andEquals) 2 else 1, T::class)) + /** * Matches if the value is less than the provided [value] via the `compareTo` function. * @param andEquals matches less than or equal to @@ -824,10 +832,12 @@ open class MockKMatcherScope( * Combines two matchers via a logical and. */ inline fun and(left: T, right: T): T = match(AndOrMatcher(true, left, right)) + /** * Combines two matchers via a logical or. */ inline fun or(left: T, right: T): T = match(AndOrMatcher(false, left, right)) + /** * Negates the matcher. */ @@ -840,6 +850,7 @@ open class MockKMatcherScope( */ inline fun isNull(inverse: Boolean = false): T = match(NullCheckMatcher(inverse)) inline fun ofType(cls: KClass): T = match(OfTypeMatcher(cls)) + /** * Checks if the value belongs to the type. */ @@ -2203,6 +2214,27 @@ class MockKCallCountVerificationScope { } } +/** + * Part of DSL. Additional operations for coroutine call count verification scope. + */ +class MockKCallCountCoVerificationScope { + operator fun Int.times(verifyBlock: suspend MockKVerificationScope.() -> Unit) { + MockKGateway.implementation().verifier.verify( + VerificationParameters(Ordering.UNORDERED, min = this, max = this, inverse = false, timeout = 0), + null, + verifyBlock + ) + } + + operator fun IntRange.times(verifyBlock: suspend MockKVerificationScope.() -> Unit) { + MockKGateway.implementation().verifier.verify( + VerificationParameters(Ordering.UNORDERED, min = this.first, max = this.last, inverse = false, timeout = 0), + null, + verifyBlock + ) + } +} + /** * Part of DSL. Object to represent phrase "wasNot Called" */ @@ -2696,7 +2728,7 @@ class CapturingSlot { * For init state (not yet captured) returns false. */ val isNull - get() = when(val value = capturedValue) { + get() = when (val value = capturedValue) { is CapturedValue.Value -> value.value == null is CapturedValue.NotYetCaptured -> false } diff --git a/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt b/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt index e3ab35364..17db2f82c 100644 --- a/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt +++ b/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt @@ -377,6 +377,20 @@ fun coVerifySequence( MockKDsl.internalCoVerifySequence(inverse, verifyBlock) } +/** + * Verifies that calls and their count. Coroutine version + * + * @see verifyCount + * @see coVerify + * @see coVerifyOrder + * @see coVerifyAll + * @see coVerifySequence + * + */ +fun coVerifyCount(verifyBlock: MockKCallCountCoVerificationScope.() -> Unit) = MockK.useImpl { + MockKCallCountCoVerificationScope().verifyBlock() +} + /** * Exclude calls from recording * From 69869226bcbc9e6d66df65bbae81acbc9aadfc10 Mon Sep 17 00:00:00 2001 From: T45K Date: Wed, 13 Mar 2024 23:21:50 +0900 Subject: [PATCH 4/8] add test for coVerifyCount --- .../kotlin/io/mockk/it/CoVerifyTest.kt | 26 ++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/modules/mockk/src/commonTest/kotlin/io/mockk/it/CoVerifyTest.kt b/modules/mockk/src/commonTest/kotlin/io/mockk/it/CoVerifyTest.kt index 656b5ddbc..5570a9876 100644 --- a/modules/mockk/src/commonTest/kotlin/io/mockk/it/CoVerifyTest.kt +++ b/modules/mockk/src/commonTest/kotlin/io/mockk/it/CoVerifyTest.kt @@ -1,9 +1,15 @@ package io.mockk.it -import io.mockk.* -import kotlinx.coroutines.coroutineScope +import io.mockk.InternalPlatformDsl +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.coVerifyCount +import io.mockk.coVerifyOrder +import io.mockk.coVerifySequence +import io.mockk.mockk import kotlin.test.Test import kotlin.test.assertEquals +import kotlinx.coroutines.coroutineScope class CoVerifyTest { class MockCls { @@ -12,7 +18,7 @@ class CoVerifyTest { val mock = mockk() - fun doCalls() { + private fun doCalls() { coEvery { mock.op(5) } returns 1 coEvery { mock.op(6) } returns 2 coEvery { mock.op(7) } returns 3 @@ -156,4 +162,18 @@ class CoVerifyTest { mock.op(7) } } + + @Test + fun verifyCount() { + doCalls() + + coVerifyCount { + 0 * { mock.op(4) } // not called + 1 * { mock.op(5) } // called + (0..Int.MAX_VALUE) * { mock.op(6) } // called + (1..1) * { mock.op(7) } // called + (0..0) * { mock.op(8) } // not called + (0..1) * { mock.op(9) } // not called + } + } } From 97d4634f17d5c4ef46c57cab6b1ac853e6d11fd7 Mon Sep 17 00:00:00 2001 From: T45K Date: Wed, 13 Mar 2024 23:23:38 +0900 Subject: [PATCH 5/8] add missing doc --- modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt b/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt index 17db2f82c..bd98c2fa6 100644 --- a/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt +++ b/modules/mockk/src/commonMain/kotlin/io/mockk/MockK.kt @@ -331,6 +331,7 @@ fun verifyCount(verifyBlock: MockKCallCountVerificationScope.() -> Unit) = MockK * @see coVerify * @see coVerifyOrder * @see coVerifySequence + * @see coVerifyCount * * @param inverse when true, the verification will check that the behaviour specified did **not** happen */ @@ -349,6 +350,7 @@ fun coVerifyAll( * @see coVerify * @see coVerifyAll * @see coVerifySequence + * @see coVerifyCount * * @param inverse when true, the verification will check that the behaviour specified did **not** happen */ @@ -367,6 +369,7 @@ fun coVerifyOrder( * @see coVerify * @see coVerifyOrder * @see coVerifyAll + * @see coVerifyCount * * @param inverse when true, the verification will check that the behaviour specified did **not** happen */ From 270225f0b9e4fb486dbf2af8c11f1ca17ac7aa27 Mon Sep 17 00:00:00 2001 From: T45K Date: Fri, 15 Mar 2024 16:55:41 +0900 Subject: [PATCH 6/8] execute `:mockk-dsl:apiDump` --- modules/mockk-dsl/api/mockk-dsl.api | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/modules/mockk-dsl/api/mockk-dsl.api b/modules/mockk-dsl/api/mockk-dsl.api index 75280a820..b06e4ff7a 100644 --- a/modules/mockk-dsl/api/mockk-dsl.api +++ b/modules/mockk-dsl/api/mockk-dsl.api @@ -531,6 +531,18 @@ public final class io/mockk/MockKAssertScope { public final fun getActual ()Ljava/lang/Object; } +public final class io/mockk/MockKCallCountCoVerificationScope { + public fun ()V + public final fun times (ILkotlin/jvm/functions/Function2;)V + public final fun times (Lkotlin/ranges/IntRange;Lkotlin/jvm/functions/Function2;)V +} + +public final class io/mockk/MockKCallCountVerificationScope { + public fun ()V + public final fun times (ILkotlin/jvm/functions/Function1;)V + public final fun times (Lkotlin/ranges/IntRange;Lkotlin/jvm/functions/Function1;)V +} + public final class io/mockk/MockKCancellationRegistry { public static final field INSTANCE Lio/mockk/MockKCancellationRegistry; public final fun cancelAll ()V From e0166d3bf6483112fe720dfbaa731e9f86f9884d Mon Sep 17 00:00:00 2001 From: T45K Date: Fri, 15 Mar 2024 17:46:31 +0900 Subject: [PATCH 7/8] update README.md --- README.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/README.md b/README.md index aec97988b..29847127c 100644 --- a/README.md +++ b/README.md @@ -674,6 +674,26 @@ verify(exactly = 0) { car.accelerate(fromSpeed = 30, toSpeed = 10) } // means no confirmVerified(car) ``` +Or you can use `verifyCount`: + +```kotlin + +val car = mockk(relaxed = true) + +car.accelerate(fromSpeed = 10, toSpeed = 20) +car.accelerate(fromSpeed = 10, toSpeed = 30) +car.accelerate(fromSpeed = 20, toSpeed = 30) + +// all pass +verifyCount { + (3..5) * { car.accelerate(allAny(), allAny()) } // same as verify(atLeast = 3, atMost = 5) { car.accelerate(allAny(), allAny()) } + 1 * { car.accelerate(fromSpeed = 10, toSpeed = 20) } // same as verify(exactly = 1) { car.accelerate(fromSpeed = 10, toSpeed = 20) } + 0 * { car.accelerate(fromSpeed = 30, toSpeed = 10) } // same as verify(exactly = 0) { car.accelerate(fromSpeed = 30, toSpeed = 10) } +} + +confirmVerified(car) +``` + ### Verification order * `verifyAll` verifies that all calls happened without checking their order. From b11b7329b74e5cba5b77ce3664442764d617e5e6 Mon Sep 17 00:00:00 2001 From: T45K Date: Sat, 16 Mar 2024 02:10:23 +0900 Subject: [PATCH 8/8] update mockk.api --- modules/mockk/api/mockk.api | 2 ++ 1 file changed, 2 insertions(+) diff --git a/modules/mockk/api/mockk.api b/modules/mockk/api/mockk.api index 9d5d7812c..8dc8f08d3 100644 --- a/modules/mockk/api/mockk.api +++ b/modules/mockk/api/mockk.api @@ -38,6 +38,7 @@ public final class io/mockk/MockKKt { public static synthetic fun coVerify$default (Lio/mockk/Ordering;ZIIIJLkotlin/jvm/functions/Function2;ILjava/lang/Object;)V public static final fun coVerifyAll (ZLkotlin/jvm/functions/Function2;)V public static synthetic fun coVerifyAll$default (ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)V + public static final fun coVerifyCount (Lkotlin/jvm/functions/Function1;)V public static final fun coVerifyOrder (ZLkotlin/jvm/functions/Function2;)V public static synthetic fun coVerifyOrder$default (ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)V public static final fun coVerifySequence (ZLkotlin/jvm/functions/Function2;)V @@ -72,6 +73,7 @@ public final class io/mockk/MockKKt { public static synthetic fun verify$default (Lio/mockk/Ordering;ZIIIJLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public static final fun verifyAll (ZLkotlin/jvm/functions/Function1;)V public static synthetic fun verifyAll$default (ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public static final fun verifyCount (Lkotlin/jvm/functions/Function1;)V public static final fun verifyOrder (ZLkotlin/jvm/functions/Function1;)V public static synthetic fun verifyOrder$default (ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public static final fun verifySequence (ZLkotlin/jvm/functions/Function1;)V