pipa-js 0.1.1

A fast, minimal ES2023 JavaScript runtime built in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use pipa::{JSContext, JSRuntime, eval};

fn assert_js_ok(ctx: &mut JSContext, code: &str, msg: &str) {
    let r = eval(ctx, code);
    assert!(r.is_ok(), "{}: {:?}", msg, r);
}

#[test]
fn test_try_catch_basic() {
    let mut runtime = JSRuntime::new();
    let mut ctx = runtime.new_context();

    assert_js_ok(
        &mut ctx,
        r#"
            var result = 0;
            try {
                result = 1;
            } catch (e) {
                result = 2;
            }
            if (result !== 1) throw new Error('try/catch basic mismatch');
        "#,
        "try catch basic failed",
    );
}

#[test]
fn test_try_catch_throw() {
    let mut runtime = JSRuntime::new();
    let mut ctx = runtime.new_context();

    assert_js_ok(
        &mut ctx,
        r#"
            var result = 0;
            try {
                throw 42;
            } catch (e) {
                result = e;
            }
            if (result !== 42) throw new Error('try/catch throw mismatch');
        "#,
        "try catch throw failed",
    );
}

#[test]
fn test_try_catch_throw_string() {
    let mut runtime = JSRuntime::new();
    let mut ctx = runtime.new_context();

    assert_js_ok(
        &mut ctx,
        r#"
        var caught = "none";
        try {
            throw "error message";
        } catch (e) {
            caught = e;
        }
        if (caught !== 'error message') throw new Error('try/catch string mismatch');
    "#,
        "try catch throw string failed",
    );
}

#[test]
fn test_try_catch_nested() {
    let mut runtime = JSRuntime::new();
    let mut ctx = runtime.new_context();

    assert_js_ok(
        &mut ctx,
        r#"
            var result = 0;
            try {
                try {
                    throw 1;
                } catch (e1) {
                    throw e1 + 1;
                }
            } catch (e2) {
                result = e2;
            }
            if (result !== 2) throw new Error('nested try/catch mismatch');
        "#,
        "try catch nested failed",
    );
}

#[test]
fn test_try_finally() {
    let mut runtime = JSRuntime::new();
    let mut ctx = runtime.new_context();

    assert_js_ok(
        &mut ctx,
        r#"
            var result = 0;
            try {
                result = 1;
            } finally {
                result = result + 10;
            }
            if (result !== 11) throw new Error('try/finally mismatch');
        "#,
        "try finally failed",
    );
}

#[test]
fn test_try_catch_in_function() {
    let mut runtime = JSRuntime::new();
    let mut ctx = runtime.new_context();

    assert_js_ok(
        &mut ctx,
        r#"
            function mayThrow(shouldThrow) {
                try {
                    if (shouldThrow) {
                        throw 100;
                    }
                    return 0;
                } catch (e) {
                    return e;
                }
            }
            if (mayThrow(true) !== 100) throw new Error('mayThrow(true) mismatch');
        "#,
        "try catch in function failed",
    );
}