Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.4

0.7.4 / tests / command / main.lucb

## Exercise real child processes through the same executable on every host.
import c
import platform
import files
import io
import os
import interop
import process
import strings
import thread
import time

extern func pipe(descriptors: i32*) -> i32
extern func close(descriptor: i32) -> i32
extern func fcntl(descriptor: i32, command: i32, ...) -> i32

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 not platform.windows:
            if arguments[1] == "descriptor" and arguments.length > 2:
                # 9 when descriptor arguments[2] (open in the parent) reached this child
                let descriptor = strings.parse_i64(arguments[2]) else return 2
                return 9 if fcntl((i32)descriptor, 1) >= 0 else 0
        if arguments[1] == "unicode":
            _ = try output.write("éλ😀".bytes)
            return 0
    # this program's own file: on Windows its first argument may leave out the `.exe`
    let running = try os.executable()
    defer strings.release(running)
    let executable = try files.canonical((c.str)running)
    defer executable.release()
    if not platform.windows:
        # A pipe of this process stays out of its children, captured or not.
        var held: i32[2]
        assert(pipe((i32*)&held) == 0)
        defer _ = close(held[0])
        defer _ = close(held[1])
        var number: u8[24]
        # a copy ends in NUL, as an argument must
        let written = try strings.copy(try strings.format(number, f"{held[1]}"))
        defer strings.release(written)
        let checked = try process.run((c.str)running, ["descriptor", (c.str)written])
        defer checked.release()
        assert(checked.value.exit_code == 0)
        assert(try process.call((c.str)running, ["descriptor", (c.str)written]) == 0)
    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