Add DSL keyword "repeatedly" which enables repeated answer

modules/mockk-dsl/api/mockk-dsl.api

@@ -5,6 +5,8 @@ public final class io/mockk/APIKt {
 	public static final fun checkEquals (Lio/mockk/MockKAssertScope;Ljava/lang/String;Ljava/lang/Object;)V
 	public static final fun internalSubstitute (Ljava/lang/Object;Ljava/util/Map;)Ljava/lang/Object;
 	public static final fun internalSubstitute (Ljava/util/List;Ljava/util/Map;)Ljava/util/List;
+	public static final fun just (Lio/mockk/MockKRepeatedAnswerScope;Lio/mockk/Awaits;)Lio/mockk/MockKAdditionalAnswerScope;
+	public static final fun just (Lio/mockk/MockKRepeatedAnswerScope;Lio/mockk/Runs;)Lio/mockk/MockKAdditionalAnswerScope;
 	public static final fun just (Lio/mockk/MockKStubScope;Lio/mockk/Awaits;)Lio/mockk/MockKAdditionalAnswerScope;
 	public static final fun just (Lio/mockk/MockKStubScope;Lio/mockk/Runs;)Lio/mockk/MockKAdditionalAnswerScope;
 	public static final fun use (Lio/mockk/Deregisterable;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
@@ -922,6 +924,15 @@ public final class io/mockk/MockKObjectScope : io/mockk/MockKUnmockKScope {
 	public final fun getRecordPrivateCalls ()Z
 }
 
+public final class io/mockk/MockKRepeatedAnswerScope {
+	public fun <init> (Lio/mockk/MockKGateway$AnswerOpportunity;Lio/mockk/MockKGateway$CallRecorder;Lio/mockk/CapturingSlot;I)V
+	public final fun answers (Lio/mockk/Answer;)Lio/mockk/MockKAdditionalAnswerScope;
+	public final fun answers (Lkotlin/jvm/functions/Function2;)Lio/mockk/MockKAdditionalAnswerScope;
+	public final fun coAnswers (Lkotlin/jvm/functions/Function3;)Lio/mockk/MockKAdditionalAnswerScope;
+	public final fun returns (Ljava/lang/Object;)Lio/mockk/MockKAdditionalAnswerScope;
+	public final fun throws (Ljava/lang/Throwable;)Lio/mockk/MockKAdditionalAnswerScope;
+}
+
 public final class io/mockk/MockKSettings {
 	public static final field INSTANCE Lio/mockk/MockKSettings;
 	public final fun getRecordPrivateCalls ()Z
@@ -952,6 +963,7 @@ public final class io/mockk/MockKStubScope {
 	public final fun coAnswers (Lkotlin/jvm/functions/Function3;)Lio/mockk/MockKAdditionalAnswerScope;
 	public final fun nullablePropertyType (Lkotlin/reflect/KClass;)Lio/mockk/MockKStubScope;
 	public final fun propertyType (Lkotlin/reflect/KClass;)Lio/mockk/MockKStubScope;
+	public final fun repeatedly (I)Lio/mockk/MockKRepeatedAnswerScope;
 	public final fun returns (Ljava/lang/Object;)Lio/mockk/MockKAdditionalAnswerScope;
 	public final fun returnsArgument (I)Lio/mockk/MockKAdditionalAnswerScope;
 	public final fun returnsMany (Ljava/util/List;)Lio/mockk/MockKAdditionalAnswerScope;

modules/mockk-dsl/src/commonMain/kotlin/io/mockk/API.kt

@@ -2292,6 +2292,9 @@ class MockKStubScope<T, B>(
         return MockKAdditionalAnswerScope(answerOpportunity, callRecorder, lambda)
     }
 
+    infix fun repeatedly(times: Int): MockKRepeatedAnswerScope<T, B> =
+        MockKRepeatedAnswerScope(answerOpportunity, callRecorder, lambda, times)
+
     infix fun returns(returnValue: T) = answers(ConstantAnswer(returnValue))
 
     infix fun returnsMany(values: List<T>) = answers(ManyAnswersAnswer(values.allConst()))
@@ -2383,6 +2386,45 @@ infix fun MockKAdditionalAnswerScope<Unit, Unit>.andThenJust(runs: Runs) = andTh
 @Suppress("UNUSED_PARAMETER")
 infix fun <T, B> MockKAdditionalAnswerScope<T, B>.andThenJust(awaits: Awaits) = coAndThen { awaitCancellation() }
 
+/**
+ * Scope to repeat an answer to reply. Part of DSL
+ */
+class MockKRepeatedAnswerScope<T, B>(
+    private val answerOpportunity: AnswerOpportunity<T>,
+    private val callRecorder: CallRecorder,
+    private val lambda: CapturingSlot<Function<*>>,
+    private val times: Int,
+) {
+    infix fun answers(answer: Answer<T>): MockKAdditionalAnswerScope<T, B> {
+        repeat(times) {
+            answerOpportunity.provideAnswer(answer)
+        }
+        return MockKAdditionalAnswerScope(answerOpportunity, callRecorder, lambda)
+    }
+
+    infix fun answers(answer: MockKAnswerScope<T, B>.(Call) -> T): MockKAdditionalAnswerScope<T, B> =
+        answers(FunctionAnswer { MockKAnswerScope<T, B>(lambda, it).answer(it) })
+
+    infix fun returns(returnValue: T) = answers(ConstantAnswer(returnValue))
+
+    infix fun throws(ex: Throwable) = answers(ThrowingAnswer(ex))
+
+    infix fun coAnswers(answer: suspend MockKAnswerScope<T, B>.(Call) -> T) =
+        answers(CoFunctionAnswer { MockKAnswerScope<T, B>(lambda, it).answer(it) })
+}
+
+/**
+ * Part of DSL. Answer placeholder for Unit returning functions.
+ */
+@Suppress("UNUSED_PARAMETER")
+infix fun MockKRepeatedAnswerScope<Unit, Unit>.just(runs: Runs) = answers(ConstantAnswer(Unit))
+
+/**
+ * Part of DSL. Answer placeholder for never returning suspend functions.
+ */
+@Suppress("UNUSED_PARAMETER")
+infix fun <T, B> MockKRepeatedAnswerScope<T, B>.just(awaits: Awaits) = coAnswers { awaitCancellation() }
+
 internal fun <T> List<T>.allConst() = this.map { ConstantAnswer(it) }
 
 /**

modules/mockk/src/commonTest/kotlin/io/mockk/it/RepeatedlyAnswersTest.kt

@@ -0,0 +1,90 @@
+package io.mockk.it
+
+import io.mockk.*
+import kotlinx.coroutines.coroutineScope
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+class RepeatedlyAnswersTest {
+    private val mock = mockk<MockClass>()
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3])
+    fun repeatedlyAnswers(times: Int) {
+        every { mock.op() } repeatedly times answers ConstantAnswer("repeating") andThen "final"
+
+        repeat(times) {
+            assertEquals("repeating", mock.op())
+        }
+        assertEquals("final", mock.op())
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3])
+    fun repeatedlyAnswersLambda(times: Int) {
+        every { mock.op() } repeatedly times answers { "repeating" } andThen "final"
+
+        repeat(times) {
+            assertEquals("repeating", mock.op())
+        }
+        assertEquals("final", mock.op())
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3])
+    fun repeatedlyReturns(times: Int) {
+        every { mock.op() } repeatedly times returns "repeating" andThen "final"
+
+        repeat(times) {
+            assertEquals("repeating", mock.op())
+        }
+        assertEquals("final", mock.op())
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3])
+    fun repeatedlyThrows(times: Int) {
+        every { mock.op() } repeatedly times throws  RuntimeException("repeating") andThen "final"
+
+        repeat(times) {
+            assertFailsWith(RuntimeException::class, message = "repeating") {
+                mock.op()
+            }
+        }
+        assertEquals("final", mock.op())
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3])
+    fun repeatedlyCoAnswers(times: Int) {
+        every { mock.op() } repeatedly times coAnswers { coroutineScope { "repeating" } } andThen "final"
+
+        repeat(times) {
+            assertEquals("repeating", mock.op())
+        }
+        assertEquals("final", mock.op())
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3])
+    fun repeatedlyJustRuns(times: Int) {
+        every { mock.unitOp() } repeatedly times just Runs andThenThrows RuntimeException("final")
+
+        repeat(times) {
+            assertDoesNotThrow {
+                mock.unitOp()
+            }
+        }
+        assertFailsWith(RuntimeException::class, message = "final") {
+            mock.unitOp()
+        }
+    }
+
+    private interface MockClass {
+        fun op(): String
+        fun unitOp()
+    }
+}