dymokomi/luce-std
Source of release 0.7.0
0.7.0 / tests / programs / command / main.lucb
## Exercise real child processes through the same executable on every host.
import c
import files
import io
import interop
import process
import strings
import thread
import time
func wait_command(command: process.Command*) -> !:
let started = time.now()
while not command.is_finished():
assert(time.now() - started < 5000000000)
thread.sleep(2)
pub func main(arguments: str[]) -> i32!:
if arguments.length > 1:
var output = io.stdout()
if arguments[1] == "stream":
_ = try output.write("first\n".bytes)
thread.sleep(100)
_ = try output.write("second\n".bytes)
return 7
if arguments[1] == "sleep":
thread.sleep(60000)
return 0
if arguments[1] == "flood":
while true:
_ = try output.write("1234567890".bytes)
if arguments[1] == "unicode":
_ = try output.write("éλ😀".bytes)
return 0
let executable = try files.canonical((c.str)arguments[0])
defer executable.release()
var command = try process.Command(executable.value, ["stream"])
defer command.close()
let started = time.now()
var observed = false
while not command.is_finished():
let text = try command.output()
if text.value == "first\n":
observed = true
text.release()
assert(time.now() - started < 5000000000)
thread.sleep(2)
let text = try command.output()
defer text.release()
assert(text.value == "first\nsecond\n")
assert(observed)
assert((command.exit_code() else -1) == 7)
command.close()
command.close()
var sleeper = try process.Command(executable.value, ["sleep"])
defer sleeper.close()
sleeper.cancel()
try wait_command(&sleeper)
assert((sleeper.exit_code() else 0) == -1)
var flood = try process.Command(executable.value, ["flood"], output_limit = 128)
defer flood.close()
try wait_command(&flood)
let failure = try flood.error_message()
defer failure.release()
assert(failure.value == "the command exceeded its output limit")
var unicode = try process.Command(executable.value, ["unicode"])
defer unicode.close()
try wait_command(&unicode)
let result = try unicode.output()
defer result.release()
assert(result.value == "éλ😀")
var waited = try process.Command(executable.value, ["stream"])
defer waited.close()
assert(try waited.wait() == 7)
assert(try waited.wait() == 7)
let streamed = try waited.output()
defer streamed.release()
assert(streamed.value == "first\nsecond\n")
var stopped = try process.Command(executable.value, ["sleep"])
defer stopped.close()
stopped.cancel()
var refused = false
_ = stopped.wait() catch cancelled:
assert(cancelled.code == process.failed)
refused = true
recover 0
assert(refused)
return 0