core/time

--  core/io's manual clock, which a test sets and advances: code that
--  times itself and sleeps, written against the `clock` and `wall_clock`
--  concepts, runs over it in no time and gives the same answer on every
--  target, Cortex-M0 included.  A sleep advances the clock by exactly
--  what was asked, both of its clocks move together, the wall clock
--  carries its nanoseconds into seconds, and spans and instants convert
--  as their counts say.  Each check that fails returns its own code.
import core/io/fake
import core/time

--  Poll until the clock has moved on by SPAN, sleeping STEP between
--  readings, and say how many times it slept: a routine that only knows
--  the `clock` concept.
waited: (provider: type is time.clock, host: provider, span: time.duration,
         step: time.duration) -> (sleeps: usize) =
    start: time.instant = time.now(host)
    deadline: time.instant = time.later(start, span)
    sleeps = 0
    while time.now(host) < deadline do
        time.sleep(host, step)
        inc sleeps
    end while
end waited

--  How long WORK took, timed on HOST's clock.
timed: (provider: type is time.clock, host: provider, work: time.duration)
       -> (took: time.duration) =
    start: time.instant = time.now(host)
    time.sleep(host, work)
    took = time.elapsed(start, time.now(host))
end timed

public main: () -> (code: i32) =
    code = 1
    return when u64(time.nanoseconds(7)) <> 7
      or u64(time.microseconds(3)) <> 3000
      or u64(time.milliseconds(250)) <> 250000000
      or u64(time.seconds(90)) <> 90000000000
      or time.in_milliseconds(time.nanoseconds(1999999)) <> 1
      or time.duration(5) <> time.nanoseconds(5)
    code = 2
    mut state: fake.clock_space = zeroed
    clock := fake.clock_over(state, time.instant(1000),
                             (seconds: 1767225600, nanoseconds: 999999000))
    return when u64(time.now(clock)) <> 1000
    took: time.duration = timed(clock, time.milliseconds(250))
    return when took <> time.milliseconds(250) or state.sleeps <> 1
      or state.slept <> 250000000
    code = 3
    --  The wall clock moved with it, carrying past a whole second.
    wall: time.wall_time = time.wall_now(clock)
    return when wall.seconds <> 1767225601 or wall.nanoseconds <> 249999000
    code = 4
    --  Three sleeps of 400 ms pass a second; the third reaches it.
    sleeps: usize = waited(clock, time.seconds(1), time.milliseconds(400))
    return when sleeps <> 3 or state.monotonic <> 1000 + 1450000000
    code = 5
    --  A sleep of zero does not move the clock; `advance` moves it as a
    --  test says, and a test may set the wall clock back.
    before: time.instant = time.now(clock)
    time.sleep(clock, time.duration(0))
    return when time.now(clock) <> before
    fake.advance(clock, time.seconds(2))
    return when u64(time.elapsed(before, time.now(clock))) <> 2000000000
    state.wall_seconds = 0
    set_back: time.wall_time = time.wall_now(clock)
    return when set_back.seconds <> 0 or set_back.nanoseconds <> 449999000
    code = 6
    return when state.readings < 10 or state.sleeps <> 5
    deadline: time.instant = time.later(time.instant(1), time.nanoseconds(2))
    return when u64(deadline) <> 3
    code = 42
end main