node-api-cts/tests/js-native-api/test_exception/test.js at 7ee5921cc88b14b9f7818b8182c45819961c2dbe · bavulapati/node-api-cts · GitHub

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
145
'use strict';

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 {
    loadAddon('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(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(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(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(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}`,
  );
}