node/test/addons-napi/test_error/test.js at 979a3aa9c3f6cd385f86744918e3b234e0d1752d · nodejs/node · 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
'use strict';

const common = require('../../common');
const test_error = require(`./build/${common.buildType}/test_error`);
const assert = require('assert');
const theError = new Error('Some error');
const theTypeError = new TypeError('Some type error');
const theSyntaxError = new SyntaxError('Some syntax error');
const theRangeError = new RangeError('Some type error');
const theReferenceError = new ReferenceError('Some reference error');
const theURIError = new URIError('Some URI error');
const theEvalError = new EvalError('Some eval error');

class MyError extends Error { }
const myError = new MyError('Some MyError');

// Test that native error object is correctly classed
assert.strictEqual(test_error.checkError(theError), true);

// Test that native type error object is correctly classed
assert.strictEqual(test_error.checkError(theTypeError), true);

// Test that native syntax error object is correctly classed
assert.strictEqual(test_error.checkError(theSyntaxError), true);

// Test that native range error object is correctly classed
assert.strictEqual(test_error.checkError(theRangeError), true);

// Test that native reference error object is correctly classed
assert.strictEqual(test_error.checkError(theReferenceError), true);

// Test that native URI error object is correctly classed
assert.strictEqual(test_error.checkError(theURIError), true);

// Test that native eval error object is correctly classed
assert.strictEqual(test_error.checkError(theEvalError), true);

// Test that class derived from native error is correctly classed
assert.strictEqual(test_error.checkError(myError), true);

// Test that non-error object is correctly classed
assert.strictEqual(test_error.checkError({}), false);

// Test that non-error primitive is correctly classed
assert.strictEqual(test_error.checkError('non-object'), false);

assert.throws(() => {
  test_error.throwExistingError();
}, /^Error: existing error$/);

assert.throws(() => {
  test_error.throwError();
}, /^Error: error$/);

assert.throws(() => {
  test_error.throwRangeError();
}, /^RangeError: range error$/);

assert.throws(() => {
  test_error.throwTypeError();
}, /^TypeError: type error$/);

common.expectsError(
  () => test_error.throwErrorCode(),
  {
    code: 'ERR_TEST_CODE',
    message: 'Error [error]'
  });

common.expectsError(
  () => test_error.throwRangeErrorCode(),
  {
    code: 'ERR_TEST_CODE',
    message: 'RangeError [range error]'
  });

common.expectsError(
  () => test_error.throwTypeErrorCode(),
  {
    code: 'ERR_TEST_CODE',
    message: 'TypeError [type error]'
  });

let error = test_error.createError();
assert.ok(error instanceof Error, 'expected error to be an instance of Error');
assert.strictEqual(error.message, 'error', 'expected message to be "error"');

error = test_error.createRangeError();
assert.ok(error instanceof RangeError,
          'expected error to be an instance of RangeError');
assert.strictEqual(error.message,
                   'range error',
                   'expected message to be "range error"');

error = test_error.createTypeError();
assert.ok(error instanceof TypeError,
          'expected error to be an instance of TypeError');
assert.strictEqual(error.message,
                   'type error',
                   'expected message to be "type error"');

error = test_error.createErrorCode();
assert.ok(error instanceof Error, 'expected error to be an instance of Error');
assert.strictEqual(error.code,
                   'ERR_TEST_CODE',
                   'expected code to be "ERR_TEST_CODE"');
assert.strictEqual(error.message,
                   'Error [error]',
                   'expected message to be "Error [error]"');
assert.strictEqual(error.name,
                   'Error [ERR_TEST_CODE]',
                   'expected name to be "Error [ERR_TEST_CODE]"');

error = test_error.createRangeErrorCode();
assert.ok(error instanceof RangeError,
          'expected error to be an instance of RangeError');
assert.strictEqual(error.message,
                   'RangeError [range error]',
                   'expected message to be "RangeError [range error]"');
assert.strictEqual(error.code,
                   'ERR_TEST_CODE',
                   'expected code to be "ERR_TEST_CODE"');
assert.strictEqual(error.name,
                   'RangeError [ERR_TEST_CODE]',
                   'expected name to be "RangeError[ERR_TEST_CODE]"');

error = test_error.createTypeErrorCode();
assert.ok(error instanceof TypeError,
          'expected error to be an instance of TypeError');
assert.strictEqual(error.message,
                   'TypeError [type error]',
                   'expected message to be "TypeError [type error]"');
assert.strictEqual(error.code,
                   'ERR_TEST_CODE',
                   'expected code to be "ERR_TEST_CODE"');
assert.strictEqual(error.name,
                   'TypeError [ERR_TEST_CODE]',
                   'expected name to be "TypeError[ERR_TEST_CODE]"');