first commit

build/node_modules/util/test/browser/inspect.js

@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var assert = require('assert');
+var util = require('../../');
+
+suite('inspect');
+
+test('util.inspect - test for sparse array', function () {
+  var a = ['foo', 'bar', 'baz'];
+  assert.equal(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]');
+  delete a[1];
+  assert.equal(util.inspect(a), '[ \'foo\', , \'baz\' ]');
+  assert.equal(util.inspect(a, true), '[ \'foo\', , \'baz\', [length]: 3 ]');
+  assert.equal(util.inspect(new Array(5)), '[ , , , ,  ]');
+});
+
+test('util.inspect -  exceptions should print the error message, not \'{}\'', function () {
+  assert.equal(util.inspect(new Error()), '[Error]');
+  assert.equal(util.inspect(new Error('FAIL')), '[Error: FAIL]');
+  assert.equal(util.inspect(new TypeError('FAIL')), '[TypeError: FAIL]');
+  assert.equal(util.inspect(new SyntaxError('FAIL')), '[SyntaxError: FAIL]');
+});

build/node_modules/util/test/browser/is.js

@@ -0,0 +1,91 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var assert = require('assert');
+
+var util = require('../../');
+
+suite('is');
+
+test('util.isArray', function () {
+  assert.equal(true, util.isArray([]));
+  assert.equal(true, util.isArray(Array()));
+  assert.equal(true, util.isArray(new Array()));
+  assert.equal(true, util.isArray(new Array(5)));
+  assert.equal(true, util.isArray(new Array('with', 'some', 'entries')));
+  assert.equal(false, util.isArray({}));
+  assert.equal(false, util.isArray({ push: function() {} }));
+  assert.equal(false, util.isArray(/regexp/));
+  assert.equal(false, util.isArray(new Error()));
+  assert.equal(false, util.isArray(Object.create(Array.prototype)));
+});
+
+test('util.isRegExp', function () {
+  assert.equal(true, util.isRegExp(/regexp/));
+  assert.equal(true, util.isRegExp(RegExp()));
+  assert.equal(true, util.isRegExp(new RegExp()));
+  assert.equal(false, util.isRegExp({}));
+  assert.equal(false, util.isRegExp([]));
+  assert.equal(false, util.isRegExp(new Date()));
+  assert.equal(false, util.isRegExp(Object.create(RegExp.prototype)));
+});
+
+test('util.isDate', function () {
+  assert.equal(true, util.isDate(new Date()));
+  assert.equal(true, util.isDate(new Date(0)));
+  assert.equal(false, util.isDate(Date()));
+  assert.equal(false, util.isDate({}));
+  assert.equal(false, util.isDate([]));
+  assert.equal(false, util.isDate(new Error()));
+  assert.equal(false, util.isDate(Object.create(Date.prototype)));
+});
+
+test('util.isError', function () {
+  assert.equal(true, util.isError(new Error()));
+  assert.equal(true, util.isError(new TypeError()));
+  assert.equal(true, util.isError(new SyntaxError()));
+  assert.equal(false, util.isError({}));
+  assert.equal(false, util.isError({ name: 'Error', message: '' }));
+  assert.equal(false, util.isError([]));
+  assert.equal(true, util.isError(Object.create(Error.prototype)));
+});
+
+test('util._extend', function () {
+  assert.deepEqual(util._extend({a:1}),             {a:1});
+  assert.deepEqual(util._extend({a:1}, []),         {a:1});
+  assert.deepEqual(util._extend({a:1}, null),       {a:1});
+  assert.deepEqual(util._extend({a:1}, true),       {a:1});
+  assert.deepEqual(util._extend({a:1}, false),      {a:1});
+  assert.deepEqual(util._extend({a:1}, {b:2}),      {a:1, b:2});
+  assert.deepEqual(util._extend({a:1, b:2}, {b:3}), {a:1, b:3});
+});
+
+test('util.isBuffer', function () {
+  assert.equal(true, util.isBuffer(new Buffer(4)));
+  assert.equal(true, util.isBuffer(Buffer(4)));
+  assert.equal(true, util.isBuffer(new Buffer(4)));
+  assert.equal(true, util.isBuffer(new Buffer([1, 2, 3, 4])));
+  assert.equal(false, util.isBuffer({}));
+  assert.equal(false, util.isBuffer([]));
+  assert.equal(false, util.isBuffer(new Error()));
+  assert.equal(false, util.isRegExp(new Date()));
+  assert.equal(true, util.isBuffer(Object.create(Buffer.prototype)));
+});

build/node_modules/util/test/node/debug.js

@@ -0,0 +1,86 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var assert = require('assert');
+var util = require('../../');
+
+if (process.argv[2] === 'child')
+  child();
+else
+  parent();
+
+function parent() {
+  test('foo,tud,bar', true);
+  test('foo,tud', true);
+  test('tud,bar', true);
+  test('tud', true);
+  test('foo,bar', false);
+  test('', false);
+}
+
+function test(environ, shouldWrite) {
+  var expectErr = '';
+  if (shouldWrite) {
+    expectErr = 'TUD %PID%: this { is: \'a\' } /debugging/\n' +
+                'TUD %PID%: number=1234 string=asdf obj={"foo":"bar"}\n';
+  }
+  var expectOut = 'ok\n';
+  var didTest = false;
+
+  var spawn = require('child_process').spawn;
+  var child = spawn(process.execPath, [__filename, 'child'], {
+    env: { NODE_DEBUG: environ }
+  });
+
+  expectErr = expectErr.split('%PID%').join(child.pid);
+
+  var err = '';
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', function(c) {
+    err += c;
+  });
+
+  var out = '';
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', function(c) {
+    out += c;
+  });
+
+  child.on('close', function(c) {
+    assert(!c);
+    assert.equal(err, expectErr);
+    assert.equal(out, expectOut);
+    didTest = true;
+    console.log('ok %j %j', environ, shouldWrite);
+  });
+
+  process.on('exit', function() {
+    assert(didTest);
+  });
+}
+
+
+function child() {
+  var debug = util.debuglog('tud');
+  debug('this', { is: 'a' }, /debugging/);
+  debug('number=%d string=%s obj=%j', 1234, 'asdf', { foo: 'bar' });
+  console.log('ok');
+}

build/node_modules/util/test/node/format.js

@@ -0,0 +1,77 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+
+var assert = require('assert');
+var util = require('../../');
+
+assert.equal(util.format(), '');
+assert.equal(util.format(''), '');
+assert.equal(util.format([]), '[]');
+assert.equal(util.format({}), '{}');
+assert.equal(util.format(null), 'null');
+assert.equal(util.format(true), 'true');
+assert.equal(util.format(false), 'false');
+assert.equal(util.format('test'), 'test');
+
+// CHECKME this is for console.log() compatibility - but is it *right*?
+assert.equal(util.format('foo', 'bar', 'baz'), 'foo bar baz');
+
+assert.equal(util.format('%d', 42.0), '42');
+assert.equal(util.format('%d', 42), '42');
+assert.equal(util.format('%s', 42), '42');
+assert.equal(util.format('%j', 42), '42');
+
+assert.equal(util.format('%d', '42.0'), '42');
+assert.equal(util.format('%d', '42'), '42');
+assert.equal(util.format('%s', '42'), '42');
+assert.equal(util.format('%j', '42'), '"42"');
+
+assert.equal(util.format('%%s%s', 'foo'), '%sfoo');
+
+assert.equal(util.format('%s'), '%s');
+assert.equal(util.format('%s', undefined), 'undefined');
+assert.equal(util.format('%s', 'foo'), 'foo');
+assert.equal(util.format('%s:%s'), '%s:%s');
+assert.equal(util.format('%s:%s', undefined), 'undefined:%s');
+assert.equal(util.format('%s:%s', 'foo'), 'foo:%s');
+assert.equal(util.format('%s:%s', 'foo', 'bar'), 'foo:bar');
+assert.equal(util.format('%s:%s', 'foo', 'bar', 'baz'), 'foo:bar baz');
+assert.equal(util.format('%%%s%%', 'hi'), '%hi%');
+assert.equal(util.format('%%%s%%%%', 'hi'), '%hi%%');
+
+(function() {
+  var o = {};
+  o.o = o;
+  assert.equal(util.format('%j', o), '[Circular]');
+})();
+
+// Errors
+assert.equal(util.format(new Error('foo')), '[Error: foo]');
+function CustomError(msg) {
+  Error.call(this);
+  Object.defineProperty(this, 'message', { value: msg, enumerable: false });
+  Object.defineProperty(this, 'name', { value: 'CustomError', enumerable: false });
+}
+util.inherits(CustomError, Error);
+assert.equal(util.format(new CustomError('bar')), '[CustomError: bar]');

build/node_modules/util/test/node/inspect.js

@@ -0,0 +1,195 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+
+var assert = require('assert');
+var util = require('../../');
+
+// test the internal isDate implementation
+var Date2 = require('vm').runInNewContext('Date');
+var d = new Date2();
+var orig = util.inspect(d);
+Date2.prototype.foo = 'bar';
+var after = util.inspect(d);
+assert.equal(orig, after);
+
+// test for sparse array
+var a = ['foo', 'bar', 'baz'];
+assert.equal(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]');
+delete a[1];
+assert.equal(util.inspect(a), '[ \'foo\', , \'baz\' ]');
+assert.equal(util.inspect(a, true), '[ \'foo\', , \'baz\', [length]: 3 ]');
+assert.equal(util.inspect(new Array(5)), '[ , , , ,  ]');
+
+// test for property descriptors
+var getter = Object.create(null, {
+  a: {
+    get: function() { return 'aaa'; }
+  }
+});
+var setter = Object.create(null, {
+  b: {
+    set: function() {}
+  }
+});
+var getterAndSetter = Object.create(null, {
+  c: {
+    get: function() { return 'ccc'; },
+    set: function() {}
+  }
+});
+assert.equal(util.inspect(getter, true), '{ [a]: [Getter] }');
+assert.equal(util.inspect(setter, true), '{ [b]: [Setter] }');
+assert.equal(util.inspect(getterAndSetter, true), '{ [c]: [Getter/Setter] }');
+
+// exceptions should print the error message, not '{}'
+assert.equal(util.inspect(new Error()), '[Error]');
+assert.equal(util.inspect(new Error('FAIL')), '[Error: FAIL]');
+assert.equal(util.inspect(new TypeError('FAIL')), '[TypeError: FAIL]');
+assert.equal(util.inspect(new SyntaxError('FAIL')), '[SyntaxError: FAIL]');
+try {
+  undef();
+} catch (e) {
+  assert.equal(util.inspect(e), '[ReferenceError: undef is not defined]');
+}
+var ex = util.inspect(new Error('FAIL'), true);
+assert.ok(ex.indexOf('[Error: FAIL]') != -1);
+assert.ok(ex.indexOf('[stack]') != -1);
+assert.ok(ex.indexOf('[message]') != -1);
+
+// GH-1941
+// should not throw:
+assert.equal(util.inspect(Object.create(Date.prototype)), '{}');
+
+// GH-1944
+assert.doesNotThrow(function() {
+  var d = new Date();
+  d.toUTCString = null;
+  util.inspect(d);
+});
+
+assert.doesNotThrow(function() {
+  var r = /regexp/;
+  r.toString = null;
+  util.inspect(r);
+});
+
+// bug with user-supplied inspect function returns non-string
+assert.doesNotThrow(function() {
+  util.inspect([{
+    inspect: function() { return 123; }
+  }]);
+});
+
+// GH-2225
+var x = { inspect: util.inspect };
+assert.ok(util.inspect(x).indexOf('inspect') != -1);
+
+// util.inspect.styles and util.inspect.colors
+function test_color_style(style, input, implicit) {
+  var color_name = util.inspect.styles[style];
+  var color = ['', ''];
+  if(util.inspect.colors[color_name])
+    color = util.inspect.colors[color_name];
+
+  var without_color = util.inspect(input, false, 0, false);
+  var with_color = util.inspect(input, false, 0, true);
+  var expect = '\u001b[' + color[0] + 'm' + without_color +
+               '\u001b[' + color[1] + 'm';
+  assert.equal(with_color, expect, 'util.inspect color for style '+style);
+}
+
+test_color_style('special', function(){});
+test_color_style('number', 123.456);
+test_color_style('boolean', true);
+test_color_style('undefined', undefined);
+test_color_style('null', null);
+test_color_style('string', 'test string');
+test_color_style('date', new Date);
+test_color_style('regexp', /regexp/);
+
+// an object with "hasOwnProperty" overwritten should not throw
+assert.doesNotThrow(function() {
+  util.inspect({
+    hasOwnProperty: null
+  });
+});
+
+// new API, accepts an "options" object
+var subject = { foo: 'bar', hello: 31, a: { b: { c: { d: 0 } } } };
+Object.defineProperty(subject, 'hidden', { enumerable: false, value: null });
+
+assert(util.inspect(subject, { showHidden: false }).indexOf('hidden') === -1);
+assert(util.inspect(subject, { showHidden: true }).indexOf('hidden') !== -1);
+assert(util.inspect(subject, { colors: false }).indexOf('\u001b[32m') === -1);
+assert(util.inspect(subject, { colors: true }).indexOf('\u001b[32m') !== -1);
+assert(util.inspect(subject, { depth: 2 }).indexOf('c: [Object]') !== -1);
+assert(util.inspect(subject, { depth: 0 }).indexOf('a: [Object]') !== -1);
+assert(util.inspect(subject, { depth: null }).indexOf('{ d: 0 }') !== -1);
+
+// "customInspect" option can enable/disable calling inspect() on objects
+subject = { inspect: function() { return 123; } };
+
+assert(util.inspect(subject, { customInspect: true }).indexOf('123') !== -1);
+assert(util.inspect(subject, { customInspect: true }).indexOf('inspect') === -1);
+assert(util.inspect(subject, { customInspect: false }).indexOf('123') === -1);
+assert(util.inspect(subject, { customInspect: false }).indexOf('inspect') !== -1);
+
+// custom inspect() functions should be able to return other Objects
+subject.inspect = function() { return { foo: 'bar' }; };
+
+assert.equal(util.inspect(subject), '{ foo: \'bar\' }');
+
+subject.inspect = function(depth, opts) {
+  assert.strictEqual(opts.customInspectOptions, true);
+};
+
+util.inspect(subject, { customInspectOptions: true });
+
+// util.inspect with "colors" option should produce as many lines as without it
+function test_lines(input) {
+  var count_lines = function(str) {
+    return (str.match(/\n/g) || []).length;
+  }
+
+  var without_color = util.inspect(input);
+  var with_color = util.inspect(input, {colors: true});
+  assert.equal(count_lines(without_color), count_lines(with_color));
+}
+
+test_lines([1, 2, 3, 4, 5, 6, 7]);
+test_lines(function() {
+  var big_array = [];
+  for (var i = 0; i < 100; i++) {
+    big_array.push(i);
+  }
+  return big_array;
+}());
+test_lines({foo: 'bar', baz: 35, b: {a: 35}});
+test_lines({
+  foo: 'bar',
+  baz: 35,
+  b: {a: 35},
+  very_long_key: 'very_long_value',
+  even_longer_key: ['with even longer value in array']
+});

build/node_modules/util/test/node/log.js

@@ -0,0 +1,58 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+var assert = require('assert');
+var util = require('../../');
+
+assert.ok(process.stdout.writable);
+assert.ok(process.stderr.writable);
+
+var stdout_write = global.process.stdout.write;
+var strings = [];
+global.process.stdout.write = function(string) {
+  strings.push(string);
+};
+console._stderr = process.stdout;
+
+var tests = [
+  {input: 'foo', output: 'foo'},
+  {input: undefined, output: 'undefined'},
+  {input: null, output: 'null'},
+  {input: false, output: 'false'},
+  {input: 42, output: '42'},
+  {input: function(){}, output: '[Function]'},
+  {input: parseInt('not a number', 10), output: 'NaN'},
+  {input: {answer: 42}, output: '{ answer: 42 }'},
+  {input: [1,2,3], output: '[ 1, 2, 3 ]'}
+];
+
+// test util.log()
+tests.forEach(function(test) {
+  util.log(test.input);
+  var result = strings.shift().trim(),
+      re = (/[0-9]{1,2} [A-Z][a-z]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} - (.+)$/),
+      match = re.exec(result);
+  assert.ok(match);
+  assert.equal(match[1], test.output);
+});
+
+global.process.stdout.write = stdout_write;

build/node_modules/util/test/node/util.js

@@ -0,0 +1,83 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+var assert = require('assert');
+var context = require('vm').runInNewContext;
+
+var util = require('../../');
+
+// isArray
+assert.equal(true, util.isArray([]));
+assert.equal(true, util.isArray(Array()));
+assert.equal(true, util.isArray(new Array()));
+assert.equal(true, util.isArray(new Array(5)));
+assert.equal(true, util.isArray(new Array('with', 'some', 'entries')));
+assert.equal(true, util.isArray(context('Array')()));
+assert.equal(false, util.isArray({}));
+assert.equal(false, util.isArray({ push: function() {} }));
+assert.equal(false, util.isArray(/regexp/));
+assert.equal(false, util.isArray(new Error));
+assert.equal(false, util.isArray(Object.create(Array.prototype)));
+
+// isRegExp
+assert.equal(true, util.isRegExp(/regexp/));
+assert.equal(true, util.isRegExp(RegExp()));
+assert.equal(true, util.isRegExp(new RegExp()));
+assert.equal(true, util.isRegExp(context('RegExp')()));
+assert.equal(false, util.isRegExp({}));
+assert.equal(false, util.isRegExp([]));
+assert.equal(false, util.isRegExp(new Date()));
+assert.equal(false, util.isRegExp(Object.create(RegExp.prototype)));
+
+// isDate
+assert.equal(true, util.isDate(new Date()));
+assert.equal(true, util.isDate(new Date(0)));
+assert.equal(true, util.isDate(new (context('Date'))));
+assert.equal(false, util.isDate(Date()));
+assert.equal(false, util.isDate({}));
+assert.equal(false, util.isDate([]));
+assert.equal(false, util.isDate(new Error));
+assert.equal(false, util.isDate(Object.create(Date.prototype)));
+
+// isError
+assert.equal(true, util.isError(new Error));
+assert.equal(true, util.isError(new TypeError));
+assert.equal(true, util.isError(new SyntaxError));
+assert.equal(true, util.isError(new (context('Error'))));
+assert.equal(true, util.isError(new (context('TypeError'))));
+assert.equal(true, util.isError(new (context('SyntaxError'))));
+assert.equal(false, util.isError({}));
+assert.equal(false, util.isError({ name: 'Error', message: '' }));
+assert.equal(false, util.isError([]));
+assert.equal(true, util.isError(Object.create(Error.prototype)));
+
+// isObject
+assert.ok(util.isObject({}) === true);
+
+// _extend
+assert.deepEqual(util._extend({a:1}),             {a:1});
+assert.deepEqual(util._extend({a:1}, []),         {a:1});
+assert.deepEqual(util._extend({a:1}, null),       {a:1});
+assert.deepEqual(util._extend({a:1}, true),       {a:1});
+assert.deepEqual(util._extend({a:1}, false),      {a:1});
+assert.deepEqual(util._extend({a:1}, {b:2}),      {a:1, b:2});
+assert.deepEqual(util._extend({a:1, b:2}, {b:3}), {a:1, b:3});