[Tests] increase coverage

Author: ljharb

package.json

@@ -9,6 +9,8 @@
     "core-js": "^2.6.12",
     "eslint": "^7.21.0",
     "for-each": "^0.3.3",
+    "functions-have-names": "^1.2.2",
+    "make-arrow-function": "^1.2.0",
     "nyc": "^10.3.2",
     "safe-publish-latest": "^1.1.4",
     "string.prototype.repeat": "^1.0.0",

test/deep.js

@@ -2,9 +2,11 @@ var inspect = require('../');
 var test = require('tape');
 
 test('deep', function (t) {
-    t.plan(3);
+    t.plan(4);
     var obj = [[[[[[500]]]]]];
     t.equal(inspect(obj), '[ [ [ [ [ [Array] ] ] ] ] ]');
     t.equal(inspect(obj, { depth: 4 }), '[ [ [ [ [Array] ] ] ] ]');
     t.equal(inspect(obj, { depth: 2 }), '[ [ [Array] ] ]');
+
+    t.equal(inspect([[[{ a: 1 }]]], { depth: 3 }), '[ [ [ [Object] ] ] ]');
 });

test/fn.js

@@ -1,5 +1,7 @@
 var inspect = require('../');
 var test = require('tape');
+var arrow = require('make-arrow-function')();
+var functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames();
 
 test('function', function (t) {
     t.plan(1);
@@ -26,3 +28,49 @@ test('anon function', function (t) {
 
     t.end();
 });
+
+test('arrow function', { skip: !arrow }, function (t) {
+    t.equal(inspect(arrow), '[Function (anonymous)]');
+
+    t.end();
+});
+
+test('truly nameless function', { skip: !arrow || !functionsHaveConfigurableNames }, function (t) {
+    function f() {}
+    Object.defineProperty(f, 'name', { value: false });
+    t.equal(f.name, false);
+    t.equal(
+        inspect(f),
+        '[Function: f]',
+        'named function with falsy `.name` does not hide its original name'
+    );
+
+    function g() {}
+    Object.defineProperty(g, 'name', { value: true });
+    t.equal(g.name, true);
+    t.equal(
+        inspect(g),
+        '[Function: true]',
+        'named function with truthy `.name` hides its original name'
+    );
+
+    var anon = function () {}; // eslint-disable-line func-style
+    Object.defineProperty(anon, 'name', { value: null });
+    t.equal(anon.name, null);
+    t.equal(
+        inspect(anon),
+        '[Function (anonymous)]',
+        'anon function with falsy `.name` does not hide its anonymity'
+    );
+
+    var anon2 = function () {}; // eslint-disable-line func-style
+    Object.defineProperty(anon2, 'name', { value: 1 });
+    t.equal(anon2.name, 1);
+    t.equal(
+        inspect(anon2),
+        '[Function: 1]',
+        'anon function with truthy `.name` hides its anonymity'
+    );
+
+    t.end();
+});

test/inspect.js

@@ -6,11 +6,16 @@ var repeat = require('string.prototype.repeat');
 var inspect = require('..');
 
 test('inspect', function (t) {
-    t.plan(3);
+    t.plan(4);
     var obj = [{ inspect: function xyzInspect() { return '!XYZ¡'; } }, []];
     t.equal(inspect(obj), '[ !XYZ¡, [] ]');
     t.equal(inspect(obj, { customInspect: true }), '[ !XYZ¡, [] ]');
     t.equal(inspect(obj, { customInspect: false }), '[ { inspect: [Function: xyzInspect] }, [] ]');
+    t['throws'](
+        function () { inspect(obj, { customInspect: 'not a boolean' }); },
+        TypeError,
+        '`customInspect` must be a boolean'
+    );
 });
 
 test('inspect custom symbol', { skip: !hasSymbols || !utilInspect || !utilInspect.custom }, function (t) {
@@ -43,11 +48,31 @@ test('symbols', { skip: !hasSymbols }, function (t) {
 });
 
 test('maxStringLength', function (t) {
+    t['throws'](
+        function () { inspect('', { maxStringLength: -1 }); },
+        TypeError,
+        'maxStringLength must be >= 0, or Infinity, not negative'
+    );
+
+    var str = repeat('a', 1e8);
+
     t.equal(
-        inspect([repeat('a', 1e8)], { maxStringLength: 10 }),
+        inspect([str], { maxStringLength: 10 }),
         '[ \'aaaaaaaaaa\'... 99999990 more characters ]',
         'maxStringLength option limits output'
     );
 
+    t.equal(
+        inspect(['f'], { maxStringLength: null }),
+        '[ \'\'... 1 more character ]',
+        'maxStringLength option accepts `null`'
+    );
+
+    t.equal(
+        inspect([str], { maxStringLength: Infinity }),
+        '[ \'' + str + '\' ]',
+        'maxStringLength option accepts ∞'
+    );
+
     t.end();
 });