Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use TestScope.withCoroutineContext method of io.kotest.engine.test.scopes.scopes class

Best Kotest code snippet using io.kotest.engine.test.scopes.scopes.TestScope.withCoroutineContext

coroutineDispatcherFactoryInterceptor.kt

Source:coroutineDispatcherFactoryInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.core.concurrency.CoroutineDispatcherFactory3import io.kotest.core.test.TestCase4import io.kotest.core.test.TestResult5import io.kotest.core.test.TestScope6import io.kotest.engine.concurrency.FixedThreadCoroutineDispatcherFactory7import io.kotest.engine.test.scopes.withCoroutineContext8import io.kotest.mpp.Logger9import kotlinx.coroutines.CoroutineDispatcher10import kotlinx.coroutines.test.TestCoroutineDispatcher11import kotlinx.coroutines.test.TestDispatcher12import kotlin.coroutines.coroutineContext13@ExperimentalStdlibApi14internal actual fun coroutineDispatcherFactoryInterceptor(15   defaultCoroutineDispatcherFactory: CoroutineDispatcherFactory16): TestExecutionInterceptor = CoroutineDispatcherFactoryInterceptor(defaultCoroutineDispatcherFactory)17/**18 * Switches execution onto a dispatcher provided by a [CoroutineDispatcherFactory].19 *20 * If the coroutine is an instance of [TestDispatcher] then the coroutine will not be changed.21 */22@ExperimentalStdlibApi23internal class CoroutineDispatcherFactoryInterceptor(24   private val defaultCoroutineDispatcherFactory: CoroutineDispatcherFactory25) : TestExecutionInterceptor {26   private val logger = Logger(CoroutineDispatcherFactoryInterceptor::class)27   override suspend fun intercept(28      testCase: TestCase,29      scope: TestScope,30      test: suspend (TestCase, TestScope) -> TestResult31   ): TestResult {32      val currentDispatcher = coroutineContext[CoroutineDispatcher]33      // we don't override if we've set a test dispatcher on this already34      return if (currentDispatcher is TestDispatcher) {35         test(testCase, scope)36      } else {37         val userFactory = testCase.spec.coroutineDispatcherFactory ?: testCase.spec.coroutineDispatcherFactory()38         val threads = testCase.spec.threads ?: testCase.spec.threads() ?: 139         logger.log { Pair(testCase.name.testName, "userFactory=$userFactory; threads=$threads") }40         val f = when {41            userFactory != null -> userFactory42            threads > 1 -> FixedThreadCoroutineDispatcherFactory(threads, false)43            else -> defaultCoroutineDispatcherFactory44         }45         logger.log { Pair(testCase.name.testName, "Switching dispatcher using factory $f") }46         f.withDispatcher(testCase) {47            test(testCase, scope.withCoroutineContext(coroutineContext))48         }49      }50   }51}...

TimeoutInterceptor.kt

Source:TimeoutInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.core.test.TestCase3import io.kotest.core.test.TestResult4import io.kotest.core.test.TestScope5import io.kotest.engine.test.scopes.withCoroutineContext6import io.kotest.mpp.Logger7import kotlinx.coroutines.withTimeout8import kotlin.time.Duration9import kotlin.time.TimeMark10/**11 * A [TestExecutionInterceptor] that installs a general timeout for all invocations of a test.12 */13internal class TimeoutInterceptor(14   private val mark: TimeMark,15) : TestExecutionInterceptor {16   private val logger = Logger(TimeoutInterceptor::class)17   override suspend fun intercept(18      testCase: TestCase,19      scope: TestScope,20      test: suspend (TestCase, TestScope) -> TestResult21   ): TestResult {22      // this timeout applies to the test itself. If the test has multiple invocations then23      // this timeout applies across all invocations. In other words, if a test has invocations = 3,24      // each test takes 300ms, and a timeout of 800ms, this would fail, becauase 3 x 300 > 800.25      logger.log { Pair(testCase.name.testName, "Switching context to add timeout ${testCase.config.timeout}") }26      return when (val timeout = testCase.config.timeout) {27         null -> test(testCase, scope)28         else -> try {29            withTimeout(timeout) {30               test(testCase, scope.withCoroutineContext(coroutineContext))31            }32         } catch (t: Throwable) {33            logger.log { Pair(testCase.name.testName, "Caught timeout $t") }34            TestResult.Error(mark.elapsedNow(), TestTimeoutException(timeout, testCase.name.testName))35         }36      }37   }38}39/**40 * Exception used for when a test exceeds its timeout.41 */42open class TestTimeoutException(val timeout: Duration, val testName: String) :43   Exception("Test '${testName}' did not complete within $timeout")...

CoroutineLoggingInterceptor.kt

Source:CoroutineLoggingInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.common.ExperimentalKotest3import io.kotest.core.config.ProjectConfiguration4import io.kotest.core.test.TestCase5import io.kotest.core.test.TestResult6import io.kotest.core.test.TestScope7import io.kotest.engine.test.TestExtensions8import io.kotest.engine.test.logging.SerialLogExtension9import io.kotest.engine.test.logging.TestLogger10import io.kotest.engine.test.logging.TestScopeLoggingCoroutineContextElement11import io.kotest.engine.test.scopes.withCoroutineContext12import io.kotest.mpp.Logger13import kotlinx.coroutines.withContext14@ExperimentalKotest15internal class CoroutineLoggingInterceptor(private val configuration: ProjectConfiguration) : TestExecutionInterceptor {16   private val logger = Logger(CoroutineLoggingInterceptor::class)17   override suspend fun intercept(18      testCase: TestCase,19      scope: TestScope,20      test: suspend (TestCase, TestScope) -> TestResult21   ): TestResult {22      val extensions = TestExtensions(configuration.registry).logExtensions(testCase)23      return when {24         configuration.logLevel.isDisabled() || extensions.isEmpty() -> {25            logger.log { Pair(testCase.name.testName, "Test logging is disabled (exts = $extensions)") }26            test(testCase, scope)27         }28         else -> {29            val logger = TestLogger(configuration.logLevel)30            withContext(TestScopeLoggingCoroutineContextElement(logger)) {31               test(testCase, scope.withCoroutineContext(coroutineContext))32            }.apply {33               extensions.map { SerialLogExtension(it) }.forEach { extension ->34                  runCatching {35                     extension.handleLogs(testCase, logger.logs.filter { it.level >= configuration.logLevel })36                  }37               }38            }39         }40      }41   }42}...

InvocationTimeoutInterceptor.kt

Source:InvocationTimeoutInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.core.test.TestCase3import io.kotest.core.test.TestResult4import io.kotest.core.test.TestScope5import io.kotest.core.test.TestType6import io.kotest.engine.test.scopes.withCoroutineContext7import io.kotest.mpp.Logger8import kotlinx.coroutines.TimeoutCancellationException9import kotlinx.coroutines.withTimeoutOrNull10import kotlin.math.min11import kotlin.time.Duration12/**13 * Installs an invocation timeout.14 */15internal object InvocationTimeoutInterceptor : TestExecutionInterceptor {16   private val logger = Logger(this::class)17   override suspend fun intercept(18      testCase: TestCase,19      scope: TestScope,20      test: suspend (TestCase, TestScope) -> TestResult21   ): TestResult {22      return if (testCase.type == TestType.Container) {23         test(testCase, scope)24      } else {25         // note: the invocation timeout cannot be larger than the test case timeout26         val timeout = min(27            testCase.config.timeout?.inWholeMilliseconds ?: 10000000,28            testCase.config.invocationTimeout?.inWholeMilliseconds ?: 1000000029         )30         logger.log { Pair(testCase.name.testName, "Switching context to add invocationTimeout $timeout") }31         return try {32            // we use orNull because we want to disambiguate between our timeouts and user level timeouts33            // user level timeouts will throw an exception, ours will return null34            withTimeoutOrNull(timeout) {35               test(testCase, scope.withCoroutineContext(coroutineContext))36            } ?: throw TestTimeoutException(Duration.milliseconds(timeout), testCase.name.testName)37         } catch (t: TimeoutCancellationException) {38            logger.log { Pair(testCase.name.testName, "Caught user timeout $t") }39            throw t40         }41      }42   }43}...

scopes.kt

Source:scopes.kt

1package io.kotest.engine.test.scopes2import io.kotest.core.concurrency.CoroutineDispatcherFactory3import io.kotest.core.config.ProjectConfiguration4import io.kotest.core.names.DuplicateTestNameMode5import io.kotest.core.test.TestCase6import io.kotest.core.test.TestScope7import io.kotest.engine.listener.TestEngineListener8import kotlin.coroutines.CoroutineContext9/**10 * Returns a new [TestScope] which uses the given [coroutineContext] with the other methods11 * delegating to the receiver context.12 */13internal fun TestScope.withCoroutineContext(coroutineContext: CoroutineContext): TestScope = when  {14   this.coroutineContext == coroutineContext -> this15   this is TestScopeWithCoroutineContext -> TestScopeWithCoroutineContext(delegate, coroutineContext)16   else -> TestScopeWithCoroutineContext(this, coroutineContext)17}18private class TestScopeWithCoroutineContext(19   val delegate: TestScope,20   override val coroutineContext: CoroutineContext21) : TestScope by delegate {22   override fun toString(): String = "TestCaseContext [$coroutineContext]"23}24/**25 * Creates a [TestScope] suitable for use in a single instance runner.26 */27fun createSingleInstanceTestScope(28   testCase: TestCase,29   coroutineContext: CoroutineContext,30   mode: DuplicateTestNameMode,31   listener: TestEngineListener,32   dispatcherFactory: CoroutineDispatcherFactory,33   configuration: ProjectConfiguration,34): TestScope {35   return DuplicateNameHandlingTestScope(36      testCase.spec.duplicateTestNameMode ?: configuration.duplicateTestNameMode,37      InOrderTestScope(38         testCase,39         coroutineContext,40         mode,41         listener,42         dispatcherFactory,43         configuration,44      )45   )46}...

TestDispatcherInterceptor.kt

Source:TestDispatcherInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.core.test.TestCase3import io.kotest.core.test.TestResult4import io.kotest.core.test.TestScope5import io.kotest.engine.test.scopes.withCoroutineContext6import io.kotest.mpp.Logger7import kotlinx.coroutines.CoroutineDispatcher8import kotlinx.coroutines.CoroutineName9import kotlinx.coroutines.ExperimentalCoroutinesApi10import kotlinx.coroutines.test.TestDispatcher11import kotlinx.coroutines.test.UnconfinedTestDispatcher12import kotlinx.coroutines.withContext13import kotlin.coroutines.coroutineContext14/**15 * A [TestExecutionInterceptor] that installs a [UnconfinedTestDispatcher] as the coroutine16 * dispatcher for the test.17 *18 * If the current dispatcher is already a [TestDispatcher] then this interceptor is a no-op.19 */20@ExperimentalCoroutinesApi21@ExperimentalStdlibApi22actual class TestDispatcherInterceptor : TestExecutionInterceptor {23   private val logger = Logger(TestDispatcherInterceptor::class)24   override suspend fun intercept(25      testCase: TestCase,26      scope: TestScope,27      test: suspend (TestCase, TestScope) -> TestResult28   ): TestResult {29      return when (coroutineContext[CoroutineDispatcher]) {30         is TestDispatcher -> test(testCase, scope)31         else -> {32            val dispatcher = UnconfinedTestDispatcher()33            logger.log { Pair(testCase.name.testName, "Switching context to StandardTestDispatcher: $dispatcher") }34            withContext(dispatcher + CoroutineName("wibble")) {35               test(testCase, scope.withCoroutineContext(dispatcher))36            }37         }38      }39   }40}...

TestCoroutineInterceptor.kt

Source:TestCoroutineInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.core.test.TestCase3import io.kotest.core.test.TestResult4import io.kotest.core.test.TestScope5import io.kotest.engine.test.scopes.withCoroutineContext6import io.kotest.mpp.Logger7import kotlinx.coroutines.ExperimentalCoroutinesApi8import kotlinx.coroutines.test.runTest9/**10 * A [TestExecutionInterceptor] that uses [runTest] from the coroutine library11 * to install test dispatchers.12 *13 * This setting cannot be nested.14 */15@ExperimentalCoroutinesApi16@ExperimentalStdlibApi17actual class TestCoroutineInterceptor : TestExecutionInterceptor {18   private val logger = Logger(TestCoroutineInterceptor::class)19   override suspend fun intercept(20      testCase: TestCase,21      scope: TestScope,22      test: suspend (TestCase, TestScope) -> TestResult23   ): TestResult {24      var result: TestResult = TestResult.Ignored25      logger.log { Pair(testCase.name.testName, "Switching context to coroutines runTest") }26      runTest {27         result = test(testCase, scope.withCoroutineContext(this.coroutineContext))28      }29      return result30   }31}...

SupervisorScopeInterceptor.kt

Source:SupervisorScopeInterceptor.kt

1package io.kotest.engine.test.interceptors2import io.kotest.core.test.TestCase3import io.kotest.core.test.TestResult4import io.kotest.core.test.TestScope5import io.kotest.engine.test.scopes.withCoroutineContext6import kotlinx.coroutines.supervisorScope7/**8 * We don't want any errors in child coroutines to propagate out and cancel all the coroutines used for9 * the specs / parent tests, therefore we install a [supervisorScope]. This scope adds a barrier10 * so that any child coroutines from this point on do not cancel any parent coroutines.11 */12internal object SupervisorScopeInterceptor : TestExecutionInterceptor {13   override suspend fun intercept(14      testCase: TestCase,15      scope: TestScope,16      test: suspend (TestCase, TestScope) -> TestResult17   ): TestResult {18      // a timeout in a parent test will still cause this to fail19      return supervisorScope {20         test(testCase, scope.withCoroutineContext(coroutineContext))21      }22   }23}...

TestScope.withCoroutineContext

Using AI Code Generation

1fun testWithCoroutineContext() = withCoroutineContext {2    delay(100)3    println("Hello World")4}5fun testWithCoroutineContext() = withCoroutineContext {6    delay(100)7    println("Hello World")8}9fun testWithCoroutineContext() = withCoroutineContext {10    delay(100)11    println("Hello World")12}13fun testWithCoroutineContext() = withCoroutineContext {14    delay(100)15    println("Hello World")16}17fun testWithCoroutineContext() = withCoroutineContext {18    delay(100)19    println("Hello World")20}21fun testWithCoroutineContext() = withCoroutineContext {22    delay(100)23    println("Hello World")24}25fun testWithCoroutineContext() = withCoroutineContext {26    delay(100)27    println("Hello World")28}29fun testWithCoroutineContext() = withCoroutineContext {30    delay(100)31    println("Hello World")32}33fun testWithCoroutineContext() = withCoroutineContext {34    delay(100)35    println("Hello World")36}37fun testWithCoroutineContext() = withCoroutineContext {38    delay(100)39    println("Hello World")40}41fun testWithCoroutineContext() = withCoroutineContext {42    delay(100)

TestScope.withCoroutineContext

Using AI Code Generation

1val scope = withCoroutineContext(coroutineContext)2scope.launch { }3scope.advanceTimeBy(1000)4scope.runBlockingTest {5}6scope.cancel()7val dispatcher = TestCoroutineDispatcher()8dispatcher.launch { }9dispatcher.advanceTimeBy(1000)10dispatcher.runBlockingTest {11}12dispatcher.cleanupTestCoroutines()13val exceptionHandler = TestCoroutineExceptionHandler()14exceptionHandler.launch { }15exceptionHandler.assertThrows<Exception> { }16exceptionHandler.cleanupTestCoroutines()17val scope = TestCoroutineScope()18scope.launch { }19scope.advanceTimeBy(1000)20scope.runBlockingTest {21}22scope.cleanupTestCoroutines()23val scope = TestCoroutineScope(coroutineContext)24scope.launch { }25scope.advanceTimeBy(1000)26scope.runBlockingTest {27}28scope.cleanupTestCoroutines()29val scope = TestCoroutineScope(dispatcher)

TestScope.withCoroutineContext

Using AI Code Generation

1suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )2suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )3suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )4suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )5suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )6suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )7suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )8suspend fun TestScope.withCoroutineContext ( context : CoroutineContext , block : suspend TestScope . ( ) -> Unit )9suspend fun TestScope.withCoroutineContext ( context : CoroutineContext ,

TestScope.withCoroutineContext

Using AI Code Generation

1}2}3}4}5}6}

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.