Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / tests / run_test262 / eval.lucb

#==============================================================================================
#
#   eval - Evaluating one test source and comparing the outcome with the known errors
#
#   DESCRIPTION:
#       Port of run-test262.c lines 1380-1599: eval_buf evaluates a script or a module,
#       drives the job queue for async tests and modules, decides pass or fail (negative
#       tests expect an error of the given type) and, in verbose mode, reports new, changed
#       and fixed errors against the errors file; eval_file runs a harness include.
#
#==============================================================================================

# mark: Exceptions ==============================================================================

## Store a TypeError as the pending exception of `ctx`.
func throw_type_error(ctx: js.Context*, message: str):
    js.js_throw_type_error(ctx, message) catch: return

## Store `val` (owned) as the pending exception of `ctx`.
func throw_value(ctx: js.Context*, val: js.Value):
    js.js_throw(ctx, val) catch: return

func strict_prefix(eval_flags: i32) -> const u8*:
    if (eval_flags & js.eval_flag_strict) != 0:
        return z("strict mode: ")
    return z("")

# mark: eval_buf ================================================================================

func eval_buf(ctx: js.Context*, buf: const u8*, buf_len: usize, filename: const u8*, is_test: bool,
              is_negative: bool, error_type: const u8*?, outf: void*?, eval_flags: i32,
              is_async: bool) -> i32:
    let tls = tls_of(ctx)
    var ret: i32 = 0
    var pos_line: i32 = 0
    var pos = skip_comments(buf, 1, &pos_line)
    var error_line = pos_line
    var has_error_line = false
    var exception_val = js.js_undefined()
    var error_name: const u8*? = none

    # a module evaluation returns a promise
    let ret_promise = (eval_flags & js.eval_type_module) != 0
    tls.async_done = 0  # counter of "Test262:AsyncTestComplete" messages

    # `failed` stands for C's res_val == JS_EXCEPTION
    var failed = false
    var res_val = js.js_eval(ctx, buf, buf_len, filename, eval_flags) catch:
        failed = true
        recover js.js_undefined()

    if (is_async or ret_promise) and not failed:
        var promise = js.js_undefined()
        if ret_promise:
            promise = res_val
        else:
            js.js_free_value(ctx, res_val)
        res_val = js.js_undefined()
        while true:
            var job_failed = false
            let ran = js.js_execute_pending_job(js.js_get_runtime(ctx), none) catch:
                job_failed = true
                recover false
            if job_failed:
                failed = true
                break
            if not ran:
                if is_async:
                    # test if the test called $DONE() once
                    if tls.async_done != 1:
                        throw_type_error(ctx, "$DONE() not called")
                        failed = true
                else:
                    # check that the returned promise is fulfilled
                    let state = js.js_promise_state(ctx, promise)
                    if state == js.PromiseState.rejected:
                        throw_value(ctx, js.js_promise_result(ctx, promise))
                        failed = true
                    elif state != js.PromiseState.fulfilled:
                        throw_type_error(ctx, "promise is pending")
                        failed = true
                break
        js.js_free_value(ctx, promise)

    if failed:
        exception_val = js.js_get_exception(ctx)
        let is_error = js.js_is_error(ctx, exception_val)
        # XXX: should get the filename and line number
        if let fo = outf:
            if not is_error:
                _ = fprintf(fo, z("%sThrow: "), strict_prefix(eval_flags))
            _ = js_print(ctx, js.js_null(), 1, &exception_val) catch: recover js.js_undefined()
        if is_error:
            let name = js.js_get_property_str(ctx, exception_val, "name") catch: recover js.js_undefined()
            error_name = js.js_to_c_string(ctx, name) catch: recover none
            let stack = js.js_get_property_str(ctx, exception_val, "stack") catch: recover js.js_undefined()
            if not js.js_is_undefined(stack):
                let stack_str: const u8*? = js.js_to_c_string(ctx, stack) catch: recover none
                if let st = stack_str:
                    if let fo = outf:
                        _ = fprintf(fo, z("%s"), st)

                    let len = strlen(filename)
                    if let p = strstr(st, filename):
                        if p[len] == ':':
                            error_line = atoi(p + len + 1)
                            has_error_line = true
                    js.js_free_c_string(ctx, st)
            js.js_free_value(ctx, stack)
            js.js_free_value(ctx, name)
        if is_negative:
            ret = 0
            if let et = error_type:
                let msg: const u8*? = js.js_to_c_string(ctx, exception_val) catch: recover none
                let m = msg else z("")
                let error_class = strdup_len(m, strcspn(m, z(":")))
                if not str_equal(error_class, et):
                    ret = -1
                c_free(error_class)
                js.js_free_c_string(ctx, msg)
        else:
            ret = -1
    else:
        if is_negative:
            ret = -1
        else:
            ret = 0

    if verbose and is_test:
        var msg_val = js.js_undefined()
        var msg: const u8*? = none
        var s_line: i32 = 0
        let s = find_error(filename, &s_line, (eval_flags & js.eval_flag_strict) != 0)
        let strict_mode = strict_prefix(eval_flags)
        var line_buf: u8[1024] = ---

        if not js.js_is_undefined(exception_val):
            msg_val = js.js_to_string(ctx, exception_val) catch: recover js.js_undefined()
            msg = js.js_to_c_string(ctx, msg_val) catch: recover none
        if is_negative:  # expect error
            if ret == 0:
                if let m = msg:
                    if let known = s:
                        let now_has = str_equal(known, z("expected error")) or strstart(known, z("unexpected error type:"), none) or str_equal(known, m)
                        if now_has:  # did not have error yet
                            if not has_error_line:
                                _ = longest_match(buf, m, pos, &pos, pos_line, &error_line)
                            _ = printf(z("%s:%d: %sOK, now has error %s\n"), filename, error_line,
                                       strict_mode, m)
                            fixed_errors += 1
            else:
                if s == none:  # not yet reported
                    if let m = msg:
                        _ = snprintf(&line_buf[0], 1024, z("%s:%d: %sunexpected error type: %s\n"),
                                     filename, error_line, strict_mode, m)
                    else:
                        _ = snprintf(&line_buf[0], 1024, z("%s:%d: %sexpected error\n"),
                                     filename, error_line, strict_mode)
                    print_error(&line_buf[0])
                    new_errors += 1
        # should not have error
        else:
            if let m = msg:
                if s == none or not str_equal(cnull(s) else z(""), m):
                    if not has_error_line:
                        let p = skip_prefix(m, z("Test262 Error: "))
                        if strstr(p, z("Test case returned non-true value!")) != none:
                            _ = longest_match(buf, z("runTestCase"), pos, &pos, pos_line, &error_line)
                        else:
                            _ = longest_match(buf, p, pos, &pos, pos_line, &error_line)
                    _ = snprintf(&line_buf[0], 1024, z("%s:%d: %s%s%s\n"), filename, error_line,
                                 strict_mode, z("unexpected error: ") if error_file != none else z(""),
                                 m)
                    print_error(&line_buf[0])

                    if let known = s:
                        if not str_equal(known, m) or error_line != s_line:
                            _ = printf(z("%s:%d: %sprevious error: %s\n"), filename, s_line,
                                       strict_mode, known)
                            changed_errors += 1
                        else:
                            new_errors += 1
                    else:
                        new_errors += 1
            else:
                if let known = s:
                    _ = printf(z("%s:%d: %sOK, fixed error: %s\n"), filename, s_line, strict_mode,
                               known)
                    fixed_errors += 1
        js.js_free_value(ctx, msg_val)
        js.js_free_c_string(ctx, msg)
        c_free(s)
    js.js_free_c_string(ctx, error_name)
    js.js_free_value(ctx, exception_val)
    js.js_free_value(ctx, res_val)
    return ret

# mark: eval_file ===============================================================================

func eval_file(ctx: js.Context*, base: const u8*?, p: const u8*, eval_flags: i32) -> i32:
    var buf_len: usize = 0
    let filename = compose_path(base, p)
    defer c_free(filename)

    let buf = load_file(filename, &buf_len)
    defer c_free(buf)
    if eval_buf(ctx, buf, buf_len, filename, false, false, none, stderr(), eval_flags, false) != 0:
        warning(f"error evaluating {view(filename)}")
        return 1
    return 0