FazBrowse GitHub Viewer | Trending |
URL:
| Home
Tools: [Download Repo ZIP]   [Original HTTPS Page]

assert: refactor the code · nodejs/node@26785a2 · GitHub

/ node Public

Commit 26785a2

Browse files
BridgeAR
authored and
addaleax
committed
assert: refactor the code
1. Rename private functions 2. Use destructuring 3. Remove obsolete comments PR-URL: #13862 Reviewed-By: Refael Ackermann <refack@gmail.com> Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com> Backport-PR-URL: #14428 Backport-Reviewed-By: Anna Henningsen <anna@addaleax.net>
1 parent 78f0c2a commit 26785a2

2 files changed

Lines changed: 75 additions & 72 deletions

File tree

‎lib/assert.js‎

Lines changed: 48 additions & 67 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,26 +46,28 @@ 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 === 1)
5666
message = actual;
5767
if (arguments.length === 2)
5868
operator = '!=';
59-
const errors = lazyErrors();
60-
throw new errors.AssertionError({
61-
message: message,
62-
actual: actual,
63-
expected: expected,
64-
operator: operator,
65-
stackStartFunction: stackStartFunction
66-
});
69+
innerFail(actual, expected, message, operator, stackStartFunction || fail);
6770
}
68-
69-
// EXTENSION! allows for well behaved errors defined elsewhere.
7071
assert.fail = fail;
7172

7273
// The AssertionError is defined in internal/error.
@@ -77,50 +78,39 @@ assert.AssertionError = lazyErrors().AssertionError;
7778

7879

7980
// Pure assertion tests whether a value is truthy, as determined
80-
// by !!guard.
81-
// assert.ok(guard, message_opt);
82-
// This statement is equivalent to assert.equal(true, !!guard,
83-
// message_opt);. To test strictly for the value true, use
84-
// assert.strictEqual(true, guard, message_opt);.
85-
81+
// by !!value.
8682
function ok(value, message) {
87-
if (!value) fail(value, true, message, '==', assert.ok);
83+
if (!value) innerFail(value, true, message, '==', ok);
8884
}
8985
assert.ok = ok;
9086

91-
// The equality assertion tests shallow, coercive equality with
92-
// ==.
93-
// assert.equal(actual, expected, message_opt);
87+
// The equality assertion tests shallow, coercive equality with ==.
9488
/* eslint-disable no-restricted-properties */
9589
assert.equal = function equal(actual, expected, message) {
9690
// eslint-disable-next-line eqeqeq
97-
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
91+
if (actual != expected) innerFail(actual, expected, message, '==', equal);
9892
};
9993

10094
// The non-equality assertion tests for whether two objects are not
10195
// equal with !=.
102-
// assert.notEqual(actual, expected, message_opt);
103-
10496
assert.notEqual = function notEqual(actual, expected, message) {
10597
// eslint-disable-next-line eqeqeq
10698
if (actual == expected) {
107-
fail(actual, expected, message, '!=', assert.notEqual);
99+
innerFail(actual, expected, message, '!=', notEqual);
108100
}
109101
};
110102

111103
// The equivalence assertion tests a deep equality relation.
112-
// assert.deepEqual(actual, expected, message_opt);
113-
114104
assert.deepEqual = function deepEqual(actual, expected, message) {
115-
if (!_deepEqual(actual, expected, false)) {
116-
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
105+
if (!innerDeepEqual(actual, expected, false)) {
106+
innerFail(actual, expected, message, 'deepEqual', deepEqual);
117107
}
118108
};
119109
/* eslint-enable */
120110

121111
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
122-
if (!_deepEqual(actual, expected, true)) {
123-
fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
112+
if (!innerDeepEqual(actual, expected, true)) {
113+
innerFail(actual, expected, message, 'deepStrictEqual', deepStrictEqual);
124114
}
125115
};
126116

@@ -149,7 +139,7 @@ function isArguments(tag) {
149139
return tag === '[object Arguments]';
150140
}
151141

152-
function _deepEqual(actual, expected, strict, memos) {
142+
function innerDeepEqual(actual, expected, strict, memos) {
153143
// All identical values are equivalent, as determined by ===.
154144
if (actual === expected) {
155145
return true;
@@ -302,7 +292,7 @@ function setHasSimilarElement(set, val1, usedEntries, strict, memo) {
302292
if (usedEntries && usedEntries.has(val2))
303293
continue;
304294

305-
if (_deepEqual(val1, val2, strict, memo)) {
295+
if (innerDeepEqual(val1, val2, strict, memo)) {
306296
if (usedEntries)
307297
usedEntries.add(val2);
308298
return true;
@@ -359,7 +349,7 @@ function mapHasSimilarEntry(map, key1, item1, usedEntries, strict, memo) {
359349
// This check is not strictly necessary. The loop performs this check, but
360350
// doing it here improves performance of the common case when reference-equal
361351
// keys exist (which includes all primitive-valued keys).
362-
if (map.has(key1) && _deepEqual(item1, map.get(key1), strict, memo)) {
352+
if (map.has(key1) && innerDeepEqual(item1, map.get(key1), strict, memo)) {
363353
if (usedEntries)
364354
usedEntries.add(key1);
365355
return true;
@@ -376,8 +366,8 @@ function mapHasSimilarEntry(map, key1, item1, usedEntries, strict, memo) {
376366
if (usedEntries && usedEntries.has(key2))
377367
continue;
378368

379-
if (_deepEqual(key1, key2, strict, memo) &&
380-
_deepEqual(item1, item2, strict, memo)) {
369+
if (innerDeepEqual(key1, key2, strict, memo) &&
370+
innerDeepEqual(item1, item2, strict, memo)) {
381371
if (usedEntries)
382372
usedEntries.add(key2);
383373
return true;
@@ -454,44 +444,39 @@ function objEquiv(a, b, strict, actualVisitedObjects) {
454444
// Possibly expensive deep test:
455445
for (i = aKeys.length - 1; i >= 0; i--) {
456446
key = aKeys[i];
457-
if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
447+
if (!innerDeepEqual(a[key], b[key], strict, actualVisitedObjects))
458448
return false;
459449
}
460450
return true;
461451
}
462452

463453
// The non-equivalence assertion tests for any deep inequality.
464-
// assert.notDeepEqual(actual, expected, message_opt);
465-
466454
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
467-
if (_deepEqual(actual, expected, false)) {
468-
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
455+
if (innerDeepEqual(actual, expected, false)) {
456+
innerFail(actual, expected, message, 'notDeepEqual', notDeepEqual);
469457
}
470458
};
471459

472460
assert.notDeepStrictEqual = notDeepStrictEqual;
473461
function notDeepStrictEqual(actual, expected, message) {
474-
if (_deepEqual(actual, expected, true)) {
475-
fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
462+
if (innerDeepEqual(actual, expected, true)) {
463+
innerFail(actual, expected, message, 'notDeepStrictEqual',
464+
notDeepStrictEqual);
476465
}
477466
}
478467

479468
// The strict equality assertion tests strict equality, as determined by ===.
480-
// assert.strictEqual(actual, expected, message_opt);
481-
482469
assert.strictEqual = function strictEqual(actual, expected, message) {
483470
if (actual !== expected) {
484-
fail(actual, expected, message, '===', assert.strictEqual);
471+
innerFail(actual, expected, message, '===', strictEqual);
485472
}
486473
};
487474

488475
// The strict non-equality assertion tests for strict inequality, as
489476
// determined by !==.
490-
// assert.notStrictEqual(actual, expected, message_opt);
491-
492477
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
493478
if (actual === expected) {
494-
fail(actual, expected, message, '!==', assert.notStrictEqual);
479+
innerFail(actual, expected, message, '!==', notStrictEqual);
495480
}
496481
};
497482

@@ -520,7 +505,7 @@ function expectedException(actual, expected) {
520505
return expected.call({}, actual) === true;
521506
}
522507

523-
function _tryBlock(block) {
508+
function tryBlock(block) {
524509
var error;
525510
try {
526511
block();
@@ -530,7 +515,7 @@ function _tryBlock(block) {
530515
return error;
531516
}
532517

533-
function _throws(shouldThrow, block, expected, message) {
518+
function innerThrows(shouldThrow, block, expected, message) {
534519
var actual;
535520

536521
if (typeof block !== 'function') {
@@ -544,13 +529,13 @@ function _throws(shouldThrow, block, expected, message) {
544529
expected = null;
545530
}
546531

547-
actual = _tryBlock(block);
532+
actual = tryBlock(block);
548533

549534
message = (expected && expected.name ? ' (' + expected.name + ')' : '') +
550535
(message ? ': ' + message : '.');
551536

552537
if (shouldThrow && !actual) {
553-
fail(actual, expected, 'Missing expected exception' + message);
538+
innerFail(actual, expected, 'Missing expected exception' + message, fail);
554539
}
555540

556541
const userProvidedMessage = typeof message === 'string';
@@ -561,7 +546,7 @@ function _throws(shouldThrow, block, expected, message) {
561546
userProvidedMessage &&
562547
expectedException(actual, expected)) ||
563548
isUnexpectedException) {
564-
fail(actual, expected, 'Got unwanted exception' + message);
549+
innerFail(actual, expected, 'Got unwanted exception' + message, fail);
565550
}
566551

567552
if ((shouldThrow && actual && expected &&
@@ -571,16 +556,12 @@ function _throws(shouldThrow, block, expected, message) {
571556
}
572557

573558
// Expected to throw an error.
574-
// assert.throws(block, Error_opt, message_opt);
575-
576-
assert.throws = function throws(block, /*optional*/error, /*optional*/message) {
577-
_throws(true, block, error, message);
559+
assert.throws = function throws(block, error, message) {
560+
innerThrows(true, block, error, message);
578561
};
579562

580-
// EXTENSION! This is annoying to write outside this module.
581-
assert.doesNotThrow = doesNotThrow;
582-
function doesNotThrow(block, /*optional*/error, /*optional*/message) {
583-
_throws(false, block, error, message);
584-
}
563+
assert.doesNotThrow = function doesNotThrow(block, error, message) {
564+
innerThrows(false, block, error, message);
565+
};
585566

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

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

Lines changed: 27 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,53 +1,75 @@
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,
12+
operator: undefined,
13+
actual: undefined,
14+
expected: undefined,
1115
message: 'undefined undefined 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,
25+
operator: undefined,
26+
actual: undefined,
27+
expected: undefined,
2128
message: 'custom message'
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,
38+
operator: '!=',
39+
actual: 'first',
40+
expected: 'second',
3141
message: '\'first\' != \'second\''
3242
})
3343
);
3444

35-
// three args
45+
// Three args
3646
assert.throws(
3747
() => { assert.fail('ignored', 'ignored', 'another custom message'); },
3848
common.expectsError({
3949
code: 'ERR_ASSERTION',
4050
type: assert.AssertionError,
51+
operator: undefined,
52+
actual: 'ignored',
53+
expected: 'ignored',
4154
message: 'another custom message'
4255
})
4356
);
4457

45-
// no third arg (but a fourth arg)
58+
// No third arg (but a fourth arg)
4659
assert.throws(
4760
() => { assert.fail('first', 'second', undefined, 'operator'); },
4861
common.expectsError({
4962
code: 'ERR_ASSERTION',
5063
type: assert.AssertionError,
64+
operator: 'operator',
65+
actual: 'first',
66+
expected: 'second',
5167
message: '\'first\' operator \'second\''
5268
})
5369
);
70+
71+
// The stackFrameFunction should exclude the foo frame
72+
assert.throws(
73+
function foo() { assert.fail('first', 'second', 'message', '!==', foo); },
74+
(err) => !/foo/m.test(err.stack)
75+
);

0 commit comments

Comments
 (0)
Back | FazBrowse Home | New Git URL