1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test: improve inspect readability

Browse Source 
The string escaping is hard to read. This changes all those escaped
strings to use double quotes instead so no escaping is necessary.

PR-URL: https://github.com/nodejs/node/pull/21624
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
This commit is contained in:
Ruben Bridgewater 2018-07-02 22:47:53 +02:00
parent b3e93a91eb
commit 9c5019995c
No known key found for this signature in database
GPG Key ID: F07496B3EB3C1762
1 changed files with 61 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
test/parallel/test-util-inspect.js
View File

@ -93,7 +93,7 @@ assert.strictEqual(
Object.assign(new String('hello'), { [Symbol('foo')]: 123 }), Object.assign(new String('hello'), { [Symbol('foo')]: 123 }),
{ showHidden: true } { showHidden: true }
), ),
'{ [String: \'hello\'] [length]: 5, [Symbol(foo)]: 123 }' "{ [String: 'hello'] [length]: 5, [Symbol(foo)]: 123 }"
); );
assert.strictEqual(util.inspect((new JSStream())._externalStream), assert.strictEqual(util.inspect((new JSStream())._externalStream),
@ -265,7 +265,7 @@ assert.strictEqual(
name: { value: 'Tim', enumerable: true }, name: { value: 'Tim', enumerable: true },
hidden: { value: 'secret' } hidden: { value: 'secret' }
})), })),
'{ name: \'Tim\' }' "{ name: 'Tim' }"
); );
// Dynamic properties. // Dynamic properties.
@ -308,7 +308,7 @@ assert.strictEqual(
} }
); );
assert.strictEqual(util.inspect(value), assert.strictEqual(util.inspect(value),
'[ 1, 2, 3, growingLength: [Getter], \'-1\': -1 ]'); "[ 1, 2, 3, growingLength: [Getter], '-1': -1 ]");
} }
// Array with inherited number properties. // Array with inherited number properties.
@ -422,24 +422,24 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
// Test for sparse array. // Test for sparse array.
{ {
const a = ['foo', 'bar', 'baz']; const a = ['foo', 'bar', 'baz'];
assert.strictEqual(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]'); assert.strictEqual(util.inspect(a), "[ 'foo', 'bar', 'baz' ]");
delete a[1]; delete a[1];
assert.strictEqual(util.inspect(a), '[ \'foo\', <1 empty item>, \'baz\' ]'); assert.strictEqual(util.inspect(a), "[ 'foo', <1 empty item>, 'baz' ]");
assert.strictEqual( assert.strictEqual(
util.inspect(a, true), util.inspect(a, true),
'[ \'foo\', <1 empty item>, \'baz\', [length]: 3 ]' "[ 'foo', <1 empty item>, 'baz', [length]: 3 ]"
); );
assert.strictEqual(util.inspect(new Array(5)), '[ <5 empty items> ]'); assert.strictEqual(util.inspect(new Array(5)), '[ <5 empty items> ]');
a[3] = 'bar'; a[3] = 'bar';
a[100] = 'qux'; a[100] = 'qux';
assert.strictEqual( assert.strictEqual(
util.inspect(a, { breakLength: Infinity }), util.inspect(a, { breakLength: Infinity }),
'[ \'foo\', <1 empty item>, \'baz\', \'bar\', <96 empty items>, \'qux\' ]' "[ 'foo', <1 empty item>, 'baz', 'bar', <96 empty items>, 'qux' ]"
); );
delete a[3]; delete a[3];
assert.strictEqual( assert.strictEqual(
util.inspect(a, { maxArrayLength: 4 }), util.inspect(a, { maxArrayLength: 4 }),
'[ \'foo\', <1 empty item>, \'baz\', <97 empty items>, ... 1 more item ]' "[ 'foo', <1 empty item>, 'baz', <97 empty items>, ... 1 more item ]"
); );
} }
@ -630,13 +630,13 @@ assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
assert.strictEqual( assert.strictEqual(
util.inspect(w), util.inspect(w),
'{ \'\\\\\': 1, \'\\\\\\\\\': 2, \'\\\\\\\\\\\\\': 3, ' + "{ '\\\\': 1, '\\\\\\\\': 2, '\\\\\\\\\\\\': 3, " +
'\'\\\\\\\\\\\\\\\\\': 4, \'\\n\': 5, \'\\r\': 6 }' "'\\\\\\\\\\\\\\\\': 4, '\\n': 5, '\\r': 6 }"
); );
assert.strictEqual( assert.strictEqual(
util.inspect(y), util.inspect(y),
'[ \'a\', \'b\', \'c\', \'\\\\\\\\\': \'d\', ' + "[ 'a', 'b', 'c', '\\\\\\\\': 'd', " +
'\'\\n\': \'e\', \'\\r\': \'f\' ]' "'\\n': 'e', '\\r': 'f' ]"
); );
} }
@ -733,7 +733,7 @@ util.inspect({ hasOwnProperty: null });
// A custom [util.inspect.custom]() should be able to return other Objects. // A custom [util.inspect.custom]() should be able to return other Objects.
subject[util.inspect.custom] = () => ({ foo: 'bar' }); subject[util.inspect.custom] = () => ({ foo: 'bar' });
assert.strictEqual(util.inspect(subject), '{ foo: \'bar\' }'); assert.strictEqual(util.inspect(subject), "{ foo: 'bar' }");
subject[util.inspect.custom] = (depth, opts) => { subject[util.inspect.custom] = (depth, opts) => {
assert.strictEqual(opts.customInspectOptions, true); assert.strictEqual(opts.customInspectOptions, true);
@ -776,7 +776,7 @@ util.inspect({ hasOwnProperty: null });
} }
// Test boxed primitives output the correct values. // Test boxed primitives output the correct values.
assert.strictEqual(util.inspect(new String('test')), '[String: \'test\']'); assert.strictEqual(util.inspect(new String('test')), "[String: 'test']");
assert.strictEqual( assert.strictEqual(
util.inspect(Object(Symbol('test'))), util.inspect(Object(Symbol('test'))),
'[Symbol: Symbol(test)]' '[Symbol: Symbol(test)]'
@ -792,15 +792,15 @@ assert.strictEqual(util.inspect(new Number(13.37)), '[Number: 13.37]');
{ {
const str = new String('baz'); const str = new String('baz');
str.foo = 'bar'; str.foo = 'bar';
assert.strictEqual(util.inspect(str), '{ [String: \'baz\'] foo: \'bar\' }'); assert.strictEqual(util.inspect(str), "{ [String: 'baz'] foo: 'bar' }");
const bool = new Boolean(true); const bool = new Boolean(true);
bool.foo = 'bar'; bool.foo = 'bar';
assert.strictEqual(util.inspect(bool), '{ [Boolean: true] foo: \'bar\' }'); assert.strictEqual(util.inspect(bool), "{ [Boolean: true] foo: 'bar' }");
const num = new Number(13.37); const num = new Number(13.37);
num.foo = 'bar'; num.foo = 'bar';
assert.strictEqual(util.inspect(num), '{ [Number: 13.37] foo: \'bar\' }'); assert.strictEqual(util.inspect(num), "{ [Number: 13.37] foo: 'bar' }");
} }
// Test es6 Symbol. // Test es6 Symbol.
@ -829,7 +829,7 @@ if (typeof Symbol !== 'undefined') {
assert.strictEqual(util.inspect(subject), '{ [Symbol(symbol)]: 42 }'); assert.strictEqual(util.inspect(subject), '{ [Symbol(symbol)]: 42 }');
assert.strictEqual( assert.strictEqual(
util.inspect(subject, options), util.inspect(subject, options),
'{ [Symbol(symbol)]: 42, [Symbol()]: \'non-enum\' }' "{ [Symbol(symbol)]: 42, [Symbol()]: 'non-enum' }"
); );
subject = [1, 2, 3]; subject = [1, 2, 3];
@ -847,7 +847,7 @@ if (typeof Symbol !== 'undefined') {
set.bar = 42; set.bar = 42;
assert.strictEqual( assert.strictEqual(
util.inspect(set, true), util.inspect(set, true),
'Set { \'foo\', [size]: 1, bar: 42 }' "Set { 'foo', [size]: 1, bar: 42 }"
); );
} }
@ -862,11 +862,11 @@ if (typeof Symbol !== 'undefined') {
{ {
assert.strictEqual(util.inspect(new Map()), 'Map {}'); assert.strictEqual(util.inspect(new Map()), 'Map {}');
assert.strictEqual(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])), assert.strictEqual(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
'Map { 1 => \'a\', 2 => \'b\', 3 => \'c\' }'); "Map { 1 => 'a', 2 => 'b', 3 => 'c' }");
const map = new Map([['foo', null]]); const map = new Map([['foo', null]]);
map.bar = 42; map.bar = 42;
assert.strictEqual(util.inspect(map, true), assert.strictEqual(util.inspect(map, true),
'Map { \'foo\' => null, [size]: 1, bar: 42 }'); "Map { 'foo' => null, [size]: 1, bar: 42 }");
} }
// Test circular Map. // Test circular Map.
@ -897,7 +897,7 @@ if (typeof Symbol !== 'undefined') {
const promiseWithProperty = Promise.resolve('foo'); const promiseWithProperty = Promise.resolve('foo');
promiseWithProperty.bar = 42; promiseWithProperty.bar = 42;
assert.strictEqual(util.inspect(promiseWithProperty), assert.strictEqual(util.inspect(promiseWithProperty),
'Promise { \'foo\', bar: 42 }'); "Promise { 'foo', bar: 42 }");
} }
// Make sure it doesn't choke on polyfills. Unlike Set/Map, there is no standard // Make sure it doesn't choke on polyfills. Unlike Set/Map, there is no standard
@ -913,14 +913,14 @@ if (typeof Symbol !== 'undefined') {
// Test Map iterators. // Test Map iterators.
{ {
const map = new Map([['foo', 'bar']]); const map = new Map([['foo', 'bar']]);
assert.strictEqual(util.inspect(map.keys()), '[Map Iterator] { \'foo\' }'); assert.strictEqual(util.inspect(map.keys()), "[Map Iterator] { 'foo' }");
assert.strictEqual(util.inspect(map.values()), '[Map Iterator] { \'bar\' }'); assert.strictEqual(util.inspect(map.values()), "[Map Iterator] { 'bar' }");
assert.strictEqual(util.inspect(map.entries()), assert.strictEqual(util.inspect(map.entries()),
'[Map Iterator] { [ \'foo\', \'bar\' ] }'); "[Map Iterator] { [ 'foo', 'bar' ] }");
// Make sure the iterator doesn't get consumed. // Make sure the iterator doesn't get consumed.
const keys = map.keys(); const keys = map.keys();
assert.strictEqual(util.inspect(keys), '[Map Iterator] { \'foo\' }'); assert.strictEqual(util.inspect(keys), "[Map Iterator] { 'foo' }");
assert.strictEqual(util.inspect(keys), '[Map Iterator] { \'foo\' }'); assert.strictEqual(util.inspect(keys), "[Map Iterator] { 'foo' }");
keys.extra = true; keys.extra = true;
assert.strictEqual( assert.strictEqual(
util.inspect(keys, { maxArrayLength: 0 }), util.inspect(keys, { maxArrayLength: 0 }),
@ -995,7 +995,7 @@ if (typeof Symbol !== 'undefined') {
assert.strictEqual(util.inspect(new SetSubclass([1, 2, 3])), assert.strictEqual(util.inspect(new SetSubclass([1, 2, 3])),
'SetSubclass [Set] { 1, 2, 3 }'); 'SetSubclass [Set] { 1, 2, 3 }');
assert.strictEqual(util.inspect(new MapSubclass([['foo', 42]])), assert.strictEqual(util.inspect(new MapSubclass([['foo', 42]])),
'MapSubclass [Map] { \'foo\' => 42 }'); "MapSubclass [Map] { 'foo' => 42 }");
assert.strictEqual(util.inspect(new PromiseSubclass(() => {})), assert.strictEqual(util.inspect(new PromiseSubclass(() => {})),
'PromiseSubclass [Promise] { <pending> }'); 'PromiseSubclass [Promise] { <pending> }');
assert.strictEqual( assert.strictEqual(
@ -1048,7 +1048,7 @@ if (typeof Symbol !== 'undefined') {
{ {
const x = []; const x = [];
x[''] = 1; x[''] = 1;
assert.strictEqual(util.inspect(x), '[ \'\': 1 ]'); assert.strictEqual(util.inspect(x), "[ '': 1 ]");
} }
// The following maxArrayLength tests were introduced after v6.0.0 was released. // The following maxArrayLength tests were introduced after v6.0.0 was released.
@ -1094,10 +1094,10 @@ if (typeof Symbol !== 'undefined') {
const breakpoint = oneLine.length - 5; const breakpoint = oneLine.length - 5;
const twoLines = util.inspect(obj, { breakLength: breakpoint }); const twoLines = util.inspect(obj, { breakLength: breakpoint });
assert.strictEqual(oneLine, '{ foo: \'abc\', bar: \'xyz\' }'); assert.strictEqual(oneLine, "{ foo: 'abc', bar: 'xyz' }");
assert.strictEqual(oneLine, assert.strictEqual(oneLine,
util.inspect(obj, { breakLength: breakpoint + 1 })); util.inspect(obj, { breakLength: breakpoint + 1 }));
assert.strictEqual(twoLines, '{ foo: \'abc\',\n bar: \'xyz\' }'); assert.strictEqual(twoLines, "{ foo: 'abc',\n bar: 'xyz' }");
} }
// util.inspect.defaultOptions tests. // util.inspect.defaultOptions tests.
@ -1168,7 +1168,7 @@ util.inspect(process);
{ {
// @@toStringTag // @@toStringTag
assert.strictEqual(util.inspect({ [Symbol.toStringTag]: 'a' }), assert.strictEqual(util.inspect({ [Symbol.toStringTag]: 'a' }),
'Object [a] { [Symbol(Symbol.toStringTag)]: \'a\' }'); "Object [a] { [Symbol(Symbol.toStringTag)]: 'a' }");
class Foo { class Foo {
constructor() { constructor() {
@ -1184,17 +1184,17 @@ util.inspect(process);
Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } })), Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } })),
'[foo] {}'); '[foo] {}');
assert.strictEqual(util.inspect(new Foo()), 'Foo [bar] { foo: \'bar\' }'); assert.strictEqual(util.inspect(new Foo()), "Foo [bar] { foo: 'bar' }");
assert.strictEqual( assert.strictEqual(
util.inspect(new (class extends Foo {})()), util.inspect(new (class extends Foo {})()),
'Foo [bar] { foo: \'bar\' }'); "Foo [bar] { foo: 'bar' }");
assert.strictEqual( assert.strictEqual(
util.inspect(Object.create(Object.create(Foo.prototype), { util.inspect(Object.create(Object.create(Foo.prototype), {
foo: { value: 'bar', enumerable: true } foo: { value: 'bar', enumerable: true }
})), })),
'Foo [bar] { foo: \'bar\' }'); "Foo [bar] { foo: 'bar' }");
class ThrowingClass { class ThrowingClass {
get [Symbol.toStringTag]() { get [Symbol.toStringTag]() {
@ -1246,19 +1246,19 @@ util.inspect(process);
' 2,', ' 2,',
' [', ' [',
' [', ' [',
' \'Lorem ipsum dolor\\nsit amet,\\tconsectetur \' +', " 'Lorem ipsum dolor\\nsit amet,\\tconsectetur ' +",
' \'adipiscing elit, sed do eiusmod tempor \' +', " 'adipiscing elit, sed do eiusmod tempor ' +",
' \'incididunt ut labore et dolore magna \' +', " 'incididunt ut labore et dolore magna ' +",
' \'aliqua.\',', " 'aliqua.',",
' \'test\',', " 'test',",
' \'foo\'', " 'foo'",
' ]', ' ]',
' ],', ' ],',
' 4', ' 4',
' ],', ' ],',
' b: Map {', ' b: Map {',
' \'za\' => 1,', " 'za' => 1,",
' \'zb\' => \'test\'', " 'zb' => 'test'",
' }', ' }',
'}' '}'
].join('\n'); ].join('\n');
@ -1266,28 +1266,28 @@ util.inspect(process);
out = util.inspect(o.a[2][0][0], { compact: false, breakLength: 30 }); out = util.inspect(o.a[2][0][0], { compact: false, breakLength: 30 });
expect = [ expect = [
'\'Lorem ipsum dolor\\nsit \' +', "'Lorem ipsum dolor\\nsit ' +",
' \'amet,\\tconsectetur \' +', " 'amet,\\tconsectetur ' +",
' \'adipiscing elit, sed do \' +', " 'adipiscing elit, sed do ' +",
' \'eiusmod tempor incididunt \' +', " 'eiusmod tempor incididunt ' +",
' \'ut labore et dolore magna \' +', " 'ut labore et dolore magna ' +",
' \'aliqua.\'' " 'aliqua.'"
].join('\n'); ].join('\n');
assert.strictEqual(out, expect); assert.strictEqual(out, expect);
out = util.inspect( out = util.inspect(
'12345678901234567890123456789012345678901234567890', '12345678901234567890123456789012345678901234567890',
{ compact: false, breakLength: 3 }); { compact: false, breakLength: 3 });
expect = '\'12345678901234567890123456789012345678901234567890\''; expect = "'12345678901234567890123456789012345678901234567890'";
assert.strictEqual(out, expect); assert.strictEqual(out, expect);
out = util.inspect( out = util.inspect(
'12 45 78 01 34 67 90 23 56 89 123456789012345678901234567890', '12 45 78 01 34 67 90 23 56 89 123456789012345678901234567890',
{ compact: false, breakLength: 3 }); { compact: false, breakLength: 3 });
expect = [ expect = [
'\'12 45 78 01 34 \' +', "'12 45 78 01 34 ' +",
' \'67 90 23 56 89 \' +', " '67 90 23 56 89 ' +",
' \'123456789012345678901234567890\'' " '123456789012345678901234567890'"
].join('\n'); ].join('\n');
assert.strictEqual(out, expect); assert.strictEqual(out, expect);
@ -1295,9 +1295,9 @@ util.inspect(process);
'12 45 78 01 34 67 90 23 56 89 1234567890123 0', '12 45 78 01 34 67 90 23 56 89 1234567890123 0',
{ compact: false, breakLength: 3 }); { compact: false, breakLength: 3 });
expect = [ expect = [
'\'12 45 78 01 34 \' +', "'12 45 78 01 34 ' +",
' \'67 90 23 56 89 \' +', " '67 90 23 56 89 ' +",
' \'1234567890123 0\'' " '1234567890123 0'"
].join('\n'); ].join('\n');
assert.strictEqual(out, expect); assert.strictEqual(out, expect);
@ -1305,10 +1305,10 @@ util.inspect(process);
'12 45 78 01 34 67 90 23 56 89 12345678901234567 0', '12 45 78 01 34 67 90 23 56 89 12345678901234567 0',
{ compact: false, breakLength: 3 }); { compact: false, breakLength: 3 });
expect = [ expect = [
'\'12 45 78 01 34 \' +', "'12 45 78 01 34 ' +",
' \'67 90 23 56 89 \' +', " '67 90 23 56 89 ' +",
' \'12345678901234567 \' +', " '12345678901234567 ' +",
' \'0\'' " '0'"
].join('\n'); ].join('\n');
assert.strictEqual(out, expect); assert.strictEqual(out, expect);
@ -1347,7 +1347,7 @@ util.inspect(process);
o[util.inspect.custom] = () => ({ a: '12 45 78 01 34 67 90 23' }); o[util.inspect.custom] = () => ({ a: '12 45 78 01 34 67 90 23' });
out = util.inspect(o, { compact: false, breakLength: 3 }); out = util.inspect(o, { compact: false, breakLength: 3 });
expect = '{\n a: \'12 45 78 01 34 \' +\n \'67 90 23\'\n}'; expect = "{\n a: '12 45 78 01 34 ' +\n '67 90 23'\n}";
assert.strictEqual(out, expect); assert.strictEqual(out, expect);
} }