diff --git a/.eslintrc b/.eslintrc index b48f2277c83212..542be9ceaa749d 100644 --- a/.eslintrc +++ b/.eslintrc @@ -85,6 +85,7 @@ rules: prefer-const: 2 # Custom rules in tools/eslint-rules + align-function-arguments: 2 align-multiline-assignment: 2 assert-fail-single-argument: 2 new-with-error: [2, "Error", "RangeError", "TypeError", "SyntaxError", "ReferenceError"] diff --git a/benchmark/tls/tls-connect.js b/benchmark/tls/tls-connect.js index a265989e04db24..342c7cb7e37d45 100644 --- a/benchmark/tls/tls-connect.js +++ b/benchmark/tls/tls-connect.js @@ -42,16 +42,18 @@ function onConnection(conn) { } function makeConnection() { - var conn = tls.connect({ port: common.PORT, - rejectUnauthorized: false }, function() { - clientConn++; - conn.on('error', function(er) { - console.error('client error', er); - throw er; - }); - conn.end(); - if (running) makeConnection(); - }); + var conn = tls.connect( + { port: common.PORT, rejectUnauthorized: false }, + function() { + clientConn++; + conn.on('error', function(er) { + console.error('client error', er); + throw er; + }); + conn.end(); + if (running) makeConnection(); + } + ); } function done() { diff --git a/lib/crypto.js b/lib/crypto.js index 534ff03917354b..f295111d23e83b 100644 --- a/lib/crypto.js +++ b/lib/crypto.js @@ -662,13 +662,12 @@ function filterDuplicates(names) { } // Legacy API -exports.__defineGetter__('createCredentials', - internalUtil.deprecate(function() { - return require('tls').createSecureContext; - }, 'crypto.createCredentials is deprecated. ' + - 'Use tls.createSecureContext instead.')); - -exports.__defineGetter__('Credentials', internalUtil.deprecate(function() { - return require('tls').SecureContext; -}, 'crypto.Credentials is deprecated. ' + - 'Use tls.createSecureContext instead.')); +function defineLegacyGetter(legacyName, tlsName) { + function wrapped() { + return require('tls')[tlsName]; + } + const msg = `crypto.${legacyName} is deprecated. Use tls.${tlsName} instead.`; + exports.__defineGetter__(legacyName, internalUtil.deprecate(wrapped, msg)); +} +defineLegacyGetter('createCredentials', 'createSecureContext'); +defineLegacyGetter('Credentials', 'SecureContext'); diff --git a/lib/readline.js b/lib/readline.js index 3948d990539d97..2095a1a57a1ea5 100644 --- a/lib/readline.js +++ b/lib/readline.js @@ -1055,17 +1055,23 @@ function codePointAt(str, index) { } return code; } -exports.codePointAt = internalUtil.deprecate(codePointAt, - 'readline.codePointAt is deprecated. ' + - 'Use String.prototype.codePointAt instead.'); +exports.codePointAt = internalUtil.deprecate( + codePointAt, + 'readline.codePointAt is deprecated. ' + + 'Use String.prototype.codePointAt instead.' +); -exports.getStringWidth = internalUtil.deprecate(getStringWidth, - 'getStringWidth is deprecated and will be removed.'); +exports.getStringWidth = internalUtil.deprecate( + getStringWidth, + 'getStringWidth is deprecated and will be removed.' +); -exports.isFullWidthCodePoint = internalUtil.deprecate(isFullWidthCodePoint, - 'isFullWidthCodePoint is deprecated and will be removed.'); +exports.isFullWidthCodePoint = internalUtil.deprecate( + isFullWidthCodePoint, + 'isFullWidthCodePoint is deprecated and will be removed.' +); exports.stripVTControlCharacters = internalUtil.deprecate( diff --git a/lib/util.js b/lib/util.js index 63d6d0f3c865af..cb06ea233e445a 100644 --- a/lib/util.js +++ b/lib/util.js @@ -541,7 +541,7 @@ function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { for (var i = 0, l = value.length; i < l; ++i) { if (hasOwnProperty(value, String(i))) { output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); + String(i), true)); } else { output.push(''); } @@ -549,7 +549,7 @@ function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { keys.forEach(function(key) { if (typeof key === 'symbol' || !key.match(/^\d+$/)) { output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); + key, true)); } }); return output; diff --git a/test/common.js b/test/common.js index 48f8ea719c5c63..c67e438af7603e 100644 --- a/test/common.js +++ b/test/common.js @@ -398,7 +398,7 @@ exports.mustCall = function(fn, expected) { var etcServicesFileName = path.join('/etc', 'services'); if (exports.isWindows) { etcServicesFileName = path.join(process.env.SystemRoot, 'System32', 'drivers', - 'etc', 'services'); + 'etc', 'services'); } /* @@ -428,7 +428,7 @@ exports.getServiceName = function getServiceName(port, protocol) { try { var servicesContent = fs.readFileSync(etcServicesFileName, - { encoding: 'utf8'}); + { encoding: 'utf8'}); var regexp = `^(\\w+)\\s+\\s${port}/${protocol}\\s`; var re = new RegExp(regexp, 'm'); diff --git a/test/internet/test-dgram-multicast-multi-process.js b/test/internet/test-dgram-multicast-multi-process.js index 54df63ba7697e1..b2bed3a4bda0d0 100644 --- a/test/internet/test-dgram-multicast-multi-process.js +++ b/test/internet/test-dgram-multicast-multi-process.js @@ -91,7 +91,7 @@ function launchChildProcess(index) { worker.pid, count); assert.strictEqual(count, messages.length, - 'A worker received an invalid multicast message'); + 'A worker received an invalid multicast message'); }); clearTimeout(timer); diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js index cf5b7d4c9933f6..64d9d61d39691b 100644 --- a/test/parallel/test-assert.js +++ b/test/parallel/test-assert.js @@ -29,7 +29,7 @@ assert.doesNotThrow(makeBlock(a.ok, true), assert.doesNotThrow(makeBlock(a.ok, 'test'), 'ok(\'test\')'); assert.throws(makeBlock(a.equal, true, false), - a.AssertionError, 'equal(true, false)'); + a.AssertionError, 'equal(true, false)'); assert.doesNotThrow(makeBlock(a.equal, null, null), 'equal(null, null)'); @@ -61,9 +61,10 @@ assert.doesNotThrow(makeBlock(a.notStrictEqual, 2, '2'), // deepEquals joy! // 7.2 -assert.doesNotThrow(makeBlock(a.deepEqual, new Date(2000, 3, 14), - new Date(2000, 3, 14)), - 'deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))'); +assert.doesNotThrow( + makeBlock(a.deepEqual, new Date(2000, 3, 14), new Date(2000, 3, 14)), + 'deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))' +); assert.throws(makeBlock(a.deepEqual, new Date(), new Date(2000, 3, 14)), a.AssertionError, @@ -163,10 +164,10 @@ assert.doesNotThrow(makeBlock(a.deepEqual, new Boolean(true), {}), a.AssertionError); //deepStrictEqual -assert.doesNotThrow(makeBlock(a.deepStrictEqual, new Date(2000, 3, 14), - new Date(2000, 3, 14)), - 'deepStrictEqual(new Date(2000, 3, 14),\ - new Date(2000, 3, 14))'); +assert.doesNotThrow( + makeBlock(a.deepStrictEqual, new Date(2000, 3, 14), new Date(2000, 3, 14)), + 'deepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))' +); assert.throws(makeBlock(a.deepStrictEqual, new Date(), new Date(2000, 3, 14)), a.AssertionError, @@ -331,10 +332,13 @@ assert.throws(function() {assert.ifError(new Error('test error'));}); assert.doesNotThrow(function() {assert.ifError(null);}); assert.doesNotThrow(function() {assert.ifError();}); -assert.throws(() => { - assert.doesNotThrow(makeBlock(thrower, Error), 'user message'); -}, /Got unwanted exception. user message/, - 'a.doesNotThrow ignores user message'); +assert.throws( + () => { + assert.doesNotThrow(makeBlock(thrower, Error), 'user message'); + }, + /Got unwanted exception. user message/, + 'a.doesNotThrow ignores user message' +); // make sure that validating using constructor really works threw = false; @@ -376,7 +380,7 @@ try { } catch (e) { threw = true; assert(e instanceof AnotherErrorType, - `expected AnotherErrorType, received ${e}`); + `expected AnotherErrorType, received ${e}`); } assert.ok(threw); @@ -410,7 +414,7 @@ function testAssertionMessage(actual, expected) { assert.equal(actual, ''); } catch (e) { assert.equal(e.toString(), - ['AssertionError:', expected, '==', '\'\''].join(' ')); + ['AssertionError:', expected, '==', '\'\''].join(' ')); assert.ok(e.generatedMessage, 'Message not marked as generated'); } } @@ -436,7 +440,7 @@ testAssertionMessage({}, '{}'); testAssertionMessage(circular, '{ y: 1, x: [Circular] }'); testAssertionMessage({a: undefined, b: null}, '{ a: undefined, b: null }'); testAssertionMessage({a: NaN, b: Infinity, c: -Infinity}, - '{ a: NaN, b: Infinity, c: -Infinity }'); + '{ a: NaN, b: Infinity, c: -Infinity }'); // #2893 try { @@ -462,7 +466,7 @@ try { } catch (e) { assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no'); assert.equal(e.generatedMessage, false, - 'Message incorrectly marked as generated'); + 'Message incorrectly marked as generated'); } // Verify that throws() and doesNotThrow() throw on non-function block diff --git a/test/parallel/test-buffer-alloc.js b/test/parallel/test-buffer-alloc.js index 85b6abbcdabeaf..5075875d3887af 100644 --- a/test/parallel/test-buffer-alloc.js +++ b/test/parallel/test-buffer-alloc.js @@ -490,8 +490,8 @@ for (let i = 0; i < Buffer.byteLength(utf8String); i++) { { const f = Buffer.from('привет', encoding); console.error('f.length: %d (should be 12)', f.length); - assert.deepStrictEqual(f, - Buffer.from([63, 4, 64, 4, 56, 4, 50, 4, 53, 4, 66, 4])); + const expected = Buffer.from([63, 4, 64, 4, 56, 4, 50, 4, 53, 4, 66, 4]); + assert.deepStrictEqual(f, expected); assert.equal(f.toString(encoding), 'привет'); } @@ -645,18 +645,30 @@ assert.equal(Buffer.from('KioqKioqKioqKioqKioqKioqKio', 'base64').toString(), '********************'); // handle padding graciously, multiple-of-4 or not -assert.equal(Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', - 'base64').length, 32); -assert.equal(Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', - 'base64').length, 32); -assert.equal(Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', - 'base64').length, 32); -assert.equal(Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', - 'base64').length, 31); -assert.equal(Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', - 'base64').length, 31); -assert.equal(Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', - 'base64').length, 31); +assert.equal( + Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length, + 32 +); +assert.equal( + Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', 'base64').length, + 32 +); +assert.equal( + Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', 'base64').length, + 32 +); +assert.equal( + Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64').length, + 31 +); +assert.equal( + Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64').length, + 31 +); +assert.equal( + Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64').length, + 31 +); // This string encodes single '.' character in UTF-16 var dot = Buffer.from('//4uAA==', 'base64'); @@ -1131,16 +1143,16 @@ assert.throws(function() { var buf = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF]); assert.equal(buf['readUInt' + bits + 'BE'](0), - (0xFFFFFFFF >>> (32 - bits))); + 0xFFFFFFFF >>> (32 - bits)); assert.equal(buf['readUInt' + bits + 'LE'](0), - (0xFFFFFFFF >>> (32 - bits))); + 0xFFFFFFFF >>> (32 - bits)); assert.equal(buf['readInt' + bits + 'BE'](0), - (0xFFFFFFFF >> (32 - bits))); + 0xFFFFFFFF >> (32 - bits)); assert.equal(buf['readInt' + bits + 'LE'](0), - (0xFFFFFFFF >> (32 - bits))); + 0xFFFFFFFF >> (32 - bits)); }); // test for common read(U)IntLE/BE diff --git a/test/parallel/test-buffer-bytelength.js b/test/parallel/test-buffer-bytelength.js index 01bf12e544908e..c91286318fa2aa 100644 --- a/test/parallel/test-buffer-bytelength.js +++ b/test/parallel/test-buffer-bytelength.js @@ -71,8 +71,10 @@ assert.equal(Buffer.byteLength('ßœ∑≈', 'unkn0wn enc0ding'), 10); assert.equal(Buffer.byteLength('aGVsbG8gd29ybGQ=', 'base64'), 11); assert.equal(Buffer.byteLength('bm9kZS5qcyByb2NrcyE=', 'base64'), 14); assert.equal(Buffer.byteLength('aGkk', 'base64'), 3); -assert.equal(Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==', - 'base64'), 25); +assert.equal( + Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==', 'base64'), + 25 +); // special padding assert.equal(Buffer.byteLength('aaa=', 'base64'), 2); assert.equal(Buffer.byteLength('aaaa==', 'base64'), 3); diff --git a/test/parallel/test-buffer-includes.js b/test/parallel/test-buffer-includes.js index 2d46e1b6e6f6d3..f2c9b16579e61c 100644 --- a/test/parallel/test-buffer-includes.js +++ b/test/parallel/test-buffer-includes.js @@ -130,11 +130,11 @@ assert(!mixedByteStringUcs2.includes('\u0396', 0, 'ucs2')); assert( 6, mixedByteStringUcs2.includes(Buffer.from('bc', 'ucs2'), 0, 'ucs2')); assert( - 10, mixedByteStringUcs2.includes(Buffer.from('\u03a3', 'ucs2'), - 0, 'ucs2')); + 10, + mixedByteStringUcs2.includes(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2')); assert( - -1, mixedByteStringUcs2.includes(Buffer.from('\u0396', 'ucs2'), - 0, 'ucs2')); + -1, + mixedByteStringUcs2.includes(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2')); twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2'); diff --git a/test/parallel/test-buffer-indexof.js b/test/parallel/test-buffer-indexof.js index 0a20d2ce9af021..40e9e421e6b9bd 100644 --- a/test/parallel/test-buffer-indexof.js +++ b/test/parallel/test-buffer-indexof.js @@ -81,43 +81,54 @@ assert.equal(Buffer.from('ff').indexOf(Buffer.from('f'), 1, 'ucs2'), -1); // test hex encoding assert.equal( Buffer.from(b.toString('hex'), 'hex') - .indexOf('64', 0, 'hex'), 3); + .indexOf('64', 0, 'hex'), + 3); assert.equal( Buffer.from(b.toString('hex'), 'hex') - .indexOf(Buffer.from('64', 'hex'), 0, 'hex'), 3); + .indexOf(Buffer.from('64', 'hex'), 0, 'hex'), + 3); // test base64 encoding assert.equal( Buffer.from(b.toString('base64'), 'base64') - .indexOf('ZA==', 0, 'base64'), 3); + .indexOf('ZA==', 0, 'base64'), + 3); assert.equal( Buffer.from(b.toString('base64'), 'base64') - .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'), 3); + .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'), + 3); // test ascii encoding assert.equal( Buffer.from(b.toString('ascii'), 'ascii') - .indexOf('d', 0, 'ascii'), 3); + .indexOf('d', 0, 'ascii'), + 3); assert.equal( Buffer.from(b.toString('ascii'), 'ascii') - .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'), 3); + .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'), + 3); // test binary encoding assert.equal( Buffer.from(b.toString('binary'), 'binary') - .indexOf('d', 0, 'binary'), 3); + .indexOf('d', 0, 'binary'), + 3); assert.equal( Buffer.from(b.toString('binary'), 'binary') - .indexOf(Buffer.from('d', 'binary'), 0, 'binary'), 3); + .indexOf(Buffer.from('d', 'binary'), 0, 'binary'), + 3); assert.equal( Buffer.from('aa\u00e8aa', 'binary') - .indexOf('\u00e8', 'binary'), 2); + .indexOf('\u00e8', 'binary'), + 2); assert.equal( Buffer.from('\u00e8', 'binary') - .indexOf('\u00e8', 'binary'), 0); + .indexOf('\u00e8', 'binary'), + 0); assert.equal( Buffer.from('\u00e8', 'binary') - .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'), 0); + .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'), + 0); // test optional offset with passed encoding diff --git a/test/parallel/test-buffer-inheritance.js b/test/parallel/test-buffer-inheritance.js index be845c66ccf508..913e1806fc8ec4 100644 --- a/test/parallel/test-buffer-inheritance.js +++ b/test/parallel/test-buffer-inheritance.js @@ -26,7 +26,7 @@ vals.forEach(function(t) { assert.equal(t.constructor, T); assert.equal(Object.getPrototypeOf(t), T.prototype); assert.equal(Object.getPrototypeOf(Object.getPrototypeOf(t)), - Buffer.prototype); + Buffer.prototype); t.fill(5); let cntr = 0; diff --git a/test/parallel/test-buffer-swap.js b/test/parallel/test-buffer-swap.js index c2a6901955ca04..8f0c5e2cf700dc 100644 --- a/test/parallel/test-buffer-swap.js +++ b/test/parallel/test-buffer-swap.js @@ -16,17 +16,19 @@ for (var i = 1; i < 33; i++) buf_array.push(i); const buf2 = Buffer.from(buf_array); buf2.swap32(); -assert.deepStrictEqual(buf2, - Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07, 0x06, 0x05, 0x0c, - 0x0b, 0x0a, 0x09, 0x10, 0x0f, 0x0e, 0x0d, 0x14, 0x13, - 0x12, 0x11, 0x18, 0x17, 0x16, 0x15, 0x1c, 0x1b, 0x1a, - 0x19, 0x20, 0x1f, 0x1e, 0x1d])); +assert.deepStrictEqual( + buf2, + Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07, 0x06, 0x05, 0x0c, + 0x0b, 0x0a, 0x09, 0x10, 0x0f, 0x0e, 0x0d, 0x14, 0x13, + 0x12, 0x11, 0x18, 0x17, 0x16, 0x15, 0x1c, 0x1b, 0x1a, + 0x19, 0x20, 0x1f, 0x1e, 0x1d])); buf2.swap16(); -assert.deepStrictEqual(buf2, - Buffer.from([0x03, 0x04, 0x01, 0x02, 0x07, 0x08, 0x05, 0x06, 0x0b, - 0x0c, 0x09, 0x0a, 0x0f, 0x10, 0x0d, 0x0e, 0x13, 0x14, - 0x11, 0x12, 0x17, 0x18, 0x15, 0x16, 0x1b, 0x1c, 0x19, - 0x1a, 0x1f, 0x20, 0x1d, 0x1e])); +assert.deepStrictEqual( + buf2, + Buffer.from([0x03, 0x04, 0x01, 0x02, 0x07, 0x08, 0x05, 0x06, 0x0b, + 0x0c, 0x09, 0x0a, 0x0f, 0x10, 0x0d, 0x0e, 0x13, 0x14, + 0x11, 0x12, 0x17, 0x18, 0x15, 0x16, 0x1b, 0x1c, 0x19, + 0x1a, 0x1f, 0x20, 0x1d, 0x1e])); const buf3 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]); buf3.slice(1, 5).swap32(); diff --git a/test/parallel/test-buffer.js b/test/parallel/test-buffer.js index 791754c7149441..60363f71b8fdda 100644 --- a/test/parallel/test-buffer.js +++ b/test/parallel/test-buffer.js @@ -643,18 +643,30 @@ assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKio', 'base64').toString(), '********************'); // handle padding graciously, multiple-of-4 or not -assert.equal(new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', - 'base64').length, 32); -assert.equal(new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', - 'base64').length, 32); -assert.equal(new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', - 'base64').length, 32); -assert.equal(new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', - 'base64').length, 31); -assert.equal(new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', - 'base64').length, 31); -assert.equal(new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', - 'base64').length, 31); +assert.equal( + new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length, + 32 +); +assert.equal( + new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', 'base64').length, + 32 +); +assert.equal( + new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', 'base64').length, + 32 +); +assert.equal( + new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64').length, + 31 +); +assert.equal( + new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64').length, + 31 +); +assert.equal( + new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64').length, + 31 +); // This string encodes single '.' character in UTF-16 var dot = new Buffer('//4uAA==', 'base64'); @@ -1134,16 +1146,16 @@ assert.throws(function() { var buf = new Buffer([0xFF, 0xFF, 0xFF, 0xFF]); assert.equal(buf['readUInt' + bits + 'BE'](0), - (0xFFFFFFFF >>> (32 - bits))); + 0xFFFFFFFF >>> (32 - bits)); assert.equal(buf['readUInt' + bits + 'LE'](0), - (0xFFFFFFFF >>> (32 - bits))); + 0xFFFFFFFF >>> (32 - bits)); assert.equal(buf['readInt' + bits + 'BE'](0), - (0xFFFFFFFF >> (32 - bits))); + 0xFFFFFFFF >> (32 - bits)); assert.equal(buf['readInt' + bits + 'LE'](0), - (0xFFFFFFFF >> (32 - bits))); + 0xFFFFFFFF >> (32 - bits)); }); // test for common read(U)IntLE/BE diff --git a/test/parallel/test-cli-eval.js b/test/parallel/test-cli-eval.js index a58c023eb6d835..ae9708aae8ca74 100644 --- a/test/parallel/test-cli-eval.js +++ b/test/parallel/test-cli-eval.js @@ -18,53 +18,55 @@ var filename = __filename.replace(/\\/g, '/'); // assert that nothing is written to stdout child.exec(nodejs + ' --eval 42', - function(err, stdout, stderr) { - assert.equal(stdout, ''); - assert.equal(stderr, ''); - }); + function(err, stdout, stderr) { + assert.equal(stdout, ''); + assert.equal(stderr, ''); + }); // assert that "42\n" is written to stderr child.exec(nodejs + ' --eval "console.error(42)"', - function(err, stdout, stderr) { - assert.equal(stdout, ''); - assert.equal(stderr, '42\n'); - }); + function(err, stdout, stderr) { + assert.equal(stdout, ''); + assert.equal(stderr, '42\n'); + }); // assert that the expected output is written to stdout ['--print', '-p -e', '-pe', '-p'].forEach(function(s) { var cmd = nodejs + ' ' + s + ' '; child.exec(cmd + '42', - function(err, stdout, stderr) { - assert.equal(stdout, '42\n'); - assert.equal(stderr, ''); - }); + function(err, stdout, stderr) { + assert.equal(stdout, '42\n'); + assert.equal(stderr, ''); + }); child.exec(cmd + "'[]'", - function(err, stdout, stderr) { - assert.equal(stdout, '[]\n'); - assert.equal(stderr, ''); - }); + function(err, stdout, stderr) { + assert.equal(stdout, '[]\n'); + assert.equal(stderr, ''); + }); }); // assert that module loading works child.exec(nodejs + ' --eval "require(\'' + filename + '\')"', - function(status, stdout, stderr) { - assert.equal(status.code, 42); - }); + function(status, stdout, stderr) { + assert.equal(status.code, 42); + }); // Check that builtin modules are pre-defined. -child.exec(nodejs + ' --print "os.platform()"', - function(status, stdout, stderr) { - assert.strictEqual(stderr, ''); - assert.strictEqual(stdout.trim(), require('os').platform()); - }); +child.exec( + nodejs + ' --print "os.platform()"', + function(status, stdout, stderr) { + assert.strictEqual(stderr, ''); + assert.strictEqual(stdout.trim(), require('os').platform()); + } +); // module path resolve bug, regression test child.exec(nodejs + ' --eval "require(\'./test/parallel/test-cli-eval.js\')"', - function(status, stdout, stderr) { - assert.equal(status.code, 42); - }); + function(status, stdout, stderr) { + assert.equal(status.code, 42); + }); // empty program should do nothing child.exec(nodejs + ' -e ""', function(status, stdout, stderr) { @@ -74,20 +76,21 @@ child.exec(nodejs + ' -e ""', function(status, stdout, stderr) { // "\\-42" should be interpreted as an escaped expression, not a switch child.exec(nodejs + ' -p "\\-42"', - function(err, stdout, stderr) { - assert.equal(stdout, '-42\n'); - assert.equal(stderr, ''); - }); + function(err, stdout, stderr) { + assert.equal(stdout, '-42\n'); + assert.equal(stderr, ''); + }); child.exec(nodejs + ' --use-strict -p process.execArgv', - function(status, stdout, stderr) { - assert.equal(stdout, "[ '--use-strict', '-p', 'process.execArgv' ]\n"); - }); + function(status, stdout, stderr) { + assert.equal(stdout, + "[ '--use-strict', '-p', 'process.execArgv' ]\n"); + }); // Regression test for https://github.com/nodejs/node/issues/3574 const emptyFile = path.join(common.fixturesDir, 'empty.js'); child.exec(nodejs + ` -e 'require("child_process").fork("${emptyFile}")'`, - function(status, stdout, stderr) { - assert.equal(stdout, ''); - assert.equal(stderr, ''); - }); + function(status, stdout, stderr) { + assert.equal(stdout, ''); + assert.equal(stderr, ''); + }); diff --git a/test/parallel/test-cluster-basic.js b/test/parallel/test-cluster-basic.js index ab9ce13e45c02c..076756ab3d6468 100644 --- a/test/parallel/test-cluster-basic.js +++ b/test/parallel/test-cluster-basic.js @@ -4,7 +4,7 @@ var assert = require('assert'); var cluster = require('cluster'); assert.equal('NODE_UNIQUE_ID' in process.env, false, - 'NODE_UNIQUE_ID should be removed on startup'); + 'NODE_UNIQUE_ID should be removed on startup'); function forEach(obj, fn) { Object.keys(obj).forEach(function(name, index) { @@ -93,7 +93,7 @@ else if (cluster.isMaster) { worker = cluster.fork(); assert.equal(worker.id, 1); assert.ok(worker instanceof cluster.Worker, - 'the worker is not a instance of the Worker constructor'); + 'the worker is not a instance of the Worker constructor'); //Check event forEach(checks.worker.events, function(bool, name, index) { diff --git a/test/parallel/test-crypto-authenticated.js b/test/parallel/test-crypto-authenticated.js index b08fb7e0198640..11fbe948716146 100644 --- a/test/parallel/test-crypto-authenticated.js +++ b/test/parallel/test-crypto-authenticated.js @@ -62,7 +62,8 @@ for (var i in TEST_CASES) { (function() { var encrypt = crypto.createCipheriv(test.algo, - Buffer.from(test.key, 'hex'), Buffer.from(test.iv, 'hex')); + Buffer.from(test.key, 'hex'), + Buffer.from(test.iv, 'hex')); if (test.aad) encrypt.setAAD(Buffer.from(test.aad, 'hex')); var hex = encrypt.update(test.plain, 'ascii', 'hex'); @@ -77,7 +78,8 @@ for (var i in TEST_CASES) { (function() { var decrypt = crypto.createDecipheriv(test.algo, - Buffer.from(test.key, 'hex'), Buffer.from(test.iv, 'hex')); + Buffer.from(test.key, 'hex'), + Buffer.from(test.iv, 'hex')); decrypt.setAuthTag(Buffer.from(test.tag, 'hex')); if (test.aad) decrypt.setAAD(Buffer.from(test.aad, 'hex')); @@ -144,18 +146,21 @@ for (var i in TEST_CASES) { (function() { // non-authenticating mode: var encrypt = crypto.createCipheriv('aes-128-cbc', - 'ipxp9a6i1Mb4USb4', '6fKjEjR3Vl30EUYC'); + 'ipxp9a6i1Mb4USb4', '6fKjEjR3Vl30EUYC'); encrypt.update('blah', 'ascii'); encrypt.final(); assert.throws(function() { encrypt.getAuthTag(); }, / state/); - assert.throws(function() { - encrypt.setAAD(Buffer.from('123', 'ascii')); }, / state/); + assert.throws( + function() { + encrypt.setAAD(Buffer.from('123', 'ascii')); + }, / state/); })(); (function() { // trying to get tag before inputting all data: var encrypt = crypto.createCipheriv(test.algo, - Buffer.from(test.key, 'hex'), Buffer.from(test.iv, 'hex')); + Buffer.from(test.key, 'hex'), + Buffer.from(test.iv, 'hex')); encrypt.update('blah', 'ascii'); assert.throws(function() { encrypt.getAuthTag(); }, / state/); })(); @@ -163,15 +168,19 @@ for (var i in TEST_CASES) { (function() { // trying to set tag on encryption object: var encrypt = crypto.createCipheriv(test.algo, - Buffer.from(test.key, 'hex'), Buffer.from(test.iv, 'hex')); - assert.throws(function() { - encrypt.setAuthTag(Buffer.from(test.tag, 'hex')); }, / state/); + Buffer.from(test.key, 'hex'), + Buffer.from(test.iv, 'hex')); + assert.throws( + function() { + encrypt.setAuthTag(Buffer.from(test.tag, 'hex')); + }, / state/); })(); (function() { // trying to read tag from decryption object: var decrypt = crypto.createDecipheriv(test.algo, - Buffer.from(test.key, 'hex'), Buffer.from(test.iv, 'hex')); + Buffer.from(test.key, 'hex'), + Buffer.from(test.iv, 'hex')); assert.throws(function() { decrypt.getAuthTag(); }, / state/); })(); } diff --git a/test/parallel/test-crypto-binary-default.js b/test/parallel/test-crypto-binary-default.js index ee14ddf966230e..0f546397bf5bd1 100644 --- a/test/parallel/test-crypto-binary-default.js +++ b/test/parallel/test-crypto-binary-default.js @@ -23,10 +23,14 @@ var path = require('path'); var certPem = fs.readFileSync(common.fixturesDir + '/test_cert.pem', 'ascii'); var certPfx = fs.readFileSync(common.fixturesDir + '/test_cert.pfx'); var keyPem = fs.readFileSync(common.fixturesDir + '/test_key.pem', 'ascii'); -var rsaPubPem = fs.readFileSync(common.fixturesDir + '/test_rsa_pubkey.pem', - 'ascii'); -var rsaKeyPem = fs.readFileSync(common.fixturesDir + '/test_rsa_privkey.pem', - 'ascii'); +var rsaPubPem = fs.readFileSync( + common.fixturesDir + '/test_rsa_pubkey.pem', + 'ascii' +); +var rsaKeyPem = fs.readFileSync( + common.fixturesDir + '/test_rsa_privkey.pem', + 'ascii' +); // PFX tests assert.doesNotThrow(function() { @@ -74,7 +78,8 @@ var rfc4231 = [ { key: Buffer.from('4a656665', 'hex'), // 'Jefe' data: Buffer.from('7768617420646f2079612077616e7420666f72206e6f74686' + - '96e673f', 'hex'), // 'what do ya want for nothing?' + '96e673f', + 'hex'), // 'what do ya want for nothing?' hmac: { sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44', sha256: @@ -110,10 +115,10 @@ var rfc4231 = [ }, { key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819', - 'hex'), - data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + - 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd', 'hex'), + data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + + 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd', + 'hex'), hmac: { sha224: '6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a', sha256: @@ -234,7 +239,7 @@ var rfc2202_md5 = [ }, { key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819', - 'hex'), + 'hex'), data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' + 'cdcdcdcdcd', @@ -288,7 +293,7 @@ var rfc2202_sha1 = [ }, { key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819', - 'hex'), + 'hex'), data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' + 'cdcdcdcdcd', @@ -347,8 +352,11 @@ var a4 = crypto.createHash('sha1').update('Test123').digest('buffer'); if (!common.hasFipsCrypto) { var a0 = crypto.createHash('md5').update('Test123').digest('binary'); - assert.equal(a0, 'h\u00ea\u00cb\u0097\u00d8o\fF!\u00fa+\u000e\u0017\u00ca' + - '\u00bd\u008c', 'Test MD5 as binary'); + assert.equal( + a0, + 'h\u00ea\u00cb\u0097\u00d8o\fF!\u00fa+\u000e\u0017\u00ca\u00bd\u008c', + 'Test MD5 as binary' + ); } assert.equal(a1, '8308651804facb7b9af8ffc53a33a22d6a1c8ac2', 'Test SHA1'); diff --git a/test/parallel/test-crypto-ecb.js b/test/parallel/test-crypto-ecb.js index d47ec8a8091f38..047742ecaa3b46 100644 --- a/test/parallel/test-crypto-ecb.js +++ b/test/parallel/test-crypto-ecb.js @@ -26,7 +26,7 @@ crypto.DEFAULT_ENCODING = 'buffer'; (function() { var decrypt = crypto.createDecipheriv('BF-ECB', 'SomeRandomBlahz0c5GZVnR', - ''); + ''); var msg = decrypt.update('6D385F424AAB0CFBF0BB86E07FFB7D71', 'hex', 'ascii'); msg += decrypt.final('ascii'); assert.equal(msg, 'Hello World!'); diff --git a/test/parallel/test-crypto-hash.js b/test/parallel/test-crypto-hash.js index cedb233d00e332..c7e19ec4e98e84 100644 --- a/test/parallel/test-crypto-hash.js +++ b/test/parallel/test-crypto-hash.js @@ -39,8 +39,11 @@ a8 = a8.read(); if (!common.hasFipsCrypto) { var a0 = crypto.createHash('md5').update('Test123').digest('binary'); - assert.equal(a0, 'h\u00ea\u00cb\u0097\u00d8o\fF!\u00fa+\u000e\u0017\u00ca' + - '\u00bd\u008c', 'Test MD5 as binary'); + assert.equal( + a0, + 'h\u00ea\u00cb\u0097\u00d8o\fF!\u00fa+\u000e\u0017\u00ca\u00bd\u008c', + 'Test MD5 as binary' + ); } assert.equal(a1, '8308651804facb7b9af8ffc53a33a22d6a1c8ac2', 'Test SHA1'); assert.equal(a2, '2bX1jws4GYKTlxhloUB09Z66PoJZW+y+hq5R8dnx9l4=', diff --git a/test/parallel/test-crypto-hmac.js b/test/parallel/test-crypto-hmac.js index 91ffc23e34bfa6..7ebe16046fd5ff 100644 --- a/test/parallel/test-crypto-hmac.js +++ b/test/parallel/test-crypto-hmac.js @@ -96,7 +96,8 @@ var rfc4231 = [ { key: Buffer.from('4a656665', 'hex'), // 'Jefe' data: Buffer.from('7768617420646f2079612077616e7420666f72206e6f74686' + - '96e673f', 'hex'), // 'what do ya want for nothing?' + '96e673f', + 'hex'), // 'what do ya want for nothing?' hmac: { sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44', sha256: @@ -132,7 +133,7 @@ var rfc4231 = [ }, { key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819', - 'hex'), + 'hex'), data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd', 'hex'), @@ -261,7 +262,7 @@ var rfc2202_md5 = [ }, { key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819', - 'hex'), + 'hex'), data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' + 'cdcdcdcdcd', @@ -315,7 +316,7 @@ var rfc2202_sha1 = [ }, { key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819', - 'hex'), + 'hex'), data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' + 'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' + 'cdcdcdcdcd', diff --git a/test/parallel/test-crypto-padding-aes256.js b/test/parallel/test-crypto-padding-aes256.js index f5aa63474ed86e..dccafd5ff79429 100644 --- a/test/parallel/test-crypto-padding-aes256.js +++ b/test/parallel/test-crypto-padding-aes256.js @@ -12,8 +12,7 @@ crypto.DEFAULT_ENCODING = 'buffer'; function aes256(decipherFinal) { var iv = Buffer.from('00000000000000000000000000000000', 'hex'); - var key = Buffer.from('0123456789abcdef0123456789abcdef' + - '0123456789abcdef0123456789abcdef', 'hex'); + var key = Buffer.from('0123456789abcdef0123456789abcdef'.repeat(2), 'hex'); function encrypt(val, pad) { var c = crypto.createCipheriv('aes256', key, iv); diff --git a/test/parallel/test-crypto-rsa-dsa.js b/test/parallel/test-crypto-rsa-dsa.js index e6f2fe6eb25131..3c40eb35986c1f 100644 --- a/test/parallel/test-crypto-rsa-dsa.js +++ b/test/parallel/test-crypto-rsa-dsa.js @@ -14,15 +14,15 @@ var crypto = require('crypto'); var certPem = fs.readFileSync(common.fixturesDir + '/test_cert.pem', 'ascii'); var keyPem = fs.readFileSync(common.fixturesDir + '/test_key.pem', 'ascii'); var rsaPubPem = fs.readFileSync(common.fixturesDir + '/test_rsa_pubkey.pem', - 'ascii'); + 'ascii'); var rsaKeyPem = fs.readFileSync(common.fixturesDir + '/test_rsa_privkey.pem', - 'ascii'); + 'ascii'); var rsaKeyPemEncrypted = fs.readFileSync( common.fixturesDir + '/test_rsa_privkey_encrypted.pem', 'ascii'); var dsaPubPem = fs.readFileSync(common.fixturesDir + '/test_dsa_pubkey.pem', - 'ascii'); + 'ascii'); var dsaKeyPem = fs.readFileSync(common.fixturesDir + '/test_dsa_privkey.pem', - 'ascii'); + 'ascii'); var dsaKeyPemEncrypted = fs.readFileSync( common.fixturesDir + '/test_dsa_privkey_encrypted.pem', 'ascii'); diff --git a/test/parallel/test-crypto.js b/test/parallel/test-crypto.js index f0e9242c0ebde8..2a38c2d20b0206 100644 --- a/test/parallel/test-crypto.js +++ b/test/parallel/test-crypto.js @@ -133,8 +133,10 @@ assert.throws(function() { // $ openssl pkcs8 -topk8 -inform PEM -outform PEM -in mykey.pem \ // -out private_key.pem -nocrypt; // Then open private_key.pem and change its header and footer. - var sha1_privateKey = fs.readFileSync(common.fixturesDir + - '/test_bad_rsa_privkey.pem', 'ascii'); + var sha1_privateKey = fs.readFileSync( + common.fixturesDir + '/test_bad_rsa_privkey.pem', + 'ascii' + ); // this would inject errors onto OpenSSL's error stack crypto.createSign('sha1').sign(sha1_privateKey); }, /asn1 encoding routines:ASN1_CHECK_TLEN:wrong tag/); diff --git a/test/parallel/test-debug-agent.js b/test/parallel/test-debug-agent.js index 0bb5d7f9be25df..6729c47a586ddf 100644 --- a/test/parallel/test-debug-agent.js +++ b/test/parallel/test-debug-agent.js @@ -3,4 +3,4 @@ require('../common'); const assert = require('assert'); assert.throws(() => { require('_debug_agent').start(); }, - assert.AssertionError); + assert.AssertionError); diff --git a/test/parallel/test-debugger-util-regression.js b/test/parallel/test-debugger-util-regression.js index a2461a480c9466..fb6ddb8cd7c31e 100644 --- a/test/parallel/test-debugger-util-regression.js +++ b/test/parallel/test-debugger-util-regression.js @@ -65,6 +65,6 @@ proc.stdin.on('error', (err) => { process.on('exit', (code) => { assert.equal(code, 0, 'the program should exit cleanly'); assert.equal(stdout.includes('{ a: \'b\' }'), true, - 'the debugger should print the result of util.inspect'); + 'the debugger should print the result of util.inspect'); assert.equal(stderr, '', 'stderr should be empty'); }); diff --git a/test/parallel/test-dns.js b/test/parallel/test-dns.js index cd5914e026d6a9..c0d2d152f9d4f9 100644 --- a/test/parallel/test-dns.js +++ b/test/parallel/test-dns.js @@ -101,7 +101,7 @@ assert.doesNotThrow(function() { */ assert.throws(function() { dns.lookup('www.google.com', { hints: (dns.V4MAPPED | dns.ADDRCONFIG) + 1 }, - noop); + noop); }); assert.throws(function() { diff --git a/test/parallel/test-domain-exit-dispose-again.js b/test/parallel/test-domain-exit-dispose-again.js index 7360e79412296d..0928addd9ace55 100644 --- a/test/parallel/test-domain-exit-dispose-again.js +++ b/test/parallel/test-domain-exit-dispose-again.js @@ -38,7 +38,7 @@ setTimeout(function firstTimer() { d.dispose(); console.error(err); console.error('in domain error handler', - process.domain, process.domain === d); + process.domain, process.domain === d); }); d.run(function() { diff --git a/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js b/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js index f4095232f41429..0eb94a6d829315 100644 --- a/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js +++ b/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js @@ -8,12 +8,12 @@ const d = domain.create(); process.on('uncaughtException', common.mustCall(function onUncaught() { assert.equal(process.domain, null, - 'domains stack should be empty in uncaughtException handler'); + 'domains stack should be empty in uncaughtException handler'); })); process.on('beforeExit', common.mustCall(function onBeforeExit() { assert.equal(process.domain, null, - 'domains stack should be empty in beforeExit handler'); + 'domains stack should be empty in beforeExit handler'); })); d.run(function() { diff --git a/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js b/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js index 499988107dae27..3f968dee166987 100644 --- a/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js +++ b/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js @@ -49,33 +49,43 @@ if (process.argv[2] === 'child') { } function runTestWithoutAbortOnUncaughtException() { - child_process.exec(createTestCmdLine(), - function onTestDone(err, stdout, stderr) { - // When _not_ passing --abort-on-uncaught-exception, the process' - // uncaughtException handler _must_ be called, and thus the error - // message must include only the message of the error thrown from the - // process' uncaughtException handler. - assert(stderr.includes(uncaughtExceptionHandlerErrMsg), - 'stderr output must include proper uncaughtException handler\'s ' + - 'error\'s message'); - assert(!stderr.includes(domainErrMsg), 'stderr output must not ' + - 'include domain\'s error\'s message'); + child_process.exec( + createTestCmdLine(), + function onTestDone(err, stdout, stderr) { + // When _not_ passing --abort-on-uncaught-exception, the process' + // uncaughtException handler _must_ be called, and thus the error + // message must include only the message of the error thrown from the + // process' uncaughtException handler. + assert( + stderr.includes(uncaughtExceptionHandlerErrMsg), + 'stderr must include uncaughtException handler\'s error message' + ); + assert( + !stderr.includes(domainErrMsg), + 'stderr must not include domain\'s error message' + ); - assert.notEqual(err.code, 0, - 'child process should have exited with a non-zero exit code, ' + - 'but did not'); - }); + assert.notEqual( + err.code, 0, + 'child process should have exited with a non-zero exit code' + ); + } + ); } function runTestWithAbortOnUncaughtException() { child_process.exec(createTestCmdLine({ withAbortOnUncaughtException: true }), function onTestDone(err, stdout, stderr) { - assert.notEqual(err.code, RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE, - 'child process should not have run its uncaughtException event ' + - 'handler'); - assert(common.nodeProcessAborted(err.code, err.signal), - 'process should have aborted, but did not'); + assert.notEqual( + err.code, + RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE, + 'child process should not have run its uncaughtException event handler' + ); + assert( + common.nodeProcessAborted(err.code, err.signal), + 'process should have aborted, but did not' + ); }); } diff --git a/test/parallel/test-domain-timers.js b/test/parallel/test-domain-timers.js index a97b300da02d31..58989e812bba50 100644 --- a/test/parallel/test-domain-timers.js +++ b/test/parallel/test-domain-timers.js @@ -34,7 +34,7 @@ timeout = setTimeout(function() {}, 10 * 1000); process.on('exit', function() { assert.equal(timeout_err.message, 'Timeout UNREFd', - 'Domain should catch timer error'); + 'Domain should catch timer error'); assert.equal(immediate_err.message, 'Immediate Error', - 'Domain should catch immediate error'); + 'Domain should catch immediate error'); }); diff --git a/test/parallel/test-domain-top-level-error-handler-clears-stack.js b/test/parallel/test-domain-top-level-error-handler-clears-stack.js index a5fec1f65ef029..f2095f09b7836c 100644 --- a/test/parallel/test-domain-top-level-error-handler-clears-stack.js +++ b/test/parallel/test-domain-top-level-error-handler-clears-stack.js @@ -23,7 +23,7 @@ d.on('error', common.mustCall(function() { // call to process._fatalException, and so on recursively and // indefinitely. console.error('domains stack length should be 1, but instead is:', - domain._stack.length); + domain._stack.length); process.exit(1); } }); diff --git a/test/parallel/test-domain-with-abort-on-uncaught-exception.js b/test/parallel/test-domain-with-abort-on-uncaught-exception.js index 3165663479fe65..a1f14e454670f4 100644 --- a/test/parallel/test-domain-with-abort-on-uncaught-exception.js +++ b/test/parallel/test-domain-with-abort-on-uncaught-exception.js @@ -121,7 +121,7 @@ if (process.argv[2] === 'child') { if (!options.useTryCatch && options.throwInDomainErrHandler) { if (cmdLineOption === '--abort_on_uncaught_exception') { assert(common.nodeProcessAborted(exitCode, signal), - 'process should have aborted, but did not'); + 'process should have aborted, but did not'); } else { // By default, uncaught exceptions make node exit with an exit // code of 7. diff --git a/test/parallel/test-file-write-stream2.js b/test/parallel/test-file-write-stream2.js index e95760bc2d9a4e..e11f7e7815f1d0 100644 --- a/test/parallel/test-file-write-stream2.js +++ b/test/parallel/test-file-write-stream2.js @@ -24,8 +24,8 @@ process.on('exit', function() { console.log(' expected: %j', cb_expected); console.log(' occurred: %j', cb_occurred); assert.strictEqual(cb_occurred, cb_expected, - 'events missing or out of order: "' + - cb_occurred + '" !== "' + cb_expected + '"'); + 'events missing or out of order: "' + + cb_occurred + '" !== "' + cb_expected + '"'); } else { console.log('ok'); } diff --git a/test/parallel/test-file-write-stream3.js b/test/parallel/test-file-write-stream3.js index 2407680d001cf5..1243460f9f314f 100644 --- a/test/parallel/test-file-write-stream3.js +++ b/test/parallel/test-file-write-stream3.js @@ -24,8 +24,8 @@ process.on('exit', function() { console.log(' expected: %j', cb_expected); console.log(' occurred: %j', cb_occurred); assert.strictEqual(cb_occurred, cb_expected, - 'events missing or out of order: "' + - cb_occurred + '" !== "' + cb_expected + '"'); + 'events missing or out of order: "' + + cb_occurred + '" !== "' + cb_expected + '"'); } }); diff --git a/test/parallel/test-fs-realpath.js b/test/parallel/test-fs-realpath.js index b7eb5145089000..5a976f0b50b653 100644 --- a/test/parallel/test-fs-realpath.js +++ b/test/parallel/test-fs-realpath.js @@ -141,7 +141,7 @@ function test_deep_relative_file_symlink(callback) { var expected = path.join(common.fixturesDir, 'cycles', 'root.js'); var linkData1 = path.relative(path.join(targetsAbsDir, 'nested-index', 'one'), - expected); + expected); var linkPath1 = path.join(targetsAbsDir, 'nested-index', 'one', 'symlink1.js'); try {fs.unlinkSync(linkPath1);} catch (e) {} @@ -243,7 +243,7 @@ function test_relative_input_cwd(callback) { // we need to calculate the relative path to the tmp dir from cwd var entrydir = process.cwd(); var entry = path.relative(entrydir, - path.join(common.tmpDir + '/cycles/realpath-3a')); + path.join(common.tmpDir + '/cycles/realpath-3a')); var expected = common.tmpDir + '/cycles/root.js'; [ [entry, '../cycles/realpath-3b'], @@ -342,14 +342,14 @@ function test_escape_cwd(cb) { console.log('test_escape_cwd'); asynctest(fs.realpath, ['..'], cb, function(er, uponeActual) { assertEqualPath(upone, uponeActual, - 'realpath("..") expected: ' + path.resolve(upone) + - ' actual:' + uponeActual); + 'realpath("..") expected: ' + path.resolve(upone) + + ' actual:' + uponeActual); }); } var uponeActual = fs.realpathSync('..'); assertEqualPath(upone, uponeActual, - 'realpathSync("..") expected: ' + path.resolve(upone) + - ' actual:' + uponeActual); + 'realpathSync("..") expected: ' + path.resolve(upone) + + ' actual:' + uponeActual); // going up with .. multiple times diff --git a/test/parallel/test-fs-write.js b/test/parallel/test-fs-write.js index 5ddd83e026c095..c33244b7d65021 100644 --- a/test/parallel/test-fs-write.js +++ b/test/parallel/test-fs-write.js @@ -32,23 +32,24 @@ fs.open(fn, 'w', 0o644, function(err, fd) { fs.open(fn2, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644, - function(err, fd) { - if (err) throw err; - console.log('open done'); - fs.write(fd, '', 0, 'utf8', function(err, written) { - assert.equal(0, written); - }); - fs.write(fd, expected, 0, 'utf8', function(err, written) { - console.log('write done'); - if (err) throw err; - assert.equal(Buffer.byteLength(expected), written); - fs.closeSync(fd); - found2 = fs.readFileSync(fn2, 'utf8'); - console.log('expected: "%s"', expected); - console.log('found: "%s"', found2); - fs.unlinkSync(fn2); - }); - }); + function(err, fd) { + if (err) throw err; + console.log('open done'); + fs.write(fd, '', 0, 'utf8', function(err, written) { + assert.equal(0, written); + }); + fs.write(fd, expected, 0, 'utf8', function(err, written) { + console.log('write done'); + if (err) throw err; + assert.equal(Buffer.byteLength(expected), written); + fs.closeSync(fd); + found2 = fs.readFileSync(fn2, 'utf8'); + console.log('expected: "%s"', expected); + console.log('found: "%s"', found2); + fs.unlinkSync(fn2); + }); + } +); process.on('exit', function() { diff --git a/test/parallel/test-http-agent-error-on-idle.js b/test/parallel/test-http-agent-error-on-idle.js index e3388ee0dcbd96..f609efc8d59b6d 100644 --- a/test/parallel/test-http-agent-error-on-idle.js +++ b/test/parallel/test-http-agent-error-on-idle.js @@ -47,7 +47,7 @@ server.listen(common.PORT, function() { function done() { assert.equal(Object.keys(agent.freeSockets).length, 0, - 'expect the freeSockets pool to be empty'); + 'expect the freeSockets pool to be empty'); agent.destroy(); server.close(); diff --git a/test/parallel/test-http-agent-keepalive.js b/test/parallel/test-http-agent-keepalive.js index 0eb87899c5b0ec..2b939db68d7cbe 100644 --- a/test/parallel/test-http-agent-keepalive.js +++ b/test/parallel/test-http-agent-keepalive.js @@ -74,7 +74,7 @@ function remoteClose() { setTimeout(function() { assert.equal(agent.sockets[name], undefined); assert.equal(agent.freeSockets[name], undefined, - 'freeSockets is not empty'); + 'freeSockets is not empty'); remoteError(); }, common.platformTimeout(200)); }); diff --git a/test/parallel/test-http-agent-maxsockets.js b/test/parallel/test-http-agent-maxsockets.js index e11aa2addad746..11f8d28a7389e2 100644 --- a/test/parallel/test-http-agent-maxsockets.js +++ b/test/parallel/test-http-agent-maxsockets.js @@ -30,7 +30,7 @@ function done() { } var freepool = agent.freeSockets[Object.keys(agent.freeSockets)[0]]; assert.equal(freepool.length, 2, - 'expect keep 2 free sockets, but got ' + freepool.length); + 'expect keep 2 free sockets, but got ' + freepool.length); agent.destroy(); server.close(); } diff --git a/test/parallel/test-http-destroyed-socket-write2.js b/test/parallel/test-http-destroyed-socket-write2.js index ac6ab92c17c072..b082dad49f6a58 100644 --- a/test/parallel/test-http-destroyed-socket-write2.js +++ b/test/parallel/test-http-destroyed-socket-write2.js @@ -36,9 +36,11 @@ server.listen(common.PORT, function() { case 'EPIPE': break; default: - assert.strictEqual(er.code, + assert.strictEqual( + er.code, 'ECONNRESET', - 'Writing to a torn down client should RESET or ABORT'); + 'Writing to a torn down client should RESET or ABORT' + ); break; } diff --git a/test/parallel/test-http-parser-bad-ref.js b/test/parallel/test-http-parser-bad-ref.js index b7f132a3ea36fb..2caf28b38bc90a 100644 --- a/test/parallel/test-http-parser-bad-ref.js +++ b/test/parallel/test-http-parser-bad-ref.js @@ -76,7 +76,8 @@ demoBug('POST /1', '/22 HTTP/1.1\r\n' + 'pong'); demoBug('POST /1/22 HTTP/1.1\r\n' + - 'Content-Type: tex', 't/plain\r\n' + + 'Content-Type: tex', + 't/plain\r\n' + 'Content-Length: 4\r\n\r\n' + 'pong'); diff --git a/test/parallel/test-http-url.parse-post.js b/test/parallel/test-http-url.parse-post.js index b6a0fdeb255235..7611b0856320a6 100644 --- a/test/parallel/test-http-url.parse-post.js +++ b/test/parallel/test-http-url.parse-post.js @@ -14,7 +14,7 @@ function check(request) { assert.strictEqual(request.url, '/asdf?qwer=zxcv'); //the host header should use the url.parse.hostname assert.strictEqual(request.headers.host, - testURL.hostname + ':' + testURL.port); + testURL.hostname + ':' + testURL.port); } var server = http.createServer(function(request, response) { diff --git a/test/parallel/test-module-relative-lookup.js b/test/parallel/test-module-relative-lookup.js index 002ae1a8fb7776..bb1fdbbdae4ecf 100644 --- a/test/parallel/test-module-relative-lookup.js +++ b/test/parallel/test-module-relative-lookup.js @@ -6,5 +6,8 @@ const _module = require('module'); // avoid collision with global.module const lookupResults = _module._resolveLookupPaths('./lodash'); const paths = lookupResults[1]; -assert.strictEqual(paths[0], '.', - 'Current directory is prioritized before node_modules for local modules'); +assert.strictEqual( + paths[0], + '.', + 'Current directory is prioritized before node_modules for local modules' +); diff --git a/test/parallel/test-net-pipe-connect-errors.js b/test/parallel/test-net-pipe-connect-errors.js index 8e341015d96b3f..05216731e8eb2a 100644 --- a/test/parallel/test-net-pipe-connect-errors.js +++ b/test/parallel/test-net-pipe-connect-errors.js @@ -45,7 +45,7 @@ var notSocketClient = net.createConnection(emptyTxt, function() { notSocketClient.on('error', function(err) { assert(err.code === 'ENOTSOCK' || err.code === 'ECONNREFUSED', - `received ${err.code} instead of ENOTSOCK or ECONNREFUSED`); + `received ${err.code} instead of ENOTSOCK or ECONNREFUSED`); notSocketErrorFired = true; }); diff --git a/test/parallel/test-promises-unhandled-rejections.js b/test/parallel/test-promises-unhandled-rejections.js index 3c7a40380505de..cb989a33cfb71b 100644 --- a/test/parallel/test-promises-unhandled-rejections.js +++ b/test/parallel/test-promises-unhandled-rejections.js @@ -106,137 +106,159 @@ function onUnhandledFail(done) { }, 10); } -asyncTest('synchronously rejected promise should trigger' + - ' unhandledRejection', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - }); - Promise.reject(e); -}); - -asyncTest('synchronously rejected promise should trigger' + - ' unhandledRejection', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - }); - new Promise(function(_, reject) { - reject(e); - }); -}); +asyncTest( + 'synchronously rejected promise should trigger unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + }); + Promise.reject(e); + } +); -asyncTest('Promise rejected after setImmediate should trigger' + - ' unhandledRejection', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - }); - new Promise(function(_, reject) { - setImmediate(function() { +asyncTest( + 'synchronously rejected promise should trigger unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + }); + new Promise(function(_, reject) { reject(e); }); - }); -}); + } +); -asyncTest('Promise rejected after setTimeout(,1) should trigger' + - ' unhandled rejection', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - }); - new Promise(function(_, reject) { - setTimeout(function() { - reject(e); - }, 1); - }); -}); +asyncTest( + 'Promise rejected after setImmediate should trigger unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + }); + new Promise(function(_, reject) { + setImmediate(function() { + reject(e); + }); + }); + } +); -asyncTest('Catching a promise rejection after setImmediate is not' + - ' soon enough to stop unhandledRejection', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - }); - var _reject; - var promise = new Promise(function(_, reject) { - _reject = reject; - }); - _reject(e); - setImmediate(function() { - promise.then(common.fail, function() {}); - }); -}); - -asyncTest('When re-throwing new errors in a promise catch, only the' + - ' re-thrown error should hit unhandledRejection', function(done) { - var e = new Error(); - var e2 = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e2, reason); - assert.strictEqual(promise2, promise); - }); - var promise2 = Promise.reject(e).then(common.fail, function(reason) { - assert.strictEqual(e, reason); - throw e2; - }); -}); - -asyncTest('Test params of unhandledRejection for a synchronously-rejected' + - 'promise', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - assert.strictEqual(promise, promise); - }); - Promise.reject(e); -}); - -asyncTest('When re-throwing new errors in a promise catch, only the ' + - 're-thrown error should hit unhandledRejection: original promise' + - ' rejected async with setTimeout(,1)', function(done) { - var e = new Error(); - var e2 = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e2, reason); - assert.strictEqual(promise2, promise); - }); - var promise2 = new Promise(function(_, reject) { - setTimeout(function() { - reject(e); - }, 1); - }).then(common.fail, function(reason) { - assert.strictEqual(e, reason); - throw e2; - }); -}); - -asyncTest('When re-throwing new errors in a promise catch, only the re-thrown' + - ' error should hit unhandledRejection: promise catch attached a' + - ' process.nextTick after rejection', function(done) { - var e = new Error(); - var e2 = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e2, reason); - assert.strictEqual(promise2, promise); - }); - var promise = new Promise(function(_, reject) { - setTimeout(function() { - reject(e); - process.nextTick(function() { - promise2 = promise.then(common.fail, function(reason) { - assert.strictEqual(e, reason); - throw e2; +asyncTest( + 'Promise rejected after setTimeout(,1) should trigger unhandled rejection', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + }); + new Promise(function(_, reject) { + setTimeout(function() { + reject(e); + }, 1); + }); + } +); + +asyncTest( + 'Catching a promise rejection after setImmediate is not soon enough to ' + + 'stop unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + }); + var _reject; + var promise = new Promise(function(_, reject) { + _reject = reject; + }); + _reject(e); + setImmediate(function() { + promise.then(common.fail, function() {}); + }); + } +); + +asyncTest( + 'When re-throwing new errors in a promise catch, only the re-thrown error ' + + 'should hit unhandledRejection', + function(done) { + var e = new Error(); + var e2 = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e2, reason); + assert.strictEqual(promise2, promise); + }); + var promise2 = Promise.reject(e).then(common.fail, function(reason) { + assert.strictEqual(e, reason); + throw e2; + }); + } +); + +asyncTest( + 'Test params of unhandledRejection for a synchronously-rejected promise', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + assert.strictEqual(promise, promise); + }); + Promise.reject(e); + } +); + +asyncTest( + 'When re-throwing new errors in a promise catch, only the re-thrown error ' + + 'should hit unhandledRejection: original promise rejected async with ' + + 'setTimeout(,1)', + function(done) { + var e = new Error(); + var e2 = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e2, reason); + assert.strictEqual(promise2, promise); + }); + var promise2 = new Promise(function(_, reject) { + setTimeout(function() { + reject(e); + }, 1); + }).then(common.fail, function(reason) { + assert.strictEqual(e, reason); + throw e2; + }); + } +); + +asyncTest( + 'When re-throwing new errors in a promise catch, only the re-thrown error ' + + 'should hit unhandledRejection: promise catch attached a ' + + 'process.nextTick after rejection', + function(done) { + var e = new Error(); + var e2 = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e2, reason); + assert.strictEqual(promise2, promise); + }); + var promise = new Promise(function(_, reject) { + setTimeout(function() { + reject(e); + process.nextTick(function() { + promise2 = promise.then(common.fail, function(reason) { + assert.strictEqual(e, reason); + throw e2; + }); }); - }); - }, 1); - }); - var promise2; -}); + }, 1); + }); + var promise2; + } +); asyncTest( 'unhandledRejection should not be triggered if a promise catch is' + - ' attached synchronously upon the promise\'s creation', + ' attached synchronously upon the promise\'s creation', function(done) { var e = new Error(); onUnhandledFail(done); @@ -246,7 +268,7 @@ asyncTest( asyncTest( 'unhandledRejection should not be triggered if a promise catch is' + - ' attached synchronously upon the promise\'s creation', + ' attached synchronously upon the promise\'s creation', function(done) { var e = new Error(); onUnhandledFail(done); @@ -256,117 +278,141 @@ asyncTest( } ); -asyncTest('Attaching a promise catch in a process.nextTick is soon enough to' + - ' prevent unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); - var promise = Promise.reject(e); - process.nextTick(function() { - promise.then(common.fail, function() {}); - }); -}); - -asyncTest('Attaching a promise catch in a process.nextTick is soon enough to' + - ' prevent unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); - var promise = new Promise(function(_, reject) { - reject(e); - }); - process.nextTick(function() { - promise.then(common.fail, function() {}); - }); -}); - -asyncTest('While inside setImmediate, catching a rejected promise derived ' + - 'from returning a rejected promise in a fulfillment handler ' + - 'prevents unhandledRejection', function(done) { - onUnhandledFail(done); - - setImmediate(function() { - // reproduces on first tick and inside of setImmediate - Promise - .resolve('resolve') - .then(function() { - return Promise.reject('reject'); - }).catch(function(e) {}); - }); -}); +asyncTest( + 'Attaching a promise catch in a process.nextTick is soon enough to' + + ' prevent unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + var promise = Promise.reject(e); + process.nextTick(function() { + promise.then(common.fail, function() {}); + }); + } +); + +asyncTest( + 'Attaching a promise catch in a process.nextTick is soon enough to' + + ' prevent unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + var promise = new Promise(function(_, reject) { + reject(e); + }); + process.nextTick(function() { + promise.then(common.fail, function() {}); + }); + } +); + +asyncTest( + 'While inside setImmediate, catching a rejected promise derived ' + + 'from returning a rejected promise in a fulfillment handler ' + + 'prevents unhandledRejection', + function(done) { + onUnhandledFail(done); + + setImmediate(function() { + // reproduces on first tick and inside of setImmediate + Promise + .resolve('resolve') + .then(function() { + return Promise.reject('reject'); + }).catch(function(e) {}); + }); + } +); // State adapation tests -asyncTest('catching a promise which is asynchronously rejected (via' + - 'resolution to an asynchronously-rejected promise) prevents' + - ' unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); - Promise.resolve().then(function() { - return new Promise(function(_, reject) { - setTimeout(function() { - reject(e); - }, 1); +asyncTest( + 'catching a promise which is asynchronously rejected (via ' + + 'resolution to an asynchronously-rejected promise) prevents ' + + 'unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + Promise.resolve().then(function() { + return new Promise(function(_, reject) { + setTimeout(function() { + reject(e); + }, 1); + }); + }).then(common.fail, function(reason) { + assert.strictEqual(e, reason); }); - }).then(common.fail, function(reason) { - assert.strictEqual(e, reason); - }); -}); - -asyncTest('Catching a rejected promise derived from throwing in a' + - ' fulfillment handler prevents unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); - Promise.resolve().then(function() { - throw e; - }).then(common.fail, function(reason) { - assert.strictEqual(e, reason); - }); -}); - -asyncTest('Catching a rejected promise derived from returning a' + - ' synchronously-rejected promise in a fulfillment handler' + - ' prevents unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); - Promise.resolve().then(function() { - return Promise.reject(e); - }).then(common.fail, function(reason) { - assert.strictEqual(e, reason); - }); -}); - -asyncTest('A rejected promise derived from returning an' + - ' asynchronously-rejected promise in a fulfillment handler' + - ' does trigger unhandledRejection', function(done) { - var e = new Error(); - var _promise; - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - assert.strictEqual(_promise, promise); - }); - _promise = Promise.resolve().then(function() { - return new Promise(function(_, reject) { - setTimeout(function() { - reject(e); - }, 1); + } +); + +asyncTest( + 'Catching a rejected promise derived from throwing in a' + + ' fulfillment handler prevents unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + Promise.resolve().then(function() { + throw e; + }).then(common.fail, function(reason) { + assert.strictEqual(e, reason); }); - }); -}); - -asyncTest('A rejected promise derived from throwing in a fulfillment handler' + - ' does trigger unhandledRejection', function(done) { - var e = new Error(); - var _promise; - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - assert.strictEqual(_promise, promise); - }); - _promise = Promise.resolve().then(function() { - throw e; - }); -}); + } +); + +asyncTest( + 'Catching a rejected promise derived from returning a' + + ' synchronously-rejected promise in a fulfillment handler' + + ' prevents unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + Promise.resolve().then(function() { + return Promise.reject(e); + }).then(common.fail, function(reason) { + assert.strictEqual(e, reason); + }); + } +); + +asyncTest( + 'A rejected promise derived from returning an' + + ' asynchronously-rejected promise in a fulfillment handler' + + ' does trigger unhandledRejection', + function(done) { + var e = new Error(); + var _promise; + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + assert.strictEqual(_promise, promise); + }); + _promise = Promise.resolve().then(function() { + return new Promise(function(_, reject) { + setTimeout(function() { + reject(e); + }, 1); + }); + }); + } +); + +asyncTest( + 'A rejected promise derived from throwing in a fulfillment handler' + + ' does trigger unhandledRejection', + function(done) { + var e = new Error(); + var _promise; + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + assert.strictEqual(_promise, promise); + }); + _promise = Promise.resolve().then(function() { + throw e; + }); + } +); asyncTest( 'A rejected promise derived from returning a synchronously-rejected' + - ' promise in a fulfillment handler does trigger unhandledRejection', + ' promise in a fulfillment handler does trigger unhandledRejection', function(done) { var e = new Error(); var _promise; @@ -381,16 +427,19 @@ asyncTest( ); // Combinations with Promise.all -asyncTest('Catching the Promise.all() of a collection that includes a' + - 'rejected promise prevents unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); - Promise.all([Promise.reject(e)]).then(common.fail, function() {}); -}); +asyncTest( + 'Catching the Promise.all() of a collection that includes a' + + 'rejected promise prevents unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + Promise.all([Promise.reject(e)]).then(common.fail, function() {}); + } +); asyncTest( 'Catching the Promise.all() of a collection that includes a ' + - 'nextTick-async rejected promise prevents unhandledRejection', + 'nextTick-async rejected promise prevents unhandledRejection', function(done) { var e = new Error(); onUnhandledFail(done); @@ -406,69 +455,58 @@ asyncTest( } ); -asyncTest('Failing to catch the Promise.all() of a collection that includes' + - ' a rejected promise triggers unhandledRejection for the returned' + - ' promise, not the passed promise', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - assert.strictEqual(p, promise); - }); - var p = Promise.all([Promise.reject(e)]); -}); - -asyncTest('Waiting setTimeout(, 10) to catch a promise causes an' + - ' unhandledRejection + rejectionHandled pair', function(done) { - clean(); - var unhandledPromises = []; - var e = new Error(); - process.on('unhandledRejection', function(reason, promise) { - assert.strictEqual(e, reason); - unhandledPromises.push(promise); - }); - process.on('rejectionHandled', function(promise) { - assert.strictEqual(1, unhandledPromises.length); - assert.strictEqual(unhandledPromises[0], promise); - assert.strictEqual(thePromise, promise); - done(); - }); - - var thePromise = new Promise(function() { - throw e; - }); - setTimeout(function() { - thePromise.then(common.fail, function(reason) { +asyncTest( + 'Failing to catch the Promise.all() of a collection that includes' + + ' a rejected promise triggers unhandledRejection for the returned' + + ' promise, not the passed promise', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { assert.strictEqual(e, reason); + assert.strictEqual(p, promise); }); - }, 10); -}); - -asyncTest('Waiting for some combination of process.nextTick + promise' + - ' microtasks to attach a catch handler is still soon enough to' + - ' prevent unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); + var p = Promise.all([Promise.reject(e)]); + } +); +asyncTest( + 'Waiting setTimeout(, 10) to catch a promise causes an' + + ' unhandledRejection + rejectionHandled pair', + function(done) { + clean(); + var unhandledPromises = []; + var e = new Error(); + process.on('unhandledRejection', function(reason, promise) { + assert.strictEqual(e, reason); + unhandledPromises.push(promise); + }); + process.on('rejectionHandled', function(promise) { + assert.strictEqual(1, unhandledPromises.length); + assert.strictEqual(unhandledPromises[0], promise); + assert.strictEqual(thePromise, promise); + done(); + }); - var a = Promise.reject(e); - process.nextTick(function() { - Promise.resolve().then(function() { - process.nextTick(function() { - Promise.resolve().then(function() { - a.catch(function() {}); - }); - }); + var thePromise = new Promise(function() { + throw e; }); - }); -}); + setTimeout(function() { + thePromise.then(common.fail, function(reason) { + assert.strictEqual(e, reason); + }); + }, 10); + } +); + +asyncTest( + 'Waiting for some combination of process.nextTick + promise' + + ' microtasks to attach a catch handler is still soon enough to' + + ' prevent unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); -asyncTest('Waiting for some combination of process.nextTick + promise' + - ' microtasks to attach a catch handler is still soon enough to ' + - 'prevent unhandledRejection: inside setImmediate', function(done) { - var e = new Error(); - onUnhandledFail(done); - setImmediate(function() { var a = Promise.reject(e); process.nextTick(function() { Promise.resolve().then(function() { @@ -479,52 +517,81 @@ asyncTest('Waiting for some combination of process.nextTick + promise' + }); }); }); - }); -}); + } +); -asyncTest('Waiting for some combination of process.nextTick + promise ' + - 'microtasks to attach a catch handler is still soon enough to ' + - 'prevent unhandledRejection: inside setTimeout', function(done) { - var e = new Error(); - onUnhandledFail(done); +asyncTest( + 'Waiting for some combination of process.nextTick + promise' + + ' microtasks to attach a catch handler is still soon enough to ' + + 'prevent unhandledRejection: inside setImmediate', + function(done) { + var e = new Error(); + onUnhandledFail(done); - setTimeout(function() { - var a = Promise.reject(e); - process.nextTick(function() { - Promise.resolve().then(function() { - process.nextTick(function() { - Promise.resolve().then(function() { - a.catch(function() {}); + setImmediate(function() { + var a = Promise.reject(e); + process.nextTick(function() { + Promise.resolve().then(function() { + process.nextTick(function() { + Promise.resolve().then(function() { + a.catch(function() {}); + }); }); }); }); }); - }, 0); -}); + } +); -asyncTest('Waiting for some combination of promise microtasks + ' + - 'process.nextTick to attach a catch handler is still soon enough' + - ' to prevent unhandledRejection', function(done) { - var e = new Error(); - onUnhandledFail(done); +asyncTest( + 'Waiting for some combination of process.nextTick + promise ' + + 'microtasks to attach a catch handler is still soon enough to ' + + 'prevent unhandledRejection: inside setTimeout', + function(done) { + var e = new Error(); + onUnhandledFail(done); + setTimeout(function() { + var a = Promise.reject(e); + process.nextTick(function() { + Promise.resolve().then(function() { + process.nextTick(function() { + Promise.resolve().then(function() { + a.catch(function() {}); + }); + }); + }); + }); + }, 0); + } +); - var a = Promise.reject(e); - Promise.resolve().then(function() { - process.nextTick(function() { - Promise.resolve().then(function() { - process.nextTick(function() { - a.catch(function() {}); +asyncTest( + 'Waiting for some combination of promise microtasks + ' + + 'process.nextTick to attach a catch handler is still soon enough' + + ' to prevent unhandledRejection', + function(done) { + var e = new Error(); + onUnhandledFail(done); + + + var a = Promise.reject(e); + Promise.resolve().then(function() { + process.nextTick(function() { + Promise.resolve().then(function() { + process.nextTick(function() { + a.catch(function() {}); + }); }); }); }); - }); -}); + } +); asyncTest( 'Waiting for some combination of promise microtasks +' + - ' process.nextTick to attach a catch handler is still soon enough' + - ' to prevent unhandledRejection: inside setImmediate', + ' process.nextTick to attach a catch handler is still soon enough' + + ' to prevent unhandledRejection: inside setImmediate', function(done) { var e = new Error(); onUnhandledFail(done); @@ -544,87 +611,99 @@ asyncTest( } ); -asyncTest('Waiting for some combination of promise microtasks +' + - ' process.nextTick to attach a catch handler is still soon enough' + - ' to prevent unhandledRejection: inside setTimeout', function(done) { - var e = new Error(); - onUnhandledFail(done); +asyncTest( + 'Waiting for some combination of promise microtasks +' + + ' process.nextTick to attach a catch handler is still soon enough' + + ' to prevent unhandledRejection: inside setTimeout', + function(done) { + var e = new Error(); + onUnhandledFail(done); - setTimeout(function() { - var a = Promise.reject(e); - Promise.resolve().then(function() { - process.nextTick(function() { - Promise.resolve().then(function() { - process.nextTick(function() { - a.catch(function() {}); + setTimeout(function() { + var a = Promise.reject(e); + Promise.resolve().then(function() { + process.nextTick(function() { + Promise.resolve().then(function() { + process.nextTick(function() { + a.catch(function() {}); + }); }); }); }); + }, 0); + } +); + +asyncTest( + 'setImmediate + promise microtasks is too late to attach a catch' + + ' handler; unhandledRejection will be triggered in that case.' + + ' (setImmediate before promise creation/rejection)', + function(done) { + var e = new Error(); + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(e, reason); + assert.strictEqual(p, promise); + }); + var p = Promise.reject(e); + setImmediate(function() { + Promise.resolve().then(function() { + p.catch(function() {}); + }); }); - }, 0); -}); + } +); -asyncTest('setImmediate + promise microtasks is too late to attach a catch' + - ' handler; unhandledRejection will be triggered in that case.' + - ' (setImmediate before promise creation/rejection)', function(done) { - var e = new Error(); - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(e, reason); - assert.strictEqual(p, promise); - }); - var p = Promise.reject(e); - setImmediate(function() { - Promise.resolve().then(function() { - p.catch(function() {}); +asyncTest( + 'setImmediate + promise microtasks is too late to attach a catch' + + ' handler; unhandledRejection will be triggered in that case' + + ' (setImmediate before promise creation/rejection)', + function(done) { + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(undefined, reason); + assert.strictEqual(p, promise); }); - }); -}); - -asyncTest('setImmediate + promise microtasks is too late to attach a catch' + - ' handler; unhandledRejection will be triggered in that case' + - ' (setImmediate before promise creation/rejection)', function(done) { - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(undefined, reason); - assert.strictEqual(p, promise); - }); - setImmediate(function() { - Promise.resolve().then(function() { + setImmediate(function() { Promise.resolve().then(function() { Promise.resolve().then(function() { Promise.resolve().then(function() { - p.catch(function() {}); + Promise.resolve().then(function() { + p.catch(function() {}); + }); }); }); }); }); - }); - var p = Promise.reject(); -}); - -asyncTest('setImmediate + promise microtasks is too late to attach a catch' + - ' handler; unhandledRejection will be triggered in that case' + - ' (setImmediate after promise creation/rejection)', function(done) { - onUnhandledSucceed(done, function(reason, promise) { - assert.strictEqual(undefined, reason); - assert.strictEqual(p, promise); - }); - var p = Promise.reject(); - setImmediate(function() { - Promise.resolve().then(function() { + var p = Promise.reject(); + } +); + +asyncTest( + 'setImmediate + promise microtasks is too late to attach a catch' + + ' handler; unhandledRejection will be triggered in that case' + + ' (setImmediate after promise creation/rejection)', + function(done) { + onUnhandledSucceed(done, function(reason, promise) { + assert.strictEqual(undefined, reason); + assert.strictEqual(p, promise); + }); + var p = Promise.reject(); + setImmediate(function() { Promise.resolve().then(function() { Promise.resolve().then(function() { Promise.resolve().then(function() { - p.catch(function() {}); + Promise.resolve().then(function() { + p.catch(function() {}); + }); }); }); }); }); - }); -}); + } +); asyncTest( 'Promise unhandledRejection handler does not interfere with domain' + - ' error handlers being given exceptions thrown from nextTick.', + ' error handlers being given exceptions thrown from nextTick.', function(done) { var d = domain.create(); var domainReceivedError; @@ -647,44 +726,49 @@ asyncTest( } ); -asyncTest('nextTick is immediately scheduled when called inside an event' + - ' handler', function(done) { - clean(); - var e = new Error('error'); - process.on('unhandledRejection', function(reason, promise) { - var order = []; - process.nextTick(function() { - order.push(1); +asyncTest( + 'nextTick is immediately scheduled when called inside an event handler', + function(done) { + clean(); + var e = new Error('error'); + process.on('unhandledRejection', function(reason, promise) { + var order = []; + process.nextTick(function() { + order.push(1); + }); + setTimeout(function() { + order.push(2); + assert.deepStrictEqual([1, 2], order); + done(); + }, 1); }); - setTimeout(function() { - order.push(2); - assert.deepStrictEqual([1, 2], order); + Promise.reject(e); + } +); + +asyncTest( + 'Throwing an error inside a rejectionHandled handler goes to' + + ' unhandledException, and does not cause .catch() to throw an' + + 'exception', + function(done) { + clean(); + var e = new Error(); + var e2 = new Error(); + var tearDownException = setupException(function(err) { + assert.equal(e2, err); + tearDownException(); done(); + }); + process.on('rejectionHandled', function() { + throw e2; + }); + var p = Promise.reject(e); + setTimeout(function() { + try { + p.catch(function() {}); + } catch (e) { + done(new Error('fail')); + } }, 1); - }); - Promise.reject(e); -}); - -asyncTest('Throwing an error inside a rejectionHandled handler goes to' + - ' unhandledException, and does not cause .catch() to throw an' + - 'exception', function(done) { - clean(); - var e = new Error(); - var e2 = new Error(); - var tearDownException = setupException(function(err) { - assert.equal(e2, err); - tearDownException(); - done(); - }); - process.on('rejectionHandled', function() { - throw e2; - }); - var p = Promise.reject(e); - setTimeout(function() { - try { - p.catch(function() {}); - } catch (e) { - done(new Error('fail')); - } - }, 1); -}); + } +); diff --git a/test/parallel/test-readline-interface.js b/test/parallel/test-readline-interface.js index 02f6dc980a10db..70c6a01951e792 100644 --- a/test/parallel/test-readline-interface.js +++ b/test/parallel/test-readline-interface.js @@ -311,9 +311,9 @@ function isWarned(emitter) { assert.equal(readline.codePointAt('ABC', 0), 0x41); assert.equal(readline.codePointAt('あいう', 1), 0x3044); assert.equal(readline.codePointAt('\ud800\udc00', 0), // surrogate - 0x10000); + 0x10000); assert.equal(readline.codePointAt('\ud800\udc00A', 2), // surrogate - 0x41); + 0x41); assert.equal(readline.getStringWidth('abcde'), 5); assert.equal(readline.getStringWidth('古池や'), 6); assert.equal(readline.getStringWidth('ノード.js'), 9); @@ -322,14 +322,14 @@ function isWarned(emitter) { assert.equal(readline.getStringWidth('A\ud83c\ude00BC'), 5); // surrogate // check if vt control chars are stripped - assert.equal(readline - .stripVTControlCharacters('\u001b[31m> \u001b[39m'), '> '); - assert.equal(readline - .stripVTControlCharacters('\u001b[31m> \u001b[39m> '), '> > '); - assert.equal(readline - .stripVTControlCharacters('\u001b[31m\u001b[39m'), ''); - assert.equal(readline - .stripVTControlCharacters('> '), '> '); + assert.equal(readline.stripVTControlCharacters('\u001b[31m> \u001b[39m'), + '> '); + assert.equal(readline.stripVTControlCharacters('\u001b[31m> \u001b[39m> '), + '> > '); + assert.equal(readline.stripVTControlCharacters('\u001b[31m\u001b[39m'), + ''); + assert.equal(readline.stripVTControlCharacters('> '), + '> '); assert.equal(readline.getStringWidth('\u001b[31m> \u001b[39m'), 2); assert.equal(readline.getStringWidth('\u001b[31m> \u001b[39m> '), 4); assert.equal(readline.getStringWidth('\u001b[31m\u001b[39m'), 0); diff --git a/test/parallel/test-regress-GH-4948.js b/test/parallel/test-regress-GH-4948.js index c6953eb78fa908..d3bb390818b4ce 100644 --- a/test/parallel/test-regress-GH-4948.js +++ b/test/parallel/test-regress-GH-4948.js @@ -16,15 +16,16 @@ var server = http.createServer(function(serverReq, serverRes) { // normally the use case would be to call an external site // does not require connecting locally or to itself to fail - var r = http.request({hostname: 'localhost', - port: common.PORT}, function(res) { - // required, just needs to be in the client response somewhere - serverRes.end(); - - // required for test to fail - res.on('data', function(data) { }); - - }); + var r = http.request( + {hostname: 'localhost', port: common.PORT}, + function(res) { + // required, just needs to be in the client response somewhere + serverRes.end(); + + // required for test to fail + res.on('data', function(data) { }); + } + ); r.on('error', function(e) {}); r.end(); diff --git a/test/parallel/test-require-process.js b/test/parallel/test-require-process.js index 33634930b4e614..69828d83a69ed5 100644 --- a/test/parallel/test-require-process.js +++ b/test/parallel/test-require-process.js @@ -3,5 +3,8 @@ require('../common'); var assert = require('assert'); var nativeProcess = require('process'); -assert.strictEqual(nativeProcess, process, - 'require("process") should return a reference to global process'); +assert.strictEqual( + nativeProcess, + process, + 'require("process") should return a reference to global process' +); diff --git a/test/parallel/test-require-symlink.js b/test/parallel/test-require-symlink.js index 6b716ffa1381ac..805de583eade52 100644 --- a/test/parallel/test-require-symlink.js +++ b/test/parallel/test-require-symlink.js @@ -6,14 +6,20 @@ const fs = require('fs'); const exec = require('child_process').exec; const spawn = require('child_process').spawn; -const linkTarget = path.join(common.fixturesDir, - '/module-require-symlink/node_modules/dep2/'); - -const linkDir = path.join(common.fixturesDir, - '/module-require-symlink/node_modules/dep1/node_modules/dep2'); - -const linkScriptTarget = path.join(common.fixturesDir, - '/module-require-symlink/symlinked.js'); +const linkTarget = path.join( + common.fixturesDir, + '/module-require-symlink/node_modules/dep2/' +); + +const linkDir = path.join( + common.fixturesDir, + '/module-require-symlink/node_modules/dep1/node_modules/dep2' +); + +const linkScriptTarget = path.join( + common.fixturesDir, + '/module-require-symlink/symlinked.js' +); const linkScript = path.join(common.tmpDir, 'module-require-symlink.js'); diff --git a/test/parallel/test-stdin-child-proc.js b/test/parallel/test-stdin-child-proc.js index 35ae0c99d3c8ff..a3ea28f2342722 100644 --- a/test/parallel/test-stdin-child-proc.js +++ b/test/parallel/test-stdin-child-proc.js @@ -5,8 +5,10 @@ const common = require('../common'); const assert = require('assert'); const child_process = require('child_process'); const path = require('path'); -const cp = child_process.spawn(process.execPath, - [path.resolve(__dirname, 'test-stdin-pause-resume.js')]); +const cp = child_process.spawn( + process.execPath, + [path.resolve(__dirname, 'test-stdin-pause-resume.js')] +); cp.on('exit', common.mustCall((code) => { assert.equal(code, 0); diff --git a/test/parallel/test-tick-processor.js b/test/parallel/test-tick-processor.js index b22e2ec14a3c6e..43941b4c1c9f85 100644 --- a/test/parallel/test-tick-processor.js +++ b/test/parallel/test-tick-processor.js @@ -19,14 +19,15 @@ process.chdir(common.tmpDir); // Unknown checked for to prevent flakiness, if pattern is not found, // then a large number of unknown ticks should be present runTest(/LazyCompile.*\[eval\]:1|.*% UNKNOWN/, - `function f() { - for (var i = 0; i < 1000000; i++) { - i++; - } - setImmediate(function() { f(); }); - }; - setTimeout(function() { process.exit(0); }, 2000); - f();`); + `function f() { + for (var i = 0; i < 1000000; i++) { + i++; + } + setImmediate(function() { f(); }); + }; + setTimeout(function() { process.exit(0); }, 2000); + f();` +); if (common.isWindows || common.isSunOS || common.isAix || @@ -36,12 +37,13 @@ if (common.isWindows || return; } runTest(/RunInDebugContext/, - `function f() { - require(\'vm\').runInDebugContext(\'Debug\'); - setImmediate(function() { f(); }); - }; - setTimeout(function() { process.exit(0); }, 2000); - f();`); + `function f() { + require(\'vm\').runInDebugContext(\'Debug\'); + setImmediate(function() { f(); }); + }; + setTimeout(function() { process.exit(0); }, 2000); + f();` +); function runTest(pattern, code) { cp.execFileSync(process.execPath, ['-prof', '-pe', code]); diff --git a/test/parallel/test-timers-ordering.js b/test/parallel/test-timers-ordering.js index cef91e58e78c3d..c23af9d8307e9a 100644 --- a/test/parallel/test-timers-ordering.js +++ b/test/parallel/test-timers-ordering.js @@ -19,7 +19,7 @@ var f = function(i) { var now = Timer.now(); console.log(i, now); assert(now >= last_ts + 1, - 'current ts ' + now + ' < prev ts ' + last_ts + ' + 1'); + 'current ts ' + now + ' < prev ts ' + last_ts + ' + 1'); last_ts = now; // schedule next iteration diff --git a/test/parallel/test-timers-reset-process-domain-on-throw.js b/test/parallel/test-timers-reset-process-domain-on-throw.js index ab3ffd3596ed53..21f04c8e3035da 100644 --- a/test/parallel/test-timers-reset-process-domain-on-throw.js +++ b/test/parallel/test-timers-reset-process-domain-on-throw.js @@ -36,8 +36,10 @@ function secondTimer() { // secondTimer was scheduled before any domain had been created, so its // callback should not have any active domain set when it runs. if (process.domain !== null) { - console.log('process.domain should be null in this timer callback, but ' + - 'instead is:', process.domain); + console.log( + 'process.domain should be null in this timer callback, but instead is:', + process.domain + ); // Do not use assert here, as it throws errors and if a domain with an error // handler is active, then asserting wouldn't make the test fail. process.exit(1); diff --git a/test/parallel/test-timers-throw-when-cb-not-function.js b/test/parallel/test-timers-throw-when-cb-not-function.js index 13533107934bd6..2aff904f06a500 100644 --- a/test/parallel/test-timers-throw-when-cb-not-function.js +++ b/test/parallel/test-timers-throw-when-cb-not-function.js @@ -9,17 +9,17 @@ function doSetTimeout(callback, after) { } assert.throws(doSetTimeout('foo'), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetTimeout({foo: 'bar'}), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetTimeout(), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetTimeout(undefined, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetTimeout(null, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetTimeout(false, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); function doSetInterval(callback, after) { @@ -29,17 +29,17 @@ function doSetInterval(callback, after) { } assert.throws(doSetInterval('foo'), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetInterval({foo: 'bar'}), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetInterval(), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetInterval(undefined, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetInterval(null, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetInterval(false, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); function doSetImmediate(callback, after) { @@ -49,14 +49,14 @@ function doSetImmediate(callback, after) { } assert.throws(doSetImmediate('foo'), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetImmediate({foo: 'bar'}), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetImmediate(), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetImmediate(undefined, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetImmediate(null, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); assert.throws(doSetImmediate(false, 0), - /"callback" argument must be a function/); + /"callback" argument must be a function/); diff --git a/test/parallel/test-timers-unref-leak.js b/test/parallel/test-timers-unref-leak.js index a1b1265763bf1d..041d7cc1a3073e 100644 --- a/test/parallel/test-timers-unref-leak.js +++ b/test/parallel/test-timers-unref-leak.js @@ -18,8 +18,7 @@ timeout._handle.close = function() { }; // Just to keep process alive and let previous timer's handle die -setTimeout(function() { -}, 50); +setTimeout(function() {}, 50); process.on('exit', function() { assert.equal(called, 1); diff --git a/test/parallel/test-tls-peer-certificate.js b/test/parallel/test-tls-peer-certificate.js index 357c3f5aa8abf7..dfdaf93dbb439f 100644 --- a/test/parallel/test-tls-peer-certificate.js +++ b/test/parallel/test-tls-peer-certificate.js @@ -41,7 +41,7 @@ server.listen(common.PORT, function() { assert.equal(peerCert.fingerprint, '8D:06:3A:B3:E5:8B:85:29:72:4F:7D:1B:54:CD:95:19:3C:EF:6F:AA'); assert.deepStrictEqual(peerCert.infoAccess['OCSP - URI'], - [ 'http://ocsp.nodejs.org/' ]); + [ 'http://ocsp.nodejs.org/' ]); var issuer = peerCert.issuerCertificate; assert.ok(issuer.issuerCertificate === issuer); diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js index 9e713cf16c542b..d593bad1504f3f 100644 --- a/test/parallel/test-util-inspect.js +++ b/test/parallel/test-util-inspect.js @@ -13,7 +13,7 @@ assert.equal(util.inspect(undefined), 'undefined'); assert.equal(util.inspect(null), 'null'); assert.equal(util.inspect(/foo(bar\n)?/gi), '/foo(bar\\n)?/gi'); assert.equal(util.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')), - new Date('2010-02-14T12:48:40+01:00').toISOString()); + new Date('2010-02-14T12:48:40+01:00').toISOString()); assert.equal(util.inspect('\n\u0001'), "'\\n\\u0001'"); @@ -29,18 +29,23 @@ assert.equal(util.inspect({a: 1, b: 2}), '{ a: 1, b: 2 }'); assert.equal(util.inspect({'a': {}}), '{ a: {} }'); assert.equal(util.inspect({'a': {'b': 2}}), '{ a: { b: 2 } }'); assert.equal(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}), - '{ a: { b: { c: [Object] } } }'); + '{ a: { b: { c: [Object] } } }'); assert.equal(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}, false, null), - '{ a: { b: { c: { d: 2 } } } }'); + '{ a: { b: { c: { d: 2 } } } }'); assert.equal(util.inspect([1, 2, 3], true), '[ 1, 2, 3, [length]: 3 ]'); assert.equal(util.inspect({'a': {'b': { 'c': 2}}}, false, 0), - '{ a: [Object] }'); + '{ a: [Object] }'); assert.equal(util.inspect({'a': {'b': { 'c': 2}}}, false, 1), - '{ a: { b: [Object] } }'); -assert.equal(util.inspect(Object.create({}, - {visible: {value: 1, enumerable: true}, hidden: {value: 2}})), - '{ visible: 1 }' -); + '{ a: { b: [Object] } }'); + +{ + const out = util.inspect( + Object.create( + {}, {visible: {value: 1, enumerable: true}, hidden: {value: 2}} + ) + ); + assert.equal(out, '{ visible: 1 }'); +} for (const showHidden of [true, false]) { const ab = new ArrayBuffer(4); @@ -161,8 +166,11 @@ for (const showHidden of [true, false]) { // See http://codereview.chromium.org/9124004/ { - const out = util.inspect(Object.create({}, - {visible: {value: 1, enumerable: true}, hidden: {value: 2}}), true); + const out = util.inspect( + Object.create( + {}, + {visible: {value: 1, enumerable: true}, hidden: {value: 2}} + ), true); if (out !== '{ [hidden]: 2, visible: 1 }' && out !== '{ visible: 1, [hidden]: 2 }') { assert.ok(false); @@ -171,32 +179,40 @@ for (const showHidden of [true, false]) { // Objects without prototype { - const out = util.inspect(Object.create(null, - { name: {value: 'Tim', enumerable: true}, - hidden: {value: 'secret'}}), true); + const out = util.inspect( + Object.create( + null, + { name: {value: 'Tim', enumerable: true}, hidden: {value: 'secret'}} + ), true); if (out !== "{ [hidden]: 'secret', name: 'Tim' }" && out !== "{ name: 'Tim', [hidden]: 'secret' }") { assert(false); } } -assert.equal( - util.inspect(Object.create(null, - {name: {value: 'Tim', enumerable: true}, - hidden: {value: 'secret'}})), - '{ name: \'Tim\' }' -); +{ + const out = util.inspect( + Object.create( + null, + {name: {value: 'Tim', enumerable: true}, hidden: {value: 'secret'}} + ) + ); + assert.equal( + out, + '{ name: \'Tim\' }' + ); +} // Dynamic properties assert.equal(util.inspect({get readonly() {}}), - '{ readonly: [Getter] }'); + '{ readonly: [Getter] }'); assert.equal(util.inspect({get readwrite() {}, set readwrite(val) {}}), - '{ readwrite: [Getter/Setter] }'); + '{ readwrite: [Getter/Setter] }'); assert.equal(util.inspect({set writeonly(val) {}}), - '{ writeonly: [Setter] }'); + '{ writeonly: [Setter] }'); var value = {}; value['a'] = value; @@ -509,7 +525,7 @@ if (typeof Symbol !== 'undefined') { assert.equal(util.inspect(subject), '[ 1, 2, 3 ]'); assert.equal(util.inspect(subject, options), - '[ 1, 2, 3, [length]: 3, [Symbol(symbol)]: 42 ]'); + '[ 1, 2, 3, [length]: 3, [Symbol(symbol)]: 42 ]'); } // test Set @@ -617,7 +633,7 @@ checkAlignment(new Map(big_array.map(function(y) { return [y, null]; }))); assert.equal(util.inspect(new SetSubclass([1, 2, 3])), 'SetSubclass { 1, 2, 3 }'); assert.equal(util.inspect(new MapSubclass([['foo', 42]])), - 'MapSubclass { \'foo\' => 42 }'); + 'MapSubclass { \'foo\' => 42 }'); assert.equal(util.inspect(new PromiseSubclass(function() {})), 'PromiseSubclass { }'); } diff --git a/test/parallel/test-vm-symbols.js b/test/parallel/test-vm-symbols.js index d3419af559a2f2..f80609c0101d51 100644 --- a/test/parallel/test-vm-symbols.js +++ b/test/parallel/test-vm-symbols.js @@ -19,7 +19,7 @@ var context = new Document(); vm.createContext(context); assert.equal(context.getSymbolValue(), 'foo', - 'should return symbol-keyed value from the outside'); + 'should return symbol-keyed value from the outside'); assert.equal(vm.runInContext('this.getSymbolValue()', context), 'foo', - 'should return symbol-keyed value from the inside'); + 'should return symbol-keyed value from the inside'); diff --git a/test/parallel/test-zlib-convenience-methods.js b/test/parallel/test-zlib-convenience-methods.js index 70c102efd2862c..ffbc339c651a34 100644 --- a/test/parallel/test-zlib-convenience-methods.js +++ b/test/parallel/test-zlib-convenience-methods.js @@ -22,34 +22,45 @@ var opts = { zlib[method[0]](expect, opts, function(err, result) { zlib[method[1]](result, opts, function(err, result) { - assert.equal(result, expect, - 'Should get original string after ' + - method[0] + '/' + method[1] + ' with options.'); + assert.equal( + result, + expect, + `Should get original string after ${method[0]}/${method[1]} with ` + + 'options.' + ); hadRun++; }); }); zlib[method[0]](expect, function(err, result) { zlib[method[1]](result, function(err, result) { - assert.equal(result, expect, - 'Should get original string after ' + - method[0] + '/' + method[1] + ' without options.'); + assert.equal( + result, + expect, + `Should get original string after ${method[0]}/${method[1]} without ` + + 'options.' + ); hadRun++; }); }); var result = zlib[method[0] + 'Sync'](expect, opts); result = zlib[method[1] + 'Sync'](result, opts); - assert.equal(result, expect, - 'Should get original string after ' + - method[0] + '/' + method[1] + ' with options.'); + assert.equal( + result, + expect, + `Should get original string after ${method[0]}/${method[1]} with options.` + ); hadRun++; result = zlib[method[0] + 'Sync'](expect); result = zlib[method[1] + 'Sync'](result); - assert.equal(result, expect, - 'Should get original string after ' + - method[0] + '/' + method[1] + ' without options.'); + assert.equal( + result, + expect, + `Should get original string after ${method[0]}/${method[1]} without ` + + 'options.' + ); hadRun++; }); diff --git a/test/parallel/test-zlib-flush-drain.js b/test/parallel/test-zlib-flush-drain.js index 9ec2f2a786dc56..45cca584858322 100644 --- a/test/parallel/test-zlib-flush-drain.js +++ b/test/parallel/test-zlib-flush-drain.js @@ -38,11 +38,11 @@ deflater.on('drain', function() { process.once('exit', function() { assert.equal(beforeFlush, true, - 'before calling flush the writable stream should need to drain'); + 'before calling flush, writable stream should need to drain'); assert.equal(afterFlush, false, - 'after calling flush the writable stream should not need to drain'); + 'after calling flush, writable stream should not need to drain'); assert.equal(drainCount, 1, - 'the deflater should have emitted a single drain event'); + 'the deflater should have emitted a single drain event'); assert.equal(flushCount, 2, - 'flush should be called twice'); + 'flush should be called twice'); }); diff --git a/test/parallel/test-zlib-from-concatenated-gzip.js b/test/parallel/test-zlib-from-concatenated-gzip.js index b5007820c8d0d7..bee9f4724c613c 100644 --- a/test/parallel/test-zlib-from-concatenated-gzip.js +++ b/test/parallel/test-zlib-from-concatenated-gzip.js @@ -53,7 +53,7 @@ fs.createReadStream(pmmFileGz) .on('data', (data) => pmmResultBuffers.push(data)) .on('finish', common.mustCall(() => { assert.deepStrictEqual(Buffer.concat(pmmResultBuffers), pmmExpected, - 'result should match original random garbage'); + 'result should match original random garbage'); })); // test that the next gzip member can wrap around the input buffer boundary @@ -66,8 +66,11 @@ fs.createReadStream(pmmFileGz) }) .on('data', (data) => resultBuffers.push(data)) .on('finish', common.mustCall(() => { - assert.strictEqual(Buffer.concat(resultBuffers).toString(), 'abcdef', - `result should match original input (offset = ${offset})`); + assert.strictEqual( + Buffer.concat(resultBuffers).toString(), + 'abcdef', + `result should match original input (offset = ${offset})` + ); })); // first write: write "abc" + the first bytes of "def" diff --git a/test/parallel/test-zlib-unzip-one-byte-chunks.js b/test/parallel/test-zlib-unzip-one-byte-chunks.js index f1b1c0f5084be9..50a383af18329d 100644 --- a/test/parallel/test-zlib-unzip-one-byte-chunks.js +++ b/test/parallel/test-zlib-unzip-one-byte-chunks.js @@ -17,7 +17,7 @@ const unzip = zlib.createUnzip() .on('data', (data) => resultBuffers.push(data)) .on('finish', common.mustCall(() => { assert.deepStrictEqual(Buffer.concat(resultBuffers).toString(), 'abcdef', - 'result should match original string'); + 'result should match original string'); })); for (let i = 0; i < data.length; i++) { diff --git a/test/sequential/test-init.js b/test/sequential/test-init.js index 6bb727ea1f6184..12dca717c7ac5d 100644 --- a/test/sequential/test-init.js +++ b/test/sequential/test-init.js @@ -16,24 +16,24 @@ envCopy.TEST_INIT = 1; child.exec('"' + process.execPath + '" test-init', {env: envCopy}, - function(err, stdout, stderr) { - assert.equal(stdout, 'Loaded successfully!', - '`node test-init` failed!'); - }); + function(err, stdout, stderr) { + assert.equal(stdout, 'Loaded successfully!', + '`node test-init` failed!'); + }); child.exec('"' + process.execPath + '" test-init.js', {env: envCopy}, - function(err, stdout, stderr) { - assert.equal(stdout, 'Loaded successfully!', - '`node test-init.js` failed!'); - }); + function(err, stdout, stderr) { + assert.equal(stdout, 'Loaded successfully!', + '`node test-init.js` failed!'); + }); // test-init-index is in fixtures dir as requested by ry, so go there process.chdir(common.fixturesDir); child.exec('"' + process.execPath + '" test-init-index', {env: envCopy}, - function(err, stdout, stderr) { - assert.equal(stdout, 'Loaded successfully!', - '`node test-init-index failed!'); - }); + function(err, stdout, stderr) { + assert.equal(stdout, 'Loaded successfully!', + '`node test-init-index failed!'); + }); // ensures that `node fs` does not mistakenly load the native 'fs' module // instead of the desired file and that the fs module loads as @@ -41,9 +41,9 @@ process.chdir(common.fixturesDir + '/test-init-native/'); child.exec('"' + process.execPath + '" fs', {env: envCopy}, - function(err, stdout, stderr) { - assert.equal(stdout, 'fs loaded successfully', - '`node fs` failed!'); - }); + function(err, stdout, stderr) { + assert.equal(stdout, 'fs loaded successfully', + '`node fs` failed!'); + }); } })(); diff --git a/tools/doc/html.js b/tools/doc/html.js index 99a8cbf21a014b..68ccf976b6c1f8 100644 --- a/tools/doc/html.js +++ b/tools/doc/html.js @@ -11,11 +11,11 @@ module.exports = toHTML; // TODO(chrisdickinson): never stop vomitting / fix this. var gtocPath = path.resolve(path.join( __dirname, - '..', - '..', - 'doc', - 'api', - '_toc.md' + '..', + '..', + 'doc', + 'api', + '_toc.md' )); var gtocLoading = null; var gtocData = null; diff --git a/tools/eslint-rules/align-function-arguments.js b/tools/eslint-rules/align-function-arguments.js new file mode 100644 index 00000000000000..17fa704c623980 --- /dev/null +++ b/tools/eslint-rules/align-function-arguments.js @@ -0,0 +1,44 @@ +/** + * @fileoverview Align arguments in multiline function calls + * @author Rich Trott + */ +'use strict'; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ +function checkArgumentAlignment(context, node) { + if (node.arguments.length === 0) + return; + + var msg = ''; + const first = node.arguments[0]; + var currentLine = first.loc.start.line; + const firstColumn = first.loc.start.column; + + node.arguments.slice(1).forEach((argument) => { + if (argument.loc.start.line > currentLine) { + // Ignore if there are multiple lines between arguments. This happens + // in situations like this: + // setTimeout(function() { + // ... do stuff ... + // }, 1); + if (argument.loc.start.line === currentLine + 1) { + if (argument.loc.start.column !== firstColumn) { + msg = 'Function called with argument in column ' + + `${argument.loc.start.column}, expected in ${firstColumn}`; + } + } + currentLine = argument.loc.start.line; + } + }); + + if (msg) + context.report(node, msg); +} + +module.exports = function(context) { + return { + 'CallExpression': (node) => checkArgumentAlignment(context, node) + }; +};