zlib: use RangeError/TypeError consistently

jasnell · jasnell · commit b514bd231ed8 · 2017-02-17T10:37:46.000-08:00
PR-URL: #11391 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
diff --git a/lib/zlib.js b/lib/zlib.js
@@ -31,9 +31,10 @@ for (var ck = 0; ck < ckeys.length; ck++) {
   codes[codes[ckey]] = ckey;
 }
 
-function isValidFlushFlag(flag) {
-  return flag >= constants.Z_NO_FLUSH &&
-         flag <= constants.Z_BLOCK;
+function isInvalidFlushFlag(flag) {
+  return typeof flag !== 'number' ||
+         flag < constants.Z_NO_FLUSH ||
+         flag > constants.Z_BLOCK;
 
   // Covers: constants.Z_NO_FLUSH (0),
   //         constants.Z_PARTIAL_FLUSH (1),
@@ -141,11 +142,11 @@ class Zlib extends Transform {
     this._opts = opts;
     this._chunkSize = opts.chunkSize || constants.Z_DEFAULT_CHUNK;
 
-    if (opts.flush && !isValidFlushFlag(opts.flush)) {
-      throw new Error('Invalid flush flag: ' + opts.flush);
+    if (opts.flush && isInvalidFlushFlag(opts.flush)) {
+      throw new RangeError('Invalid flush flag: ' + opts.flush);
     }
-    if (opts.finishFlush && !isValidFlushFlag(opts.finishFlush)) {
-      throw new Error('Invalid flush flag: ' + opts.finishFlush);
+    if (opts.finishFlush && isInvalidFlushFlag(opts.finishFlush)) {
+      throw new RangeError('Invalid flush flag: ' + opts.finishFlush);
     }
 
     this._flushFlag = opts.flush || constants.Z_NO_FLUSH;
@@ -154,37 +155,38 @@ class Zlib extends Transform {
 
     if (opts.chunkSize) {
       if (opts.chunkSize < constants.Z_MIN_CHUNK) {
-        throw new Error('Invalid chunk size: ' + opts.chunkSize);
+        throw new RangeError('Invalid chunk size: ' + opts.chunkSize);
       }
     }
 
     if (opts.windowBits) {
       if (opts.windowBits < constants.Z_MIN_WINDOWBITS ||
           opts.windowBits > constants.Z_MAX_WINDOWBITS) {
-        throw new Error('Invalid windowBits: ' + opts.windowBits);
+        throw new RangeError('Invalid windowBits: ' + opts.windowBits);
       }
     }
 
     if (opts.level) {
       if (opts.level < constants.Z_MIN_LEVEL ||
           opts.level > constants.Z_MAX_LEVEL) {
-        throw new Error('Invalid compression level: ' + opts.level);
+        throw new RangeError('Invalid compression level: ' + opts.level);
       }
     }
 
     if (opts.memLevel) {
       if (opts.memLevel < constants.Z_MIN_MEMLEVEL ||
           opts.memLevel > constants.Z_MAX_MEMLEVEL) {
-        throw new Error('Invalid memLevel: ' + opts.memLevel);
+        throw new RangeError('Invalid memLevel: ' + opts.memLevel);
       }
     }
 
     if (opts.strategy && isInvalidStrategy(opts.strategy))
-      throw new Error('Invalid strategy: ' + opts.strategy);
+      throw new TypeError('Invalid strategy: ' + opts.strategy);
 
     if (opts.dictionary) {
       if (!(opts.dictionary instanceof Buffer)) {
-        throw new Error('Invalid dictionary: it should be a Buffer instance');
+        throw new TypeError(
+          'Invalid dictionary: it should be a Buffer instance');
       }
     }
 
@@ -280,7 +282,7 @@ class Zlib extends Transform {
     var last = ending && (!chunk || ws.length === chunk.length);
 
     if (chunk !== null && !(chunk instanceof Buffer))
-      return cb(new Error('invalid input'));
+      return cb(new TypeError('invalid input'));
 
     if (!this._handle)
       return cb(new Error('zlib binding closed'));
diff --git a/test/parallel/test-zlib-deflate-constructors.js b/test/parallel/test-zlib-deflate-constructors.js
@@ -15,7 +15,7 @@ assert.ok(new zlib.DeflateRaw() instanceof zlib.DeflateRaw);
 // Throws if `opts.chunkSize` is invalid
 assert.throws(
   () => { new zlib.Deflate({chunkSize: -Infinity}); },
-  /^Error: Invalid chunk size: -Infinity$/
+  /^RangeError: Invalid chunk size: -Infinity$/
 );
 
 // Confirm that maximum chunk size cannot be exceeded because it is `Infinity`.
@@ -24,23 +24,23 @@ assert.strictEqual(zlib.constants.Z_MAX_CHUNK, Infinity);
 // Throws if `opts.windowBits` is invalid
 assert.throws(
   () => { new zlib.Deflate({windowBits: -Infinity}); },
-  /^Error: Invalid windowBits: -Infinity$/
+  /^RangeError: Invalid windowBits: -Infinity$/
 );
 
 assert.throws(
   () => { new zlib.Deflate({windowBits: Infinity}); },
-  /^Error: Invalid windowBits: Infinity$/
+  /^RangeError: Invalid windowBits: Infinity$/
 );
 
 // Throws if `opts.level` is invalid
 assert.throws(
   () => { new zlib.Deflate({level: -Infinity}); },
-  /^Error: Invalid compression level: -Infinity$/
+  /^RangeError: Invalid compression level: -Infinity$/
 );
 
 assert.throws(
   () => { new zlib.Deflate({level: Infinity}); },
-  /^Error: Invalid compression level: Infinity$/
+  /^RangeError: Invalid compression level: Infinity$/
 );
 
 // Throws a RangeError if `level` invalid in  `Deflate.prototype.params()`
@@ -57,12 +57,12 @@ assert.throws(
 // Throws if `opts.memLevel` is invalid
 assert.throws(
   () => { new zlib.Deflate({memLevel: -Infinity}); },
-  /^Error: Invalid memLevel: -Infinity$/
+  /^RangeError: Invalid memLevel: -Infinity$/
 );
 
 assert.throws(
   () => { new zlib.Deflate({memLevel: Infinity}); },
-  /^Error: Invalid memLevel: Infinity$/
+  /^RangeError: Invalid memLevel: Infinity$/
 );
 
 // Does not throw if opts.strategy is valid
@@ -89,13 +89,13 @@ assert.doesNotThrow(
 // Throws if opt.strategy is the wrong type.
 assert.throws(
   () => { new zlib.Deflate({strategy: '' + zlib.constants.Z_RLE }); },
-  /^Error: Invalid strategy: 3$/
+  /^TypeError: Invalid strategy: 3$/
 );
 
 // Throws if opts.strategy is invalid
 assert.throws(
   () => { new zlib.Deflate({strategy: 'this is a bogus strategy'}); },
-  /^Error: Invalid strategy: this is a bogus strategy$/
+  /^TypeError: Invalid strategy: this is a bogus strategy$/
 );
 
 // Throws TypeError if `strategy` is invalid in `Deflate.prototype.params()`
@@ -107,5 +107,5 @@ assert.throws(
 // Throws if opts.dictionary is not a Buffer
 assert.throws(
   () => { new zlib.Deflate({dictionary: 'not a buffer'}); },
-  /^Error: Invalid dictionary: it should be a Buffer instance$/
+  /^TypeError: Invalid dictionary: it should be a Buffer instance$/
 );
diff --git a/test/parallel/test-zlib-flush-flags.js b/test/parallel/test-zlib-flush-flags.js
@@ -9,20 +9,20 @@ assert.doesNotThrow(() => {
 
 assert.throws(() => {
   zlib.createGzip({ flush: 'foobar' });
-}, /Invalid flush flag: foobar/);
+}, /^RangeError: Invalid flush flag: foobar$/);
 
 assert.throws(() => {
   zlib.createGzip({ flush: 10000 });
-}, /Invalid flush flag: 10000/);
+}, /^RangeError: Invalid flush flag: 10000$/);
 
 assert.doesNotThrow(() => {
   zlib.createGzip({ finishFlush: zlib.constants.Z_SYNC_FLUSH });
 });
 
 assert.throws(() => {
   zlib.createGzip({ finishFlush: 'foobar' });
-}, /Invalid flush flag: foobar/);
+}, /^RangeError: Invalid flush flag: foobar$/);
 
 assert.throws(() => {
   zlib.createGzip({ finishFlush: 10000 });
-}, /Invalid flush flag: 10000/);
+}, /^RangeError: Invalid flush flag: 10000$/);

Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,10 @@ for (var ck = 0; ck < ckeys.length; ck++) {`
`31`	`31`	`codes[codes[ckey]] = ckey;`
`32`	`32`	`}`
`33`	`33`
`34`		`-function isValidFlushFlag(flag) {`
`35`		`- return flag >= constants.Z_NO_FLUSH &&`
`36`		`- flag <= constants.Z_BLOCK;`
	`34`	`+function isInvalidFlushFlag(flag) {`
	`35`	`+ return typeof flag !== 'number' \|\|`
	`36`	`+ flag < constants.Z_NO_FLUSH \|\|`
	`37`	`+ flag > constants.Z_BLOCK;`
`37`	`38`
`38`	`39`	`// Covers: constants.Z_NO_FLUSH (0),`
`39`	`40`	`// constants.Z_PARTIAL_FLUSH (1),`
`@@ -141,11 +142,11 @@ class Zlib extends Transform {`
`141`	`142`	`this._opts = opts;`
`142`	`143`	`this._chunkSize = opts.chunkSize \|\| constants.Z_DEFAULT_CHUNK;`
`143`	`144`
`144`		`- if (opts.flush && !isValidFlushFlag(opts.flush)) {`
`145`		`- throw new Error('Invalid flush flag: ' + opts.flush);`
	`145`	`+ if (opts.flush && isInvalidFlushFlag(opts.flush)) {`
	`146`	`+ throw new RangeError('Invalid flush flag: ' + opts.flush);`
`146`	`147`	`}`
`147`		`- if (opts.finishFlush && !isValidFlushFlag(opts.finishFlush)) {`
`148`		`- throw new Error('Invalid flush flag: ' + opts.finishFlush);`
	`148`	`+ if (opts.finishFlush && isInvalidFlushFlag(opts.finishFlush)) {`
	`149`	`+ throw new RangeError('Invalid flush flag: ' + opts.finishFlush);`
`149`	`150`	`}`
`150`	`151`
`151`	`152`	`this._flushFlag = opts.flush \|\| constants.Z_NO_FLUSH;`
`@@ -154,37 +155,38 @@ class Zlib extends Transform {`
`154`	`155`
`155`	`156`	`if (opts.chunkSize) {`
`156`	`157`	`if (opts.chunkSize < constants.Z_MIN_CHUNK) {`
`157`		`- throw new Error('Invalid chunk size: ' + opts.chunkSize);`
	`158`	`+ throw new RangeError('Invalid chunk size: ' + opts.chunkSize);`
`158`	`159`	`}`
`159`	`160`	`}`
`160`	`161`
`161`	`162`	`if (opts.windowBits) {`
`162`	`163`	`if (opts.windowBits < constants.Z_MIN_WINDOWBITS \|\|`
`163`	`164`	`opts.windowBits > constants.Z_MAX_WINDOWBITS) {`
`164`		`- throw new Error('Invalid windowBits: ' + opts.windowBits);`
	`165`	`+ throw new RangeError('Invalid windowBits: ' + opts.windowBits);`
`165`	`166`	`}`
`166`	`167`	`}`
`167`	`168`
`168`	`169`	`if (opts.level) {`
`169`	`170`	`if (opts.level < constants.Z_MIN_LEVEL \|\|`
`170`	`171`	`opts.level > constants.Z_MAX_LEVEL) {`
`171`		`- throw new Error('Invalid compression level: ' + opts.level);`
	`172`	`+ throw new RangeError('Invalid compression level: ' + opts.level);`
`172`	`173`	`}`
`173`	`174`	`}`
`174`	`175`
`175`	`176`	`if (opts.memLevel) {`
`176`	`177`	`if (opts.memLevel < constants.Z_MIN_MEMLEVEL \|\|`
`177`	`178`	`opts.memLevel > constants.Z_MAX_MEMLEVEL) {`
`178`		`- throw new Error('Invalid memLevel: ' + opts.memLevel);`
	`179`	`+ throw new RangeError('Invalid memLevel: ' + opts.memLevel);`
`179`	`180`	`}`
`180`	`181`	`}`
`181`	`182`
`182`	`183`	`if (opts.strategy && isInvalidStrategy(opts.strategy))`
`183`		`- throw new Error('Invalid strategy: ' + opts.strategy);`
	`184`	`+ throw new TypeError('Invalid strategy: ' + opts.strategy);`
`184`	`185`
`185`	`186`	`if (opts.dictionary) {`
`186`	`187`	`if (!(opts.dictionary instanceof Buffer)) {`
`187`		`- throw new Error('Invalid dictionary: it should be a Buffer instance');`
	`188`	`+ throw new TypeError(`
	`189`	`+ 'Invalid dictionary: it should be a Buffer instance');`
`188`	`190`	`}`
`189`	`191`	`}`
`190`	`192`
`@@ -280,7 +282,7 @@ class Zlib extends Transform {`
`280`	`282`	`var last = ending && (!chunk \|\| ws.length === chunk.length);`
`281`	`283`
`282`	`284`	`if (chunk !== null && !(chunk instanceof Buffer))`
`283`		`- return cb(new Error('invalid input'));`
	`285`	`+ return cb(new TypeError('invalid input'));`
`284`	`286`
`285`	`287`	`if (!this._handle)`
`286`	`288`	`return cb(new Error('zlib binding closed'));`