Only run isType tests against supported types

Author: lukechilds

test/node/types.js

@@ -23,47 +23,53 @@ const inspect = value => {
 
 const wasmBuffer = Buffer.from('0061736d01000000', 'hex');
 
-for (const [ value, _method ] of [
+for (const [ getValue, _method ] of [
   // [ external, 'isExternal' ],
-  [ new Date() ],
-  [ (function() { return arguments; })(), 'isArgumentsObject' ],
-  [ new Boolean(), 'isBooleanObject' ],
-  [ new Number(), 'isNumberObject' ],
-  [ new String(), 'isStringObject' ],
-  [ Object(Symbol()), 'isSymbolObject' ],
-  [ Object(BigInt(0)), 'isBigIntObject' ],
-  [ new Error(), 'isNativeError' ],
-  [ new RegExp() ],
-  [ async function() {}, 'isAsyncFunction' ],
-  [ function*() {}, 'isGeneratorFunction' ],
-  [ (function*() {})(), 'isGeneratorObject' ],
-  [ Promise.resolve() ],
-  [ new Map() ],
-  [ new Set() ],
-  [ (new Map())[Symbol.iterator](), 'isMapIterator' ],
-  [ (new Set())[Symbol.iterator](), 'isSetIterator' ],
-  [ new WeakMap() ],
-  [ new WeakSet() ],
-  [ new ArrayBuffer() ],
-  [ new Uint8Array() ],
-  [ new Uint8ClampedArray() ],
-  [ new Uint16Array() ],
-  [ new Uint32Array() ],
-  [ new Int8Array() ],
-  [ new Int16Array() ],
-  [ new Int32Array() ],
-  [ new Float32Array() ],
-  [ new Float64Array() ],
-  [ new BigInt64Array() ],
-  [ new BigUint64Array() ],
-  [ Object.defineProperty(new Uint8Array(),
+  [ function() { return new Date(); } ],
+  [ function() { return (function() { return arguments; })(); }, 'isArgumentsObject' ],
+  [ function() { return new Boolean(); }, 'isBooleanObject' ],
+  [ function() { return new Number(); }, 'isNumberObject' ],
+  [ function() { return new String(); }, 'isStringObject' ],
+  [ function() { return Object(Symbol()); }, 'isSymbolObject' ],
+  [ function() { return Object(BigInt(0)); }, 'isBigIntObject' ],
+  [ function() { return new Error(); }, 'isNativeError' ],
+  [ function() { return new RegExp(); } ],
+  [ function() { return async function() {}; }, 'isAsyncFunction' ],
+  [ function() { return function*() {}; }, 'isGeneratorFunction' ],
+  [ function() { return (function*() {})(); }, 'isGeneratorObject' ],
+  [ function() { return Promise.resolve(); } ],
+  [ function() { return new Map(); } ],
+  [ function() { return new Set(); } ],
+  [ function() { return (new Map())[Symbol.iterator](); }, 'isMapIterator' ],
+  [ function() { return (new Set())[Symbol.iterator](); }, 'isSetIterator' ],
+  [ function() { return new WeakMap(); } ],
+  [ function() { return new WeakSet(); } ],
+  [ function() { return new ArrayBuffer(); } ],
+  [ function() { return new Uint8Array(); } ],
+  [ function() { return new Uint8ClampedArray(); } ],
+  [ function() { return new Uint16Array(); } ],
+  [ function() { return new Uint32Array(); } ],
+  [ function() { return new Int8Array(); } ],
+  [ function() { return new Int16Array(); } ],
+  [ function() { return new Int32Array(); } ],
+  [ function() { return new Float32Array(); } ],
+  [ function() { return new Float64Array(); } ],
+  [ function() { return new BigInt64Array(); } ],
+  [ function() { return new BigUint64Array(); } ],
+  [ function() { return Object.defineProperty(new Uint8Array(),
                           Symbol.toStringTag,
-                          { value: 'foo' }) ],
-  [ new DataView(new ArrayBuffer()) ],
-  [ new SharedArrayBuffer() ],
+                          { value: 'foo' }); } ],
+  [ function() { return new DataView(new ArrayBuffer()); } ],
+  [ function() { return new SharedArrayBuffer(); } ],
   // [ new Proxy({}, {}), 'isProxy' ],
-  [ new WebAssembly.Module(wasmBuffer), 'isWebAssemblyCompiledModule' ],
+  [ function() { return new WebAssembly.Module(wasmBuffer); }, 'isWebAssemblyCompiledModule' ],
 ]) {
+  let value;
+  try {
+    value = getValue();
+  } catch (e) {
+    continue;
+  }
   const method = _method || `is${value.constructor.name}`;
   console.log('Testing', method);
   assert(method in types, `Missing ${method} for ${inspect(value)}`);