| /* |
| * Copyright 2010-2021 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:OptIn(ExperimentalTime::class) |
| @file:Suppress("INVISIBLE_MEMBER") |
| package test.time |
| |
| import test.numbers.assertAlmostEquals |
| import kotlin.math.nextDown |
| import kotlin.native.concurrent.SharedImmutable |
| import kotlin.test.* |
| import kotlin.time.* |
| import kotlin.random.* |
| |
| @SharedImmutable |
| private val units = DurationUnit.values() |
| |
| class DurationTest { |
| |
| @Test |
| fun constructionFromNumber() { |
| // nanosecond precision |
| val testValues = listOf(0L, 1L, MAX_NANOS) + List(100) { Random.nextLong(0, MAX_NANOS) } |
| for (value in testValues) { |
| assertEquals(value, value.toDuration(DurationUnit.NANOSECONDS).inWholeNanoseconds) |
| assertEquals(-value, -value.toDuration(DurationUnit.NANOSECONDS).inWholeNanoseconds) |
| } |
| // expressible as long nanoseconds but stored as milliseconds |
| for (delta in testValues) { |
| val value = (MAX_NANOS + 1) + delta |
| val expected = value - (value % NANOS_IN_MILLIS) |
| assertEquals(expected, value.toDuration(DurationUnit.NANOSECONDS).inWholeNanoseconds) |
| assertEquals(-expected, -value.toDuration(DurationUnit.NANOSECONDS).inWholeNanoseconds) |
| } |
| // any int value of small units can always be represented in nanoseconds |
| for (unit in units.filter { it <= DurationUnit.SECONDS }) { |
| val scale = convertDurationUnitOverflow(1L, unit, DurationUnit.NANOSECONDS) |
| repeat(100) { |
| val value = Random.nextInt() |
| assertEquals(value * scale, value.toDuration(unit).inWholeNanoseconds) |
| } |
| } |
| |
| for (unit in units) { |
| val borderValue = convertDurationUnit(MAX_NANOS, DurationUnit.NANOSECONDS, unit) |
| val d1 = borderValue.toDuration(unit) |
| val d2 = (borderValue + 1).toDuration(unit) |
| assertNotEquals(d1, d1 + Duration.nanoseconds(1)) |
| assertEquals(d2, d2 + Duration.nanoseconds(1)) |
| } |
| |
| assertEquals(Long.MAX_VALUE / 1000, Long.MAX_VALUE.toDuration(DurationUnit.MICROSECONDS).inWholeMilliseconds) |
| assertEquals(Long.MAX_VALUE / 1000 * 1000, Long.MAX_VALUE.toDuration(DurationUnit.MICROSECONDS).toLong(DurationUnit.MICROSECONDS)) |
| |
| assertEquals(Duration.INFINITE, (MAX_MILLIS).toDuration(DurationUnit.MILLISECONDS)) |
| assertEquals(-Duration.INFINITE, (-MAX_MILLIS).toDuration(DurationUnit.MILLISECONDS)) |
| |
| run { |
| val maxNsDouble = MAX_NANOS.toDouble() |
| val lessThanMaxDouble = maxNsDouble.nextDown() |
| val maxNs = maxNsDouble.toDuration(DurationUnit.NANOSECONDS).inWholeNanoseconds |
| val lessThanMaxNs = lessThanMaxDouble.toDuration(DurationUnit.NANOSECONDS).inWholeNanoseconds |
| assertTrue(maxNs > lessThanMaxNs, "$maxNs should be > $lessThanMaxNs") |
| } |
| |
| assertFailsWith<IllegalArgumentException> { Double.NaN.toDuration(DurationUnit.SECONDS) } |
| } |
| |
| @Test |
| fun equality() { |
| val data = listOf<Pair<Double, DurationUnit>>( |
| Pair(2.0, DurationUnit.DAYS), |
| Pair(2.0, DurationUnit.HOURS), |
| Pair(0.25, DurationUnit.MINUTES), |
| Pair(1.0, DurationUnit.SECONDS), |
| Pair(50.0, DurationUnit.MILLISECONDS), |
| Pair(0.3, DurationUnit.MICROSECONDS), |
| Pair(20_000_000_000.0, DurationUnit.NANOSECONDS), |
| Pair(1.0, DurationUnit.NANOSECONDS) |
| ) |
| |
| for ((value, unit) in data) { |
| repeat(10) { |
| val d1 = value.toDuration(unit) |
| val unit2 = units.random() |
| val value2 = Duration.convert(value, unit, unit2) |
| val d2 = value2.toDuration(unit2) |
| assertEquals(d1, d2, "$value $unit in $unit2") |
| assertEquals(d1.hashCode(), d2.hashCode()) |
| |
| val d3 = (value2 * 2).toDuration(unit2) |
| assertNotEquals(d1, d3, "$value $unit in $unit2") |
| } |
| } |
| |
| run { // invariant Duration.nanoseconds(d.inWholeNanoseconds) == d when whole nanoseconds fits into Long range |
| val d1 = Duration.nanoseconds(MAX_NANOS + 1) |
| val d2 = Duration.nanoseconds(d1.inWholeNanoseconds) |
| assertEquals(d1.inWholeNanoseconds, d2.inWholeNanoseconds) |
| assertEquals(d1, d2) |
| } |
| } |
| |
| @Test |
| fun comparison() { |
| fun assertGreater(d1: Duration, d2: Duration, message: String) { |
| assertTrue(d1 > d2, message) |
| assertFalse(d1 <= d2, message) |
| assertTrue( |
| d1.inWholeNanoseconds > d2.inWholeNanoseconds || |
| d1.inWholeNanoseconds == d2.inWholeNanoseconds && d1.inWholeMilliseconds > d2.inWholeMilliseconds, |
| message |
| ) |
| } |
| |
| val d4 = Duration.nanoseconds(Long.MAX_VALUE) |
| val d3 = Duration.nanoseconds(MAX_NANOS + 1) |
| val d2 = Duration.nanoseconds(MAX_NANOS) |
| val d1 = Duration.nanoseconds(MAX_NANOS - 1) |
| |
| assertGreater(d4, d2, "same sign, different ranges") |
| assertGreater(d3, d2, "same sign, different ranges 2") |
| assertGreater(d2, d1, "same sign, same range nanos") |
| assertGreater(d4, d3, "same sign, same range millis") |
| assertGreater(d2, -d3, "different signs, different ranges") |
| assertGreater(d3, -d4, "different signs, same ranges") |
| assertGreater(d1, -d2, "different signs, same ranges 2") |
| } |
| |
| |
| @Test |
| fun constructionFactoryFunctions() { |
| val n1 = Random.nextInt(Int.MAX_VALUE) |
| val n2 = Random.nextLong(Long.MAX_VALUE) |
| val n3 = Random.nextDouble() |
| |
| assertEquals(n1.toDuration(DurationUnit.DAYS), Duration.days(n1)) |
| assertEquals(n2.toDuration(DurationUnit.DAYS), Duration.days(n2)) |
| assertEquals(n3.toDuration(DurationUnit.DAYS), Duration.days(n3)) |
| |
| assertEquals(n1.toDuration(DurationUnit.HOURS), Duration.hours(n1)) |
| assertEquals(n2.toDuration(DurationUnit.HOURS), Duration.hours(n2)) |
| assertEquals(n3.toDuration(DurationUnit.HOURS), Duration.hours(n3)) |
| |
| assertEquals(n1.toDuration(DurationUnit.MINUTES), Duration.minutes(n1)) |
| assertEquals(n2.toDuration(DurationUnit.MINUTES), Duration.minutes(n2)) |
| assertEquals(n3.toDuration(DurationUnit.MINUTES), Duration.minutes(n3)) |
| |
| assertEquals(n1.toDuration(DurationUnit.SECONDS), Duration.seconds(n1)) |
| assertEquals(n2.toDuration(DurationUnit.SECONDS), Duration.seconds(n2)) |
| assertEquals(n3.toDuration(DurationUnit.SECONDS), Duration.seconds(n3)) |
| |
| assertEquals(n1.toDuration(DurationUnit.MILLISECONDS), Duration.milliseconds(n1)) |
| assertEquals(n2.toDuration(DurationUnit.MILLISECONDS), Duration.milliseconds(n2)) |
| assertEquals(n3.toDuration(DurationUnit.MILLISECONDS), Duration.milliseconds(n3)) |
| |
| assertEquals(n1.toDuration(DurationUnit.MICROSECONDS), Duration.microseconds(n1)) |
| assertEquals(n2.toDuration(DurationUnit.MICROSECONDS), Duration.microseconds(n2)) |
| assertEquals(n3.toDuration(DurationUnit.MICROSECONDS), Duration.microseconds(n3)) |
| |
| assertEquals(n1.toDuration(DurationUnit.NANOSECONDS), Duration.nanoseconds(n1)) |
| assertEquals(n2.toDuration(DurationUnit.NANOSECONDS), Duration.nanoseconds(n2)) |
| assertEquals(n3.toDuration(DurationUnit.NANOSECONDS), Duration.nanoseconds(n3)) |
| } |
| |
| @Test |
| fun conversionToNumber() { |
| assertEquals(24, Duration.days(1).inWholeHours) |
| assertEquals(0.5, Duration.hours(12).toDouble(DurationUnit.DAYS)) |
| assertEquals(0, Duration.hours(12).inWholeDays) |
| assertEquals(15, Duration.hours(0.25).inWholeMinutes) |
| assertEquals(600, Duration.minutes(10).inWholeSeconds) |
| assertEquals(500, Duration.seconds(0.5).inWholeMilliseconds) |
| assertEquals(50_000, Duration.seconds(0.05).inWholeMicroseconds) |
| assertEquals(50_000, Duration.milliseconds(0.05).inWholeNanoseconds) |
| |
| assertEquals(365 * 86400 * 1_000_000_000L, Duration.days(365).inWholeNanoseconds) |
| |
| assertEquals(0, Duration.ZERO.inWholeNanoseconds) |
| assertEquals(0, Duration.ZERO.inWholeMicroseconds) |
| assertEquals(0, Duration.ZERO.inWholeMilliseconds) |
| |
| assertEquals(10500, Duration.seconds(10.5).inWholeMilliseconds) |
| assertEquals(11, Duration.milliseconds(11.5).inWholeMilliseconds) |
| assertEquals(-11, Duration.milliseconds((-11.5)).inWholeMilliseconds) |
| assertEquals(252_000_000, Duration.milliseconds(252).inWholeNanoseconds) |
| assertEquals(Long.MAX_VALUE, (Duration.days(365) * 293).inWholeNanoseconds) // clamping overflowed value |
| |
| repeat(100) { |
| val value = Random.nextLong(1000) |
| val unit = units.random() |
| val unit2 = units.random() |
| |
| assertAlmostEquals(Duration.convert(value.toDouble(), unit, unit2), value.toDuration(unit).toDouble(unit2)) |
| } |
| |
| for (unit in units) { |
| assertEquals(Long.MAX_VALUE, Duration.INFINITE.toLong(unit)) |
| assertEquals(Int.MAX_VALUE, Duration.INFINITE.toInt(unit)) |
| assertEquals(Double.POSITIVE_INFINITY, Duration.INFINITE.toDouble(unit)) |
| assertEquals(Long.MIN_VALUE, (-Duration.INFINITE).toLong(unit)) |
| assertEquals(Int.MIN_VALUE, (-Duration.INFINITE).toInt(unit)) |
| assertEquals(Double.NEGATIVE_INFINITY, (-Duration.INFINITE).toDouble(unit)) |
| } |
| } |
| |
| @Test |
| fun componentsOfProperSum() { |
| repeat(100) { |
| val d = Random.nextInt(365 * 50) // fits in Int seconds |
| val h = Random.nextInt(24) |
| val m = Random.nextInt(60) |
| val s = Random.nextInt(60) |
| val ns = Random.nextInt(1e9.toInt()) |
| (Duration.days(d) + Duration.hours(h) + Duration.minutes(m) + Duration.seconds(s) + Duration.nanoseconds(ns)).run { |
| toComponents { seconds, nanoseconds -> |
| assertEquals(d.toLong() * 86400 + h * 3600 + m * 60 + s, seconds) |
| assertEquals(ns, nanoseconds) |
| } |
| toComponents { minutes, seconds, nanoseconds -> |
| assertEquals(d * 1440 + h * 60 + m, minutes) |
| assertEquals(s, seconds) |
| assertEquals(ns, nanoseconds) |
| } |
| toComponents { hours, minutes, seconds, nanoseconds -> |
| assertEquals(d * 24 + h, hours) |
| assertEquals(m, minutes) |
| assertEquals(s, seconds) |
| assertEquals(ns, nanoseconds) |
| } |
| toComponents { days, hours, minutes, seconds, nanoseconds -> |
| assertEquals(d, days) |
| assertEquals(h, hours) |
| assertEquals(m, minutes) |
| assertEquals(s, seconds) |
| assertEquals(ns, nanoseconds) |
| } |
| } |
| } |
| } |
| |
| @Test |
| fun componentsOfCarriedSum() { |
| (Duration.hours(36) + Duration.minutes(90) + Duration.seconds(90) + Duration.milliseconds(1500)).run { |
| toComponents { days, hours, minutes, seconds, nanoseconds -> |
| assertEquals(1, days) |
| assertEquals(13, hours) |
| assertEquals(31, minutes) |
| assertEquals(31, seconds) |
| assertEquals(500_000_000, nanoseconds) |
| } |
| } |
| } |
| |
| @Test |
| fun infinite() { |
| assertTrue(Duration.INFINITE.isInfinite()) |
| assertTrue((-Duration.INFINITE).isInfinite()) |
| assertTrue(Duration.nanoseconds(Double.POSITIVE_INFINITY).isInfinite()) |
| |
| // seconds converted to nanoseconds overflow to infinite |
| assertTrue(Duration.seconds(Double.MAX_VALUE).isInfinite()) |
| assertTrue(Duration.seconds((-Double.MAX_VALUE)).isInfinite()) |
| } |
| |
| |
| @Test |
| fun negation() { |
| repeat(100) { |
| val value = Random.nextLong() |
| val unit = units.random() |
| |
| assertEquals((-value).toDuration(unit), -value.toDuration(unit)) |
| } |
| } |
| |
| @Test |
| fun signAndAbsoluteValue() { |
| val negative = -Duration.seconds(1) |
| val positive = Duration.seconds(1) |
| val zero = Duration.ZERO |
| |
| assertTrue(negative.isNegative()) |
| assertFalse(zero.isNegative()) |
| assertFalse(positive.isNegative()) |
| |
| assertFalse(negative.isPositive()) |
| assertFalse(zero.isPositive()) |
| assertTrue(positive.isPositive()) |
| |
| assertEquals(positive, negative.absoluteValue) |
| assertEquals(positive, positive.absoluteValue) |
| assertEquals(zero, zero.absoluteValue) |
| } |
| |
| @Test |
| fun negativeZero() { |
| fun equivalentToZero(value: Duration) { |
| assertEquals(Duration.ZERO, value) |
| assertEquals(Duration.ZERO, value.absoluteValue) |
| assertEquals(value, value.absoluteValue) |
| assertEquals(value, value.absoluteValue) |
| assertFalse(value.isNegative()) |
| assertFalse(value.isPositive()) |
| assertEquals(Duration.ZERO.toString(), value.toString()) |
| assertEquals(Duration.ZERO.toIsoString(), value.toIsoString()) |
| assertEquals(Duration.ZERO.toDouble(DurationUnit.SECONDS), value.toDouble(DurationUnit.SECONDS)) |
| assertEquals(0, Duration.ZERO.compareTo(value)) |
| assertEquals(0, Duration.ZERO.toDouble(DurationUnit.NANOSECONDS).compareTo(value.toDouble(DurationUnit.NANOSECONDS))) |
| } |
| equivalentToZero(Duration.seconds(-0.0)) |
| equivalentToZero((-0.0).toDuration(DurationUnit.DAYS)) |
| equivalentToZero(-Duration.ZERO) |
| equivalentToZero(Duration.seconds(-1) / Double.POSITIVE_INFINITY) |
| equivalentToZero(Duration.seconds(0) / -1) |
| equivalentToZero(Duration.seconds(-1) * 0.0) |
| equivalentToZero(Duration.seconds(0) * -1) |
| } |
| |
| |
| @Test |
| fun addition() { |
| assertEquals(Duration.hours(1.5), Duration.hours(1) + Duration.minutes(30)) |
| assertEquals(Duration.days(0.5), Duration.hours(6) + Duration.minutes(360)) |
| assertEquals(Duration.seconds(0.5), Duration.milliseconds(200) + Duration.microseconds(300_000)) |
| |
| for (value in listOf(Duration.ZERO, Duration.nanoseconds(1), Duration.days(500 * 365))) { |
| for (inf in listOf(Duration.INFINITE, -Duration.INFINITE)) { |
| for (result in listOf(inf + inf, inf + value, inf + (-value), value + inf, (-value) + inf)) { |
| assertEquals(inf, result) |
| } |
| } |
| } |
| |
| assertFailsWith<IllegalArgumentException> { Duration.INFINITE + (-Duration.INFINITE) } |
| } |
| |
| @Test |
| fun subtraction() { |
| assertEquals(Duration.hours(10), Duration.days(0.5) - Duration.minutes(120)) |
| assertEquals(Duration.milliseconds(850), Duration.seconds(1) - Duration.milliseconds(150)) |
| assertEquals(Duration.milliseconds(1150), Duration.seconds(1) - Duration.milliseconds(-150)) |
| assertEquals(Duration.milliseconds(1), Duration.microseconds(Long.MAX_VALUE) - Duration.microseconds(Long.MAX_VALUE - 1_000)) |
| assertEquals(Duration.milliseconds(-1), Duration.microseconds(Long.MAX_VALUE - 1_000) - Duration.microseconds(Long.MAX_VALUE)) |
| |
| run { |
| val offset = 2L * NANOS_IN_MILLIS |
| val value = MAX_NANOS + offset |
| val base = Duration.nanoseconds(value) |
| val baseNs = base.inWholeMilliseconds * NANOS_IN_MILLIS |
| assertEquals(baseNs, base.inWholeNanoseconds) // base stored as millis |
| |
| val smallDeltas = listOf(1L, 2L, 1000L, NANOS_IN_MILLIS - 1L) + List(10) { Random.nextLong(NANOS_IN_MILLIS.toLong()) } |
| for (smallDeltaNs in smallDeltas) { |
| assertEquals(base, base - Duration.nanoseconds(smallDeltaNs), "delta: $smallDeltaNs") |
| } |
| |
| val deltas = listOf(offset + 1L, offset + 1500L) + |
| List(10) { Random.nextLong(offset + 1500, offset + 10000) } + |
| List(100) { Random.nextLong(offset + 1500, MAX_NANOS) } |
| for (deltaNs in deltas) { |
| val delta = Duration.nanoseconds(deltaNs) |
| assertEquals(deltaNs, delta.inWholeNanoseconds) |
| assertEquals(baseNs - deltaNs, (base - delta).inWholeNanoseconds, "base: $baseNs, delta: $deltaNs") |
| } |
| } |
| |
| for (value in listOf(Duration.ZERO, Duration.nanoseconds(1), Duration.days(500 * 365))) { |
| for (inf in listOf(Duration.INFINITE, -Duration.INFINITE)) { |
| for (result in listOf(inf - (-inf), inf - value, inf - (-value), value - (-inf), (-value) - (-inf))) { |
| assertEquals(inf, result) |
| } |
| } |
| } |
| |
| assertFailsWith<IllegalArgumentException> { Duration.INFINITE - Duration.INFINITE } |
| } |
| |
| @Test |
| fun multiplication() { |
| assertEquals(Duration.days(1), Duration.hours(12) * 2) |
| assertEquals(Duration.days(1), Duration.minutes(60) * 24.0) |
| assertEquals(Duration.microseconds(1), Duration.nanoseconds(20) * 50) |
| |
| assertEquals(Duration.days(1), 2 * Duration.hours(12)) |
| assertEquals(Duration.hours(12.5), 12.5 * Duration.minutes(60)) |
| assertEquals(Duration.microseconds(1), 50 * Duration.nanoseconds(20)) |
| |
| assertEquals(Duration.ZERO, 0 * Duration.hours(1)) |
| assertEquals(Duration.ZERO, Duration.seconds(1) * 0.0) |
| |
| run { // promoting nanos range to millis range after multiplication |
| val value = MAX_NANOS |
| assertEquals(value, (Duration.nanoseconds(value) * 1_000_000).inWholeMilliseconds) |
| assertEquals(value / 1000, (Duration.nanoseconds(value) * 1_000).inWholeMilliseconds) |
| assertEquals(Duration.INFINITE, Duration.nanoseconds(Long.MAX_VALUE / 1000 + 1) * 1_000_000_000) |
| } |
| |
| run { |
| val value = MAX_NANOS / Int.MAX_VALUE |
| assertTrue((Duration.nanoseconds(value) * Int.MIN_VALUE).inWholeNanoseconds < -MAX_NANOS) |
| } |
| |
| assertEquals(Duration.INFINITE, Duration.days(Int.MAX_VALUE) * Int.MAX_VALUE) |
| assertEquals(-Duration.INFINITE, Duration.days(Int.MAX_VALUE) * Int.MIN_VALUE) |
| |
| assertEquals(Duration.INFINITE, Duration.INFINITE * Double.POSITIVE_INFINITY) |
| assertEquals(Duration.INFINITE, Duration.INFINITE * Double.MIN_VALUE) |
| assertEquals(-Duration.INFINITE, Duration.INFINITE * Double.NEGATIVE_INFINITY) |
| assertEquals(-Duration.INFINITE, Duration.INFINITE * -1) |
| |
| assertFailsWith<IllegalArgumentException> { Duration.INFINITE * 0 } |
| assertFailsWith<IllegalArgumentException> { 0.0 * Duration.INFINITE } |
| } |
| |
| @Test |
| fun divisionByNumber() { |
| assertEquals(Duration.hours(12), Duration.days(1) / 2) |
| assertEquals(Duration.minutes(60), Duration.days(1) / 24.0) |
| assertEquals(Duration.seconds(20), Duration.minutes(2) / 6) |
| assertEquals(Duration.days(365), Duration.days(365 * 299) / 299) |
| assertEquals(Duration.days(365), Duration.days(365 * 299.5) / 299.5) |
| |
| run { |
| val value = MAX_NANOS |
| assertEquals(value, (Duration.milliseconds(value) / 1_000_000).inWholeNanoseconds) |
| } |
| |
| assertEquals(Duration.INFINITE, Duration.seconds(1) / 0) |
| assertEquals(-Duration.INFINITE, -Duration.seconds(1) / 0.0) |
| assertEquals(Duration.INFINITE, -Duration.seconds(1) / (-0.0)) |
| |
| assertEquals(Duration.INFINITE, Duration.INFINITE / Int.MAX_VALUE) |
| assertEquals(Duration.INFINITE, -Duration.INFINITE / Int.MIN_VALUE) |
| assertEquals(-Duration.INFINITE, Duration.INFINITE / -1) |
| assertEquals(Duration.INFINITE, Duration.INFINITE / Double.MAX_VALUE) |
| |
| assertFailsWith<IllegalArgumentException> { Duration.INFINITE / Double.POSITIVE_INFINITY } |
| assertFailsWith<IllegalArgumentException> { Duration.ZERO / 0 } |
| assertFailsWith<IllegalArgumentException> { Duration.ZERO / 0.0 } |
| } |
| |
| @Test |
| fun divisionByDuration() { |
| assertEquals(24.0, Duration.days(1) / Duration.hours(1)) |
| assertEquals(0.1, Duration.minutes(9) / Duration.hours(1.5)) |
| assertEquals(50.0, Duration.microseconds(1) / Duration.nanoseconds(20)) |
| assertEquals(299.0, Duration.days(365 * 299) / Duration.days(365)) |
| |
| assertTrue((Duration.INFINITE / Duration.INFINITE).isNaN()) |
| assertTrue((Duration.ZERO / Duration.ZERO).isNaN()) |
| } |
| |
| @Test |
| fun toIsoString() { |
| // zero |
| assertEquals("PT0S", Duration.ZERO.toIsoString()) |
| |
| // single unit |
| assertEquals("PT24H", Duration.days(1).toIsoString()) |
| assertEquals("PT1H", Duration.hours(1).toIsoString()) |
| assertEquals("PT1M", Duration.minutes(1).toIsoString()) |
| assertEquals("PT1S", Duration.seconds(1).toIsoString()) |
| assertEquals("PT0.001S", Duration.milliseconds(1).toIsoString()) |
| assertEquals("PT0.000001S", Duration.microseconds(1).toIsoString()) |
| assertEquals("PT0.000000001S", Duration.nanoseconds(1).toIsoString()) |
| |
| // rounded to zero |
| assertEquals("PT0S", Duration.nanoseconds(0.1).toIsoString()) |
| assertEquals("PT0S", Duration.nanoseconds(0.9).toIsoString()) |
| |
| // several units combined |
| assertEquals("PT24H1M", (Duration.days(1) + Duration.minutes(1)).toIsoString()) |
| assertEquals("PT24H0M1S", (Duration.days(1) + Duration.seconds(1)).toIsoString()) |
| assertEquals("PT24H0M0.001S", (Duration.days(1) + Duration.milliseconds(1)).toIsoString()) |
| assertEquals("PT1H30M", (Duration.hours(1) + Duration.minutes(30)).toIsoString()) |
| assertEquals("PT1H0M0.500S", (Duration.hours(1) + Duration.milliseconds(500)).toIsoString()) |
| assertEquals("PT2M0.500S", (Duration.minutes(2) + Duration.milliseconds(500)).toIsoString()) |
| assertEquals("PT1M30.500S", (Duration.milliseconds(90_500)).toIsoString()) |
| |
| // negative |
| assertEquals("-PT23H45M", (-Duration.days(1) + Duration.minutes(15)).toIsoString()) |
| assertEquals("-PT24H15M", (-Duration.days(1) - Duration.minutes(15)).toIsoString()) |
| |
| // infinite |
| assertEquals("PT2147483647H", Duration.INFINITE.toIsoString()) |
| } |
| |
| @Test |
| fun toStringInUnits() { |
| var d = with(Duration) { |
| days(1) + hours(15) + minutes(31) + seconds(45) + |
| milliseconds(678) + microseconds(920) + nanoseconds(516.34) |
| } |
| |
| fun test(unit: DurationUnit, vararg representations: String) { |
| assertFails { d.toString(unit, -1) } |
| assertEquals(representations.toList(), representations.indices.map { d.toString(unit, it) }) |
| } |
| |
| test(DurationUnit.DAYS, "2d", "1.6d", "1.65d", "1.647d") |
| test(DurationUnit.HOURS, "40h", "39.5h", "39.53h") |
| test(DurationUnit.MINUTES, "2372m", "2371.8m", "2371.76m") |
| d -= Duration.hours(39) |
| test(DurationUnit.SECONDS, "1906s", "1905.7s", "1905.68s", "1905.679s") |
| d -= Duration.seconds(1904) |
| test(DurationUnit.MILLISECONDS, "1679ms", "1678.9ms", "1678.92ms", "1678.921ms") |
| d -= Duration.milliseconds(1678) |
| test(DurationUnit.MICROSECONDS, "921us", "920.5us", "920.52us", "920.516us") |
| d -= Duration.microseconds(920) |
| // no sub-nanosecond precision |
| test(DurationUnit.NANOSECONDS, "516ns", "516.0ns", "516.00ns", "516.000ns", "516.0000ns") |
| d = (d - Duration.nanoseconds(516)) / 17 |
| test(DurationUnit.NANOSECONDS, "0ns", "0.0ns", "0.00ns", "0.000ns", "0.0000ns") |
| |
| // infinite |
| // d = Duration.nanoseconds(Double.MAX_VALUE) |
| // test(DurationUnit.DAYS, "2.08e+294d") |
| // test(DurationUnit.NANOSECONDS, "1.80e+308ns") |
| |
| assertEquals("0.500000000000s", Duration.seconds(0.5).toString(DurationUnit.SECONDS, 100)) |
| assertEquals("99999000000000.000000000000ns", Duration.seconds(99_999).toString(DurationUnit.NANOSECONDS, 15)) |
| assertEquals("1.00e+14ns", Duration.seconds(100_000).toString(DurationUnit.NANOSECONDS, 9)) |
| |
| d = Duration.INFINITE |
| test(DurationUnit.DAYS, "Infinity", "Infinity") |
| d = -Duration.INFINITE |
| test(DurationUnit.NANOSECONDS, "-Infinity", "-Infinity") |
| } |
| |
| |
| @Test |
| fun toStringDefault() { |
| fun test(duration: Duration, vararg expectedOptions: String) { |
| val actual = duration.toString() |
| |
| if (!expectedOptions.contains(actual)) { |
| assertEquals<Any>(expectedOptions.toList(), duration.toString()) |
| } |
| if (duration > Duration.ZERO) |
| assertEquals("-$actual", (-duration).toString()) |
| } |
| |
| test(Duration.days(101), "101d") |
| test(Duration.days(45.3), "45.3d") |
| test(Duration.days(45), "45.0d") |
| |
| test(Duration.days(40.5), "972h") |
| test(Duration.hours(40) + Duration.minutes(15), "40.3h", "40.2h") |
| test(Duration.hours(40), "40.0h") |
| |
| test(Duration.hours(12.5), "750m") |
| test(Duration.minutes(30), "30.0m") |
| test(Duration.minutes(17.5), "17.5m") |
| |
| test(Duration.minutes(16.5), "990s") |
| test(Duration.seconds(90.36), "90.4s") |
| test(Duration.seconds(50), "50.0s") |
| test(Duration.seconds(1.3), "1.30s") |
| test(Duration.seconds(1), "1.00s") |
| |
| test(Duration.seconds(0.5), "500ms") |
| test(Duration.milliseconds(40.2), "40.2ms") |
| test(Duration.milliseconds(4.225), "4.23ms", "4.22ms") |
| test(Duration.milliseconds(4.245), "4.25ms") |
| test(Duration.milliseconds(1), "1.00ms") |
| |
| test(Duration.milliseconds(0.75), "750us") |
| test(Duration.microseconds(75.35), "75.4us", "75.3us") |
| test(Duration.microseconds(7.25), "7.25us") |
| test(Duration.microseconds(1.035), "1.04us", "1.03us") |
| test(Duration.microseconds(1.005), "1.01us", "1.00us") |
| |
| test(Duration.nanoseconds(950.5), "951ns", "950ns") |
| test(Duration.nanoseconds(85.23), "85.0ns") |
| test(Duration.nanoseconds(8.235), "8.00ns") |
| test(Duration.nanoseconds(1.3), "1.00ns") |
| |
| // equal to zero |
| // test(Duration.nanoseconds(0.75), "0.75ns") |
| // test(Duration.nanoseconds(0.7512), "0.7512ns") |
| // test(Duration.nanoseconds(0.023), "0.023ns") |
| // test(Duration.nanoseconds(0.0034), "0.0034ns") |
| // test(Duration.nanoseconds(0.0000035), "0.0000035ns") |
| |
| test(Duration.ZERO, "0s") |
| test(Duration.days(365) * 10000, "3650000d") |
| test(Duration.days(300) * 100000, "3.00e+7d") |
| test(Duration.days(365) * 100000, "3.65e+7d") |
| |
| // all infinite |
| // val universeAge = Duration.days(365.25) * 13.799e9 |
| // val planckTime = Duration.seconds(5.4e-44) |
| |
| // test(universeAge, "5.04e+12d") |
| // test(planckTime, "5.40e-44s") |
| // test(Duration.nanoseconds(Double.MAX_VALUE), "2.08e+294d") |
| test(Duration.INFINITE, "Infinity") |
| } |
| |
| } |
