smock 0.1.1

data/node_modules/webpack/node_modules/node-libs-browser/node_modules/assert/assert.js

@@ -0,0 +1,359 @@
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// 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 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.
+
+// when used in node, this will actually load the util module we depend on
+// versus loading the builtin util module as happens otherwise
+// this is a bug in node module loading as far as I am concerned
+var util = require('util/');
+
+var pSlice = Array.prototype.slice;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = module.exports = ok;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+//                             actual: actual,
+//                             expected: expected })
+
+assert.AssertionError = function AssertionError(options) {
+  this.name = 'AssertionError';
+  this.actual = options.actual;
+  this.expected = options.expected;
+  this.operator = options.operator;
+  if (options.message) {
+    this.message = options.message;
+    this.generatedMessage = false;
+  } else {
+    this.message = getMessage(this);
+    this.generatedMessage = true;
+  }
+  var stackStartFunction = options.stackStartFunction || fail;
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  }
+  else {
+    // non v8 browsers so we can have a stacktrace
+    var err = new Error();
+    if (err.stack) {
+      var out = err.stack;
+
+      // try to strip useless frames
+      var fn_name = stackStartFunction.name;
+      var idx = out.indexOf('\n' + fn_name);
+      if (idx >= 0) {
+        // once we have located the function frame
+        // we need to strip out everything before it (and its line)
+        var next_line = out.indexOf('\n', idx + 1);
+        out = out.substring(next_line + 1);
+      }
+
+      this.stack = out;
+    }
+  }
+};
+
+// assert.AssertionError instanceof Error
+util.inherits(assert.AssertionError, Error);
+
+function replacer(key, value) {
+  if (util.isUndefined(value)) {
+    return '' + value;
+  }
+  if (util.isNumber(value) && !isFinite(value)) {
+    return value.toString();
+  }
+  if (util.isFunction(value) || util.isRegExp(value)) {
+    return value.toString();
+  }
+  return value;
+}
+
+function truncate(s, n) {
+  if (util.isString(s)) {
+    return s.length < n ? s : s.slice(0, n);
+  } else {
+    return s;
+  }
+}
+
+function getMessage(self) {
+  return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
+         self.operator + ' ' +
+         truncate(JSON.stringify(self.expected, replacer), 128);
+}
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided.  All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+  throw new assert.AssertionError({
+    message: message,
+    actual: actual,
+    expected: expected,
+    operator: operator,
+    stackStartFunction: stackStartFunction
+  });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, !!guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+function ok(value, message) {
+  if (!value) fail(value, true, message, '==', assert.ok);
+}
+assert.ok = ok;
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+  if (actual == expected) {
+    fail(actual, expected, message, '!=', assert.notEqual);
+  }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+  if (!_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+  }
+};
+
+function _deepEqual(actual, expected) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+
+  } else if (util.isBuffer(actual) && util.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+
+    return true;
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  } else if (util.isDate(actual) && util.isDate(expected)) {
+    return actual.getTime() === expected.getTime();
+
+  // 7.3 If the expected value is a RegExp object, the actual value is
+  // equivalent if it is also a RegExp object with the same source and
+  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+    return actual.source === expected.source &&
+           actual.global === expected.global &&
+           actual.multiline === expected.multiline &&
+           actual.lastIndex === expected.lastIndex &&
+           actual.ignoreCase === expected.ignoreCase;
+
+  // 7.4. Other pairs that do not both pass typeof value == 'object',
+  // equivalence is determined by ==.
+  } else if (!util.isObject(actual) && !util.isObject(expected)) {
+    return actual == expected;
+
+  // 7.5 For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical 'prototype' property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  } else {
+    return objEquiv(actual, expected);
+  }
+}
+
+function isArguments(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b) {
+  if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
+    return false;
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) return false;
+  // if one is a primitive, the other must be same
+  if (util.isPrimitive(a) || util.isPrimitive(b)) {
+    return a === b;
+  }
+  var aIsArgs = isArguments(a),
+      bIsArgs = isArguments(b);
+  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+    return false;
+  if (aIsArgs) {
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return _deepEqual(a, b);
+  }
+  var ka = objectKeys(a),
+      kb = objectKeys(b),
+      key, i;
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length != kb.length)
+    return false;
+  //the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  //~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i])
+      return false;
+  }
+  //equivalent values for every corresponding key, and
+  //~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!_deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+  if (_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+  }
+};
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+  if (actual !== expected) {
+    fail(actual, expected, message, '===', assert.strictEqual);
+  }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+  if (actual === expected) {
+    fail(actual, expected, message, '!==', assert.notStrictEqual);
+  }
+};
+
+function expectedException(actual, expected) {
+  if (!actual || !expected) {
+    return false;
+  }
+
+  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+    return expected.test(actual);
+  } else if (actual instanceof expected) {
+    return true;
+  } else if (expected.call({}, actual) === true) {
+    return true;
+  }
+
+  return false;
+}
+
+function _throws(shouldThrow, block, expected, message) {
+  var actual;
+
+  if (util.isString(expected)) {
+    message = expected;
+    expected = null;
+  }
+
+  try {
+    block();
+  } catch (e) {
+    actual = e;
+  }
+
+  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+            (message ? ' ' + message : '.');
+
+  if (shouldThrow && !actual) {
+    fail(actual, expected, 'Missing expected exception' + message);
+  }
+
+  if (!shouldThrow && expectedException(actual, expected)) {
+    fail(actual, expected, 'Got unwanted exception' + message);
+  }
+
+  if ((shouldThrow && actual && expected &&
+      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+    throw actual;
+  }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+  _throws.apply(this, [true].concat(pSlice.call(arguments)));
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/message) {
+  _throws.apply(this, [false].concat(pSlice.call(arguments)));
+};
+
+assert.ifError = function(err) { if (err) {throw err;}};
+
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (hasOwn.call(obj, key)) keys.push(key);
+  }
+  return keys;
+};

data/node_modules/webpack/node_modules/node-libs-browser/node_modules/assert/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "assert",
+  "description": "commonjs assert - node.js api compatible",
+  "keywords": [
+    "assert"
+  ],
+  "version": "1.3.0",
+  "homepage": "https://github.com/defunctzombie/commonjs-assert",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/defunctzombie/commonjs-assert.git"
+  },
+  "main": "./assert.js",
+  "dependencies": {
+    "util": "0.10.3"
+  },
+  "devDependencies": {
+    "zuul": "~1.10.2",
+    "mocha": "~1.21.4"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "mocha --ui qunit test.js && zuul -- test.js"
+  },
+  "gitHead": "cc3c9020e9ca440bdc431f92570d676dd8a89a3c",
+  "bugs": {
+    "url": "https://github.com/defunctzombie/commonjs-assert/issues"
+  },
+  "_id": "assert@1.3.0",
+  "_shasum": "03939a622582a812cc202320a0b9a56c9b815849",
+  "_from": "assert@^1.1.1",
+  "_npmVersion": "2.1.12",
+  "_nodeVersion": "0.10.33",
+  "_npmUser": {
+    "name": "shtylman",
+    "email": "shtylman@gmail.com"
+  },
+  "maintainers": [
+    {
+      "name": "coolaj86",
+      "email": "coolaj86@gmail.com"
+    },
+    {
+      "name": "shtylman",
+      "email": "shtylman@gmail.com"
+    }
+  ],
+  "dist": {
+    "shasum": "03939a622582a812cc202320a0b9a56c9b815849",
+    "tarball": "http://registry.npmjs.org/assert/-/assert-1.3.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/assert/-/assert-1.3.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/node_modules/webpack/node_modules/node-libs-browser/node_modules/assert/test.js

@@ -0,0 +1,343 @@
+// 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('./');
+
+var keys = Object.keys;
+
+function makeBlock(f) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  return function() {
+    return f.apply(this, args);
+  };
+}
+
+test('assert.ok', function () {
+  assert.throws(makeBlock(assert, false), assert.AssertionError, 'ok(false)');
+
+  assert.doesNotThrow(makeBlock(assert, true), assert.AssertionError, 'ok(true)');
+
+  assert.doesNotThrow(makeBlock(assert, 'test', 'ok(\'test\')'));
+
+  assert.throws(makeBlock(assert.ok, false),
+                assert.AssertionError, 'ok(false)');
+
+  assert.doesNotThrow(makeBlock(assert.ok, true),
+                      assert.AssertionError, 'ok(true)');
+
+  assert.doesNotThrow(makeBlock(assert.ok, 'test'), 'ok(\'test\')');
+});
+
+test('assert.equal', function () {
+  assert.throws(makeBlock(assert.equal, true, false), assert.AssertionError, 'equal');
+
+  assert.doesNotThrow(makeBlock(assert.equal, null, null), 'equal');
+
+  assert.doesNotThrow(makeBlock(assert.equal, undefined, undefined), 'equal');
+
+  assert.doesNotThrow(makeBlock(assert.equal, null, undefined), 'equal');
+
+  assert.doesNotThrow(makeBlock(assert.equal, true, true), 'equal');
+
+  assert.doesNotThrow(makeBlock(assert.equal, 2, '2'), 'equal');
+
+  assert.doesNotThrow(makeBlock(assert.notEqual, true, false), 'notEqual');
+
+  assert.throws(makeBlock(assert.notEqual, true, true),
+                assert.AssertionError, 'notEqual');
+});
+
+test('assert.strictEqual', function () {
+  assert.throws(makeBlock(assert.strictEqual, 2, '2'),
+                assert.AssertionError, 'strictEqual');
+
+  assert.throws(makeBlock(assert.strictEqual, null, undefined),
+                assert.AssertionError, 'strictEqual');
+
+  assert.doesNotThrow(makeBlock(assert.notStrictEqual, 2, '2'), 'notStrictEqual');
+});
+
+test('assert.deepEqual - 7.2', function () {
+  assert.doesNotThrow(makeBlock(assert.deepEqual, new Date(2000, 3, 14),
+                      new Date(2000, 3, 14)), 'deepEqual date');
+
+  assert.throws(makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)),
+                assert.AssertionError,
+                'deepEqual date');
+});
+
+test('assert.deepEqual - 7.3', function () {
+  assert.doesNotThrow(makeBlock(assert.deepEqual, /a/, /a/));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, /a/g, /a/g));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, /a/i, /a/i));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, /a/m, /a/m));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, /a/igm, /a/igm));
+  assert.throws(makeBlock(assert.deepEqual, /ab/, /a/));
+  assert.throws(makeBlock(assert.deepEqual, /a/g, /a/));
+  assert.throws(makeBlock(assert.deepEqual, /a/i, /a/));
+  assert.throws(makeBlock(assert.deepEqual, /a/m, /a/));
+  assert.throws(makeBlock(assert.deepEqual, /a/igm, /a/im));
+
+  var re1 = /a/;
+  re1.lastIndex = 3;
+  assert.throws(makeBlock(assert.deepEqual, re1, /a/));
+});
+
+test('assert.deepEqual - 7.4', function () {
+  assert.doesNotThrow(makeBlock(assert.deepEqual, 4, '4'), 'deepEqual == check');
+  assert.doesNotThrow(makeBlock(assert.deepEqual, true, 1), 'deepEqual == check');
+  assert.throws(makeBlock(assert.deepEqual, 4, '5'),
+            assert.AssertionError,
+            'deepEqual == check');
+});
+
+test('assert.deepEqual - 7.5', function () {
+  // having the same number of owned properties && the same set of keys
+  assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4}, {a: 4}));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'}));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, [4], ['4']));
+  assert.throws(makeBlock(assert.deepEqual, {a: 4}, {a: 4, b: true}),
+            assert.AssertionError);
+  assert.doesNotThrow(makeBlock(assert.deepEqual, ['a'], {0: 'a'}));
+  //(although not necessarily the same order),
+  assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '1'}, {b: '1', a: 4}));
+  var a1 = [1, 2, 3];
+  var a2 = [1, 2, 3];
+  a1.a = 'test';
+  a1.b = true;
+  a2.b = true;
+  a2.a = 'test';
+  assert.throws(makeBlock(assert.deepEqual, keys(a1), keys(a2)),
+            assert.AssertionError);
+  assert.doesNotThrow(makeBlock(assert.deepEqual, a1, a2));
+});
+
+test('assert.deepEqual - instances', function () {
+  // having an identical prototype property
+  var nbRoot = {
+    toString: function() { return this.first + ' ' + this.last; }
+  };
+
+  function nameBuilder(first, last) {
+    this.first = first;
+    this.last = last;
+    return this;
+  }
+  nameBuilder.prototype = nbRoot;
+
+  function nameBuilder2(first, last) {
+    this.first = first;
+    this.last = last;
+    return this;
+  }
+  nameBuilder2.prototype = nbRoot;
+
+  var nb1 = new nameBuilder('Ryan', 'Dahl');
+  var nb2 = new nameBuilder2('Ryan', 'Dahl');
+
+  assert.doesNotThrow(makeBlock(assert.deepEqual, nb1, nb2));
+
+  nameBuilder2.prototype = Object;
+  nb2 = new nameBuilder2('Ryan', 'Dahl');
+  assert.throws(makeBlock(assert.deepEqual, nb1, nb2), assert.AssertionError);
+});
+
+test('assert.deepEqual - ES6 primitives', function () {
+  assert.throws(makeBlock(assert.deepEqual, null, {}), assert.AssertionError);
+  assert.throws(makeBlock(assert.deepEqual, undefined, {}), assert.AssertionError);
+  assert.throws(makeBlock(assert.deepEqual, 'a', ['a']), assert.AssertionError);
+  assert.throws(makeBlock(assert.deepEqual, 'a', {0: 'a'}), assert.AssertionError);
+  assert.throws(makeBlock(assert.deepEqual, 1, {}), assert.AssertionError);
+  assert.throws(makeBlock(assert.deepEqual, true, {}), assert.AssertionError);
+  if (typeof Symbol === 'symbol') {
+    assert.throws(makeBlock(assert.deepEqual, Symbol(), {}), assert.AssertionError);
+  }
+});
+
+test('assert.deepEqual - object wrappers', function () {
+  assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), ['a']));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), {0: 'a'}));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, new Number(1), {}));
+  assert.doesNotThrow(makeBlock(assert.deepEqual, new Boolean(true), {}));
+});
+
+function thrower(errorConstructor) {
+  throw new errorConstructor('test');
+}
+
+test('assert - Testing the throwing', function () {
+  var aethrow = makeBlock(thrower, assert.AssertionError);
+  aethrow = makeBlock(thrower, assert.AssertionError);
+
+  // the basic calls work
+  assert.throws(makeBlock(thrower, assert.AssertionError),
+                assert.AssertionError, 'message');
+  assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError);
+  assert.throws(makeBlock(thrower, assert.AssertionError));
+
+  // if not passing an error, catch all.
+  assert.throws(makeBlock(thrower, TypeError));
+
+  // when passing a type, only catch errors of the appropriate type
+  var threw = false;
+  try {
+    assert.throws(makeBlock(thrower, TypeError), assert.AssertionError);
+  } catch (e) {
+    threw = true;
+    assert.ok(e instanceof TypeError, 'type');
+  }
+  assert.equal(true, threw,
+               'a.throws with an explicit error is eating extra errors',
+               assert.AssertionError);
+  threw = false;
+
+  // doesNotThrow should pass through all errors
+  try {
+    assert.doesNotThrow(makeBlock(thrower, TypeError), assert.AssertionError);
+  } catch (e) {
+    threw = true;
+    assert.ok(e instanceof TypeError);
+  }
+  assert.equal(true, threw,
+               'a.doesNotThrow with an explicit error is eating extra errors');
+
+  // key difference is that throwing our correct error makes an assertion error
+  try {
+    assert.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
+  } catch (e) {
+    threw = true;
+    assert.ok(e instanceof assert.AssertionError);
+  }
+  assert.equal(true, threw,
+               'a.doesNotThrow is not catching type matching errors');
+});
+
+test('assert.ifError', function () {
+  assert.throws(function() {assert.ifError(new Error('test error'))});
+  assert.doesNotThrow(function() {assert.ifError(null)});
+  assert.doesNotThrow(function() {assert.ifError()});
+});
+
+test('assert - make sure that validating using constructor really works', function () {
+  var threw = false;
+  try {
+    assert.throws(
+        function() {
+          throw ({});
+        },
+        Array
+    );
+  } catch (e) {
+    threw = true;
+  }
+  assert.ok(threw, 'wrong constructor validation');
+});
+
+test('assert -  use a RegExp to validate error message', function () {
+  assert.throws(makeBlock(thrower, TypeError), /test/);
+});
+
+test('assert - se a fn to validate error object', function () {
+  assert.throws(makeBlock(thrower, TypeError), function(err) {
+    if ((err instanceof TypeError) && /test/.test(err)) {
+      return true;
+    }
+  });
+});
+
+test('assert - Make sure deepEqual doesn\'t loop forever on circular refs', function () {
+  var b = {};
+  b.b = b;
+
+  var c = {};
+  c.b = c;
+
+  var gotError = false;
+  try {
+    assert.deepEqual(b, c);
+  } catch (e) {
+    gotError = true;
+  }
+
+  assert.ok(gotError);
+});
+
+test('assert - Ensure reflexivity of deepEqual with `arguments` objects', function() {
+    var args = (function() { return arguments; })();
+    assert.throws(makeBlock(assert.deepEqual, [], args), assert.AssertionError);
+    assert.throws(makeBlock(assert.deepEqual, args, []), assert.AssertionError);
+});
+
+test('assert - test assertion message', function () {
+  function testAssertionMessage(actual, expected) {
+    try {
+      assert.equal(actual, '');
+    } catch (e) {
+      assert.equal(e.toString(),
+          ['AssertionError:', expected, '==', '""'].join(' '));
+    }
+  }
+  testAssertionMessage(undefined, '"undefined"');
+  testAssertionMessage(null, 'null');
+  testAssertionMessage(true, 'true');
+  testAssertionMessage(false, 'false');
+  testAssertionMessage(0, '0');
+  testAssertionMessage(100, '100');
+  testAssertionMessage(NaN, '"NaN"');
+  testAssertionMessage(Infinity, '"Infinity"');
+  testAssertionMessage(-Infinity, '"-Infinity"');
+  testAssertionMessage('', '""');
+  testAssertionMessage('foo', '"foo"');
+  testAssertionMessage([], '[]');
+  testAssertionMessage([1, 2, 3], '[1,2,3]');
+  testAssertionMessage(/a/, '"/a/"');
+  testAssertionMessage(function f() {}, '"function f() {}"');
+  testAssertionMessage({}, '{}');
+  testAssertionMessage({a: undefined, b: null}, '{"a":"undefined","b":null}');
+  testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
+      '{"a":"NaN","b":"Infinity","c":"-Infinity"}');
+});
+
+test('assert - regressions from node.js testcase', function () {
+  var threw = false;
+
+  try {
+    assert.throws(function () {
+      assert.ifError(null);
+    });
+  } catch (e) {
+    threw = true;
+    assert.equal(e.message, 'Missing expected exception..');
+  }
+  assert.ok(threw);
+
+  try {
+    assert.equal(1, 2);
+  } catch (e) {
+    assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2');
+  }
+
+  try {
+    assert.equal(1, 2, 'oh no');
+  } catch (e) {
+    assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no');
+  }
+});