buffer: improve error messages

lib/buffer.js

@@ -224,7 +224,8 @@ Buffer.from = function from(value, encodingOrOffset, length) {
   throw new errors.TypeError(
     'ERR_INVALID_ARG_TYPE',
     'first argument',
-    ['string', 'buffer', 'arrayBuffer', 'array', 'array-like object']
+    ['string', 'buffer', 'arrayBuffer', 'array', 'array-like object'],
+    value
   );
 };
 
@@ -507,7 +508,8 @@ function byteLength(string, encoding) {
     }
 
     throw new errors.TypeError(
-      'ERR_INVALID_ARG_TYPE', 'string', ['string', 'buffer', 'arrayBuffer']
+      'ERR_INVALID_ARG_TYPE', 'string',
+      ['string', 'buffer', 'arrayBuffer'], string
     );
   }
 
@@ -668,7 +670,8 @@ Buffer.prototype.toString = function toString(encoding, start, end) {
 Buffer.prototype.equals = function equals(b) {
   if (!isUint8Array(b)) {
     throw new errors.TypeError(
-      'ERR_INVALID_ARG_TYPE', 'otherBuffer', ['buffer', 'uint8Array']
+      'ERR_INVALID_ARG_TYPE', 'otherBuffer',
+      ['buffer', 'uint8Array'], b
     );
   }
   if (this === b)
@@ -696,7 +699,8 @@ Buffer.prototype.compare = function compare(target,
                                             thisEnd) {
   if (!isUint8Array(target)) {
     throw new errors.TypeError(
-      'ERR_INVALID_ARG_TYPE', 'target', ['buffer', 'uint8Array']
+      'ERR_INVALID_ARG_TYPE', 'target',
+      ['buffer', 'uint8Array'], target
     );
   }
   if (arguments.length === 1)
@@ -778,7 +782,8 @@ function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
   }
 
   throw new errors.TypeError(
-    'ERR_INVALID_ARG_TYPE', 'val', ['string', 'buffer', 'uint8Array']
+    'ERR_INVALID_ARG_TYPE', 'value',
+    ['string', 'buffer', 'uint8Array'], val
   );
 }
 
@@ -847,7 +852,8 @@ Buffer.prototype.fill = function fill(val, start, end, encoding) {
     }
 
     if (encoding !== undefined && typeof encoding !== 'string') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'encoding', 'string');
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'encoding',
+                                 'string', encoding);
     }
     var normalizedEncoding = normalizeEncoding(encoding);
     if (normalizedEncoding === undefined) {

test/parallel/test-buffer-bytelength.js

@@ -5,17 +5,22 @@ const assert = require('assert');
 const SlowBuffer = require('buffer').SlowBuffer;
 const vm = require('vm');
 
-// coerce values to string
-const errMsg = common.expectsError({
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "string" argument must be one of type string, ' +
-           'buffer, or arrayBuffer'
-}, 4);
-assert.throws(() => { Buffer.byteLength(32, 'latin1'); }, errMsg);
-assert.throws(() => { Buffer.byteLength(NaN, 'utf8'); }, errMsg);
-assert.throws(() => { Buffer.byteLength({}, 'latin1'); }, errMsg);
-assert.throws(() => { Buffer.byteLength(); }, errMsg);
+[
+  [32, 'latin1'],
+  [NaN, 'utf8'],
+  [{}, 'latin1'],
+  []
+].forEach((args) => {
+  common.expectsError(
+    () => Buffer.byteLength(...args),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "string" argument must be one of type string, ' +
+               `buffer, or arrayBuffer. Received type ${typeof args[0]}`
+    }
+  );
+});
 
 assert.strictEqual(Buffer.byteLength('', undefined, true), -1);
 

test/parallel/test-buffer-compare-offset.js

@@ -69,5 +69,6 @@ assert.throws(() => a.compare(b, -Infinity, Infinity), oor);
 assert.throws(() => a.compare(), common.expectsError({
   code: 'ERR_INVALID_ARG_TYPE',
   type: TypeError,
-  message: 'The "target" argument must be one of type buffer or uint8Array'
+  message: 'The "target" argument must be one of ' +
+           'type buffer or uint8Array. Received type undefined'
 }));

test/parallel/test-buffer-compare.js

@@ -41,5 +41,6 @@ assert.throws(() => Buffer.compare('abc', Buffer.alloc(1)), errMsg);
 assert.throws(() => Buffer.alloc(1).compare('abc'), common.expectsError({
   code: 'ERR_INVALID_ARG_TYPE',
   type: TypeError,
-  message: 'The "target" argument must be one of type buffer or uint8Array'
+  message: 'The "target" argument must be one of ' +
+           'type buffer or uint8Array. Received type string'
 }));

test/parallel/test-buffer-equals.js

@@ -14,10 +14,12 @@ assert.ok(!d.equals(e));
 assert.ok(d.equals(d));
 assert.ok(d.equals(new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65])));
 
-assert.throws(() => Buffer.alloc(1).equals('abc'),
-              common.expectsError({
-                code: 'ERR_INVALID_ARG_TYPE',
-                type: TypeError,
-                message: 'The "otherBuffer" argument must be one of type ' +
-                         'buffer or uint8Array'
-              }));
+common.expectsError(
+  () => Buffer.alloc(1).equals('abc'),
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message: 'The "otherBuffer" argument must be one of type ' +
+    'buffer or uint8Array. Received type string'
+  }
+);

test/parallel/test-buffer-fill.js

@@ -192,45 +192,49 @@ deepStrictEqualValues(genBuffer(4, [hexBufFill, 1, -1]), [0, 0, 0, 0]);
 
 
 // Check exceptions
-assert.throws(
-  () => buf1.fill(0, -1),
-  common.expectsError({ code: 'ERR_INDEX_OUT_OF_RANGE' }));
-assert.throws(
-  () => buf1.fill(0, 0, buf1.length + 1),
-  common.expectsError({ code: 'ERR_INDEX_OUT_OF_RANGE' }));
-assert.throws(
-  () => buf1.fill('', -1),
-  common.expectsError({ code: 'ERR_INDEX_OUT_OF_RANGE' }));
-assert.throws(
-  () => buf1.fill('', 0, buf1.length + 1),
-  common.expectsError({ code: 'ERR_INDEX_OUT_OF_RANGE' }));
-assert.throws(
+[
+  [0, -1],
+  [0, 0, buf1.length + 1],
+  ['', -1],
+  ['', 0, buf1.length + 1]
+].forEach((args) => {
+  common.expectsError(
+    () => buf1.fill(...args),
+    { code: 'ERR_INDEX_OUT_OF_RANGE' }
+  );
+});
+
+common.expectsError(
   () => buf1.fill('a', 0, buf1.length, 'node rocks!'),
-  common.expectsError({
+  {
     code: 'ERR_UNKNOWN_ENCODING',
     type: TypeError,
     message: 'Unknown encoding: node rocks!'
-  }));
-assert.throws(
-  () => buf1.fill('a', 0, 0, NaN),
-  common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "encoding" argument must be of type string'
-  }));
-assert.throws(
-  () => buf1.fill('a', 0, 0, null),
-  common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "encoding" argument must be of type string'
-  }));
-assert.throws(
+  }
+);
+
+[
+  ['a', 0, 0, NaN],
+  ['a', 0, 0, null]
+].forEach((args) => {
+  common.expectsError(
+    () => buf1.fill(...args),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: 'The "encoding" argument must be of type ' +
+      `string. Received type ${args[3] === null ? 'null' : typeof args[3]}`
+    }
+  );
+});
+
+common.expectsError(
   () => buf1.fill('a', 0, 0, 'foo'),
-  common.expectsError({
+  {
     code: 'ERR_UNKNOWN_ENCODING',
     type: TypeError,
     message: 'Unknown encoding: foo'
-  }));
-
+  }
+);
 
 function genBuffer(size, args) {
   const b = Buffer.allocUnsafe(size);

test/parallel/test-buffer-from.js

@@ -36,18 +36,19 @@ deepStrictEqual(
 );
 
 [
-  {},
-  new Boolean(true),
-  { valueOf() { return null; } },
-  { valueOf() { return undefined; } },
-  { valueOf: null },
-  Object.create(null)
-].forEach((input) => {
+  [{}, 'object'],
+  [new Boolean(true), 'boolean'],
+  [{ valueOf() { return null; } }, 'object'],
+  [{ valueOf() { return undefined; } }, 'object'],
+  [{ valueOf: null }, 'object'],
+  [Object.create(null), 'object']
+].forEach(([input, actualType]) => {
   const err = common.expectsError({
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
     message: 'The first argument must be one of type string, buffer, ' +
-    'arrayBuffer, array, or array-like object'
+             'arrayBuffer, array, or array-like object. Received ' +
+             `type ${actualType}`
   });
   throws(() => Buffer.from(input), err);
 });

test/parallel/test-buffer-includes.js

@@ -148,7 +148,7 @@ assert(twoByteString.includes(
 assert(!twoByteString.includes('\u03a3', -2, 'ucs2'));
 
 const mixedByteStringUcs2 =
-    Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2');
+  Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2');
 assert(mixedByteStringUcs2.includes('bc', 0, 'ucs2'));
 assert(mixedByteStringUcs2.includes('\u03a3', 0, 'ucs2'));
 assert(!mixedByteStringUcs2.includes('\u0396', 0, 'ucs2'));
@@ -261,7 +261,7 @@ for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
     const length = lengths[lengthIndex];
 
     const patternBufferUcs2 =
-        allCharsBufferUcs2.slice(index, index + length);
+      allCharsBufferUcs2.slice(index, index + length);
     assert.ok(
       allCharsBufferUcs2.includes(patternBufferUcs2, 0, 'ucs2'));
 
@@ -271,21 +271,21 @@ for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
   }
 }
 
-const expectedError = common.expectsError({
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "val" argument must be one of type ' +
-           'string, buffer, or uint8Array'
-}, 3);
-assert.throws(() => {
-  b.includes(() => {});
-}, expectedError);
-assert.throws(() => {
-  b.includes({});
-}, expectedError);
-assert.throws(() => {
-  b.includes([]);
-}, expectedError);
+[
+  () => { },
+  {},
+  []
+].forEach((val) => {
+  common.expectsError(
+    () => b.includes(val),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "value" argument must be one of type string, ' +
+               `buffer, or uint8Array. Received type ${typeof val}`
+    }
+  );
+});
 
 // test truncation of Number arguments to uint8
 {

test/parallel/test-buffer-indexof.js

@@ -344,24 +344,21 @@ assert.strictEqual(Buffer.from('aaaaa').indexOf('b', 'ucs2'), -1);
   }
 }
 
-const argumentExpected = common.expectsError({
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "val" argument must be one of type ' +
-           'string, buffer, or uint8Array'
-}, 3);
-
-assert.throws(() => {
-  b.indexOf(() => { });
-}, argumentExpected);
-
-assert.throws(() => {
-  b.indexOf({});
-}, argumentExpected);
-
-assert.throws(() => {
-  b.indexOf([]);
-}, argumentExpected);
+[
+  () => {},
+  {},
+  []
+].forEach((val) => {
+  common.expectsError(
+    () => b.indexOf(val),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "value" argument must be one of type string, ' +
+               `buffer, or uint8Array. Received type ${typeof val}`
+    }
+  );
+});
 
 // Test weird offset arguments.
 // The following offsets coerce to NaN or 0, searching the whole Buffer