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

"use strict";

function assert(condition, message) {
    if (!condition) {
        throw new Error(message || "Assertion failed");
    }
}

/*
// Non-strict mode test for arguments.callee

function testCallee() {
    console.log("In testCallee, arguments.callee =", arguments.callee);
    if (arguments.callee !== testCallee) {
        throw new Error("arguments.callee is not the function itself");
    }
    return "ok";
}

console.log("=== Testing arguments.callee property ===");
{
    // Normal call
    let v = testCallee();
    console.log("Normal call: pass", v);

    // Call via .call
    testCallee.call(null);
    console.log("Call via .call: pass");

    // Call via .apply
    testCallee.apply(null, []);
    console.log("Call via .apply: pass");

    // Closure call
    var f = function() {
        if (arguments.callee !== f) {
            throw new Error("arguments.callee (closure) is not the function itself");
        }
        console.log("In closure f, arguments.callee =", arguments.callee);
    };
    f();
    console.log("Closure call: pass");
    f.call({});
    console.log("Closure .call: pass");
    f.apply({}, []);
    console.log("Closure .apply: pass");
}
// */

console.log("=== Checking existence of Function.prototype.call, apply, bind: ===");
try {
    console.log("Function.prototype.call: " + Function.prototype.call);
    console.log("Function.prototype.apply: " + Function.prototype.apply);
    console.log("Function.prototype.bind: " + Function.prototype.bind);
    
    var f = function() {};
    console.log("f.call: " + f.call);
    console.log("f.apply: " + f.apply);

} catch (e) {
    console.log("Error: " + e);
}

{
    console.log("=== Testing that accessing arguments.callee throws TypeError in strict mode (inside function) ===");
    (function() {
        "use strict";
        try {
            arguments.callee;
            throw new Error("Accessing arguments.callee did not throw");
        } catch (e) {
            console.log(e);
            if (!(e instanceof TypeError)) {
                throw new Error('Expected a TypeError, but got: ' + e);
            }
        }
    })();

    console.log("=== Testing that arguments is not defined at global scope ===");
    try {
        arguments;
        throw new Error("arguments should not be defined at global scope");
    } catch (e) {
        console.log(e);
        if (!(e instanceof ReferenceError)) {
            throw new Error('Expected a ReferenceError, but got: ' + e);
        }
    }
}

{
    console.log("=== Testing that arguments.length is writable ===");

    let str = "something different";

    function f1(){
        arguments.length = str;
        return arguments;
    }

    try{
        if(f1().length !== str){
            throw new Error("#1: A property length have attribute { ReadOnly }");
        }
    }
    catch(e){
        console.log(e);
        throw new Error("#1: arguments object don't exists");
    }
}

{
    console.log("=== Test arguments.callee property descriptor ===");

    function testcase() {
        var desc = Object.getOwnPropertyDescriptor(arguments,"callee");

        assert(desc.configurable === false, 'desc.configurable');
        assert(desc.enumerable === false, 'desc.enumerable');
        assert(desc.hasOwnProperty('value') === false, 'desc.hasOwnProperty("value")');
        assert(desc.hasOwnProperty('writable') === false, 'desc.hasOwnProperty("writable")');
        assert(desc.hasOwnProperty('get') === true, 'desc.hasOwnProperty("get")');
        assert(desc.hasOwnProperty('set') === true, 'desc.hasOwnProperty("set")');
    }

    testcase();
}

true;