mirror of
https://github.com/go-sylixos/elvish.git
synced 2024-12-04 02:37:50 +08:00
179 lines
4.8 KiB
Plaintext
179 lines
4.8 KiB
Plaintext
/////////
|
|
# sleep #
|
|
/////////
|
|
|
|
//mock-time-after
|
|
|
|
## number with no unit ##
|
|
~> sleep 0
|
|
slept for 0s
|
|
~> sleep 1
|
|
slept for 1s
|
|
~> sleep 0.1
|
|
slept for 100ms
|
|
~> sleep (num 0)
|
|
slept for 0s
|
|
~> sleep (num 42)
|
|
slept for 42s
|
|
~> sleep (num 1.7)
|
|
slept for 1.7s
|
|
|
|
## number with unit ##
|
|
~> sleep 1.3s
|
|
slept for 1.3s
|
|
~> sleep 0.1ms
|
|
slept for 100µs
|
|
~> sleep 3h5m7s
|
|
slept for 3h5m7s
|
|
|
|
## valid durations ##
|
|
~> sleep 1x
|
|
Exception: invalid sleep duration
|
|
[tty]:1:1-8: sleep 1x
|
|
~> sleep -7
|
|
Exception: sleep duration must be >= zero
|
|
[tty]:1:1-8: sleep -7
|
|
~> sleep -3h
|
|
Exception: sleep duration must be >= zero
|
|
[tty]:1:1-9: sleep -3h
|
|
~> sleep 1/2
|
|
slept for 500ms
|
|
~> sleep (num -7)
|
|
Exception: sleep duration must be >= zero
|
|
[tty]:1:1-14: sleep (num -7)
|
|
~> sleep [1]
|
|
Exception: invalid sleep duration
|
|
[tty]:1:1-9: sleep [1]
|
|
|
|
## can be interrupted ##
|
|
//inject-time-after-with-sigint-or-skip
|
|
~> sleep 1s
|
|
Exception: interrupted
|
|
[tty]:1:1-8: sleep 1s
|
|
|
|
////////
|
|
# time #
|
|
////////
|
|
|
|
// Since runtime duration is non-deterministic, we only have some sanity checks
|
|
// here.
|
|
|
|
~> time { echo foo } | var out time = (all)
|
|
put $out
|
|
▶ foo
|
|
|
|
## &on-end ##
|
|
~> var duration = ''
|
|
time &on-end={|x| set duration = $x } { echo foo } | var out = (all)
|
|
put $out
|
|
kind-of $duration
|
|
▶ foo
|
|
▶ number
|
|
|
|
## propagating exception ##
|
|
~> time { fail body } | nop (all)
|
|
Exception: body
|
|
[tty]:1:8-17: time { fail body } | nop (all)
|
|
[tty]:1:1-19: time { fail body } | nop (all)
|
|
|
|
## propagating exception from &on-end ##
|
|
~> time &on-end={|_| fail on-end } { }
|
|
Exception: on-end
|
|
[tty]:1:19-30: time &on-end={|_| fail on-end } { }
|
|
[tty]:1:1-35: time &on-end={|_| fail on-end } { }
|
|
|
|
## exception from body takes precedence ##
|
|
~> time &on-end={|_| fail on-end } { fail body }
|
|
Exception: body
|
|
[tty]:1:35-44: time &on-end={|_| fail on-end } { fail body }
|
|
[tty]:1:1-45: time &on-end={|_| fail on-end } { fail body }
|
|
|
|
## bubbling output error ##
|
|
~> time { } >&-
|
|
Exception: invalid argument
|
|
[tty]:1:1-12: time { } >&-
|
|
|
|
/////////////
|
|
# benchmark #
|
|
/////////////
|
|
|
|
// These steps depend on the implementation detail that benchmark calls time.Now
|
|
// once before a run and once after a run.
|
|
|
|
## default output ##
|
|
//mock-benchmark-run-durations 1 2
|
|
~> benchmark &min-runs=2 &min-time=2s { }
|
|
1.5s ± 500ms (min 1s, max 2s, 2 runs)
|
|
|
|
## &on-end ##
|
|
//mock-benchmark-run-durations 1 2
|
|
~> benchmark &min-runs=2 &min-time=2s &on-end=$put~ { }
|
|
▶ [&avg=(num 1.5) &max=(num 2.0) &min=(num 1.0) &runs=(num 2) &stddev=(num 0.5)]
|
|
|
|
## &min-runs determining number of runs ##
|
|
//mock-benchmark-run-durations 1 2 1 2
|
|
~> benchmark &min-runs=4 &min-time=0s &on-end={|m| put $m[runs]} { }
|
|
▶ (num 4)
|
|
|
|
## &min-time determining number of runs ##
|
|
//mock-benchmark-run-durations 1 5 5
|
|
~> benchmark &min-runs=0 &min-time=10s &on-end={|m| put $m[runs]} { }
|
|
▶ (num 3)
|
|
|
|
## &on-run-end ##
|
|
//mock-benchmark-run-durations 1 2 1
|
|
~> benchmark &min-runs=3 &on-run-end=$put~ &on-end={|m| } { }
|
|
▶ (num 1.0)
|
|
▶ (num 2.0)
|
|
▶ (num 1.0)
|
|
|
|
## body throws exception ##
|
|
//mock-benchmark-run-durations 1 2 1
|
|
~> var i = 0
|
|
benchmark { set i = (+ $i 1); if (== $i 3) { fail failure } }
|
|
1.5s ± 500ms (min 1s, max 2s, 2 runs)
|
|
Exception: failure
|
|
[tty]:2:46-58: benchmark { set i = (+ $i 1); if (== $i 3) { fail failure } }
|
|
[tty]:2:1-61: benchmark { set i = (+ $i 1); if (== $i 3) { fail failure } }
|
|
|
|
## body throws exception on first run ##
|
|
~> benchmark { fail failure }
|
|
Exception: failure
|
|
[tty]:1:13-25: benchmark { fail failure }
|
|
[tty]:1:1-26: benchmark { fail failure }
|
|
~> benchmark &on-end=$put~ { fail failure }
|
|
Exception: failure
|
|
[tty]:1:27-39: benchmark &on-end=$put~ { fail failure }
|
|
[tty]:1:1-40: benchmark &on-end=$put~ { fail failure }
|
|
|
|
## &on-run-end throws exception ##
|
|
//mock-benchmark-run-durations 1
|
|
~> benchmark &on-run-end={|_| fail failure } { }
|
|
1s ± 0s (min 1s, max 1s, 1 runs)
|
|
Exception: failure
|
|
[tty]:1:28-40: benchmark &on-run-end={|_| fail failure } { }
|
|
[tty]:1:1-45: benchmark &on-run-end={|_| fail failure } { }
|
|
|
|
## &on-end throws exception ##
|
|
~> benchmark &min-runs=2 &min-time=0s &on-end={|_| fail failure } { }
|
|
Exception: failure
|
|
[tty]:1:49-61: benchmark &min-runs=2 &min-time=0s &on-end={|_| fail failure } { }
|
|
[tty]:1:1-66: benchmark &min-runs=2 &min-time=0s &on-end={|_| fail failure } { }
|
|
|
|
## option errors ##
|
|
~> benchmark &min-runs=-1 { }
|
|
Exception: bad value: min-runs option must be non-negative integer, but is -1
|
|
[tty]:1:1-26: benchmark &min-runs=-1 { }
|
|
~> benchmark &min-time=abc { }
|
|
Exception: bad value: min-time option must be duration string, but is abc
|
|
[tty]:1:1-27: benchmark &min-time=abc { }
|
|
~> benchmark &min-time=-1s { }
|
|
Exception: bad value: min-time option must be non-negative duration, but is -1s
|
|
[tty]:1:1-27: benchmark &min-time=-1s { }
|
|
|
|
## bubbling output error ##
|
|
//mock-benchmark-run-durations 1
|
|
~> benchmark &min-runs=0 &min-time=0s { } >&-
|
|
Exception: invalid argument
|
|
[tty]:1:1-42: benchmark &min-runs=0 &min-time=0s { } >&-
|