Reverted use of 1.6 duration methods where possible

sksamuel · sksamuel · commit c006ceb5e850 · 2022-01-31T13:03:11.000-06:00
diff --git a/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/Retry.kt b/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/Retry.kt
@@ -6,7 +6,6 @@ import kotlin.time.Duration
 import kotlin.time.DurationUnit
 import kotlin.time.TimeSource
 import kotlinx.coroutines.delay
-import kotlin.time.Duration.Companion.seconds
 
 /**
  * Retry [f] until it's a success or [maxRetry]/[timeout] is reached
@@ -27,7 +26,7 @@ import kotlin.time.Duration.Companion.seconds
 suspend fun <T> retry(
    maxRetry: Int,
    timeout: Duration,
-   delay: Duration = 1.seconds,
+   delay: Duration = Duration.seconds(1),
    multiplier: Int = 1,
    f: suspend () -> T
 ): T = retry(maxRetry, timeout, delay, multiplier, Exception::class, f)
@@ -52,7 +51,7 @@ suspend fun <T> retry(
 suspend fun <T, E : Throwable> retry(
    maxRetry: Int,
    timeout: Duration,
-   delay: Duration = 1.seconds,
+   delay: Duration = Duration.seconds(1),
    multiplier: Int = 1,
    exceptionClass: KClass<E>,
    f: suspend () -> T
diff --git a/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/timing/continually.kt b/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/timing/continually.kt
@@ -6,7 +6,6 @@ import io.kotest.assertions.until.Interval
 import io.kotest.assertions.until.fixed
 import kotlinx.coroutines.delay
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.TimeMark
 import kotlin.time.TimeSource
 
@@ -22,7 +21,7 @@ fun interface ContinuallyListener<in T> {
 
 data class Continually<T> (
    val duration: Duration = Duration.INFINITE,
-   val interval: Interval = 25.milliseconds.fixed(),
+   val interval: Interval = Duration.milliseconds(25).fixed(),
    val listener: ContinuallyListener<T> = ContinuallyListener.noop,
    ) {
    suspend operator fun invoke(f: SuspendingProducer<T>): T? {
@@ -57,5 +56,5 @@ data class Continually<T> (
 suspend fun <T> continually(duration: Duration, poll: Duration, f: suspend () -> T) =
    continually(duration, poll.fixed(), f = f)
 
-suspend fun <T> continually(duration: Duration, interval: Interval = 10.milliseconds.fixed(), f: suspend () -> T) =
+suspend fun <T> continually(duration: Duration, interval: Interval = Duration.milliseconds(10).fixed(), f: suspend () -> T) =
    Continually<T>(duration, interval).invoke(f)
diff --git a/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/timing/eventually.kt b/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/timing/eventually.kt
@@ -8,7 +8,6 @@ import io.kotest.assertions.until.fixed
 import kotlinx.coroutines.delay
 import kotlin.reflect.KClass
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.TimeMark
 import kotlin.time.TimeSource
 
@@ -59,7 +58,7 @@ suspend fun <T> eventually(duration: Duration, exceptionClass: KClass<out Throwa
  */
 suspend fun <T> eventually(
    duration: Duration = Duration.INFINITE,
-   interval: Interval = 25.milliseconds.fixed(),
+   interval: Interval = Duration.milliseconds(25).fixed(),
    predicate: EventuallyPredicate<T> = { true },
    listener: EventuallyListener<T> = EventuallyListener { },
    retries: Int = Int.MAX_VALUE,
@@ -150,7 +149,7 @@ suspend fun <T> eventually(
 
 data class EventuallyConfig(
    val duration: Duration = Duration.INFINITE,
-   val interval: Interval = 25.milliseconds.fixed(),
+   val interval: Interval = Duration.milliseconds(25).fixed(),
    val retries: Int = Int.MAX_VALUE,
    val exceptionClass: KClass<out Throwable>? = null,
 ) {
diff --git a/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/ExponentialInterval.kt b/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/ExponentialInterval.kt
@@ -2,7 +2,6 @@ package io.kotest.assertions.until
 
 import kotlin.math.pow
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.hours
 
 /**
  * Exponential interval implements a delay where each duration is calculated as a multiplier
@@ -24,7 +23,7 @@ class ExponentialInterval(private val base: Duration, private val factor: Double
    }
 
    companion object {
-      val defaultMax = 2.hours
+      val defaultMax = Duration.hours(2)
       const val defaultFactor = 2.0
    }
 }
diff --git a/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/FibonacciInterval.kt b/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/FibonacciInterval.kt
@@ -1,8 +1,6 @@
 package io.kotest.assertions.until
 
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.hours
-import kotlin.time.Duration.Companion.milliseconds
 
 /**
  * Fibonacci delay implements a delay where each duration is calculated as a multiplier
@@ -26,12 +24,12 @@ class FibonacciInterval(private val base: Duration, private val offset: Int, pri
    override fun next(count: Int): Duration {
       val baseMs = base.inWholeMilliseconds
       val total = baseMs * fibonacci(offset + count)
-      val result = total.milliseconds
+      val result = Duration.milliseconds(total)
       return if (max == null) result else minOf(max, result)
    }
 
    companion object {
-      val defaultMax = 2.hours
+      val defaultMax = Duration.hours(2)
    }
 }
 
diff --git a/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/until.kt b/kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/until.kt
@@ -4,7 +4,6 @@ import io.kotest.assertions.failure
 import kotlin.time.Duration
 import kotlin.time.TimeSource
 import kotlinx.coroutines.delay
-import kotlin.time.Duration.Companion.seconds
 
 fun interface UntilListener<in T> {
    fun onEval(t: T)
@@ -33,7 +32,7 @@ data class PatienceConfig(
  * This method supports suspension.
  */
 suspend fun until(duration: Duration, f: suspend () -> Boolean) =
-   until(duration, interval = 1.seconds.fixed(), f = f)
+   until(duration, interval = Duration.seconds(1).fixed(), f = f)
 
 /**
  * Executes a function at a given interval until it returns true, or until a specified duration has elapsed.
@@ -72,7 +71,7 @@ suspend fun <T> until(
    duration: Duration,
    predicate: suspend (T) -> Boolean,
    f: suspend () -> T
-): T = until(duration, interval = 1.seconds.fixed(), predicate = predicate, f = f)
+): T = until(duration, interval = Duration.seconds(1).fixed(), predicate = predicate, f = f)
 
 /**
  * Executes the function [f] at a given [interval] until it returns a value that passes the given [predicate],
@@ -109,7 +108,7 @@ suspend fun <T> until(
 @Deprecated("Simply move the listener code into the predicate code. Will be removed in 6.0")
 suspend fun <T> until(
    duration: Duration,
-   interval: Interval = 1.seconds.fixed(),
+   interval: Interval = Duration.seconds(1).fixed(),
    predicate: suspend (T) -> Boolean,
    listener: UntilListener<T>,
    f: suspend () -> T
diff --git a/kotest-extensions/kotest-extensions-junitxml/src/jvmMain/kotlin/io/kotest/extensions/junitxml/JunitXmlReporter.kt b/kotest-extensions/kotest-extensions-junitxml/src/jvmMain/kotlin/io/kotest/extensions/junitxml/JunitXmlReporter.kt
@@ -24,7 +24,7 @@ import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter.ISO_LOCAL_DATE_TIME
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.reflect.KClass
-import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration
 import kotlin.time.DurationUnit
 
 @Deprecated("Now called JunitXmlReporter. Deprecated since 4.6.")
@@ -85,7 +85,7 @@ class JunitXmlReporter(
       val document = Document()
       val testSuite = Element("testsuite")
       testSuite.setAttribute("timestamp", ISO_LOCAL_DATE_TIME.format(getCurrentDateTime()))
-      testSuite.setAttribute("time", (duration.milliseconds.toDouble(DurationUnit.SECONDS)).toString())
+      testSuite.setAttribute("time", (Duration.milliseconds(duration).toDouble(DurationUnit.SECONDS)).toString())
       testSuite.setAttribute("hostname", hostname())
       testSuite.setAttribute("errors", filtered.filter { it.value.isError }.size.toString())
       testSuite.setAttribute("failures", filtered.filter { it.value.isFailure }.size.toString())
diff --git a/kotest-framework/kotest-framework-api/src/commonMain/kotlin/io/kotest/core/test/TestResult.kt b/kotest-framework/kotest-framework-api/src/commonMain/kotlin/io/kotest/core/test/TestResult.kt
@@ -1,7 +1,6 @@
 package io.kotest.core.test
 
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
 
 sealed interface TestResult {
 
@@ -10,19 +9,19 @@ sealed interface TestResult {
          "Replaced with TestResult.Success. Deprecated since 5.0",
          ReplaceWith("TestResult.Success(durationMillis.milliseconds)", "kotlin.time.Duration.Companion.milliseconds")
       )
-      fun success(durationMillis: Long): Success = Success(durationMillis.milliseconds)
+      fun success(durationMillis: Long): Success = Success(Duration.milliseconds(durationMillis))
 
       @Deprecated(
          "Replaced with TestResult.Failure. Deprecated since 5.0",
          ReplaceWith("TestResult.Failure(durationMillis.milliseconds, error)", "kotlin.time.Duration.Companion.milliseconds")
       )
-      fun failure(error: AssertionError, durationMillis: Long): Failure = Failure(durationMillis.milliseconds, error)
+      fun failure(error: AssertionError, durationMillis: Long): Failure = Failure(Duration.milliseconds(durationMillis), error)
 
       @Deprecated(
          "Replaced with TestResult.Error. Deprecated since 5.0",
          ReplaceWith("TestResult.Error(durationMillis.milliseconds, error)", "kotlin.time.Duration.Companion.milliseconds")
       )
-      fun error(error: Throwable, durationMillis: Long): Error = Error(durationMillis.milliseconds, error)
+      fun error(error: Throwable, durationMillis: Long): Error = Error(Duration.milliseconds(durationMillis), error)
 
       val Ignored = Ignored(null)
    }
diff --git a/kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/spec/resolveConfig.kt b/kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/spec/resolveConfig.kt
@@ -1,14 +1,14 @@
 package io.kotest.engine.spec
 
 import io.kotest.core.config.ProjectConfiguration
-import io.kotest.engine.tags.tags
 import io.kotest.core.spec.Spec
 import io.kotest.core.test.Enabled
 import io.kotest.core.test.EnabledOrReasonIf
 import io.kotest.core.test.TestCase
 import io.kotest.core.test.config.ResolvedTestConfig
 import io.kotest.core.test.config.UnresolvedTestConfig
-import kotlin.time.Duration.Companion.milliseconds
+import io.kotest.engine.tags.tags
+import kotlin.time.Duration
 
 /**
  * Accepts an [UnresolvedTestConfig] and returns a [ResolvedTestConfig] by completing
@@ -41,10 +41,10 @@ internal fun resolveConfig(
 
    val timeout = config?.timeout
       ?: parent?.config?.timeout
-      ?: spec.timeout?.milliseconds
-      ?: spec.timeout()?.milliseconds
+      ?: spec.timeout?.toMillis()
+      ?: spec.timeout()?.toMillis()
       ?: defaultTestConfig.timeout
-      ?: configuration.timeout.milliseconds
+      ?: configuration.timeout.toMillis()
 
    val threads = config?.threads
       ?: spec.threads
@@ -56,10 +56,10 @@ internal fun resolveConfig(
 
    val invocationTimeout = config?.invocationTimeout
       ?: parent?.config?.invocationTimeout
-      ?: spec.invocationTimeout?.milliseconds
-      ?: spec.invocationTimeout()?.milliseconds
+      ?: spec.invocationTimeout?.toMillis()
+      ?: spec.invocationTimeout()?.toMillis()
       ?: defaultTestConfig.invocationTimeout
-      ?: configuration.invocationTimeout.milliseconds
+      ?: configuration.invocationTimeout.toMillis()
 
    val extensions = (config?.listeners ?: emptyList()) +
       (config?.extensions ?: emptyList()) +
@@ -83,3 +83,6 @@ internal fun resolveConfig(
       blockingTest = config?.blockingTest ?: parent?.config?.blockingTest ?: spec.blockingTest ?: configuration.blockingTest,
    )
 }
+
+fun Long.toMillis(): Duration = Duration.milliseconds(this)
+fun Long?.toMillis(): Duration? = if (this == null) null else Duration.milliseconds(this)
diff --git a/kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/test/createResult.kt b/kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/test/createResult.kt
@@ -4,7 +4,6 @@ import io.kotest.core.test.TestResult
 import io.kotest.mpp.bestName
 import kotlin.jvm.JvmName
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
 
 /**
  * Returns a [TestResult] derived from a throwable.
@@ -19,7 +18,7 @@ import kotlin.time.Duration.Companion.milliseconds
    ReplaceWith("createTestResult(duration.milliseconds, error)")
 )
 fun createTestResult(duration: Long, error: Throwable?): TestResult =
-   createTestResult(duration.milliseconds, error)
+   createTestResult(Duration.milliseconds(duration), error)
 
 fun createTestResult(duration: Duration, error: Throwable?): TestResult = when {
    error == null -> TestResult.Success(duration)
@@ -33,7 +32,7 @@ fun createTestResult(duration: Duration, error: Throwable?): TestResult = when {
    "Replaced with Throwable.toTestResult(Duration)",
    ReplaceWith("createTestResult(duration.milliseconds, this)", "kotlin.time.milliseconds")
 )
-fun Throwable.toTestResult(duration: Long): TestResult = createTestResult(duration.milliseconds, this)
+fun Throwable.toTestResult(duration: Long): TestResult = createTestResult(Duration.milliseconds(duration), this)
 
 @JvmName("throwableToTestResult")
 fun Throwable.toTestResult(duration: Duration): TestResult = createTestResult(duration, this)
diff --git a/kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/test/interceptors/InvocationTimeoutInterceptor.kt b/kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/test/interceptors/InvocationTimeoutInterceptor.kt
@@ -9,7 +9,7 @@ import io.kotest.mpp.Logger
 import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.withTimeoutOrNull
 import kotlin.math.min
-import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration
 
 /**
  * Installs an invocation timeout.
@@ -29,10 +29,10 @@ internal object InvocationTimeoutInterceptor : TestExecutionInterceptor {
       } else {
 
          // note: the invocation timeout cannot be larger than the test case timeout
-         val timeout = min(
+         val timeout = Duration.milliseconds(min(
             testCase.config.timeout.inWholeMilliseconds,
             testCase.config.invocationTimeout.inWholeMilliseconds
-         ).milliseconds
+         ))
 
          logger.log { Pair(testCase.name.testName, "Switching context to add invocationTimeout $timeout") }
 
diff --git a/kotest-framework/kotest-framework-engine/src/jvmMain/kotlin/io/kotest/engine/config/applyConfigFromSystemProperties.kt b/kotest-framework/kotest-framework-engine/src/jvmMain/kotlin/io/kotest/engine/config/applyConfigFromSystemProperties.kt
@@ -1,15 +1,14 @@
 package io.kotest.engine.config
 
-import io.kotest.core.config.ProjectConfiguration
 import io.kotest.core.config.LogLevel
+import io.kotest.core.config.ProjectConfiguration
 import io.kotest.core.internal.KotestEngineProperties
 import io.kotest.core.names.DuplicateTestNameMode
 import io.kotest.core.spec.IsolationMode
 import io.kotest.core.test.AssertionMode
 import io.kotest.mpp.env
 import io.kotest.mpp.sysprop
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
 
 /**
  * Uses system properties to load configuration values onto the supplied [ProjectConfiguration] object.
@@ -65,8 +64,11 @@ internal fun testNameAppendTags(): Boolean? =
 internal fun duplicateTestNameMode(): DuplicateTestNameMode? =
    sysprop(KotestEngineProperties.duplicateTestNameMode)?.let { DuplicateTestNameMode.valueOf(it) }
 
-internal fun projectTimeout(): Duration? =
-   sysprop(KotestEngineProperties.projectTimeout)?.toLong()?.milliseconds
+internal fun projectTimeout(): Duration? {
+   val d = sysprop(KotestEngineProperties.projectTimeout)?.toLong() ?: return null
+   return Duration.milliseconds(d)
+}
+
 
 internal fun logLevel(): LogLevel {
    val levelProp = sysprop(KotestEngineProperties.logLevel)?.let { LogLevel.from(it) }
diff --git a/kotest-framework/kotest-framework-engine/src/jvmMain/kotlin/io/kotest/engine/listener/EnhancedConsoleTestEngineListener.kt b/kotest-framework/kotest-framework-engine/src/jvmMain/kotlin/io/kotest/engine/listener/EnhancedConsoleTestEngineListener.kt
@@ -15,7 +15,6 @@ import io.kotest.engine.test.names.formatTestPath
 import io.kotest.engine.test.names.getDisplayNameFormatter
 import kotlin.reflect.KClass
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
 
 /**
  * Generates test output to the console in an enhanced, formatted, coloured, way.
@@ -30,8 +29,8 @@ class EnhancedConsoleTestEngineListener(private val term: TermColors) : Abstract
    private var testsPassed = 0
    private var specsFailed = emptyList<Descriptor.SpecDescriptor>()
    private var specsSeen = emptyList<Descriptor>()
-   private var slow = 500.milliseconds
-   private var verySlow = 5000.milliseconds
+   private var slow = Duration.milliseconds(500)
+   private var verySlow = Duration.milliseconds(5000)
 
    private var formatter:DisplayNameFormatter = DefaultDisplayNameFormatter(ProjectConfiguration())
 
diff --git a/kotest-framework/kotest-framework-engine/src/jvmTest/kotlin/com/sksamuel/kotest/engine/test/timeout/WithTimeoutTest.kt b/kotest-framework/kotest-framework-engine/src/jvmTest/kotlin/com/sksamuel/kotest/engine/test/timeout/WithTimeoutTest.kt
@@ -6,8 +6,7 @@ import io.kotest.engine.listener.CollectingTestEngineListener
 import io.kotest.matchers.shouldBe
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withTimeout
-import kotlin.time.Duration.Companion.minutes
-import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Duration
 import kotlin.time.ExperimentalTime
 
 @ExperimentalTime
@@ -29,8 +28,8 @@ class WithTimeoutTest : FunSpec() {
 private class WithTimeoutSpec : FunSpec() {
    init {
       test("a") {
-         withTimeout(1.seconds) {
-            delay(1.minutes)
+         withTimeout(Duration.seconds(1)) {
+            delay(Duration.minutes(1))
          }
       }
    }

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@ package io.kotest.assertions.until`
`2`	`2`
`3`	`3`	`import kotlin.math.pow`
`4`	`4`	`import kotlin.time.Duration`
`5`		`-import kotlin.time.Duration.Companion.hours`
`6`	`5`
`7`	`6`	`/**`
`8`	`7`	`* Exponential interval implements a delay where each duration is calculated as a multiplier`
`@@ -24,7 +23,7 @@ class ExponentialInterval(private val base: Duration, private val factor: Double`
`24`	`23`	`}`
`25`	`24`
`26`	`25`	`companion object {`
`27`		`- val defaultMax = 2.hours`
	`26`	`+ val defaultMax = Duration.hours(2)`
`28`	`27`	`const val defaultFactor = 2.0`
`29`	`28`	`}`
`30`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`	`1`	`package io.kotest.assertions.until`
`2`	`2`
`3`	`3`	`import kotlin.time.Duration`
`4`		`-import kotlin.time.Duration.Companion.hours`
`5`		`-import kotlin.time.Duration.Companion.milliseconds`
`6`	`4`
`7`	`5`	`/**`
`8`	`6`	`* Fibonacci delay implements a delay where each duration is calculated as a multiplier`
`@@ -26,12 +24,12 @@ class FibonacciInterval(private val base: Duration, private val offset: Int, pri`
`26`	`24`	`override fun next(count: Int): Duration {`
`27`	`25`	`val baseMs = base.inWholeMilliseconds`
`28`	`26`	`val total = baseMs * fibonacci(offset + count)`
`29`		`- val result = total.milliseconds`
	`27`	`+ val result = Duration.milliseconds(total)`
`30`	`28`	`return if (max == null) result else minOf(max, result)`
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`companion object {`
`34`		`- val defaultMax = 2.hours`
	`32`	`+ val defaultMax = Duration.hours(2)`
`35`	`33`	`}`
`36`	`34`	`}`
`37`	`35`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`package io.kotest.core.test`
`2`	`2`
`3`	`3`	`import kotlin.time.Duration`
`4`		`-import kotlin.time.Duration.Companion.milliseconds`
`5`	`4`
`6`	`5`	`sealed interface TestResult {`
`7`	`6`
`@@ -10,19 +9,19 @@ sealed interface TestResult {`
`10`	`9`	`"Replaced with TestResult.Success. Deprecated since 5.0",`
`11`	`10`	`ReplaceWith("TestResult.Success(durationMillis.milliseconds)", "kotlin.time.Duration.Companion.milliseconds")`
`12`	`11`	`)`
`13`		`- fun success(durationMillis: Long): Success = Success(durationMillis.milliseconds)`
	`12`	`+ fun success(durationMillis: Long): Success = Success(Duration.milliseconds(durationMillis))`
`14`	`13`
`15`	`14`	`@Deprecated(`
`16`	`15`	`"Replaced with TestResult.Failure. Deprecated since 5.0",`
`17`	`16`	`ReplaceWith("TestResult.Failure(durationMillis.milliseconds, error)", "kotlin.time.Duration.Companion.milliseconds")`
`18`	`17`	`)`
`19`		`- fun failure(error: AssertionError, durationMillis: Long): Failure = Failure(durationMillis.milliseconds, error)`
	`18`	`+ fun failure(error: AssertionError, durationMillis: Long): Failure = Failure(Duration.milliseconds(durationMillis), error)`
`20`	`19`
`21`	`20`	`@Deprecated(`
`22`	`21`	`"Replaced with TestResult.Error. Deprecated since 5.0",`
`23`	`22`	`ReplaceWith("TestResult.Error(durationMillis.milliseconds, error)", "kotlin.time.Duration.Companion.milliseconds")`
`24`	`23`	`)`
`25`		`- fun error(error: Throwable, durationMillis: Long): Error = Error(durationMillis.milliseconds, error)`
	`24`	`+ fun error(error: Throwable, durationMillis: Long): Error = Error(Duration.milliseconds(durationMillis), error)`
`26`	`25`
`27`	`26`	`val Ignored = Ignored(null)`
`28`	`27`	`}`