Skip to content

Commit 0455fff

Browse files
BridgeARrefack
BridgeAR
authored and
refack
committed
assert: refactor the code
1. Rename private functions 2. Use destructuring 3. Remove obsolete comments PR-URL: #13862 Reviewed-By: Refael Ackermann <[email protected]> Reviewed-By: Joyee Cheung <[email protected]>
1 parent 7a2b3e2 commit 0455fff

File tree

2 files changed

+83
-78
lines changed

2 files changed

+83
-78
lines changed

‎lib/assert.js

Lines changed: 50 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -20,12 +20,11 @@
2020

2121
'use strict';
2222

23-
// UTILITY
24-
const compare = process.binding('buffer').compare;
23+
const { compare } = process.binding('buffer');
2524
const util = require('util');
2625
const { isSet, isMap } = process.binding('util');
27-
const objectToString = require('internal/util').objectToString;
28-
const Buffer = require('buffer').Buffer;
26+
const { objectToString } = require('internal/util');
27+
const { Buffer } = require('buffer');
2928

3029
var errors;
3130
function lazyErrors() {
@@ -47,10 +46,21 @@ const assert = module.exports = ok;
4746

4847
// All of the following functions must throw an AssertionError
4948
// when a corresponding condition is not met, with a message that
50-
// may be undefined if not provided. All assertion methods provide
49+
// may be undefined if not provided. All assertion methods provide
5150
// both the actual and expected values to the assertion error for
5251
// display purposes.
5352

53+
function innerFail(actual, expected, message, operator, stackStartFunction) {
54+
const errors = lazyErrors();
55+
throw new errors.AssertionError({
56+
message,
57+
actual,
58+
expected,
59+
operator,
60+
stackStartFunction
61+
});
62+
}
63+
5464
function fail(actual, expected, message, operator, stackStartFunction) {
5565
if (arguments.length === 0) {
5666
message = 'Failed';
@@ -59,19 +69,11 @@ function fail(actual, expected, message, operator, stackStartFunction) {
5969
message = actual;
6070
actual = undefined;
6171
}
62-
if (arguments.length === 2)
72+
if (arguments.length === 2) {
6373
operator = '!=';
64-
const errors = lazyErrors();
65-
throw new errors.AssertionError({
66-
message: message,
67-
actual: actual,
68-
expected: expected,
69-
operator: operator,
70-
stackStartFunction: stackStartFunction
71-
});
74+
}
75+
innerFail(actual, expected, message, operator, stackStartFunction || fail);
7276
}
73-
74-
// EXTENSION! allows for well behaved errors defined elsewhere.
7577
assert.fail = fail;
7678

7779
// The AssertionError is defined in internal/error.
@@ -82,50 +84,39 @@ assert.AssertionError = lazyErrors().AssertionError;
8284

8385

8486
// Pure assertion tests whether a value is truthy, as determined
85-
// by !!guard.
86-
// assert.ok(guard, message_opt);
87-
// This statement is equivalent to assert.equal(true, !!guard,
88-
// message_opt);. To test strictly for the value true, use
89-
// assert.strictEqual(true, guard, message_opt);.
90-
87+
// by !!value.
9188
function ok(value, message) {
92-
if (!value) fail(value, true, message, '==', assert.ok);
89+
if (!value) innerFail(value, true, message, '==', ok);
9390
}
9491
assert.ok = ok;
9592

96-
// The equality assertion tests shallow, coercive equality with
97-
// ==.
98-
// assert.equal(actual, expected, message_opt);
93+
// The equality assertion tests shallow, coercive equality with ==.
9994
/* eslint-disable no-restricted-properties */
10095
assert.equal = function equal(actual, expected, message) {
10196
// eslint-disable-next-line eqeqeq
102-
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
97+
if (actual != expected) innerFail(actual, expected, message, '==', equal);
10398
};
10499

105100
// The non-equality assertion tests for whether two objects are not
106101
// equal with !=.
107-
// assert.notEqual(actual, expected, message_opt);
108-
109102
assert.notEqual = function notEqual(actual, expected, message) {
110103
// eslint-disable-next-line eqeqeq
111104
if (actual == expected) {
112-
fail(actual, expected, message, '!=', assert.notEqual);
105+
innerFail(actual, expected, message, '!=', notEqual);
113106
}
114107
};
115108

116109
// The equivalence assertion tests a deep equality relation.
117-
// assert.deepEqual(actual, expected, message_opt);
118-
119110
assert.deepEqual = function deepEqual(actual, expected, message) {
120-
if (!_deepEqual(actual, expected, false)) {
121-
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
111+
if (!innerDeepEqual(actual, expected, false)) {
112+
innerFail(actual, expected, message, 'deepEqual', deepEqual);
122113
}
123114
};
124115
/* eslint-enable */
125116

126117
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
127-
if (!_deepEqual(actual, expected, true)) {
128-
fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
118+
if (!innerDeepEqual(actual, expected, true)) {
119+
innerFail(actual, expected, message, 'deepStrictEqual', deepStrictEqual);
129120
}
130121
};
131122

@@ -154,7 +145,7 @@ function isArguments(tag) {
154145
return tag === '[object Arguments]';
155146
}
156147

157-
function _deepEqual(actual, expected, strict, memos) {
148+
function innerDeepEqual(actual, expected, strict, memos) {
158149
// All identical values are equivalent, as determined by ===.
159150
if (actual === expected) {
160151
return true;
@@ -307,7 +298,7 @@ function setHasSimilarElement(set, val1, usedEntries, strict, memo) {
307298
if (usedEntries && usedEntries.has(val2))
308299
continue;
309300

310-
if (_deepEqual(val1, val2, strict, memo)) {
301+
if (innerDeepEqual(val1, val2, strict, memo)) {
311302
if (usedEntries)
312303
usedEntries.add(val2);
313304
return true;
@@ -364,7 +355,7 @@ function mapHasSimilarEntry(map, key1, item1, usedEntries, strict, memo) {
364355
// This check is not strictly necessary. The loop performs this check, but
365356
// doing it here improves performance of the common case when reference-equal
366357
// keys exist (which includes all primitive-valued keys).
367-
if (map.has(key1) && _deepEqual(item1, map.get(key1), strict, memo)) {
358+
if (map.has(key1) && innerDeepEqual(item1, map.get(key1), strict, memo)) {
368359
if (usedEntries)
369360
usedEntries.add(key1);
370361
return true;
@@ -381,8 +372,8 @@ function mapHasSimilarEntry(map, key1, item1, usedEntries, strict, memo) {
381372
if (usedEntries && usedEntries.has(key2))
382373
continue;
383374

384-
if (_deepEqual(key1, key2, strict, memo) &&
385-
_deepEqual(item1, item2, strict, memo)) {
375+
if (innerDeepEqual(key1, key2, strict, memo) &&
376+
innerDeepEqual(item1, item2, strict, memo)) {
386377
if (usedEntries)
387378
usedEntries.add(key2);
388379
return true;
@@ -459,44 +450,39 @@ function objEquiv(a, b, strict, actualVisitedObjects) {
459450
// Possibly expensive deep test:
460451
for (i = aKeys.length - 1; i >= 0; i--) {
461452
key = aKeys[i];
462-
if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
453+
if (!innerDeepEqual(a[key], b[key], strict, actualVisitedObjects))
463454
return false;
464455
}
465456
return true;
466457
}
467458

468459
// The non-equivalence assertion tests for any deep inequality.
469-
// assert.notDeepEqual(actual, expected, message_opt);
470-
471460
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
472-
if (_deepEqual(actual, expected, false)) {
473-
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
461+
if (innerDeepEqual(actual, expected, false)) {
462+
innerFail(actual, expected, message, 'notDeepEqual', notDeepEqual);
474463
}
475464
};
476465

477466
assert.notDeepStrictEqual = notDeepStrictEqual;
478467
function notDeepStrictEqual(actual, expected, message) {
479-
if (_deepEqual(actual, expected, true)) {
480-
fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
468+
if (innerDeepEqual(actual, expected, true)) {
469+
innerFail(actual, expected, message, 'notDeepStrictEqual',
470+
notDeepStrictEqual);
481471
}
482472
}
483473

484474
// The strict equality assertion tests strict equality, as determined by ===.
485-
// assert.strictEqual(actual, expected, message_opt);
486-
487475
assert.strictEqual = function strictEqual(actual, expected, message) {
488476
if (actual !== expected) {
489-
fail(actual, expected, message, '===', assert.strictEqual);
477+
innerFail(actual, expected, message, '===', strictEqual);
490478
}
491479
};
492480

493481
// The strict non-equality assertion tests for strict inequality, as
494482
// determined by !==.
495-
// assert.notStrictEqual(actual, expected, message_opt);
496-
497483
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
498484
if (actual === expected) {
499-
fail(actual, expected, message, '!==', assert.notStrictEqual);
485+
innerFail(actual, expected, message, '!==', notStrictEqual);
500486
}
501487
};
502488

@@ -525,7 +511,7 @@ function expectedException(actual, expected) {
525511
return expected.call({}, actual) === true;
526512
}
527513

528-
function _tryBlock(block) {
514+
function tryBlock(block) {
529515
var error;
530516
try {
531517
block();
@@ -535,7 +521,7 @@ function _tryBlock(block) {
535521
return error;
536522
}
537523

538-
function _throws(shouldThrow, block, expected, message) {
524+
function innerThrows(shouldThrow, block, expected, message) {
539525
var actual;
540526

541527
if (typeof block !== 'function') {
@@ -549,13 +535,13 @@ function _throws(shouldThrow, block, expected, message) {
549535
expected = null;
550536
}
551537

552-
actual = _tryBlock(block);
538+
actual = tryBlock(block);
553539

554540
message = (expected && expected.name ? ' (' + expected.name + ')' : '') +
555541
(message ? ': ' + message : '.');
556542

557543
if (shouldThrow && !actual) {
558-
fail(actual, expected, 'Missing expected exception' + message);
544+
innerFail(actual, expected, 'Missing expected exception' + message, fail);
559545
}
560546

561547
const userProvidedMessage = typeof message === 'string';
@@ -566,7 +552,7 @@ function _throws(shouldThrow, block, expected, message) {
566552
userProvidedMessage &&
567553
expectedException(actual, expected)) ||
568554
isUnexpectedException) {
569-
fail(actual, expected, 'Got unwanted exception' + message);
555+
innerFail(actual, expected, 'Got unwanted exception' + message, fail);
570556
}
571557

572558
if ((shouldThrow && actual && expected &&
@@ -576,16 +562,12 @@ function _throws(shouldThrow, block, expected, message) {
576562
}
577563

578564
// Expected to throw an error.
579-
// assert.throws(block, Error_opt, message_opt);
580-
581-
assert.throws = function throws(block, /*optional*/error, /*optional*/message) {
582-
_throws(true, block, error, message);
565+
assert.throws = function throws(block, error, message) {
566+
innerThrows(true, block, error, message);
583567
};
584568

585-
// EXTENSION! This is annoying to write outside this module.
586-
assert.doesNotThrow = doesNotThrow;
587-
function doesNotThrow(block, /*optional*/error, /*optional*/message) {
588-
_throws(false, block, error, message);
589-
}
569+
assert.doesNotThrow = function doesNotThrow(block, error, message) {
570+
innerThrows(false, block, error, message);
571+
};
590572

591573
assert.ifError = function ifError(err) { if (err) throw err; };

‎test/parallel/test-assert-fail.js

Lines changed: 33 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,53 +1,76 @@
11
'use strict';
2+
23
const common = require('../common');
34
const assert = require('assert');
45

5-
// no args
6+
// No args
67
assert.throws(
78
() => { assert.fail(); },
89
common.expectsError({
910
code: 'ERR_ASSERTION',
1011
type: assert.AssertionError,
11-
message: 'Failed'
12+
message: 'Failed',
13+
operator: undefined,
14+
actual: undefined,
15+
expected: undefined
1216
})
1317
);
1418

15-
// one arg = message
19+
// One arg = message
1620
assert.throws(
1721
() => { assert.fail('custom message'); },
1822
common.expectsError({
1923
code: 'ERR_ASSERTION',
2024
type: assert.AssertionError,
21-
message: 'custom message'
25+
message: 'custom message',
26+
operator: undefined,
27+
actual: undefined,
28+
expected: undefined
2229
})
2330
);
2431

25-
// two args only, operator defaults to '!='
32+
// Two args only, operator defaults to '!='
2633
assert.throws(
2734
() => { assert.fail('first', 'second'); },
2835
common.expectsError({
2936
code: 'ERR_ASSERTION',
3037
type: assert.AssertionError,
31-
message: '\'first\' != \'second\''
38+
message: '\'first\' != \'second\'',
39+
operator: '!=',
40+
actual: 'first',
41+
expected: 'second'
42+
3243
})
3344
);
3445

35-
// three args
46+
// Three args
3647
assert.throws(
3748
() => { assert.fail('ignored', 'ignored', 'another custom message'); },
3849
common.expectsError({
3950
code: 'ERR_ASSERTION',
4051
type: assert.AssertionError,
41-
message: 'another custom message'
52+
message: 'another custom message',
53+
operator: undefined,
54+
actual: 'ignored',
55+
expected: 'ignored'
4256
})
4357
);
4458

45-
// no third arg (but a fourth arg)
59+
// No third arg (but a fourth arg)
4660
assert.throws(
4761
() => { assert.fail('first', 'second', undefined, 'operator'); },
4862
common.expectsError({
4963
code: 'ERR_ASSERTION',
5064
type: assert.AssertionError,
51-
message: '\'first\' operator \'second\''
65+
message: '\'first\' operator \'second\'',
66+
operator: 'operator',
67+
actual: 'first',
68+
expected: 'second'
5269
})
5370
);
71+
72+
// The stackFrameFunction should exclude the foo frame
73+
assert.throws(
74+
function foo() { assert.fail('first', 'second', 'message', '!==', foo); },
75+
(err) => !/foo/m.test(err.stack)
76+
);

0 commit comments

Comments
 (0)