javascript 0.1.13

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

// Minimal Test262 bootstrap for host-provided helpers
// Define globalThis if missing
if (typeof globalThis === 'undefined') {
    try {
        this.globalThis = this;
    } catch (e) {
        this.globalThis = (function(){ return this; })();
    }
}

// $DONE helper for async tests; here it prints reason and throws if provided
if (typeof $DONE === 'undefined') {
    function $DONE(err) {
        if (err) {
            // If err is an Error-like object, throw it so harness sees it
            throw err;
        }
        // For completed tests, just return
    }
    console.log('block-scoped typeof $DONE:', typeof $DONE);
}

console.log('global typeof $DONE:', typeof $DONE);

// Minimal $262 host object stub
if (typeof $262 === 'undefined') {
    var $262 = {
        createRealm: function() { return {}; },
        detachArrayBuffer: function(buf) { /* no-op for now */ },
        evalScript: function(s) { return eval(s); },
        // Add other shims as needed by tests
    };
}

console.log('typeof $262:', typeof $262);

// Provide Test262Error constructor if not present (fallback)
if (typeof Test262Error === 'undefined') {
    function Test262Error(message) {
        this.message = message;
    }
    Test262Error.prototype = {};
    Test262Error.prototype.constructor = Test262Error;
    Test262Error.prototype.name = 'Test262Error';
    Test262Error.prototype.toString = function() { return (this.name || 'Test262Error') + (this.message ? ': ' + this.message : ''); };
    this.Test262Error = Test262Error;
}

// Ensure Error is defined as a function constructor if absent
if (typeof Error === 'undefined') {
    function Error(message) {
        this.message = message;
    }
    Error.prototype = {};
    Error.prototype.constructor = Error;
    this.Error = Error;
}


// --- harness files follow ---

// Provide a minimal `assert` helper if the harness doesn't supply one
if (typeof assert === 'undefined') {
    function assert(cond) {
        if (!cond) throw new Test262Error('assertion failed');
    }
    this.assert = assert;
}

console.log('typeof assert:', typeof assert);

// --- begin assert-false.js ---
// Copyright (C) 2015 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/*---
description: >
    `false` does not satisfy the assertion.
---*/

var threw = false;

try {
    assert(false);
} catch(err) {
    threw = true;
    if (err.constructor !== Test262Error) {
        throw new Error(
            'Expected a Test262Error, but a "' + err.constructor.name +
            '" was thrown.'
        );
    }
}

if (threw === false) {
  throw new Error('Expected a Test262Error, but no error was thrown.');
}

console.log('Test262Error successfully thrown.');