test_binary_import.ae

// This test imports the compiled librexxae artifact. It deliberately has no
// import of src.engine, src.values or any other engine implementation file.
import std.spec
import std.string
import rexxae

main() {
    fw = spec.init()
    spec.describe(fw, "Aether consuming compiled RexxAE") {
        spec.it("passes typed values and host replies through the binary") callback {
            ctx = rexxae.rexxae_create("LET result = TESTECHO(input)\nSAY TYPEOF(result)")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_set_variable_json(ctx, "input", "{\"items\":[1,true,null]}"), 0, "seed input")
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTECHO", 1, 1), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "request")
            spec.assert_str_eq(string.copy(rexxae.rexxae_function(ctx)), "TESTECHO", "name")
            spec.assert_eq(rexxae.rexxae_argument_type(ctx, 0), 5, "object type")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(ctx)), "[{\"items\":[1,true,null]}]", "typed args")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "{\"ok\":true,\"items\":[1,null]}", ""), 0, "reply")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "SAY")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "object", "typed result")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 0, "done")
            spec.assert_str_eq(string.copy(rexxae.rexxae_get_variable_json(ctx, "result")), "{\"ok\":true,\"items\":[1,null]}", "inspect")
        }
        spec.it("resumes a loop across command and function events") callback {
            ctx = rexxae.rexxae_create("DO i = 1 TO 2\nADDRESS APP 'work'\nLET n = TESTSTEP(i)\nSAY n\nEND")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTSTEP", 1, 1), 0, "register")
            status = 3
            calls = 0
            commands = 0
            output = 0
            steps = 0
            while status > 0 && steps < 100 {
                status = rexxae.rexxae_step(ctx, 1)
                if status == 2 {
                    commands = commands + 1
                    spec.assert_str_eq(string.copy(rexxae.rexxae_address(ctx)), "app", "address")
                    spec.assert_eq(rexxae.rexxae_reply(ctx, 0, "done", ""), 0, "command reply")
                }
                if status == 4 {
                    calls = calls + 1
                    spec.assert_str_eq(string.copy(rexxae.rexxae_argument_text(ctx, 0)), string.from_int(calls), "loop argument")
                    spec.assert_eq(rexxae.rexxae_reply_value(ctx, string.from_int(calls * 10), ""), 0, "typed reply")
                }
                if status == 1 { output = output + 1 }
                steps = steps + 1
            }
            spec.assert_eq(status, 0, "completed")
            spec.assert_eq(calls, 2, "function count")
            spec.assert_eq(commands, 2, "command count")
            spec.assert_eq(output, 2, "output count")
        }
        spec.it("preserves error status and source locations across the boundary") callback {
            ctx = rexxae.rexxae_create("\nLET n = TESTERROR()")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTERROR", 0, 0), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "request")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "invalid JSON", ""), -1, "reject malformed")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "still pending")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "null", "application refused"), 0, "host failure")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "terminal")
            spec.assert_eq(rexxae.rexxae_line(ctx), 2, "line")
            spec.assert_str_eq(string.copy(rexxae.rexxae_error(ctx)), "application refused", "error")
        }
        spec.it("tears down suspended binary contexts without keeping caller data") callback {
            i = 0
            while i < 50 {
                ctx = rexxae.rexxae_create("LET n = TESTWAIT([1,true], JSON_PARSE('null'))")
                spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTWAIT", 2, 2), 0, "register")
                spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "wait")
                rexxae.rexxae_destroy(ctx)
                i = i + 1
            }
        }
        spec.it("returns typed data from nested routines across host suspension") callback {
            ctx = rexxae.rexxae_create("CALL outer 0\nSAY JSON_STRINGIFY(RESULT)\nEXIT\nouter:\nARG n\nCALL inner n\nLET answer = RESULT\nRETURN answer\ninner:\nARG value\nCALL TESTECHO value\nLET response = RESULT\nRETURN response")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTECHO", 1, 1), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "nested request")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(ctx)), "[0]", "zero retained")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "{\"ok\":true,\"data\":[null,1]}", ""), 0, "typed reply")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "returned output")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "{\"ok\":true,\"data\":[null,1]}", "return value")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 0, "done")
        }
        spec.it("suspends PROCEDURE calls without losing caller data or host mounts") callback {
            ctx = rexxae.rexxae_create("LET secret = 'caller'\nLET key = 'other'\nCALL work 0\nSAY secret RESULT.ok\nEXIT\nwork: PROCEDURE EXPOSE input.\nARG value\nLET key = 'other'\nLET input.changed = true\nCALL TESTECHO value\nRETURN RESULT")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_set_variable_json(ctx, "input.key", "42"), 0, "literal host path")
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTECHO", 1, 1), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "procedure suspended")
            spec.assert_true(rexxae.rexxae_get_variable_json(ctx, "secret") == null, "caller hidden")
            spec.assert_str_eq(string.copy(rexxae.rexxae_get_variable_json(ctx, "input.key")), "42", "literal API unaffected by tail names")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(ctx)), "[0]", "typed local argv")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "{\"ok\":true}", ""), 0, "typed reply")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "returned")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "caller true", "caller restored")
            spec.assert_str_eq(string.copy(rexxae.rexxae_get_variable_json(ctx, "input.changed")), "true", "exposed stem")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 0, "done")
        }
        spec.it("restores caller data when a PROCEDURE host operation is vetoed") callback {
            ctx = rexxae.rexxae_create("LET x = 'caller'\nCALL work\nEXIT\nwork: PROCEDURE\nx = 'local'\nCALL TESTERROR\nRETURN")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTERROR", 0, 0), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "suspended")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "null", "vetoed"), 0, "veto")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "terminal")
            spec.assert_str_eq(string.copy(rexxae.rexxae_get_variable_json(ctx, "x")), "\"caller\"", "generation restored")
        }
        spec.it("bounds recursive binary calls and preserves error locations") callback {
            ctx = rexxae.rexxae_create("CALL recurse\nEXIT\nrecurse:\nCALL recurse\nRETURN")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_step(ctx, 1000), -1, "depth guard")
            spec.assert_eq(rexxae.rexxae_line(ctx), 4, "call line")
        }
        spec.it("frees nested binary frames while awaiting a host reply") callback {
            i = 0
            while i < 30 {
                ctx = rexxae.rexxae_create("CALL outer\nEXIT\nouter: PROCEDURE\nCALL inner\nRETURN\ninner: PROCEDURE\nCALL TESTWAIT\nRETURN")
                spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTWAIT", 0, 0), 0, "register")
                spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "wait in inner routine")
                rexxae.rexxae_destroy(ctx)
                i = i + 1
            }
        }
        spec.it("selects a typed host condition and returns through the binary") callback {
            ctx = rexxae.rexxae_create("CALL work\nSAY JSON_STRINGIFY(RESULT)\nEXIT\nwork:\nSELECT\nWHEN TESTSELECT(1) THEN CALL TESTSELECT 2\nWHEN TESTSELECT(3) THEN RETURN 0\nOTHERWISE RETURN 0\nEND\nLET answer = RESULT\nRETURN answer")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTSELECT", 1, 1), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "WHEN condition")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(ctx)), "[1]", "condition argument")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "true", ""), 0, "match")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "selected body")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(ctx)), "[2]", "body argument")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "{\"selected\":true}", ""), 0, "typed result")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "returned SAY")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "{\"selected\":true}", "typed return")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 0, "later WHEN skipped")
        }
        spec.it("preserves selected condition errors across the binary boundary") callback {
            ctx = rexxae.rexxae_create("SELECT\nWHEN TESTSELECT() THEN SAY 'bad'\nEND")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTSELECT", 0, 0), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "pending condition")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "null", "selection refused"), 0, "host error")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "terminal")
            spec.assert_eq(rexxae.rexxae_line(ctx), 2, "WHEN line")
        }
        spec.it("tears down nested selections pending in binary contexts") callback {
            i = 0
            while i < 20 {
                ctx = rexxae.rexxae_create("SELECT\nWHEN 1 THEN\nSELECT\nWHEN TESTSELECT() THEN SAY 'ready'\nEND\nEND")
                spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTSELECT", 0, 0), 0, "register")
                spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "pending inner WHEN")
                rexxae.rexxae_destroy(ctx)
                i = i + 1
            }
        }
        spec.it("parses a suspended host reply into owned nested fields") callback {
            ctx = rexxae.rexxae_create("PARSE VALUE TESTLINE() WITH parsed_first ':' parsed_rest\nLET result.first = parsed_first\nLET result.rest = parsed_rest\nSAY result.first result.rest")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "TESTLINE", 0, 0), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "input pending")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "\"one:two\"", ""), 0, "text input")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "parsed output")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "one two", "PARSE fields")
            spec.assert_str_eq(string.copy(rexxae.rexxae_get_variable_json(ctx, "result.rest")), "\"two\"", "typed nested output")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 0, "done")
        }
        spec.it("seeds compound inputs through the binary API") callback {
            ctx = rexxae.rexxae_create("SAY config.message\nLET config.response.ok = true")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_set_variable_json(ctx, "config.message", "\"hello\""), 0, "seed property")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "SAY input")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "hello", "seeded value")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 0, "done")
            spec.assert_str_eq(string.copy(rexxae.rexxae_get_variable_json(ctx, "config.response.ok")), "true", "owned boolean")
        }
    }
    spec.describe(fw, "binary session continuation") {
        spec.it("retains typed state and mounted services without replay") callback {
            first = rexxae.rexxae_create("LET x = 7\nLET data = [1,true]")
            spec.assert_eq(rexxae.rexxae_register_function(first, "TESTNEXT", 1, 1), 0, "mount")
            spec.assert_eq(rexxae.rexxae_step(first, 100), 0, "done")
            next = rexxae.rexxae_create_next(first, "CALL TESTNEXT data\nSAY x RESULT")
            rexxae.rexxae_destroy(first)
            defer rexxae.rexxae_destroy(next)
            spec.assert_eq(rexxae.rexxae_step(next, 100), 4, "copied mount")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(next)), "[[1,true]]", "typed value retained")
            spec.assert_true(rexxae.rexxae_create_next(next, "EXIT") == null, "pending cannot fork")
            spec.assert_eq(rexxae.rexxae_reply_value(next, "8", ""), 0, "reply")
            spec.assert_eq(rexxae.rexxae_step(next, 100), 1, "output")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(next)), "7 8", "fresh entry")
            spec.assert_eq(rexxae.rexxae_step(next, 100), 0, "done")
        }
        spec.it("does not turn copied script data into a mounted service") callback {
            first = rexxae.rexxae_create("LET h.EXEC = {min:0,max:1}")
            spec.assert_eq(rexxae.rexxae_step(first, 100), 0, "data")
            next = rexxae.rexxae_create_next(first, "CALL EXEC 'anything'")
            rexxae.rexxae_destroy(first)
            defer rexxae.rexxae_destroy(next)
            spec.assert_eq(rexxae.rexxae_step(next, 100), -1, "unmounted")
        }
    }
    spec.describe(fw, "binary REQUIRE AS protocol") {
        spec.it("suspends for an import then binds its prefixed export") callback {
            ctx = rexxae.rexxae_create("REQUIRE 'calculator' AS remote_(.*)\nSAY remote_CALC('add','1','2')")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "REQUIRE", 1, 2), 0, "resolver")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "import")
            spec.assert_str_eq(string.copy(rexxae.rexxae_arguments_json(ctx)), "[\"calculator\",\"remote_(.*)\"]", "module and alias")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "true", ""), 0, "resolve")
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "remote_CALC", 3, 3), 0, "bind export")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "prefixed call")
            spec.assert_str_eq(string.copy(rexxae.rexxae_function(ctx)), "REMOTE_CALC", "alias applied")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "\"3\"", ""), 0, "reply")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 1, "output")
            spec.assert_str_eq(string.copy(rexxae.rexxae_text(ctx)), "3", "result")
        }
        spec.it("cancels a long DO loop between steps and keeps failing") callback {
            ctx = rexxae.rexxae_create("DO i = 1 TO 1000000\nx = i\nEND\nSAY 'finished'")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_step(ctx, 50), 3, "loop still running")
            spec.assert_eq(rexxae.rexxae_cancel(ctx, "deadline 5s"), 0, "cancel recorded")
            spec.assert_eq(rexxae.rexxae_cancel(ctx, "second"), 1, "first reason wins")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100000), -1, "step fails promptly")
            spec.assert_str_eq(string.copy(rexxae.rexxae_error(ctx)), "cancelled by host: deadline 5s", "message")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "stays failed")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "stays failed again")
            spec.assert_str_eq(string.copy(rexxae.rexxae_error(ctx)), "cancelled by host: deadline 5s", "message kept")
        }
        spec.it("cancels while suspended on a FUNCTION and discards the reply") callback {
            ctx = rexxae.rexxae_create("LET v = WAITFOR(1)\nSAY v")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "WAITFOR", 1, 1), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "suspended")
            spec.assert_eq(rexxae.rexxae_cancel(ctx, "host deadline"), 0, "cancel")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "step reports cancel")
            spec.assert_str_eq(string.copy(rexxae.rexxae_error(ctx)), "cancelled by host: host deadline", "message")
            spec.assert_eq(rexxae.rexxae_reply_value(ctx, "5", ""), -1, "late reply discarded")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "no SAY after cancel")
        }
        spec.it("cancels while suspended on a COMMAND and inside a routine") callback {
            ctx = rexxae.rexxae_create("CALL work\nSAY 'after'\nEXIT 0\nwork:\nADDRESS APP\n'go'\nRETURN 1")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 2, "command pending")
            spec.assert_eq(rexxae.rexxae_cancel(ctx, ""), 0, "cancel with empty reason")
            spec.assert_eq(rexxae.rexxae_reply(ctx, 0, "late", ""), 0, "reply accepted before the next step")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "cancel wins")
            spec.assert_str_eq(string.copy(rexxae.rexxae_error(ctx)), "cancelled by host", "bare message")
        }
        spec.it("cancel before the first step and on a finished context") callback {
            early = rexxae.rexxae_create("SAY 'x'")
            defer rexxae.rexxae_destroy(early)
            spec.assert_eq(rexxae.rexxae_cancel(early, "early"), 0, "cancel")
            spec.assert_eq(rexxae.rexxae_step(early, 100), -1, "never runs")
            spec.assert_eq(rexxae.rexxae_cancel(null, "x"), -1, "null handle")
            done = rexxae.rexxae_create("SAY 'x'")
            defer rexxae.rexxae_destroy(done)
            spec.assert_eq(rexxae.rexxae_step(done, 100), 1, "say")
            spec.assert_eq(rexxae.rexxae_step(done, 100), 0, "done")
            spec.assert_eq(rexxae.rexxae_cancel(done, "late"), 0, "recorded")
            spec.assert_eq(rexxae.rexxae_step(done, 100), 0, "completed script stays done")
        }
        spec.it("destroys a cancelled context mid-DO inside a routine and its successor") callback {
            ctx = rexxae.rexxae_create("DO i = 1 TO 10\nCALL f i\nEND\nf:\nLET q = P(1)\nRETURN")
            spec.assert_eq(rexxae.rexxae_register_function(ctx, "P", 1, 1), 0, "register")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), 4, "inside call inside loop")
            spec.assert_eq(rexxae.rexxae_cancel(ctx, "bye"), 0, "cancel")
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "error")
            next = rexxae.rexxae_create_next(ctx, "SAY 'again'")
            spec.assert_eq(rexxae.rexxae_step(next, 100), 1, "successor is not cancelled")
            rexxae.rexxae_destroy(next)
            rexxae.rexxae_destroy(ctx)
        }
        spec.it("does not load relative references without a mounted resolver") callback {
            ctx = rexxae.rexxae_create("REQUIRE '/static/calculator.rexx' AS remote")
            defer rexxae.rexxae_destroy(ctx)
            spec.assert_eq(rexxae.rexxae_step(ctx, 100), -1, "no ambient loader")
        }
    }
    return spec.run_summary(fw)
}