Lines Matching refs:util
27 const util = require('util'); constant
31 const { inspect } = util;
34 assert.strictEqual(util.inspect(1), '1');
35 assert.strictEqual(util.inspect(false), 'false');
36 assert.strictEqual(util.inspect(''), "''");
37 assert.strictEqual(util.inspect('hello'), "'hello'");
38 assert.strictEqual(util.inspect(function abc() {}), '[Function: abc]');
39 assert.strictEqual(util.inspect(() => {}), '[Function (anonymous)]');
41 util.inspect(async function() {}),
44 assert.strictEqual(util.inspect(async () => {}), '[AsyncFunction (anonymous)]');
50 util.inspect(fn),
54 util.inspect(async function* abc() {}),
59 util.inspect(fn),
64 util.inspect(fn),
72 util.inspect({ ['5']: fn }),
78 util.inspect(fn),
82 util.inspect({ ['5']: fn }),
87 assert.strictEqual(util.inspect(undefined), 'undefined');
88 assert.strictEqual(util.inspect(null), 'null');
89 assert.strictEqual(util.inspect(/foo(bar\n)?/gi), '/foo(bar\\n)?/gi');
91 util.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')),
94 assert.strictEqual(util.inspect(new Date('')), (new Date('')).toString());
95 assert.strictEqual(util.inspect('\n\x01'), "'\\n\\x01'");
97 util.inspect(`${Array(75).fill(1)}'\n\x1d\n\x03\x85\x7f\x7e\x9f\xa0`),
101 assert.strictEqual(util.inspect([]), '[]');
102 assert.strictEqual(util.inspect(Object.create([])), 'Array {}');
103 assert.strictEqual(util.inspect([1, 2]), '[ 1, 2 ]');
104 assert.strictEqual(util.inspect([1, [2, 3]]), '[ 1, [ 2, 3 ] ]');
105 assert.strictEqual(util.inspect({}), '{}');
106 assert.strictEqual(util.inspect({ a: 1 }), '{ a: 1 }');
107 assert.strictEqual(util.inspect({ a: function() {} }), '{ a: [Function: a] }');
108 assert.strictEqual(util.inspect({ a: () => {} }), '{ a: [Function: a] }');
110 assert.strictEqual(util.inspect({ a: async function abc() {} }),
112 assert.strictEqual(util.inspect({ a: async () => {} }),
114 assert.strictEqual(util.inspect({ a: function*() {} }),
116 assert.strictEqual(util.inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
117 assert.strictEqual(util.inspect({ 'a': {} }), '{ a: {} }');
118 assert.strictEqual(util.inspect({ 'a': { 'b': 2 } }), '{ a: { b: 2 } }');
119 assert.strictEqual(util.inspect({ 'a': { 'b': { 'c': { 'd': 2 } } } }),
122 util.inspect({ 'a': { 'b': { 'c': { 'd': 2 } } } }, false, null),
124 assert.strictEqual(util.inspect([1, 2, 3], true), '[ 1, 2, 3, [length]: 3 ]');
125 assert.strictEqual(util.inspect({ 'a': { 'b': { 'c': 2 } } }, false, 0),
127 assert.strictEqual(util.inspect({ 'a': { 'b': { 'c': 2 } } }, false, 1),
129 assert.strictEqual(util.inspect({ 'a': { 'b': ['c'] } }, false, 1),
131 assert.strictEqual(util.inspect(new Uint8Array(0)), 'Uint8Array(0) []');
134 util.inspect(
143 util.inspect(
150 assert.match(util.inspect((new JSStream())._externalStream),
156 assert.strictEqual(util.inspect({ a: regexp }, false, 0), '{ a: /regexp/ }');
160 util.inspect({ a: { a: { a: { a: {} } } } }, undefined, undefined, true)
163 util.inspect({ a: { a: { a: { a: {} } } } }, undefined, null, true)
171 util.inspect(ab, showHidden),
174 assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
181 util.inspect(ab, showHidden),
184 assert.strictEqual(util.inspect(dv, showHidden),
192 assert.strictEqual(util.inspect(ab, showHidden),
195 assert.strictEqual(util.inspect(dv, showHidden),
209 assert.strictEqual(util.inspect(ab),
216 assert.strictEqual(util.inspect(ab, { showHidden: true, maxArrayLength: 2 }),
219 assert.strictEqual(util.inspect(ab, { showHidden: true, maxArrayLength: 1 }),
230 util.inspect(ab, showHidden),
233 assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
240 util.inspect(ab, showHidden),
243 assert.strictEqual(util.inspect(dv, showHidden),
251 assert.strictEqual(util.inspect(ab, showHidden),
254 assert.strictEqual(util.inspect(dv, showHidden),
278 util.inspect(array, { showHidden: true }),
288 util.inspect(array, false),
312 util.inspect(array, true),
322 util.inspect(array, false),
334 util.inspect(Object.create({}, {
342 util.inspect(Object.create(null, {
350 util.inspect(Object.create(null, {
360 util.inspect({ get readonly() { return 1; } }),
364 util.inspect({ get readwrite() { return 1; }, set readwrite(val) {} }),
369 util.inspect({ set writeonly(val) {} }),
374 assert.strictEqual(util.inspect(value), '<ref *1> { a: [Circular *1] }');
381 util.inspect(getterFn, { getters: true }),
405 assert.strictEqual(util.inspect(value),
418 util.inspect(arr),
422 util.inspect(arr, { showHidden: true }),
437 assert.strictEqual(util.inspect(arr),
441 assert.strictEqual(util.inspect([], { showHidden: true }), '[ [length]: 0 ]');
443 assert.strictEqual(util.inspect(arr2), "[ '00': 1 ]");
444 assert.strictEqual(util.inspect(arr2, { showHidden: true }),
447 assert.strictEqual(util.inspect(arr2), "[ <1 empty item>, 0, '00': 1 ]");
448 assert.strictEqual(util.inspect(arr2, { showHidden: true }),
451 assert.strictEqual(util.inspect(arr2), "[ <2 empty items>, '00': 1 ]");
452 assert.strictEqual(util.inspect(arr2, { showHidden: true }),
455 assert.strictEqual(util.inspect(arr2),
457 assert.strictEqual(util.inspect(arr2, { showHidden: true }),
461 assert.strictEqual(util.inspect(arr2),
463 assert.strictEqual(util.inspect(arr2, { showHidden: true }),
469 util.inspect(arr2),
475 assert.strictEqual(util.inspect(arr3), "[ '-1': -1 ]");
482 assert.strictEqual(util.inspect(arr), "[ '4294967296': true ]");
485 assert.strictEqual(util.inspect(arr),
492 assert.strictEqual(util.inspect(arr),
506 assert.strictEqual(util.inspect(value), '[Function: value] { aprop: 42 }');
514 util.inspect(value),
523 assert.strictEqual(util.inspect(value), '/123/gi { aprop: 42 }');
530 assert.strictEqual(util.inspect(value),
538 const orig = util.inspect(d);
540 const after = util.inspect(d);
545 assert.strictEqual(util.inspect(0), '0');
546 assert.strictEqual(util.inspect(-0), '-0');
548 assert.strictEqual(util.inspect(-5e-324), '-5e-324');
553 assert.strictEqual(util.inspect(a), "[ 'foo', 'bar', 'baz' ]");
555 assert.strictEqual(util.inspect(a), "[ 'foo', <1 empty item>, 'baz' ]");
557 util.inspect(a, true),
560 assert.strictEqual(util.inspect(new Array(5)), '[ <5 empty items> ]');
564 util.inspect(a, { breakLength: Infinity }),
569 util.inspect(a, { maxArrayLength: 4 }),
573 assert.strictEqual(util.inspect(a, {
588 assert.strictEqual(util.inspect(valsSetIterator), '[ 1, 2 ]');
589 assert.strictEqual(util.inspect(valsMapIterEntries), '[ [ 1, 2 ], true ]');
590 assert.strictEqual(util.inspect(valsMapIterKeys), '[ [ 1 ], false ]');
596 assert.strictEqual(util.inspect(obj), '{}');
598 assert.strictEqual(util.inspect(obj), 'Map(1) { 1 => 2 }');
600 assert.strictEqual(util.inspect(obj), 'Set(2) { 1, 2 }');
602 assert.strictEqual(util.inspect(obj), 'Promise { <pending> }');
624 util.inspect(getter, true),
628 util.inspect(setter, true),
632 util.inspect(getterAndSetter, true),
645 assert.strictEqual(util.inspect(err), err.stack);
650 assert.strictEqual(util.inspect(e), e.stack);
655 const ex = util.inspect(new Error('FAIL'), true);
666 assert.strictEqual(util.inspect(err, { compact: true }), '[Error: foo]');
670 assert.strictEqual(util.inspect(err, { compact: true }), '[Error: foo]');
672 util.inspect(err2, { compact: true }),
680 util.inspect(err, { compact: true }),
684 util.inspect(err2, { compact: true }),
688 util.inspect(err, { compact: true, breakLength: 5 }),
692 util.inspect(err, { compact: true, breakLength: 1 }),
696 util.inspect(err2, { compact: true, breakLength: 5 }),
700 util.inspect(err, { compact: false }),
704 util.inspect(err2, { compact: false }),
715 let out = util.inspect(err).split('\n');
723 out = util.inspect(err).split('\n');
727 out = util.inspect(err).split('\n');
745 util.inspect(new BadCustomError('foo')),
766 util.inspect(err).startsWith(outputStart),
767 util.format(
776 assert.strictEqual(util.inspect(err), stack);
780 assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
786 util.inspect(d);
793 util.inspect(d);
800 util.inspect(r);
805 const x = { [util.inspect.custom]: util.inspect };
806 assert(util.inspect(x).includes(
827 util.inspect(w),
832 util.inspect(y),
841 const colorName = util.inspect.styles[style];
843 if (util.inspect.colors[colorName])
844 color = util.inspect.colors[colorName];
846 const withoutColor = util.inspect(input, false, 0, false);
847 const withColor = util.inspect(input, false, 0, true);
866 util.inspect({ hasOwnProperty: null });
874 util.inspect(subject, { showHidden: false }).includes('hidden'),
878 util.inspect(subject, { showHidden: true }).includes('hidden'),
882 util.inspect(subject, { colors: false }).includes('\u001b[32m'),
886 util.inspect(subject, { colors: true }).includes('\u001b[32m'),
890 util.inspect(subject, { depth: 2 }).includes('c: [Object]'),
894 util.inspect(subject, { depth: 0 }).includes('a: [Object]'),
898 util.inspect(subject, { depth: null }).includes('{ d: 0 }'),
902 util.inspect(subject, { depth: undefined }).includes('{ d: 0 }'),
909 const subject = { [util.inspect.custom]: () => 123 };
912 util.inspect(subject, { customInspect: true }).includes('123'),
916 util.inspect(subject, { customInspect: true }).includes('inspect'),
920 util.inspect(subject, { customInspect: false }).includes('123'),
924 util.inspect(subject, { customInspect: false }).includes('inspect'),
929 subject[util.inspect.custom] = () => ({ foo: 'bar' });
931 assert.strictEqual(util.inspect(subject), "{ foo: 'bar' }");
933 subject[util.inspect.custom] = common.mustCall((depth, opts) => {
944 new Set(Object.keys(util.inspect.defaultOptions).concat(['stylize'])),
948 return { [util.inspect.custom]: common.mustCall((depth, opts2) => {
953 util.inspect(subject);
961 assert.strictEqual(util.inspect(subject), '{ baz: \'quux\' }');
969 util.inspect(subject, { customInspectOptions: true, seen: null });
973 const subject = { [util.inspect.custom]: common.mustCall((depth, opts) => {
977 util.inspect(subject, { depth: null, compact: true });
982 const subject = { a: 123, [util.inspect.custom]() { return this; } };
985 util.inspect(subject),
992 util.inspect([1, 2, 3], { stylize() { return 'x'; } }),
1001 const withoutColor = util.inspect(input);
1002 const withColor = util.inspect(input, { colors: true });
1022 assert.strictEqual(util.inspect(new String('test')), "[String: 'test']");
1024 util.inspect(new String('test'), { colors: true }),
1028 util.inspect(Object(Symbol('test'))),
1031 assert.strictEqual(util.inspect(new Boolean(false)), '[Boolean: false]');
1033 util.inspect(Object.setPrototypeOf(new Boolean(true), null)),
1036 assert.strictEqual(util.inspect(new Number(0)), '[Number: 0]');
1038 util.inspect(
1047 assert.strictEqual(util.inspect(new Number(-1.1)), '[Number: -1.1]');
1048 assert.strictEqual(util.inspect(new Number(13.37)), '[Number: 13.37]');
1054 assert.strictEqual(util.inspect(str), "[String: 'baz'] { foo: 'bar' }");
1058 assert.strictEqual(util.inspect(bool), "[Boolean: true] { foo: 'bar' }");
1062 assert.strictEqual(util.inspect(num), "[Number: 13.37] { foo: 'bar' }");
1066 assert.strictEqual(util.inspect(sym), "[Symbol: Symbol(foo)] { foo: 'bar' }");
1070 assert.strictEqual(util.inspect(big), "[BigInt: 55n] { foo: 'bar' }");
1075 assert.strictEqual(util.inspect(Symbol()), 'Symbol()');
1076 assert.strictEqual(util.inspect(Symbol(123)), 'Symbol(123)');
1077 assert.strictEqual(util.inspect(Symbol('hi')), 'Symbol(hi)');
1078 assert.strictEqual(util.inspect([Symbol()]), '[ Symbol() ]');
1079 assert.strictEqual(util.inspect({ foo: Symbol() }), '{ foo: Symbol() }');
1086 assert.strictEqual(util.inspect(subject), '{ [Symbol(sym\\nbol)]: 42 }');
1088 util.inspect(subject, options),
1096 assert.strictEqual(util.inspect(subject), '{ [Symbol(sym\\nbol)]: 42 }');
1098 util.inspect(subject, options),
1105 assert.strictEqual(util.inspect(subject),
1111 assert.strictEqual(util.inspect(new Set()), 'Set(0) {}');
1112 assert.strictEqual(util.inspect(new Set([1, 2, 3])), 'Set(3) { 1, 2, 3 }');
1116 util.inspect(set, { showHidden: true }),
1125 assert.strictEqual(util.inspect(set), '<ref *1> Set(1) { [Circular *1] }');
1130 assert.strictEqual(util.inspect(new Map()), 'Map(0) {}');
1131 assert.strictEqual(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
1135 assert.strictEqual(util.inspect(map, true),
1180 assert.strictEqual(util.inspect(resolved), 'Promise { 3 }');
1183 assert.strictEqual(util.inspect(rejected), 'Promise { <rejected> 3 }');
1188 assert.strictEqual(util.inspect(pending), 'Promise { <pending> }');
1192 assert.strictEqual(util.inspect(promiseWithProperty),
1202 assert.strictEqual(util.inspect(new Promise()), '{ bar: 42 }');
1209 assert.strictEqual(util.inspect(map.keys()), '[Map Iterator] { \'foo\' }');
1213 util.inspect(mapValues),
1217 assert.strictEqual(util.inspect(map.entries(), { maxArrayLength: 1 }),
1221 assert.strictEqual(util.inspect(keys), "[Map Iterator] { 'foo', 'A' }");
1222 assert.strictEqual(util.inspect(keys), "[Map Iterator] { 'foo', 'A' }");
1225 util.inspect(keys, { maxArrayLength: 0 }),
1232 assert.strictEqual(util.inspect(aSet.entries(), { compact: false }),
1235 assert.strictEqual(util.inspect(aSet.keys()), '[Set Iterator] { 1, 3 }');
1236 assert.strictEqual(util.inspect(aSet.values()), '[Set Iterator] { 1, 3 }');
1239 assert.strictEqual(util.inspect(setEntries),
1244 assert.strictEqual(util.inspect(keys), '[Set Iterator] { 1, 3 }');
1245 assert.strictEqual(util.inspect(keys), '[Set Iterator] { 1, 3 }');
1248 util.inspect(keys, { maxArrayLength: 1 }),
1297 const lines = util.inspect(container).split('\n');
1341 assert.strictEqual(util.inspect(x),
1343 assert.strictEqual(util.inspect(new ArraySubclass(1, 2, 3)),
1345 assert.strictEqual(util.inspect(new SetSubclass([1, 2, 3])),
1347 assert.strictEqual(util.inspect(new MapSubclass([['foo', 42]])),
1349 assert.strictEqual(util.inspect(new PromiseSubclass(() => {})),
1352 util.inspect({ a: { b: new ArraySubclass([1, [2], 3]) } }, { depth: 1 }),
1356 util.inspect(Object.setPrototypeOf(x, null)),
1364 assert.strictEqual(util.inspect(arr), '[ [ [ [] ] ] ]');
1366 assert.strictEqual(util.inspect(arr), '[ [ [ [Array] ] ] ]');
1368 assert.strictEqual(util.inspect(arr), '[ [ [ {} ] ] ]');
1370 assert.strictEqual(util.inspect(arr), '[ [ [ [Object] ] ] ]');
1372 assert.strictEqual(util.inspect(arr), '<ref *1> [ [ [ [Circular *1] ] ] ]');
1374 assert.strictEqual(util.inspect(arr), '[ [ <ref *1> [ [Circular *1] ] ] ]');
1380 assert.strictEqual(util.inspect(x), '{ constructor: 42 }');
1391 assert.strictEqual(util.inspect(x), '{ constructor: [Getter] }');
1396 assert.strictEqual(util.inspect(x), '{}');
1401 assert.strictEqual(util.inspect(x), '[Object: null prototype] {}');
1407 assert.strictEqual(util.inspect(x), "[ '': 1 ]");
1415 assert(util.inspect(x).endsWith('1 more item\n]'));
1416 assert(!util.inspect(x, { maxArrayLength: 101 }).endsWith('1 more item\n]'));
1418 util.inspect(x, { maxArrayLength: -1 }),
1421 assert.strictEqual(util.inspect(x, { maxArrayLength: 0 }),
1427 assert.strictEqual(util.inspect(x, { maxArrayLength: 0 }),
1429 assert(!util.inspect(x, { maxArrayLength: null }).endsWith('1 more item\n]'));
1430 assert(!util.inspect(
1437 assert(util.inspect(x).endsWith('1 more item\n]'));
1438 assert(!util.inspect(x, { maxArrayLength: 101 }).includes('1 more item'));
1439 assert.strictEqual(util.inspect(x, { maxArrayLength: 0 }),
1441 assert(!util.inspect(x, { maxArrayLength: null }).includes('1 more item'));
1442 assert(util.inspect(x, { maxArrayLength: Infinity }).endsWith(' 0, 0\n]'));
1447 const oneLine = util.inspect(obj, { breakLength: Infinity });
1451 const twoLines = util.inspect(obj, { breakLength: breakpoint });
1455 util.inspect(obj, { breakLength: breakpoint + 1 }),
1466 const oldOptions = { ...util.inspect.defaultOptions };
1469 util.inspect.defaultOptions.maxArrayLength = null;
1470 assert(!/1 more item/.test(util.inspect(arr)));
1471 util.inspect.defaultOptions.maxArrayLength = oldOptions.maxArrayLength;
1472 assert(/1 more item/.test(util.inspect(arr)));
1473 util.inspect.defaultOptions.depth = null;
1474 assert(!/Object/.test(util.inspect(obj)));
1475 util.inspect.defaultOptions.depth = oldOptions.depth;
1476 assert(/Object/.test(util.inspect(obj)));
1478 JSON.stringify(util.inspect.defaultOptions),
1483 util.inspect.defaultOptions = { maxArrayLength: null, depth: 2 };
1484 assert(!/1 more item/.test(util.inspect(arr)));
1485 assert(/Object/.test(util.inspect(obj)));
1486 util.inspect.defaultOptions = oldOptions;
1487 assert(/1 more item/.test(util.inspect(arr)));
1488 assert(/Object/.test(util.inspect(obj)));
1490 JSON.stringify(util.inspect.defaultOptions),
1495 util.inspect.defaultOptions = null;
1505 util.inspect.defaultOptions = 'bad';
1515 util.inspect(process);
1519 const obj = { [util.inspect.custom]: 'fhqwhgads' };
1521 util.inspect(obj),
1530 util.inspect(obj),
1537 assert.strictEqual(util.inspect(obj), 'Object [a] {}');
1539 util.inspect(obj, { showHidden: true }),
1553 assert.strictEqual(util.inspect(
1557 assert.strictEqual(util.inspect(new Foo()), "Foo [bar] { foo: 'bar' }");
1560 util.inspect(new (class extends Foo {})()),
1564 util.inspect(Object.create(Object.create(Foo.prototype), {
1575 assert.throws(() => util.inspect(new ThrowingClass()), /toStringTag error/);
1583 assert.strictEqual(util.inspect(new NotStringClass()),
1597 let out = util.inspect(o, { compact: true, depth: 5, breakLength: 80 });
1611 out = util.inspect(o, { compact: false, depth: 5, breakLength: 60 });
1636 out = util.inspect(o.a[2][0][0], { compact: false, breakLength: 30 });
1644 out = util.inspect(
1650 out = util.inspect(
1660 out = util.inspect(o, { compact: false, breakLength: 3 });
1669 out = util.inspect(o, { compact: false, breakLength: 3, showHidden: true });
1681 o[util.inspect.custom] = () => 42;
1682 out = util.inspect(o, { compact: false, breakLength: 3 });
1686 o[util.inspect.custom] = () => '12 45 78 01 34 67 90 23';
1687 out = util.inspect(o, { compact: false, breakLength: 3 });
1691 o[util.inspect.custom] = () => ({ a: '12 45 78 01 34 67 90 23' });
1692 out = util.inspect(o, { compact: false, breakLength: 3 });
1706 let out = util.inspect(map, { compact: false, showHidden: true, depth: 9 });
1760 out = util.inspect(map, { compact: 2, showHidden: true, depth: 9 });
1799 out = util.inspect(map, {
1845 let out = util.inspect(weakMap, { showHidden: true });
1849 out = util.inspect(weakMap);
1853 out = util.inspect(weakMap, { maxArrayLength: 0, showHidden: true });
1858 out = util.inspect(weakMap, { maxArrayLength: 1, showHidden: true });
1869 out = util.inspect(weakSet, { showHidden: true });
1873 out = util.inspect(weakSet);
1877 out = util.inspect(weakSet, { maxArrayLength: -2, showHidden: true });
1882 out = util.inspect(weakSet, { maxArrayLength: 1, showHidden: true });
1895 assert.strictEqual(util.inspect(args), "[Arguments] { '0': 'a' }");
1907 util.inspect(list),
1910 const longList = util.inspect(list, { depth: Infinity });
1918 assert.strictEqual(util.inspect("'"), '"\'"');
1919 assert.strictEqual(util.inspect('"\''), '`"\'`');
1921 assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
1940 util.inspect(foo).startsWith(
1942 util.inspect(foo)
1952 util.inspect(foo),
1957 util.inspect(foo).startsWith(
1959 util.inspect(foo)
1963 util.inspect(foo).startsWith(
1966 util.inspect(foo)
1971 util.inspect(foo).startsWith(
1973 util.inspect(foo)
1977 util.inspect(foo),
1982 util.inspect(foo),
2006 const inspected = util.inspect(clazz);
2018 util.inspect(clazz),
2027 util.inspect(clazz),
2032 util.inspect(clazz),
2037 assert.strictEqual(util.inspect(clazz), res);
2039 assert.strictEqual(util.inspect(clazz), `${res} { foo: true }`);
2047 util.inspect(obj),
2052 util.inspect(obj),
2057 util.inspect(obj),
2063 util.inspect(Foo),
2069 util.inspect(fn),
2107 assert.strictEqual(util.inspect(value), expected);
2109 assert.notStrictEqual(util.inspect(value), expected);
2112 assert.notStrictEqual(util.inspect(value), expected);
2147 util.inspect(Object.setPrototypeOf(value, null)),
2151 assert.notStrictEqual(util.inspect(value), expected);
2154 assert.notStrictEqual(util.inspect(value), expected);
2175 assert.strictEqual(util.inspect(value), expected);
2177 assert.notStrictEqual(util.inspect(value), expected);
2180 util.inspect(Object.setPrototypeOf(value, null)),
2184 let res = util.inspect(value);
2189 res = util.inspect(value);
2206 util.inspect(obj, { showHidden: true }),
2309 util.inspect(obj),
2313 util.inspect(obj, { colors: true }),
2323 util.inspect(obj),
2330 util.inspect(new StorageObject()),
2351 util.inspect(new StorageObject()),
2355 util.inspect(new StorageObject(), { depth: 1 }),
2369 assert.strictEqual(util.inspect(obj), '[Set(2): null prototype] { 1, 2 }');
2380 util.inspect(obj),
2447 let out = util.inspect(obj, { compact: 3, depth: 10, breakLength: 60 });
2537 out = util.inspect(obj, { compact: 3 });
2559 out = util.inspect(obj, { compact: 3 });
2589 out = util.inspect(obj, { compact: 1, breakLength: Infinity, colors: true });
2609 out = util.inspect(obj, { compact: 1, breakLength: Infinity, colors: true });
2635 out = util.inspect([1, 2, 3, 4], { compact: 1, colors: true });
2681 out = util.inspect(
2751 util.inspect(err, { colors: true }).split('\n').forEach((line, i) => {
2765 util.inspect(err, { colors: true }).split('\n').forEach((line, i) => {
2774 const actualDepth0 = util.inspect({ trace }, { depth: 0 });
2776 const actualDepth1 = util.inspect({ trace }, { depth: 1 });
2803 [util.inspect.custom]() {
2814 [util.inspect.custom]() {
2893 assert.strictEqual(util.inspect(object), '{ constructor: [Function: Func] }');
2898 const colors = util.inspect.colors;
2931 assert.strictEqual(util.inspect('bl', { maxStringLength: 1 }),
2938 util.inspect(x, { maxStringLength: 4 }),
2941 assert.match(util.inspect(x, { maxStringLength: null }), /a'$/);
2950 [Symbol.for('nodejs.util.inspect.custom')](depth, ctx) {
3065 util.inspect(generator, { showHidden: true }),
3083 util.inspect(obj, { breakLength: 256 }),
3100 util.inspect({ ['__proto__']: { a: 1 } }),