wasmer-napi 0.701.0

NAPI library for Wasmer WebAssembly runtime
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

'use strict';
// Flags: --expose-gc

const common = require('../../common');
const assert = require('assert');
const theError = new Error('Some error');

// The test module throws an error during Init, but in order for its exports to
// not be lost, it attaches them to the error's "bindings" property. This way,
// we can make sure that exceptions thrown during the module initialization
// phase are propagated through require() into JavaScript.
// https://github.com/nodejs/node/issues/19437
const test_exception = (function() {
  let resultingException;
  try {
    require(`./build/${common.buildType}/test_exception`);
  } catch (anException) {
    resultingException = anException;
  }
  assert.strictEqual(resultingException.message, 'Error during Init');
  return resultingException.binding;
})();

{
  const throwTheError = () => { throw theError; };

  // Test that the native side successfully captures the exception
  let returnedError = test_exception.returnException(throwTheError);
  assert.strictEqual(returnedError, theError);

  // Test that the native side passes the exception through
  assert.throws(
    () => { test_exception.allowException(throwTheError); },
    (err) => err === theError,
  );

  // Test that the exception thrown above was marked as pending
  // before it was handled on the JS side
  const exception_pending = test_exception.wasPending();
  assert.strictEqual(exception_pending, true,
                     'Exception not pending as expected,' +
                     ` .wasPending() returned ${exception_pending}`);

  // Test that the native side does not capture a non-existing exception
  returnedError = test_exception.returnException(common.mustCall());
  assert.strictEqual(returnedError, undefined,
                     'Returned error should be undefined when no exception is' +
                     ` thrown, but ${returnedError} was passed`);
}


{
  const throwTheError = class { constructor() { throw theError; } };

  // Test that the native side successfully captures the exception
  let returnedError = test_exception.constructReturnException(throwTheError);
  assert.strictEqual(returnedError, theError);

  // Test that the native side passes the exception through
  assert.throws(
    () => { test_exception.constructAllowException(throwTheError); },
    (err) => err === theError,
  );

  // Test that the exception thrown above was marked as pending
  // before it was handled on the JS side
  const exception_pending = test_exception.wasPending();
  assert.strictEqual(exception_pending, true,
                     'Exception not pending as expected,' +
                     ` .wasPending() returned ${exception_pending}`);

  // Test that the native side does not capture a non-existing exception
  returnedError = test_exception.constructReturnException(common.mustCall());
  assert.strictEqual(returnedError, undefined,
                     'Returned error should be undefined when no exception is' +
                     ` thrown, but ${returnedError} was passed`);
}

{
  // Test that no exception appears that was not thrown by us
  let caughtError;
  try {
    test_exception.allowException(common.mustCall());
  } catch (anError) {
    caughtError = anError;
  }
  assert.strictEqual(caughtError, undefined,
                     'No exception originated on the native side, but' +
                     ` ${caughtError} was passed`);

  // Test that the exception state remains clear when no exception is thrown
  const exception_pending = test_exception.wasPending();
  assert.strictEqual(exception_pending, false,
                     'Exception state did not remain clear as expected,' +
                     ` .wasPending() returned ${exception_pending}`);
}

{
  // Test that no exception appears that was not thrown by us
  let caughtError;
  try {
    test_exception.constructAllowException(common.mustCall());
  } catch (anError) {
    caughtError = anError;
  }
  assert.strictEqual(caughtError, undefined,
                     'No exception originated on the native side, but' +
                     ` ${caughtError} was passed`);

  // Test that the exception state remains clear when no exception is thrown
  const exception_pending = test_exception.wasPending();
  assert.strictEqual(exception_pending, false,
                     'Exception state did not remain clear as expected,' +
                     ` .wasPending() returned ${exception_pending}`);
}