buffer: improve error messages

Some errors in buffer module losed some arguments or received
wrong arguments when they were created. This PR added these
losing arguments and fixed the wrong arguments.

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