asset scripts:
    path: ../asset/shell


test ShellSpawn:
    spawn as p
    with p:
        send "load ${scripts.path}/spawn.et"
        local:
            expect /(load-.*)/ capture done
            guard (done == "load-done")
        flush

        send "run *"
        expect /run-test-result ShellTrue done/
        expect /child-fail sh failed at: .*: false/
        expect /child-fail sh exit code: 1/
        expect /run-test-result ShellFalse failed/
        expect /run-done/


def expect_next_stdout from p (expected):
    expect from p /child-stdout sh (.*)/ capture line
    guard (line == expected)

test ShellEcho:
    spawn as p
    with p:
        send "load ${scripts.path}/echo.et"
        local:
            expect /(load-.*)/ capture done
            guard (done == "load-done")
        flush

        send "run *"

    expect_next_stdout from p:
        "a b c"
        "a b  c"
        "a b  d"
        "a b  c  d"

        "abcd xyz"
        "aa bc d"
        "b echo c"

        "a   b"
        "a   b"
        "\$space_str"

        "\$ \" \\"
        "\"\"a"
        "' \" \\\\\\ \\"
        "a b  c"

        "\" ' \\ \$ # | > < ; [ ] { } ( ) * ? ~ & !"

    with p:
        expect /run-test-result Echo done/
        expect /run-done/


test ShellPipe:
    spawn as p
    with p:
        send "load ${scripts.path}/pipe.et"
        local:
            expect /(load-.*)/ capture done
            guard (done == "load-done")
        flush

        send "run *"

    expect_next_stdout from p:
        "bc"
        "b"
    with p:
        expect /run-test-result Pipe done/

    expect_next_stdout from p:
        "x"
        "b"
        "c"
        "y"
        "b"
        "c"
        "z"
    with p:
        expect /run-test-result Redirect done/

    expect_next_stdout from p:
        "c"
        "e"
        "g"
        "bcdefg"
    with p:
        expect /run-test-result PipeRedirect done/

    with p:
        expect /run-done/


test ShellWorkingDirectory:
    spawn as p
    with p:
        send "load ${scripts.path}/working-directory.et"
        local:
            expect /(load-.*)/ capture done
            guard (done == "load-done")
        flush

        send "run *"

        expect from p /child-stdout sh (\/.*)/ capture home
        expect_next_stdout from p:
            "$home/abc/def"
            "$home/abc"
            "$home/abc/def/ghi"
            "$home/abc"
            "$home/abc"
            "$home/abc/def/ghi"
            "$home/abc/def/ghi"
            "$home"
            "$home"
            "/tmp"


test ShellExitOnError:
    spawn as p
    with p:
        send "load ${scripts.path}/error-exit.et"
        local:
            expect /(load-.*)/ capture done
            guard (done == "load-done")

        send "run Default"
        expect /child-fail sh failed at: .*error-exit.et:4:9: false/
        expect /run-test-result Default failed/
        expect /run-done/
        flush

        send "run DisabledSuccess"
        expect /run-test-result DisabledSuccess done/
        expect /run-done/
        flush

        send "run DisabledFailure"
        expect /run-test-result DisabledFailure failed/
        expect /run-done/
        flush

        send "run Enabled"
        expect /child-fail sh failed at: .*error-exit.et:25:9: false/
        expect /run-test-result Enabled failed/
        expect /run-done/
        flush


test ShellLogic:
    spawn as p
    with p:
        send "load ${scripts.path}/logic.et"
        local:
            expect /(load-.*)/ capture done
            guard (done == "load-done")

        send "run NegateFalse"
        expect /run-test-result NegateFalse done/
        expect /run-done/
        flush

        send "run NegateTrue"
        expect /child-fail sh failed at: .*logic.et:9:9: ! true/
        expect /run-test-result NegateTrue failed/
        expect /run-done/
        flush

        send "run NegateNothing"
        expect /child-fail sh failed at: .*logic.et:14:9: !/
        expect /run-test-result NegateNothing failed/
        expect /run-done/
        flush