javascript 0.3.0

A JavaScript engine implementation 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
135
136
137
138
139
140
141
142
143
144

use javascript::*;

// Initialize logger for this integration test binary so `RUST_LOG` is honored.
// Using `ctor` ensures initialization runs before tests start.
#[ctor::ctor(unsafe)]
fn __init_test_logger() {
    let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
}

#[test]
fn test_reflect_has() {
    // Test Reflect.has with existing property
    let result = evaluate_script("Reflect.has({test: 1}, 'test')", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "true");

    // Test Reflect.has with non-existing property
    let result = evaluate_script("Reflect.has({}, 'test')", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "false");
}

#[test]
fn test_reflect_get() {
    // Test Reflect.get with existing property
    let result = evaluate_script("Reflect.get({test: 42}, 'test')", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "42");

    // Test Reflect.get with non-existing property
    let result = evaluate_script("Reflect.get({}, 'test')", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "undefined");
}

#[test]
fn test_reflect_set() {
    // Test Reflect.set
    let result = evaluate_script(
        "let obj = {}; Reflect.set(obj, 'test', 123); obj.test",
        false,
        None::<&std::path::Path>,
    )
    .unwrap();
    assert_eq!(result, "123");
}

#[test]
fn test_reflect_own_keys() {
    // Test Reflect.ownKeys
    let result = evaluate_script("Reflect.ownKeys({a: 1, b: 2}).length", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "2");
}

#[test]
fn test_reflect_is_extensible() {
    // Test Reflect.isExtensible
    let result = evaluate_script("Reflect.isExtensible({})", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "true");
}

#[test]
fn test_reflect_get_prototype_of() {
    // Test Reflect.getPrototypeOf returns an object (not null for regular objects)
    let result = evaluate_script("typeof Reflect.getPrototypeOf({})", false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "\"object\"");
}
#[test]
fn test_object_define_property_defaults() {
    let script = r#"
            var o = {};
            Object.defineProperty(o, 'a', { value: 1 });
            var d = Object.getOwnPropertyDescriptor(o, 'a');
            [d.value === 1, d.writable, d.enumerable, d.configurable].toString();
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "\"true,false,false,false\"");
}

#[test]
fn test_object_define_property_accessor() {
    let script = r#"
            var o = {};
            Object.defineProperty(o, 'a', { get: function(){ return 7; }, enumerable: true });
            var d = Object.getOwnPropertyDescriptor(o, 'a');
            [typeof d.get === 'function', d.enumerable, d.configurable].toString();
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "\"true,true,false\"");
}

#[test]
fn test_reflect_get_own_property_descriptor() {
    let script = r#"
            var o = {};
            Object.defineProperty(o, 'a', { get: function(){ return 7; }, enumerable: true });
            var d = Reflect.getOwnPropertyDescriptor(o, 'a');
            [typeof d.get === 'function', d.enumerable, d.configurable].toString();
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "\"true,true,false\"");
}

#[test]
fn test_object_define_properties_invalid_getter_throws() {
    let script = r#"
            var o = {};
            try {
                Object.defineProperties(o, { a: { get: 5 } });
                'NO THROW';
            } catch (e) { 'THROW ' + (e.name || e); }
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "\"THROW TypeError\"");
}

#[test]
fn test_reflect_define_property_invalid_getter_returns_false() {
    let script = r#"
            var o = {};
            Reflect.defineProperty(o, 'a', { get: 5 });
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "false");
}

#[test]
fn test_object_define_property_mixed_descriptor_throws() {
    let script = r#"
            var o = {};
            try {
                Object.defineProperty(o, 'a', { get: function() {}, value: 1 });
                'NO THROW';
            } catch (e) { 'THROW ' + (e.name || e); }
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "\"THROW TypeError\"");
}

#[test]
fn test_reflect_define_property_mixed_descriptor_returns_false() {
    let script = r#"
            var o = {};
            Reflect.defineProperty(o, 'a', { get: function() {}, value: 1 });
        "#;
    let result = evaluate_script(script, false, None::<&std::path::Path>).unwrap();
    assert_eq!(result, "false");
}