diff --git a/libraries/stdlib/js/src/kotlin/time/MonoTimeSource.kt b/libraries/stdlib/js/src/kotlin/time/MonoTimeSource.kt index ef069cf90a4..71fb0d61ce5 100644 --- a/libraries/stdlib/js/src/kotlin/time/MonoTimeSource.kt +++ b/libraries/stdlib/js/src/kotlin/time/MonoTimeSource.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -10,20 +10,20 @@ import org.w3c.performance.Performance @SinceKotlin("1.3") @ExperimentalTime -public actual object MonoClock : Clock { +internal actual object MonotonicTimeSource : TimeSource { - private val actualClock: Clock = run { + private val actualSource: TimeSource = run { val isNode: Boolean = js("typeof process !== 'undefined' && process.versions && !!process.versions.node") if (isNode) - HrTimeClock(js("process").unsafeCast()) + HrTimeSource(js("process").unsafeCast()) else - js("self").unsafeCast()?.performance?.let(::PerformanceClock) - ?: DateNowClock + js("self").unsafeCast()?.performance?.let(::PerformanceTimeSource) + ?: DateNowTimeSource } - override fun markNow(): ClockMark = actualClock.markNow() + override fun markNow(): TimeMark = actualSource.markNow() } internal external interface Process { @@ -32,27 +32,27 @@ internal external interface Process { @SinceKotlin("1.3") @ExperimentalTime -internal class HrTimeClock(val process: Process) : Clock { +internal class HrTimeSource(val process: Process) : TimeSource { - override fun markNow(): ClockMark = object : ClockMark() { + override fun markNow(): TimeMark = object : TimeMark() { val startedAt = process.hrtime() override fun elapsedNow(): Duration = process.hrtime(startedAt).let { (seconds, nanos) -> seconds.seconds + nanos.nanoseconds } } - override fun toString(): String = "Clock(process.hrtime())" + override fun toString(): String = "TimeSource(process.hrtime())" } @SinceKotlin("1.3") @ExperimentalTime -internal class PerformanceClock(val performance: Performance) : AbstractDoubleClock(unit = DurationUnit.MILLISECONDS) { +internal class PerformanceTimeSource(val performance: Performance) : AbstractDoubleTimeSource(unit = DurationUnit.MILLISECONDS) { override fun read(): Double = performance.now() - override fun toString(): String = "Clock(self.performance.now())" + override fun toString(): String = "TimeSource(self.performance.now())" } @SinceKotlin("1.3") @ExperimentalTime -internal object DateNowClock : AbstractDoubleClock(unit = DurationUnit.MILLISECONDS) { +internal object DateNowTimeSource : AbstractDoubleTimeSource(unit = DurationUnit.MILLISECONDS) { override fun read(): Double = kotlin.js.Date.now() - override fun toString(): String = "Clock(Date.now())" + override fun toString(): String = "TimeSource(Date.now())" } \ No newline at end of file diff --git a/libraries/stdlib/jvm/src/kotlin/time/MonoTimeSource.kt b/libraries/stdlib/jvm/src/kotlin/time/MonoTimeSource.kt index 6cf242c9647..ad40f8e1ec9 100644 --- a/libraries/stdlib/jvm/src/kotlin/time/MonoTimeSource.kt +++ b/libraries/stdlib/jvm/src/kotlin/time/MonoTimeSource.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -7,7 +7,7 @@ package kotlin.time @SinceKotlin("1.3") @ExperimentalTime -public actual object MonoClock : AbstractLongClock(unit = DurationUnit.NANOSECONDS), Clock { // TODO: interface should not be required here +internal actual object MonotonicTimeSource : AbstractLongTimeSource(unit = DurationUnit.NANOSECONDS), TimeSource { // TODO: interface should not be required here override fun read(): Long = System.nanoTime() - override fun toString(): String = "Clock(System.nanoTime())" + override fun toString(): String = "TimeSource(System.nanoTime())" } \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/time/TimeSource.kt b/libraries/stdlib/src/kotlin/time/TimeSource.kt index 3e2853b7ae5..5ffbe1c8385 100644 --- a/libraries/stdlib/src/kotlin/time/TimeSource.kt +++ b/libraries/stdlib/src/kotlin/time/TimeSource.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -8,65 +8,80 @@ package kotlin.time /** * A source of time for measuring time intervals. * - * The only operation provided by the clock is [markNow]. It returns a [ClockMark], which can be used to query the elapsed time later. + * The only operation provided by the time source is [markNow]. It returns a [TimeMark], which can be used to query the elapsed time later. * * @see [measureTime] * @see [measureTimedValue] */ @SinceKotlin("1.3") @ExperimentalTime -public interface Clock { +public interface TimeSource { /** - * Marks a time point on this clock. + * Marks a point in time on this time source. * - * The returned [ClockMark] instance encapsulates captured time point and allows querying - * the duration of time interval [elapsed][ClockMark.elapsedNow] from that point. + * The returned [TimeMark] instance encapsulates the captured time point and allows querying + * the duration of time interval [elapsed][TimeMark.elapsedNow] from that point. */ - public fun markNow(): ClockMark + public fun markNow(): TimeMark + + /** + * The most precise time source available in the platform. + * + * This time source returns its readings from a source of monotonic time when it is available in a target platform, + * and resorts to a non-monotonic time source otherwise. + */ + public object Monotonic : TimeSource by MonotonicTimeSource { + override fun toString(): String = MonotonicTimeSource.toString() + } + + + public companion object { + + } } /** - * Represents a time point notched on a particular [Clock]. Remains bound to the clock it was taken from + * Represents a time point notched on a particular [TimeSource]. Remains bound to the time source it was taken from * and allows querying for the duration of time elapsed from that point (see the function [elapsedNow]). */ @SinceKotlin("1.3") @ExperimentalTime -public abstract class ClockMark { +public abstract class TimeMark { /** - * Returns the amount of time passed from this clock mark on the clock from which this mark was taken. + * Returns the amount of time passed from this mark measured with the time source from which this mark was taken. * * Note that the value returned by this function can change on subsequent invocations. */ public abstract fun elapsedNow(): Duration /** - * Returns a clock mark on the same clock that is ahead of this clock mark by the specified [duration]. + * Returns a time mark on the same time source that is ahead of this time mark by the specified [duration]. * - * The returned clock mark is more _late_ when the [duration] is positive, and more _early_ when the [duration] is negative. + * The returned time mark is more _late_ when the [duration] is positive, and more _early_ when the [duration] is negative. */ - public open operator fun plus(duration: Duration): ClockMark = AdjustedClockMark(this, duration) + public open operator fun plus(duration: Duration): TimeMark = AdjustedTimeMark(this, duration) /** - * Returns a clock mark on the same clock that is behind this clock mark by the specified [duration]. + * Returns a time mark on the same time source that is behind this time mark by the specified [duration]. * - * The returned clock mark is more _early_ when the [duration] is positive, and more _late_ when the [duration] is negative. + * The returned time mark is more _early_ when the [duration] is positive, and more _late_ when the [duration] is negative. */ - public open operator fun minus(duration: Duration): ClockMark = plus(-duration) + public open operator fun minus(duration: Duration): TimeMark = plus(-duration) /** - * Returns true if this clock mark has passed according to the clock from which this mark was taken. + * Returns true if this time mark has passed according to the time source from which this mark was taken. * * Note that the value returned by this function can change on subsequent invocations. - * If the clock is monotonic, it can change only from `false` to `true`, namely, when the clock mark becomes behind the current point of the clock. + * If the time source is monotonic, it can change only from `false` to `true`, namely, when the time mark becomes behind the current point of the time source. */ public fun hasPassedNow(): Boolean = !elapsedNow().isNegative() /** - * Returns false if this clock mark has not passed according to the clock from which this mark was taken. + * Returns false if this time mark has not passed according to the time source from which this mark was taken. * * Note that the value returned by this function can change on subsequent invocations. - * If the clock is monotonic, it can change only from `true` to `false`, namely, when the clock mark becomes behind the current point of the clock. + * If the time source is monotonic, it can change only from `true` to `false`, namely, when the time mark becomes behind the current point of the time source. */ public fun hasNotPassedNow(): Boolean = elapsedNow().isNegative() } @@ -75,19 +90,36 @@ public abstract class ClockMark { @ExperimentalTime @SinceKotlin("1.3") @kotlin.internal.InlineOnly -@Deprecated("Subtracting one ClockMark from another is not a well defined operation because these clock marks could have been obtained from the different clocks.", level = DeprecationLevel.ERROR) -public inline operator fun ClockMark.minus(other: ClockMark): Duration = throw Error("Operation is disallowed.") +@Deprecated( + "Subtracting one TimeMark from another is not a well defined operation because these time marks could have been obtained from the different time sources.", + level = DeprecationLevel.ERROR +) +public inline operator fun TimeMark.minus(other: TimeMark): Duration = throw Error("Operation is disallowed.") @ExperimentalTime @SinceKotlin("1.3") @kotlin.internal.InlineOnly -@Deprecated("Comparing one ClockMark to another is not a well defined operation because these clock marks could have been obtained from the different clocks.", level = DeprecationLevel.ERROR) -public inline operator fun ClockMark.compareTo(other: ClockMark): Int = throw Error("Operation is disallowed.") +@Deprecated( + "Comparing one TimeMark to another is not a well defined operation because these time marks could have been obtained from the different time sources.", + level = DeprecationLevel.ERROR +) +public inline operator fun TimeMark.compareTo(other: TimeMark): Int = throw Error("Operation is disallowed.") @ExperimentalTime -private class AdjustedClockMark(val mark: ClockMark, val adjustment: Duration) : ClockMark() { +private class AdjustedTimeMark(val mark: TimeMark, val adjustment: Duration) : TimeMark() { override fun elapsedNow(): Duration = mark.elapsedNow() - adjustment - override fun plus(duration: Duration): ClockMark = AdjustedClockMark(mark, adjustment + duration) -} \ No newline at end of file + override fun plus(duration: Duration): TimeMark = AdjustedTimeMark(mark, adjustment + duration) +} + + +@SinceKotlin("1.3") +@ExperimentalTime +@Deprecated("Use TimeSource interface instead.", ReplaceWith("TimeSource", "kotlin.time.TimeSource")) +public typealias Clock = TimeSource + +@SinceKotlin("1.3") +@ExperimentalTime +@Deprecated("Use TimeMark class instead.", ReplaceWith("TimeMark", "kotlin.time.TimeMark")) +public typealias ClockMark = TimeMark diff --git a/libraries/stdlib/src/kotlin/time/TimeSources.kt b/libraries/stdlib/src/kotlin/time/TimeSources.kt index 5ffe717b2b0..33b0b5d0633 100644 --- a/libraries/stdlib/src/kotlin/time/TimeSources.kt +++ b/libraries/stdlib/src/kotlin/time/TimeSources.kt @@ -1,91 +1,85 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package kotlin.time -/** - * The most precise clock available in the platform. - * - * The clock returns its readings from a source of monotonic time when it is available in a target platform, - * and resorts to a non-monotonic time source otherwise. - */ @SinceKotlin("1.3") @ExperimentalTime -public expect object MonoClock : Clock +internal expect object MonotonicTimeSource : TimeSource /** - * An abstract class used to implement clocks that return their readings as [Long] values in the specified [unit]. + * An abstract class used to implement time sources that return their readings as [Long] values in the specified [unit]. * - * @property unit The unit in which this clock readings are expressed. + * @property unit The unit in which this time source's readings are expressed. */ @SinceKotlin("1.3") @ExperimentalTime -public abstract class AbstractLongClock(protected val unit: DurationUnit) : Clock { +public abstract class AbstractLongTimeSource(protected val unit: DurationUnit) : TimeSource { /** - * This protected method should be overridden to return the current reading of the clock expressed as a [Long] number + * This protected method should be overridden to return the current reading of the time source expressed as a [Long] number * in the unit specified by the [unit] property. */ protected abstract fun read(): Long - private class LongClockMark(private val startedAt: Long, private val clock: AbstractLongClock, private val offset: Duration) : ClockMark() { - override fun elapsedNow(): Duration = (clock.read() - startedAt).toDuration(clock.unit) - offset - override fun plus(duration: Duration): ClockMark = LongClockMark(startedAt, clock, offset + duration) + private class LongTimeMark(private val startedAt: Long, private val timeSource: AbstractLongTimeSource, private val offset: Duration) : TimeMark() { + override fun elapsedNow(): Duration = (timeSource.read() - startedAt).toDuration(timeSource.unit) - offset + override fun plus(duration: Duration): TimeMark = LongTimeMark(startedAt, timeSource, offset + duration) } - override fun markNow(): ClockMark = LongClockMark(read(), this, Duration.ZERO) + override fun markNow(): TimeMark = LongTimeMark(read(), this, Duration.ZERO) } /** - * An abstract class used to implement clocks that return their readings as [Double] values in the specified [unit]. + * An abstract class used to implement time sources that return their readings as [Double] values in the specified [unit]. * - * @property unit The unit in which this clock readings are expressed. + * @property unit The unit in which this time source's readings are expressed. */ @SinceKotlin("1.3") @ExperimentalTime -public abstract class AbstractDoubleClock(protected val unit: DurationUnit) : Clock { +public abstract class AbstractDoubleTimeSource(protected val unit: DurationUnit) : TimeSource { /** - * This protected method should be overridden to return the current reading of the clock expressed as a [Double] number + * This protected method should be overridden to return the current reading of the time source expressed as a [Double] number * in the unit specified by the [unit] property. */ protected abstract fun read(): Double - private class DoubleClockMark(private val startedAt: Double, private val clock: AbstractDoubleClock, private val offset: Duration) : ClockMark() { - override fun elapsedNow(): Duration = (clock.read() - startedAt).toDuration(clock.unit) - offset - override fun plus(duration: Duration): ClockMark = DoubleClockMark(startedAt, clock, offset + duration) + private class DoubleTimeMark(private val startedAt: Double, private val timeSource: AbstractDoubleTimeSource, private val offset: Duration) : TimeMark() { + override fun elapsedNow(): Duration = (timeSource.read() - startedAt).toDuration(timeSource.unit) - offset + override fun plus(duration: Duration): TimeMark = DoubleTimeMark(startedAt, timeSource, offset + duration) } - override fun markNow(): ClockMark = DoubleClockMark(read(), this, Duration.ZERO) + override fun markNow(): TimeMark = DoubleTimeMark(read(), this, Duration.ZERO) } /** - * A clock that has programmatically updatable readings. It is useful as a predictable source of time in tests. + * A time source that has programmatically updatable readings. It is useful as a predictable source of time in tests. * - * The current clock reading value can be advanced by the specified duration amount with the operator [plusAssign]: + * The current reading value can be advanced by the specified duration amount with the operator [plusAssign]: * * ``` - * val clock = TestClock() - * clock += 10.seconds + * val timeSource = TestTimeSource() + * timeSource += 10.seconds * ``` * - * Implementation note: the current clock reading value is stored as a [Long] number of nanoseconds, + * Implementation note: the current reading value is stored as a [Long] number of nanoseconds, * thus it's capable to represent a time range of approximately ±292 years. * Should the reading value overflow as the result of [plusAssign] operation, an [IllegalStateException] is thrown. */ @SinceKotlin("1.3") @ExperimentalTime -public class TestClock : AbstractLongClock(unit = DurationUnit.NANOSECONDS) { +public class TestTimeSource : AbstractLongTimeSource(unit = DurationUnit.NANOSECONDS) { private var reading: Long = 0L override fun read(): Long = reading /** - * Advances the current reading value of this clock by the specified [duration]. + * Advances the current reading value of this time source by the specified [duration]. * * [duration] value is rounded down towards zero when converting it to a [Long] number of nanoseconds. - * For example, if the duration being added is `0.6.nanoseconds`, the clock reading won't advance because - * the duration value will be rounded to zero nanoseconds. + * For example, if the duration being added is `0.6.nanoseconds`, the reading doesn't advance because + * the duration value is rounded to zero nanoseconds. * * @throws IllegalStateException when the reading value overflows as the result of this operation. */ @@ -106,18 +100,26 @@ public class TestClock : AbstractLongClock(unit = DurationUnit.NANOSECONDS) { } private fun overflow(duration: Duration) { - throw IllegalStateException("TestClock will overflow if its reading ${reading}ns is advanced by $duration.") + throw IllegalStateException("TestTimeSource will overflow if its reading ${reading}ns is advanced by $duration.") } } -/* -public interface WallClock { - fun currentTimeMilliseconds(): Long +@SinceKotlin("1.3") +@ExperimentalTime +@Deprecated("Use TimeSource.Monotonic instead.", ReplaceWith("TimeSource.Monotonic", "kotlin.time.TimeSource")) +public typealias MonoClock = TimeSource.Monotonic - companion object : WallClock, AbstractLongClock(unit = DurationUnit.MILLISECONDS) { - override fun currentTimeMilliseconds(): Long = System.currentTimeMillis() - override fun read(): Long = System.currentTimeMillis() - override fun toString(): String = "WallClock(System.currentTimeMillis())" - } -} -*/ \ No newline at end of file +@SinceKotlin("1.3") +@ExperimentalTime +@Deprecated("Use AbstractLongTimeSource instead.", ReplaceWith("AbstractLongTimeSource", "kotlin.time.AbstractLongTimeSource")) +public typealias AbstractLongClock = AbstractLongTimeSource + +@SinceKotlin("1.3") +@ExperimentalTime +@Deprecated("Use AbstractDoubleTimeSource instead.", ReplaceWith("AbstractDoubleTimeSource", "kotlin.time.AbstractDoubleTimeSource")) +public typealias AbstractDoubleClock = AbstractDoubleTimeSource + +@SinceKotlin("1.3") +@ExperimentalTime +@Deprecated("Use TestTimeSource instead.", ReplaceWith("TestTimeSource", "kotlin.time.TestTimeSource")) +public typealias TestClock = TestTimeSource diff --git a/libraries/stdlib/src/kotlin/time/measureTime.kt b/libraries/stdlib/src/kotlin/time/measureTime.kt index 035da34659c..080a8af9948 100644 --- a/libraries/stdlib/src/kotlin/time/measureTime.kt +++ b/libraries/stdlib/src/kotlin/time/measureTime.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -10,7 +10,7 @@ import kotlin.contracts.* /** * Executes the given function [block] and returns the duration of elapsed time interval. * - * The elapsed time is measured with [MonoClock]. + * The elapsed time is measured with [TimeSource.Monotonic]. */ @SinceKotlin("1.3") @ExperimentalTime @@ -18,18 +18,18 @@ public inline fun measureTime(block: () -> Unit): Duration { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } - return MonoClock.measureTime(block) + return TimeSource.Monotonic.measureTime(block) } /** * Executes the given function [block] and returns the duration of elapsed time interval. * - * The elapsed time is measured with the specified `this` [Clock] instance. + * The elapsed time is measured with the specified `this` [TimeSource] instance. */ @SinceKotlin("1.3") @ExperimentalTime -public inline fun Clock.measureTime(block: () -> Unit): Duration { +public inline fun TimeSource.measureTime(block: () -> Unit): Duration { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } @@ -54,7 +54,7 @@ public data class TimedValue(val value: T, val duration: Duration) * Executes the given function [block] and returns an instance of [TimedValue] class, containing both * the result of the function execution and the duration of elapsed time interval. * - * The elapsed time is measured with [MonoClock]. + * The elapsed time is measured with [TimeSource.Monotonic]. */ @SinceKotlin("1.3") @ExperimentalTime @@ -63,18 +63,18 @@ public inline fun measureTimedValue(block: () -> T): TimedValue { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } - return MonoClock.measureTimedValue(block) + return TimeSource.Monotonic.measureTimedValue(block) } /** * Executes the given [block] and returns an instance of [TimedValue] class, containing both * the result of function execution and the duration of elapsed time interval. * - * The elapsed time is measured with the specified `this` [Clock] instance. + * The elapsed time is measured with the specified `this` [TimeSource] instance. */ @SinceKotlin("1.3") @ExperimentalTime -public inline fun Clock.measureTimedValue(block: () -> T): TimedValue { +public inline fun TimeSource.measureTimedValue(block: () -> T): TimedValue { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } diff --git a/libraries/stdlib/test/time/MeasureTimeTest.kt b/libraries/stdlib/test/time/MeasureTimeTest.kt index 26b9485bedd..53494baf76e 100644 --- a/libraries/stdlib/test/time/MeasureTimeTest.kt +++ b/libraries/stdlib/test/time/MeasureTimeTest.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -49,18 +49,18 @@ class MeasureTimeTest { @Test fun measureTimeTestClock() { - val clock = TestClock() + val timeSource = TestTimeSource() val expectedNs = Random.nextLong(1_000_000_000L) - val elapsed = clock.measureTime { - clock += expectedNs.nanoseconds + val elapsed = timeSource.measureTime { + timeSource += expectedNs.nanoseconds } assertEquals(expectedNs.nanoseconds, elapsed) val expectedResult: Long - val (result, elapsed2) = clock.measureTimedValue { - clock += expectedNs.nanoseconds + val (result, elapsed2) = timeSource.measureTimedValue { + timeSource += expectedNs.nanoseconds expectedResult = expectedNs expectedNs } diff --git a/libraries/stdlib/test/time/TestClockTest.kt b/libraries/stdlib/test/time/TestTimeSourceTest.kt similarity index 58% rename from libraries/stdlib/test/time/TestClockTest.kt rename to libraries/stdlib/test/time/TestTimeSourceTest.kt index f6e116a485e..de7e81625e5 100644 --- a/libraries/stdlib/test/time/TestClockTest.kt +++ b/libraries/stdlib/test/time/TestTimeSourceTest.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -9,54 +9,54 @@ package test.time import kotlin.test.* import kotlin.time.* -class TestClockTest { +class TestTimeSourceTest { @Test fun overflows() { for (enormousDuration in listOf(Duration.INFINITE, Double.MAX_VALUE.nanoseconds, Long.MAX_VALUE.nanoseconds * 2)) { - assertFailsWith(enormousDuration.toString()) { TestClock() += enormousDuration } - assertFailsWith((-enormousDuration).toString()) { TestClock() += -enormousDuration } + assertFailsWith(enormousDuration.toString()) { TestTimeSource() += enormousDuration } + assertFailsWith((-enormousDuration).toString()) { TestTimeSource() += -enormousDuration } } val moderatePositiveDuration = Long.MAX_VALUE.takeHighestOneBit().nanoseconds val borderlinePositiveDuration = Long.MAX_VALUE.nanoseconds // rounded to 2.0^63, which is slightly more than Long.MAX_VALUE val borderlineNegativeDuration = Long.MIN_VALUE.nanoseconds run { - val clock = TestClock() - clock += moderatePositiveDuration - assertFailsWith("Should overflow positive") { clock += moderatePositiveDuration } + val timeSource = TestTimeSource() + timeSource += moderatePositiveDuration + assertFailsWith("Should overflow positive") { timeSource += moderatePositiveDuration } } run { - val clock = TestClock() - clock += borderlinePositiveDuration - assertFailsWith("Should overflow positive") { clock += 1.nanoseconds } + val timeSource = TestTimeSource() + timeSource += borderlinePositiveDuration + assertFailsWith("Should overflow positive") { timeSource += 1.nanoseconds } } run { - val clock = TestClock() - clock += borderlineNegativeDuration - assertFailsWith("Should overflow negative") { clock += -1.nanoseconds } + val timeSource = TestTimeSource() + timeSource += borderlineNegativeDuration + assertFailsWith("Should overflow negative") { timeSource += -1.nanoseconds } } run { - val clock = TestClock() - clock += moderatePositiveDuration + val timeSource = TestTimeSource() + timeSource += moderatePositiveDuration // does not overflow event if duration doesn't fit in long - clock += -moderatePositiveDuration + borderlineNegativeDuration + timeSource += -moderatePositiveDuration + borderlineNegativeDuration } } @Test fun nanosecondRounding() { - val clock = TestClock() - val mark = clock.markNow() + val timeSource = TestTimeSource() + val mark = timeSource.markNow() repeat(10_000) { - clock += 0.9.nanoseconds + timeSource += 0.9.nanoseconds assertEquals(Duration.ZERO, mark.elapsedNow()) } - clock += 1.9.nanoseconds + timeSource += 1.9.nanoseconds assertEquals(1.nanoseconds, mark.elapsedNow()) } } \ No newline at end of file diff --git a/libraries/stdlib/test/time/ClockMarkTest.kt b/libraries/stdlib/test/time/TimeMarkTest.kt similarity index 83% rename from libraries/stdlib/test/time/ClockMarkTest.kt rename to libraries/stdlib/test/time/TimeMarkTest.kt index 28e905093af..8c8c900ac31 100644 --- a/libraries/stdlib/test/time/ClockMarkTest.kt +++ b/libraries/stdlib/test/time/TimeMarkTest.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @file:UseExperimental(ExperimentalTime::class) @@ -8,27 +8,27 @@ package test.time import kotlin.test.* import kotlin.time.* -class ClockMarkTest { +class TimeMarkTest { @Test fun adjustment() { - val clock = TestClock() + val timeSource = TestTimeSource() - fun ClockMark.assertHasPassed(hasPassed: Boolean) { + fun TimeMark.assertHasPassed(hasPassed: Boolean) { assertEquals(!hasPassed, this.hasNotPassedNow(), "Expected mark in the future") assertEquals(hasPassed, this.hasPassedNow(), "Expected mark in the past") assertEquals(!hasPassed, this.elapsedNow() < Duration.ZERO, "Mark elapsed: ${this.elapsedNow()}, expected hasPassed: $hasPassed") } - val mark = clock.markNow() + val mark = timeSource.markNow() val markFuture1 = (mark + 1.milliseconds).apply { assertHasPassed(false) } val markFuture2 = (mark - (-1).milliseconds).apply { assertHasPassed(false) } val markPast1 = (mark - 1.milliseconds).apply { assertHasPassed(true) } val markPast2 = (markFuture1 + (-2).milliseconds).apply { assertHasPassed(true) } - clock += 500_000.nanoseconds + timeSource += 500_000.nanoseconds val elapsed = mark.elapsedNow() val elapsedFromFuture = elapsed - 1.milliseconds @@ -44,7 +44,7 @@ class ClockMarkTest { markFuture1.assertHasPassed(false) markPast1.assertHasPassed(true) - clock += 1.milliseconds + timeSource += 1.milliseconds markFuture1.assertHasPassed(true) markPast1.assertHasPassed(true) diff --git a/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt b/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt index 73fa556415c..5957385c343 100644 --- a/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt +++ b/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt @@ -5338,33 +5338,20 @@ public final class kotlin/text/UStringsKt { public static final fun toUShortOrNull (Ljava/lang/String;I)Lkotlin/UShort; } -public abstract class kotlin/time/AbstractDoubleClock : kotlin/time/Clock { +public abstract class kotlin/time/AbstractDoubleTimeSource : kotlin/time/TimeSource { public fun (Ljava/util/concurrent/TimeUnit;)V protected final fun getUnit ()Ljava/util/concurrent/TimeUnit; - public fun markNow ()Lkotlin/time/ClockMark; + public fun markNow ()Lkotlin/time/TimeMark; protected abstract fun read ()D } -public abstract class kotlin/time/AbstractLongClock : kotlin/time/Clock { +public abstract class kotlin/time/AbstractLongTimeSource : kotlin/time/TimeSource { public fun (Ljava/util/concurrent/TimeUnit;)V protected final fun getUnit ()Ljava/util/concurrent/TimeUnit; - public fun markNow ()Lkotlin/time/ClockMark; + public fun markNow ()Lkotlin/time/TimeMark; protected abstract fun read ()J } -public abstract interface class kotlin/time/Clock { - public abstract fun markNow ()Lkotlin/time/ClockMark; -} - -public abstract class kotlin/time/ClockMark { - public fun ()V - public abstract fun elapsedNow ()D - public final fun hasNotPassedNow ()Z - public final fun hasPassedNow ()Z - public fun minus-LRDsOJo (D)Lkotlin/time/ClockMark; - public fun plus-LRDsOJo (D)Lkotlin/time/ClockMark; -} - public final class kotlin/time/Duration : java/lang/Comparable { public static final field Companion Lkotlin/time/Duration$Companion; public static final synthetic fun box-impl (D)Lkotlin/time/Duration; @@ -5451,21 +5438,39 @@ public abstract interface annotation class kotlin/time/ExperimentalTime : java/l public final class kotlin/time/MeasureTimeKt { public static final fun measureTime (Lkotlin/jvm/functions/Function0;)D - public static final fun measureTime (Lkotlin/time/Clock;Lkotlin/jvm/functions/Function0;)D + public static final fun measureTime (Lkotlin/time/TimeSource;Lkotlin/jvm/functions/Function0;)D public static final fun measureTimedValue (Lkotlin/jvm/functions/Function0;)Lkotlin/time/TimedValue; - public static final fun measureTimedValue (Lkotlin/time/Clock;Lkotlin/jvm/functions/Function0;)Lkotlin/time/TimedValue; + public static final fun measureTimedValue (Lkotlin/time/TimeSource;Lkotlin/jvm/functions/Function0;)Lkotlin/time/TimedValue; } -public final class kotlin/time/MonoClock : kotlin/time/AbstractLongClock, kotlin/time/Clock { - public static final field INSTANCE Lkotlin/time/MonoClock; - public fun toString ()Ljava/lang/String; -} - -public final class kotlin/time/TestClock : kotlin/time/AbstractLongClock { +public final class kotlin/time/TestTimeSource : kotlin/time/AbstractLongTimeSource { public fun ()V public final fun plusAssign-LRDsOJo (D)V } +public abstract class kotlin/time/TimeMark { + public fun ()V + public abstract fun elapsedNow ()D + public final fun hasNotPassedNow ()Z + public final fun hasPassedNow ()Z + public fun minus-LRDsOJo (D)Lkotlin/time/TimeMark; + public fun plus-LRDsOJo (D)Lkotlin/time/TimeMark; +} + +public abstract interface class kotlin/time/TimeSource { + public static final field Companion Lkotlin/time/TimeSource$Companion; + public abstract fun markNow ()Lkotlin/time/TimeMark; +} + +public final class kotlin/time/TimeSource$Companion { +} + +public final class kotlin/time/TimeSource$Monotonic : kotlin/time/TimeSource { + public static final field INSTANCE Lkotlin/time/TimeSource$Monotonic; + public fun markNow ()Lkotlin/time/TimeMark; + public fun toString ()Ljava/lang/String; +} + public final class kotlin/time/TimedValue { public synthetic fun (Ljava/lang/Object;DLkotlin/jvm/internal/DefaultConstructorMarker;)V public final fun component1 ()Ljava/lang/Object;