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

"use strict";

if (typeof assert === 'undefined') {
  var assert = {};
}

assert.throwsAsync = function (expectedErrorConstructor, func, message) {
  if (typeof expectedErrorConstructor !== "function") {
    return Promise.reject(new Error("invalid expected constructor"));
  }
  if (typeof func !== "function") {
    return Promise.reject(new Error("func not a function"));
  }

  return new Promise(function (resolve) {
    var pendingFailDetail;
    var onResFulfilled, onResRejected;
    var fail = function (detail) {
      if (typeof onResRejected === "function") {
        onResRejected(new Error(detail));
        return;
      }
      pendingFailDetail = detail;
      return;
    };
    var expectedName = expectedErrorConstructor.name;
    var expectation = "Expected a " + expectedName + " to be thrown asynchronously";
    var res;
    try {
      res = func();
      console.log('DBG throwsAsync: res after func call ->', res === null ? 'null' : typeof res, res);
    } catch (thrown) {
      console.log('DBG throwsAsync: func threw synchronously ->', thrown && thrown.message ? thrown.message : thrown);
      fail(expectation + " but the function threw synchronously");
    }
    if (res === null || typeof res !== "object" || typeof res.then !== "function") {
      console.log('DBG throwsAsync: res is not thenable ->', res);
      fail(expectation + " but result was not a thenable");
    }
    var resSettlementP = new Promise(function (onFulfilled, onRejected) {
      onResFulfilled = onFulfilled;
      onResRejected = onRejected;
    });
    if (pendingFailDetail !== undefined && typeof onResRejected === "function") {
      console.log('DBG throwsAsync: applying pendingFailDetail via onResRejected ->', pendingFailDetail);
      onResRejected(new Error(pendingFailDetail));
      pendingFailDetail = undefined;
    }
    try {
      console.log('DBG throwsAsync: attaching then handlers');
      res.then(function (v) {
        console.log('DBG throwsAsync: res.then fulfilled with', v);
        onResFulfilled(v);
      }, function (thrown) {
        console.log('DBG throwsAsync: res.then rejected with', thrown && thrown.message ? thrown.message : thrown);
        onResRejected(thrown);
      });
    } catch (thrown) {
      console.log('DBG throwsAsync: .then threw synchronously ->', thrown && thrown.message ? thrown.message : thrown);
      fail(expectation + " but .then threw synchronously");
    }
    resolve(resSettlementP.then(
      function () { fail(expectation + " but no exception was thrown at all"); },
      function (thrown) {
        var actualName;
        if (thrown === null || typeof thrown !== "object") {
          fail(expectation + " but thrown value was not an object");
        } else if (thrown.constructor !== expectedErrorConstructor) {
          actualName = thrown.constructor.name;
          if (expectedName === actualName) {
            fail(expectation +
              " but got a different error constructor with the same name");
          }
          fail(expectation + " but got a " + actualName);
        }
      }
    ));
  });
};

(async function () {
  try {
    console.log('RUN: before inline failCase');
    try {
      try {
        await assert.throwsAsync(TypeError, function () { return Promise.resolve('ok'); });
        console.log('RUN: inline failCase -> FAIL (should have rejected)');
      } catch (e) {
        console.log('RUN: inline failCase -> PASS (rejected with:', e && e.message ? e.message : e, ')');
      }
    } catch (e) { console.log('RUN: inline failCase outer error', e && e.message ? e.message : e); }
  } catch (e) {
    console.log('IIFE CATCH', e && e.message ? e.message : e);
  }
})();