-
Notifications
You must be signed in to change notification settings - Fork 1.8k
/
RunTestTest.kt
156 lines (140 loc) · 4.81 KB
/
RunTestTest.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/*
* Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
*/
package kotlinx.coroutines.test
import kotlinx.coroutines.*
import kotlin.coroutines.*
import kotlin.test.*
class RunTestTest {
/** Tests that [withContext] that sends work to other threads works in [runTest]. */
@Test
fun testWithContextDispatching() = runTest {
var counter = 0
withContext(Dispatchers.Default) {
counter += 1
}
assertEquals(counter, 1)
}
/** Tests that joining [GlobalScope.launch] works in [runTest]. */
@Test
fun testJoiningForkedJob() = runTest {
var counter = 0
val job = GlobalScope.launch {
counter += 1
}
job.join()
assertEquals(counter, 1)
}
/** Tests [suspendCoroutine] not failing [runTest]. */
@Test
fun testSuspendCoroutine() = runTest {
val answer = suspendCoroutine<Int> {
it.resume(42)
}
assertEquals(42, answer)
}
/** Tests that [runTest] attempts to detect it being run inside another [runTest] and failing in such scenarios. */
@Test
fun testNestedRunTestForbidden() = runTest {
assertFailsWith<IllegalStateException> {
runTest { }
}
}
/** Tests that even the dispatch timeout of `0` is fine if all the dispatches go through the same scheduler. */
@Test
fun testRunTestWithZeroTimeoutWithControlledDispatches() = runTest(dispatchTimeoutMs = 0) {
// below is some arbitrary concurrent code where all dispatches go through the same scheduler.
launch {
delay(2000)
}
val deferred = async {
val job = launch(TestCoroutineDispatcher(testScheduler)) {
launch {
delay(500)
}
delay(1000)
}
job.join()
}
deferred.await()
}
/** Tests that a dispatch timeout of `0` will fail the test if there are some dispatches outside the scheduler. */
@Test
fun testRunTestWithZeroTimeoutWithUncontrolledDispatches() = testResultMap({ fn ->
assertFailsWith<UncompletedCoroutinesError> { fn() }
}) {
runTest(dispatchTimeoutMs = 0) {
withContext(Dispatchers.Default) {
delay(10)
3
}
throw IllegalStateException("shouldn't be reached")
}
}
/** Tests that too low of a dispatch timeout causes crashes. */
@Test
@Ignore // TODO: timeout leads to `Cannot execute task because event loop was shut down` on Native
fun testRunTestWithSmallTimeout() = testResultMap({ fn ->
assertFailsWith<UncompletedCoroutinesError> { fn() }
}) {
runTest(dispatchTimeoutMs = 100) {
withContext(Dispatchers.Default) {
delay(10000)
3
}
throw RuntimeException("shouldn't be reached")
}
}
/** Tests that too low of a dispatch timeout causes crashes. */
@Test
fun testRunTestWithLargeTimeout() = runTest(dispatchTimeoutMs = 5000) {
withContext(Dispatchers.Default) {
delay(50)
}
}
/** Tests uncaught exceptions taking priority over dispatch timeout in error reports. */
@Test
@Ignore // TODO: timeout leads to `Cannot execute task because event loop was shut down` on Native
fun testRunTestTimingOutAndThrowing() = testResultMap({ fn ->
assertFailsWith<IllegalArgumentException> { fn() }
}) {
runTest(dispatchTimeoutMs = 1) {
coroutineContext[CoroutineExceptionHandler]!!.handleException(coroutineContext, IllegalArgumentException())
withContext(Dispatchers.Default) {
delay(10000)
3
}
throw RuntimeException("shouldn't be reached")
}
}
/** Tests that passing invalid contexts to [runTest] causes it to fail (on JS, without forking). */
@Test
fun testRunTestWithIllegalContext() {
for (ctx in TestCoroutineScopeTest.invalidContexts) {
assertFailsWith<IllegalArgumentException> {
runTest(ctx) { }
}
}
}
/** Tests that throwing exceptions in [runTest] fails the test with them. */
@Test
fun testThrowingInRunTestBody() = testResultMap({
assertFailsWith<RuntimeException> { it() }
}) {
runTest {
throw RuntimeException()
}
}
/** Tests that throwing exceptions in pending tasks [runTest] fails the test with them. */
@Test
fun testThrowingInRunTestPendingTask() = testResultMap({
assertFailsWith<RuntimeException> { it() }
}) {
runTest {
launch {
delay(SLOW)
throw RuntimeException()
}
}
}
}