ecomp-portal-FE/client/bower_components/lodash/vendor/underscore/test/objects.js

   1 (function() {
   2   var _ = typeof require == 'function' ? require('..') : window._;
   3
   4   QUnit.module('Objects');
   5
   6   var testElement = typeof document === 'object' ? document.createElement('div') : void 0;
   7
   8   QUnit.test('keys', function(assert) {
   9     assert.deepEqual(_.keys({one: 1, two: 2}), ['one', 'two'], 'can extract the keys from an object');
  10     // the test above is not safe because it relies on for-in enumeration order
  11     var a = []; a[1] = 0;
  12     assert.deepEqual(_.keys(a), ['1'], 'is not fooled by sparse arrays; see issue #95');
  13     assert.deepEqual(_.keys(null), []);
  14     assert.deepEqual(_.keys(void 0), []);
  15     assert.deepEqual(_.keys(1), []);
  16     assert.deepEqual(_.keys('a'), []);
  17     assert.deepEqual(_.keys(true), []);
  18
  19     // keys that may be missed if the implementation isn't careful
  20     var trouble = {
  21       constructor: Object,
  22       valueOf: _.noop,
  23       hasOwnProperty: null,
  24       toString: 5,
  25       toLocaleString: void 0,
  26       propertyIsEnumerable: /a/,
  27       isPrototypeOf: this,
  28       __defineGetter__: Boolean,
  29       __defineSetter__: {},
  30       __lookupSetter__: false,
  31       __lookupGetter__: []
  32     };
  33     var troubleKeys = ['constructor', 'valueOf', 'hasOwnProperty', 'toString', 'toLocaleString', 'propertyIsEnumerable',
  34                   'isPrototypeOf', '__defineGetter__', '__defineSetter__', '__lookupSetter__', '__lookupGetter__'].sort();
  35     assert.deepEqual(_.keys(trouble).sort(), troubleKeys, 'matches non-enumerable properties');
  36   });
  37
  38   QUnit.test('allKeys', function(assert) {
  39     assert.deepEqual(_.allKeys({one: 1, two: 2}), ['one', 'two'], 'can extract the allKeys from an object');
  40     // the test above is not safe because it relies on for-in enumeration order
  41     var a = []; a[1] = 0;
  42     assert.deepEqual(_.allKeys(a), ['1'], 'is not fooled by sparse arrays; see issue #95');
  43
  44     a.a = a;
  45     assert.deepEqual(_.allKeys(a), ['1', 'a'], 'is not fooled by sparse arrays with additional properties');
  46
  47     _.each([null, void 0, 1, 'a', true, NaN, {}, [], new Number(5), new Date(0)], function(val) {
  48       assert.deepEqual(_.allKeys(val), []);
  49     });
  50
  51     // allKeys that may be missed if the implementation isn't careful
  52     var trouble = {
  53       constructor: Object,
  54       valueOf: _.noop,
  55       hasOwnProperty: null,
  56       toString: 5,
  57       toLocaleString: void 0,
  58       propertyIsEnumerable: /a/,
  59       isPrototypeOf: this
  60     };
  61     var troubleKeys = ['constructor', 'valueOf', 'hasOwnProperty', 'toString', 'toLocaleString', 'propertyIsEnumerable',
  62                   'isPrototypeOf'].sort();
  63     assert.deepEqual(_.allKeys(trouble).sort(), troubleKeys, 'matches non-enumerable properties');
  64
  65     function A() {}
  66     A.prototype.foo = 'foo';
  67     var b = new A();
  68     b.bar = 'bar';
  69     assert.deepEqual(_.allKeys(b).sort(), ['bar', 'foo'], 'should include inherited keys');
  70
  71     function y() {}
  72     y.x = 'z';
  73     assert.deepEqual(_.allKeys(y), ['x'], 'should get keys from constructor');
  74   });
  75
  76   QUnit.test('values', function(assert) {
  77     assert.deepEqual(_.values({one: 1, two: 2}), [1, 2], 'can extract the values from an object');
  78     assert.deepEqual(_.values({one: 1, two: 2, length: 3}), [1, 2, 3], '... even when one of them is "length"');
  79   });
  80
  81   QUnit.test('pairs', function(assert) {
  82     assert.deepEqual(_.pairs({one: 1, two: 2}), [['one', 1], ['two', 2]], 'can convert an object into pairs');
  83     assert.deepEqual(_.pairs({one: 1, two: 2, length: 3}), [['one', 1], ['two', 2], ['length', 3]], '... even when one of them is "length"');
  84   });
  85
  86   QUnit.test('invert', function(assert) {
  87     var obj = {first: 'Moe', second: 'Larry', third: 'Curly'};
  88     assert.deepEqual(_.keys(_.invert(obj)), ['Moe', 'Larry', 'Curly'], 'can invert an object');
  89     assert.deepEqual(_.invert(_.invert(obj)), obj, 'two inverts gets you back where you started');
  90
  91     obj = {length: 3};
  92     assert.equal(_.invert(obj)['3'], 'length', 'can invert an object with "length"');
  93   });
  94
  95   QUnit.test('functions', function(assert) {
  96     var obj = {a: 'dash', b: _.map, c: /yo/, d: _.reduce};
  97     assert.deepEqual(['b', 'd'], _.functions(obj), 'can grab the function names of any passed-in object');
  98
  99     var Animal = function(){};
 100     Animal.prototype.run = function(){};
 101     assert.deepEqual(_.functions(new Animal), ['run'], 'also looks up functions on the prototype');
 102   });
 103
 104   QUnit.test('methods', function(assert) {
 105     assert.strictEqual(_.methods, _.functions, 'is an alias for functions');
 106   });
 107
 108   QUnit.test('extend', function(assert) {
 109     var result;
 110     assert.equal(_.extend({}, {a: 'b'}).a, 'b', 'can extend an object with the attributes of another');
 111     assert.equal(_.extend({a: 'x'}, {a: 'b'}).a, 'b', 'properties in source override destination');
 112     assert.equal(_.extend({x: 'x'}, {a: 'b'}).x, 'x', "properties not in source don't get overriden");
 113     result = _.extend({x: 'x'}, {a: 'a'}, {b: 'b'});
 114     assert.deepEqual(result, {x: 'x', a: 'a', b: 'b'}, 'can extend from multiple source objects');
 115     result = _.extend({x: 'x'}, {a: 'a', x: 2}, {a: 'b'});
 116     assert.deepEqual(result, {x: 2, a: 'b'}, 'extending from multiple source objects last property trumps');
 117     result = _.extend({}, {a: void 0, b: null});
 118     assert.deepEqual(_.keys(result), ['a', 'b'], 'extend copies undefined values');
 119
 120     var F = function() {};
 121     F.prototype = {a: 'b'};
 122     var subObj = new F();
 123     subObj.c = 'd';
 124     assert.deepEqual(_.extend({}, subObj), {a: 'b', c: 'd'}, 'extend copies all properties from source');
 125     _.extend(subObj, {});
 126     assert.ok(!subObj.hasOwnProperty('a'), "extend does not convert destination object's 'in' properties to 'own' properties");
 127
 128     try {
 129       result = {};
 130       _.extend(result, null, void 0, {a: 1});
 131     } catch (e) { /* ignored */ }
 132
 133     assert.equal(result.a, 1, 'should not error on `null` or `undefined` sources');
 134
 135     assert.strictEqual(_.extend(null, {a: 1}), null, 'extending null results in null');
 136     assert.strictEqual(_.extend(void 0, {a: 1}), void 0, 'extending undefined results in undefined');
 137   });
 138
 139   QUnit.test('extendOwn', function(assert) {
 140     var result;
 141     assert.equal(_.extendOwn({}, {a: 'b'}).a, 'b', 'can extend an object with the attributes of another');
 142     assert.equal(_.extendOwn({a: 'x'}, {a: 'b'}).a, 'b', 'properties in source override destination');
 143     assert.equal(_.extendOwn({x: 'x'}, {a: 'b'}).x, 'x', "properties not in source don't get overriden");
 144     result = _.extendOwn({x: 'x'}, {a: 'a'}, {b: 'b'});
 145     assert.deepEqual(result, {x: 'x', a: 'a', b: 'b'}, 'can extend from multiple source objects');
 146     result = _.extendOwn({x: 'x'}, {a: 'a', x: 2}, {a: 'b'});
 147     assert.deepEqual(result, {x: 2, a: 'b'}, 'extending from multiple source objects last property trumps');
 148     assert.deepEqual(_.extendOwn({}, {a: void 0, b: null}), {a: void 0, b: null}, 'copies undefined values');
 149
 150     var F = function() {};
 151     F.prototype = {a: 'b'};
 152     var subObj = new F();
 153     subObj.c = 'd';
 154     assert.deepEqual(_.extendOwn({}, subObj), {c: 'd'}, 'copies own properties from source');
 155
 156     result = {};
 157     assert.deepEqual(_.extendOwn(result, null, void 0, {a: 1}), {a: 1}, 'should not error on `null` or `undefined` sources');
 158
 159     _.each(['a', 5, null, false], function(val) {
 160       assert.strictEqual(_.extendOwn(val, {a: 1}), val, 'extending non-objects results in returning the non-object value');
 161     });
 162
 163     assert.strictEqual(_.extendOwn(void 0, {a: 1}), void 0, 'extending undefined results in undefined');
 164
 165     result = _.extendOwn({a: 1, 0: 2, 1: '5', length: 6}, {0: 1, 1: 2, length: 2});
 166     assert.deepEqual(result, {a: 1, 0: 1, 1: 2, length: 2}, 'should treat array-like objects like normal objects');
 167   });
 168
 169   QUnit.test('assign', function(assert) {
 170     assert.strictEqual(_.assign, _.extendOwn, 'is an alias for extendOwn');
 171   });
 172
 173   QUnit.test('pick', function(assert) {
 174     var result;
 175     result = _.pick({a: 1, b: 2, c: 3}, 'a', 'c');
 176     assert.deepEqual(result, {a: 1, c: 3}, 'can restrict properties to those named');
 177     result = _.pick({a: 1, b: 2, c: 3}, ['b', 'c']);
 178     assert.deepEqual(result, {b: 2, c: 3}, 'can restrict properties to those named in an array');
 179     result = _.pick({a: 1, b: 2, c: 3}, ['a'], 'b');
 180     assert.deepEqual(result, {a: 1, b: 2}, 'can restrict properties to those named in mixed args');
 181     result = _.pick(['a', 'b'], 1);
 182     assert.deepEqual(result, {1: 'b'}, 'can pick numeric properties');
 183
 184     _.each([null, void 0], function(val) {
 185       assert.deepEqual(_.pick(val, 'hasOwnProperty'), {}, 'Called with null/undefined');
 186       assert.deepEqual(_.pick(val, _.constant(true)), {});
 187     });
 188     assert.deepEqual(_.pick(5, 'toString', 'b'), {toString: Number.prototype.toString}, 'can iterate primitives');
 189
 190     var data = {a: 1, b: 2, c: 3};
 191     var callback = function(value, key, object) {
 192       assert.strictEqual(key, {1: 'a', 2: 'b', 3: 'c'}[value]);
 193       assert.strictEqual(object, data);
 194       return value !== this.value;
 195     };
 196     result = _.pick(data, callback, {value: 2});
 197     assert.deepEqual(result, {a: 1, c: 3}, 'can accept a predicate and context');
 198
 199     var Obj = function(){};
 200     Obj.prototype = {a: 1, b: 2, c: 3};
 201     var instance = new Obj();
 202     assert.deepEqual(_.pick(instance, 'a', 'c'), {a: 1, c: 3}, 'include prototype props');
 203
 204     assert.deepEqual(_.pick(data, function(val, key) {
 205       return this[key] === 3 && this === instance;
 206     }, instance), {c: 3}, 'function is given context');
 207
 208     assert.ok(!_.has(_.pick({}, 'foo'), 'foo'), 'does not set own property if property not in object');
 209     _.pick(data, function(value, key, obj) {
 210       assert.equal(obj, data, 'passes same object as third parameter of iteratee');
 211     });
 212   });
 213
 214   QUnit.test('omit', function(assert) {
 215     var result;
 216     result = _.omit({a: 1, b: 2, c: 3}, 'b');
 217     assert.deepEqual(result, {a: 1, c: 3}, 'can omit a single named property');
 218     result = _.omit({a: 1, b: 2, c: 3}, 'a', 'c');
 219     assert.deepEqual(result, {b: 2}, 'can omit several named properties');
 220     result = _.omit({a: 1, b: 2, c: 3}, ['b', 'c']);
 221     assert.deepEqual(result, {a: 1}, 'can omit properties named in an array');
 222     result = _.omit(['a', 'b'], 0);
 223     assert.deepEqual(result, {1: 'b'}, 'can omit numeric properties');
 224
 225     assert.deepEqual(_.omit(null, 'a', 'b'), {}, 'non objects return empty object');
 226     assert.deepEqual(_.omit(void 0, 'toString'), {}, 'null/undefined return empty object');
 227     assert.deepEqual(_.omit(5, 'toString', 'b'), {}, 'returns empty object for primitives');
 228
 229     var data = {a: 1, b: 2, c: 3};
 230     var callback = function(value, key, object) {
 231       assert.strictEqual(key, {1: 'a', 2: 'b', 3: 'c'}[value]);
 232       assert.strictEqual(object, data);
 233       return value !== this.value;
 234     };
 235     result = _.omit(data, callback, {value: 2});
 236     assert.deepEqual(result, {b: 2}, 'can accept a predicate');
 237
 238     var Obj = function(){};
 239     Obj.prototype = {a: 1, b: 2, c: 3};
 240     var instance = new Obj();
 241     assert.deepEqual(_.omit(instance, 'b'), {a: 1, c: 3}, 'include prototype props');
 242
 243     assert.deepEqual(_.omit(data, function(val, key) {
 244       return this[key] === 3 && this === instance;
 245     }, instance), {a: 1, b: 2}, 'function is given context');
 246   });
 247
 248   QUnit.test('defaults', function(assert) {
 249     var options = {zero: 0, one: 1, empty: '', nan: NaN, nothing: null};
 250
 251     _.defaults(options, {zero: 1, one: 10, twenty: 20, nothing: 'str'});
 252     assert.equal(options.zero, 0, 'value exists');
 253     assert.equal(options.one, 1, 'value exists');
 254     assert.equal(options.twenty, 20, 'default applied');
 255     assert.equal(options.nothing, null, "null isn't overridden");
 256
 257     _.defaults(options, {empty: 'full'}, {nan: 'nan'}, {word: 'word'}, {word: 'dog'});
 258     assert.equal(options.empty, '', 'value exists');
 259     assert.ok(_.isNaN(options.nan), "NaN isn't overridden");
 260     assert.equal(options.word, 'word', 'new value is added, first one wins');
 261
 262     try {
 263       options = {};
 264       _.defaults(options, null, void 0, {a: 1});
 265     } catch (e) { /* ignored */ }
 266
 267     assert.equal(options.a, 1, 'should not error on `null` or `undefined` sources');
 268
 269     assert.deepEqual(_.defaults(null, {a: 1}), {a: 1}, 'defaults skips nulls');
 270     assert.deepEqual(_.defaults(void 0, {a: 1}), {a: 1}, 'defaults skips undefined');
 271   });
 272
 273   QUnit.test('clone', function(assert) {
 274     var moe = {name: 'moe', lucky: [13, 27, 34]};
 275     var clone = _.clone(moe);
 276     assert.equal(clone.name, 'moe', 'the clone as the attributes of the original');
 277
 278     clone.name = 'curly';
 279     assert.ok(clone.name === 'curly' && moe.name === 'moe', 'clones can change shallow attributes without affecting the original');
 280
 281     clone.lucky.push(101);
 282     assert.equal(_.last(moe.lucky), 101, 'changes to deep attributes are shared with the original');
 283
 284     assert.equal(_.clone(void 0), void 0, 'non objects should not be changed by clone');
 285     assert.equal(_.clone(1), 1, 'non objects should not be changed by clone');
 286     assert.equal(_.clone(null), null, 'non objects should not be changed by clone');
 287   });
 288
 289   QUnit.test('create', function(assert) {
 290     var Parent = function() {};
 291     Parent.prototype = {foo: function() {}, bar: 2};
 292
 293     _.each(['foo', null, void 0, 1], function(val) {
 294       assert.deepEqual(_.create(val), {}, 'should return empty object when a non-object is provided');
 295     });
 296
 297     assert.ok(_.create([]) instanceof Array, 'should return new instance of array when array is provided');
 298
 299     var Child = function() {};
 300     Child.prototype = _.create(Parent.prototype);
 301     assert.ok(new Child instanceof Parent, 'object should inherit prototype');
 302
 303     var func = function() {};
 304     Child.prototype = _.create(Parent.prototype, {func: func});
 305     assert.strictEqual(Child.prototype.func, func, 'properties should be added to object');
 306
 307     Child.prototype = _.create(Parent.prototype, {constructor: Child});
 308     assert.strictEqual(Child.prototype.constructor, Child);
 309
 310     Child.prototype.foo = 'foo';
 311     var created = _.create(Child.prototype, new Child);
 312     assert.ok(!created.hasOwnProperty('foo'), 'should only add own properties');
 313   });
 314
 315   QUnit.test('isEqual', function(assert) {
 316     function First() {
 317       this.value = 1;
 318     }
 319     First.prototype.value = 1;
 320     function Second() {
 321       this.value = 1;
 322     }
 323     Second.prototype.value = 2;
 324
 325     // Basic equality and identity comparisons.
 326     assert.ok(_.isEqual(null, null), '`null` is equal to `null`');
 327     assert.ok(_.isEqual(), '`undefined` is equal to `undefined`');
 328
 329     assert.ok(!_.isEqual(0, -0), '`0` is not equal to `-0`');
 330     assert.ok(!_.isEqual(-0, 0), 'Commutative equality is implemented for `0` and `-0`');
 331     assert.ok(!_.isEqual(null, void 0), '`null` is not equal to `undefined`');
 332     assert.ok(!_.isEqual(void 0, null), 'Commutative equality is implemented for `null` and `undefined`');
 333
 334     // String object and primitive comparisons.
 335     assert.ok(_.isEqual('Curly', 'Curly'), 'Identical string primitives are equal');
 336     assert.ok(_.isEqual(new String('Curly'), new String('Curly')), 'String objects with identical primitive values are equal');
 337     assert.ok(_.isEqual(new String('Curly'), 'Curly'), 'String primitives and their corresponding object wrappers are equal');
 338     assert.ok(_.isEqual('Curly', new String('Curly')), 'Commutative equality is implemented for string objects and primitives');
 339
 340     assert.ok(!_.isEqual('Curly', 'Larry'), 'String primitives with different values are not equal');
 341     assert.ok(!_.isEqual(new String('Curly'), new String('Larry')), 'String objects with different primitive values are not equal');
 342     assert.ok(!_.isEqual(new String('Curly'), {toString: function(){ return 'Curly'; }}), 'String objects and objects with a custom `toString` method are not equal');
 343
 344     // Number object and primitive comparisons.
 345     assert.ok(_.isEqual(75, 75), 'Identical number primitives are equal');
 346     assert.ok(_.isEqual(new Number(75), new Number(75)), 'Number objects with identical primitive values are equal');
 347     assert.ok(_.isEqual(75, new Number(75)), 'Number primitives and their corresponding object wrappers are equal');
 348     assert.ok(_.isEqual(new Number(75), 75), 'Commutative equality is implemented for number objects and primitives');
 349     assert.ok(!_.isEqual(new Number(0), -0), '`new Number(0)` and `-0` are not equal');
 350     assert.ok(!_.isEqual(0, new Number(-0)), 'Commutative equality is implemented for `new Number(0)` and `-0`');
 351
 352     assert.ok(!_.isEqual(new Number(75), new Number(63)), 'Number objects with different primitive values are not equal');
 353     assert.ok(!_.isEqual(new Number(63), {valueOf: function(){ return 63; }}), 'Number objects and objects with a `valueOf` method are not equal');
 354
 355     // Comparisons involving `NaN`.
 356     assert.ok(_.isEqual(NaN, NaN), '`NaN` is equal to `NaN`');
 357     assert.ok(_.isEqual(new Number(NaN), NaN), 'Object(`NaN`) is equal to `NaN`');
 358     assert.ok(!_.isEqual(61, NaN), 'A number primitive is not equal to `NaN`');
 359     assert.ok(!_.isEqual(new Number(79), NaN), 'A number object is not equal to `NaN`');
 360     assert.ok(!_.isEqual(Infinity, NaN), '`Infinity` is not equal to `NaN`');
 361
 362     // Boolean object and primitive comparisons.
 363     assert.ok(_.isEqual(true, true), 'Identical boolean primitives are equal');
 364     assert.ok(_.isEqual(new Boolean, new Boolean), 'Boolean objects with identical primitive values are equal');
 365     assert.ok(_.isEqual(true, new Boolean(true)), 'Boolean primitives and their corresponding object wrappers are equal');
 366     assert.ok(_.isEqual(new Boolean(true), true), 'Commutative equality is implemented for booleans');
 367     assert.ok(!_.isEqual(new Boolean(true), new Boolean), 'Boolean objects with different primitive values are not equal');
 368
 369     // Common type coercions.
 370     assert.ok(!_.isEqual(new Boolean(false), true), '`new Boolean(false)` is not equal to `true`');
 371     assert.ok(!_.isEqual('75', 75), 'String and number primitives with like values are not equal');
 372     assert.ok(!_.isEqual(new Number(63), new String(63)), 'String and number objects with like values are not equal');
 373     assert.ok(!_.isEqual(75, '75'), 'Commutative equality is implemented for like string and number values');
 374     assert.ok(!_.isEqual(0, ''), 'Number and string primitives with like values are not equal');
 375     assert.ok(!_.isEqual(1, true), 'Number and boolean primitives with like values are not equal');
 376     assert.ok(!_.isEqual(new Boolean(false), new Number(0)), 'Boolean and number objects with like values are not equal');
 377     assert.ok(!_.isEqual(false, new String('')), 'Boolean primitives and string objects with like values are not equal');
 378     assert.ok(!_.isEqual(12564504e5, new Date(2009, 9, 25)), 'Dates and their corresponding numeric primitive values are not equal');
 379
 380     // Dates.
 381     assert.ok(_.isEqual(new Date(2009, 9, 25), new Date(2009, 9, 25)), 'Date objects referencing identical times are equal');
 382     assert.ok(!_.isEqual(new Date(2009, 9, 25), new Date(2009, 11, 13)), 'Date objects referencing different times are not equal');
 383     assert.ok(!_.isEqual(new Date(2009, 11, 13), {
 384       getTime: function(){
 385         return 12606876e5;
 386       }
 387     }), 'Date objects and objects with a `getTime` method are not equal');
 388     assert.ok(!_.isEqual(new Date('Curly'), new Date('Curly')), 'Invalid dates are not equal');
 389
 390     // Functions.
 391     assert.ok(!_.isEqual(First, Second), 'Different functions with identical bodies and source code representations are not equal');
 392
 393     // RegExps.
 394     assert.ok(_.isEqual(/(?:)/gim, /(?:)/gim), 'RegExps with equivalent patterns and flags are equal');
 395     assert.ok(_.isEqual(/(?:)/gi, /(?:)/ig), 'Flag order is not significant');
 396     assert.ok(!_.isEqual(/(?:)/g, /(?:)/gi), 'RegExps with equivalent patterns and different flags are not equal');
 397     assert.ok(!_.isEqual(/Moe/gim, /Curly/gim), 'RegExps with different patterns and equivalent flags are not equal');
 398     assert.ok(!_.isEqual(/(?:)/gi, /(?:)/g), 'Commutative equality is implemented for RegExps');
 399     assert.ok(!_.isEqual(/Curly/g, {source: 'Larry', global: true, ignoreCase: false, multiline: false}), 'RegExps and RegExp-like objects are not equal');
 400
 401     // Empty arrays, array-like objects, and object literals.
 402     assert.ok(_.isEqual({}, {}), 'Empty object literals are equal');
 403     assert.ok(_.isEqual([], []), 'Empty array literals are equal');
 404     assert.ok(_.isEqual([{}], [{}]), 'Empty nested arrays and objects are equal');
 405     assert.ok(!_.isEqual({length: 0}, []), 'Array-like objects and arrays are not equal.');
 406     assert.ok(!_.isEqual([], {length: 0}), 'Commutative equality is implemented for array-like objects');
 407
 408     assert.ok(!_.isEqual({}, []), 'Object literals and array literals are not equal');
 409     assert.ok(!_.isEqual([], {}), 'Commutative equality is implemented for objects and arrays');
 410
 411     // Arrays with primitive and object values.
 412     assert.ok(_.isEqual([1, 'Larry', true], [1, 'Larry', true]), 'Arrays containing identical primitives are equal');
 413     assert.ok(_.isEqual([/Moe/g, new Date(2009, 9, 25)], [/Moe/g, new Date(2009, 9, 25)]), 'Arrays containing equivalent elements are equal');
 414
 415     // Multi-dimensional arrays.
 416     var a = [new Number(47), false, 'Larry', /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
 417     var b = [new Number(47), false, 'Larry', /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
 418     assert.ok(_.isEqual(a, b), 'Arrays containing nested arrays and objects are recursively compared');
 419
 420     // Overwrite the methods defined in ES 5.1 section 15.4.4.
 421     a.forEach = a.map = a.filter = a.every = a.indexOf = a.lastIndexOf = a.some = a.reduce = a.reduceRight = null;
 422     b.join = b.pop = b.reverse = b.shift = b.slice = b.splice = b.concat = b.sort = b.unshift = null;
 423
 424     // Array elements and properties.
 425     assert.ok(_.isEqual(a, b), 'Arrays containing equivalent elements and different non-numeric properties are equal');
 426     a.push('White Rocks');
 427     assert.ok(!_.isEqual(a, b), 'Arrays of different lengths are not equal');
 428     a.push('East Boulder');
 429     b.push('Gunbarrel Ranch', 'Teller Farm');
 430     assert.ok(!_.isEqual(a, b), 'Arrays of identical lengths containing different elements are not equal');
 431
 432     // Sparse arrays.
 433     assert.ok(_.isEqual(Array(3), Array(3)), 'Sparse arrays of identical lengths are equal');
 434     assert.ok(!_.isEqual(Array(3), Array(6)), 'Sparse arrays of different lengths are not equal when both are empty');
 435
 436     var sparse = [];
 437     sparse[1] = 5;
 438     assert.ok(_.isEqual(sparse, [void 0, 5]), 'Handles sparse arrays as dense');
 439
 440     // Simple objects.
 441     assert.ok(_.isEqual({a: 'Curly', b: 1, c: true}, {a: 'Curly', b: 1, c: true}), 'Objects containing identical primitives are equal');
 442     assert.ok(_.isEqual({a: /Curly/g, b: new Date(2009, 11, 13)}, {a: /Curly/g, b: new Date(2009, 11, 13)}), 'Objects containing equivalent members are equal');
 443     assert.ok(!_.isEqual({a: 63, b: 75}, {a: 61, b: 55}), 'Objects of identical sizes with different values are not equal');
 444     assert.ok(!_.isEqual({a: 63, b: 75}, {a: 61, c: 55}), 'Objects of identical sizes with different property names are not equal');
 445     assert.ok(!_.isEqual({a: 1, b: 2}, {a: 1}), 'Objects of different sizes are not equal');
 446     assert.ok(!_.isEqual({a: 1}, {a: 1, b: 2}), 'Commutative equality is implemented for objects');
 447     assert.ok(!_.isEqual({x: 1, y: void 0}, {x: 1, z: 2}), 'Objects with identical keys and different values are not equivalent');
 448
 449     // `A` contains nested objects and arrays.
 450     a = {
 451       name: new String('Moe Howard'),
 452       age: new Number(77),
 453       stooge: true,
 454       hobbies: ['acting'],
 455       film: {
 456         name: 'Sing a Song of Six Pants',
 457         release: new Date(1947, 9, 30),
 458         stars: [new String('Larry Fine'), 'Shemp Howard'],
 459         minutes: new Number(16),
 460         seconds: 54
 461       }
 462     };
 463
 464     // `B` contains equivalent nested objects and arrays.
 465     b = {
 466       name: new String('Moe Howard'),
 467       age: new Number(77),
 468       stooge: true,
 469       hobbies: ['acting'],
 470       film: {
 471         name: 'Sing a Song of Six Pants',
 472         release: new Date(1947, 9, 30),
 473         stars: [new String('Larry Fine'), 'Shemp Howard'],
 474         minutes: new Number(16),
 475         seconds: 54
 476       }
 477     };
 478     assert.ok(_.isEqual(a, b), 'Objects with nested equivalent members are recursively compared');
 479
 480     // Instances.
 481     assert.ok(_.isEqual(new First, new First), 'Object instances are equal');
 482     assert.ok(!_.isEqual(new First, new Second), 'Objects with different constructors and identical own properties are not equal');
 483     assert.ok(!_.isEqual({value: 1}, new First), 'Object instances and objects sharing equivalent properties are not equal');
 484     assert.ok(!_.isEqual({value: 2}, new Second), 'The prototype chain of objects should not be examined');
 485
 486     // Circular Arrays.
 487     (a = []).push(a);
 488     (b = []).push(b);
 489     assert.ok(_.isEqual(a, b), 'Arrays containing circular references are equal');
 490     a.push(new String('Larry'));
 491     b.push(new String('Larry'));
 492     assert.ok(_.isEqual(a, b), 'Arrays containing circular references and equivalent properties are equal');
 493     a.push('Shemp');
 494     b.push('Curly');
 495     assert.ok(!_.isEqual(a, b), 'Arrays containing circular references and different properties are not equal');
 496
 497     // More circular arrays #767.
 498     a = ['everything is checked but', 'this', 'is not'];
 499     a[1] = a;
 500     b = ['everything is checked but', ['this', 'array'], 'is not'];
 501     assert.ok(!_.isEqual(a, b), 'Comparison of circular references with non-circular references are not equal');
 502
 503     // Circular Objects.
 504     a = {abc: null};
 505     b = {abc: null};
 506     a.abc = a;
 507     b.abc = b;
 508     assert.ok(_.isEqual(a, b), 'Objects containing circular references are equal');
 509     a.def = 75;
 510     b.def = 75;
 511     assert.ok(_.isEqual(a, b), 'Objects containing circular references and equivalent properties are equal');
 512     a.def = new Number(75);
 513     b.def = new Number(63);
 514     assert.ok(!_.isEqual(a, b), 'Objects containing circular references and different properties are not equal');
 515
 516     // More circular objects #767.
 517     a = {everything: 'is checked', but: 'this', is: 'not'};
 518     a.but = a;
 519     b = {everything: 'is checked', but: {that: 'object'}, is: 'not'};
 520     assert.ok(!_.isEqual(a, b), 'Comparison of circular references with non-circular object references are not equal');
 521
 522     // Cyclic Structures.
 523     a = [{abc: null}];
 524     b = [{abc: null}];
 525     (a[0].abc = a).push(a);
 526     (b[0].abc = b).push(b);
 527     assert.ok(_.isEqual(a, b), 'Cyclic structures are equal');
 528     a[0].def = 'Larry';
 529     b[0].def = 'Larry';
 530     assert.ok(_.isEqual(a, b), 'Cyclic structures containing equivalent properties are equal');
 531     a[0].def = new String('Larry');
 532     b[0].def = new String('Curly');
 533     assert.ok(!_.isEqual(a, b), 'Cyclic structures containing different properties are not equal');
 534
 535     // Complex Circular References.
 536     a = {foo: {b: {foo: {c: {foo: null}}}}};
 537     b = {foo: {b: {foo: {c: {foo: null}}}}};
 538     a.foo.b.foo.c.foo = a;
 539     b.foo.b.foo.c.foo = b;
 540     assert.ok(_.isEqual(a, b), 'Cyclic structures with nested and identically-named properties are equal');
 541
 542     // Chaining.
 543     assert.ok(!_.isEqual(_({x: 1, y: void 0}).chain(), _({x: 1, z: 2}).chain()), 'Chained objects containing different values are not equal');
 544
 545     a = _({x: 1, y: 2}).chain();
 546     b = _({x: 1, y: 2}).chain();
 547     assert.equal(_.isEqual(a.isEqual(b), _(true)), true, '`isEqual` can be chained');
 548
 549     // Objects without a `constructor` property
 550     if (Object.create) {
 551       a = Object.create(null, {x: {value: 1, enumerable: true}});
 552       b = {x: 1};
 553       assert.ok(_.isEqual(a, b), 'Handles objects without a constructor (e.g. from Object.create');
 554     }
 555
 556     function Foo() { this.a = 1; }
 557     Foo.prototype.constructor = null;
 558
 559     var other = {a: 1};
 560     assert.strictEqual(_.isEqual(new Foo, other), false, 'Objects from different constructors are not equal');
 561
 562
 563     // Tricky object cases val comparisions
 564     assert.equal(_.isEqual([0], [-0]), false);
 565     assert.equal(_.isEqual({a: 0}, {a: -0}), false);
 566     assert.equal(_.isEqual([NaN], [NaN]), true);
 567     assert.equal(_.isEqual({a: NaN}, {a: NaN}), true);
 568
 569     if (typeof Symbol !== 'undefined') {
 570       var symbol = Symbol('x');
 571       assert.strictEqual(_.isEqual(symbol, symbol), true, 'A symbol is equal to itself');
 572       assert.strictEqual(_.isEqual(symbol, Object(symbol)), true, 'Even when wrapped in Object()');
 573       assert.strictEqual(_.isEqual(symbol, null), false, 'Different types are not equal');
 574     }
 575
 576   });
 577
 578   QUnit.test('isEmpty', function(assert) {
 579     assert.ok(!_([1]).isEmpty(), '[1] is not empty');
 580     assert.ok(_.isEmpty([]), '[] is empty');
 581     assert.ok(!_.isEmpty({one: 1}), '{one: 1} is not empty');
 582     assert.ok(_.isEmpty({}), '{} is empty');
 583     assert.ok(_.isEmpty(new RegExp('')), 'objects with prototype properties are empty');
 584     assert.ok(_.isEmpty(null), 'null is empty');
 585     assert.ok(_.isEmpty(), 'undefined is empty');
 586     assert.ok(_.isEmpty(''), 'the empty string is empty');
 587     assert.ok(!_.isEmpty('moe'), 'but other strings are not');
 588
 589     var obj = {one: 1};
 590     delete obj.one;
 591     assert.ok(_.isEmpty(obj), 'deleting all the keys from an object empties it');
 592
 593     var args = function(){ return arguments; };
 594     assert.ok(_.isEmpty(args()), 'empty arguments object is empty');
 595     assert.ok(!_.isEmpty(args('')), 'non-empty arguments object is not empty');
 596
 597     // covers collecting non-enumerable properties in IE < 9
 598     var nonEnumProp = {toString: 5};
 599     assert.ok(!_.isEmpty(nonEnumProp), 'non-enumerable property is not empty');
 600   });
 601
 602   if (typeof document === 'object') {
 603     QUnit.test('isElement', function(assert) {
 604       assert.ok(!_.isElement('div'), 'strings are not dom elements');
 605       assert.ok(_.isElement(testElement), 'an element is a DOM element');
 606     });
 607   }
 608
 609   QUnit.test('isArguments', function(assert) {
 610     var args = (function(){ return arguments; }(1, 2, 3));
 611     assert.ok(!_.isArguments('string'), 'a string is not an arguments object');
 612     assert.ok(!_.isArguments(_.isArguments), 'a function is not an arguments object');
 613     assert.ok(_.isArguments(args), 'but the arguments object is an arguments object');
 614     assert.ok(!_.isArguments(_.toArray(args)), 'but not when it\'s converted into an array');
 615     assert.ok(!_.isArguments([1, 2, 3]), 'and not vanilla arrays.');
 616   });
 617
 618   QUnit.test('isObject', function(assert) {
 619     assert.ok(_.isObject(arguments), 'the arguments object is object');
 620     assert.ok(_.isObject([1, 2, 3]), 'and arrays');
 621     if (testElement) {
 622       assert.ok(_.isObject(testElement), 'and DOM element');
 623     }
 624     assert.ok(_.isObject(function() {}), 'and functions');
 625     assert.ok(!_.isObject(null), 'but not null');
 626     assert.ok(!_.isObject(void 0), 'and not undefined');
 627     assert.ok(!_.isObject('string'), 'and not string');
 628     assert.ok(!_.isObject(12), 'and not number');
 629     assert.ok(!_.isObject(true), 'and not boolean');
 630     assert.ok(_.isObject(new String('string')), 'but new String()');
 631   });
 632
 633   QUnit.test('isArray', function(assert) {
 634     assert.ok(!_.isArray(void 0), 'undefined vars are not arrays');
 635     assert.ok(!_.isArray(arguments), 'the arguments object is not an array');
 636     assert.ok(_.isArray([1, 2, 3]), 'but arrays are');
 637   });
 638
 639   QUnit.test('isString', function(assert) {
 640     var obj = new String('I am a string object');
 641     if (testElement) {
 642       assert.ok(!_.isString(testElement), 'an element is not a string');
 643     }
 644     assert.ok(_.isString([1, 2, 3].join(', ')), 'but strings are');
 645     assert.strictEqual(_.isString('I am a string literal'), true, 'string literals are');
 646     assert.ok(_.isString(obj), 'so are String objects');
 647     assert.strictEqual(_.isString(1), false);
 648   });
 649
 650   QUnit.test('isSymbol', function(assert) {
 651     assert.ok(!_.isSymbol(0), 'numbers are not symbols');
 652     assert.ok(!_.isSymbol(''), 'strings are not symbols');
 653     assert.ok(!_.isSymbol(_.isSymbol), 'functions are not symbols');
 654     if (typeof Symbol === 'function') {
 655       assert.ok(_.isSymbol(Symbol()), 'symbols are symbols');
 656       assert.ok(_.isSymbol(Symbol('description')), 'described symbols are symbols');
 657       assert.ok(_.isSymbol(Object(Symbol())), 'boxed symbols are symbols');
 658     }
 659   });
 660
 661   QUnit.test('isNumber', function(assert) {
 662     assert.ok(!_.isNumber('string'), 'a string is not a number');
 663     assert.ok(!_.isNumber(arguments), 'the arguments object is not a number');
 664     assert.ok(!_.isNumber(void 0), 'undefined is not a number');
 665     assert.ok(_.isNumber(3 * 4 - 7 / 10), 'but numbers are');
 666     assert.ok(_.isNumber(NaN), 'NaN *is* a number');
 667     assert.ok(_.isNumber(Infinity), 'Infinity is a number');
 668     assert.ok(!_.isNumber('1'), 'numeric strings are not numbers');
 669   });
 670
 671   QUnit.test('isBoolean', function(assert) {
 672     assert.ok(!_.isBoolean(2), 'a number is not a boolean');
 673     assert.ok(!_.isBoolean('string'), 'a string is not a boolean');
 674     assert.ok(!_.isBoolean('false'), 'the string "false" is not a boolean');
 675     assert.ok(!_.isBoolean('true'), 'the string "true" is not a boolean');
 676     assert.ok(!_.isBoolean(arguments), 'the arguments object is not a boolean');
 677     assert.ok(!_.isBoolean(void 0), 'undefined is not a boolean');
 678     assert.ok(!_.isBoolean(NaN), 'NaN is not a boolean');
 679     assert.ok(!_.isBoolean(null), 'null is not a boolean');
 680     assert.ok(_.isBoolean(true), 'but true is');
 681     assert.ok(_.isBoolean(false), 'and so is false');
 682   });
 683
 684   QUnit.test('isMap', function(assert) {
 685     assert.ok(!_.isMap('string'), 'a string is not a map');
 686     assert.ok(!_.isMap(2), 'a number is not a map');
 687     assert.ok(!_.isMap({}), 'an object is not a map');
 688     assert.ok(!_.isMap(false), 'a boolean is not a map');
 689     assert.ok(!_.isMap(void 0), 'undefined is not a map');
 690     assert.ok(!_.isMap([1, 2, 3]), 'an array is not a map');
 691     if (typeof Set === 'function') {
 692       assert.ok(!_.isMap(new Set()), 'a set is not a map');
 693     }
 694     if (typeof WeakSet === 'function') {
 695       assert.ok(!_.isMap(new WeakSet()), 'a weakset is not a map');
 696     }
 697     if (typeof WeakMap === 'function') {
 698       assert.ok(!_.isMap(new WeakMap()), 'a weakmap is not a map');
 699     }
 700     if (typeof Map === 'function') {
 701       var keyString = 'a string';
 702       var obj = new Map();
 703       obj.set(keyString, 'value');
 704       assert.ok(_.isMap(obj), 'but a map is');
 705     }
 706   });
 707
 708   QUnit.test('isWeakMap', function(assert) {
 709     assert.ok(!_.isWeakMap('string'), 'a string is not a weakmap');
 710     assert.ok(!_.isWeakMap(2), 'a number is not a weakmap');
 711     assert.ok(!_.isWeakMap({}), 'an object is not a weakmap');
 712     assert.ok(!_.isWeakMap(false), 'a boolean is not a weakmap');
 713     assert.ok(!_.isWeakMap(void 0), 'undefined is not a weakmap');
 714     assert.ok(!_.isWeakMap([1, 2, 3]), 'an array is not a weakmap');
 715     if (typeof Set === 'function') {
 716       assert.ok(!_.isWeakMap(new Set()), 'a set is not a weakmap');
 717     }
 718     if (typeof WeakSet === 'function') {
 719       assert.ok(!_.isWeakMap(new WeakSet()), 'a weakset is not a weakmap');
 720     }
 721     if (typeof Map === 'function') {
 722       assert.ok(!_.isWeakMap(new Map()), 'a map is not a weakmap');
 723     }
 724     if (typeof WeakMap === 'function') {
 725       var keyObj = {}, obj = new WeakMap();
 726       obj.set(keyObj, 'value');
 727       assert.ok(_.isWeakMap(obj), 'but a weakmap is');
 728     }
 729   });
 730
 731   QUnit.test('isSet', function(assert) {
 732     assert.ok(!_.isSet('string'), 'a string is not a set');
 733     assert.ok(!_.isSet(2), 'a number is not a set');
 734     assert.ok(!_.isSet({}), 'an object is not a set');
 735     assert.ok(!_.isSet(false), 'a boolean is not a set');
 736     assert.ok(!_.isSet(void 0), 'undefined is not a set');
 737     assert.ok(!_.isSet([1, 2, 3]), 'an array is not a set');
 738     if (typeof Map === 'function') {
 739       assert.ok(!_.isSet(new Map()), 'a map is not a set');
 740     }
 741     if (typeof WeakMap === 'function') {
 742       assert.ok(!_.isSet(new WeakMap()), 'a weakmap is not a set');
 743     }
 744     if (typeof WeakSet === 'function') {
 745       assert.ok(!_.isSet(new WeakSet()), 'a weakset is not a set');
 746     }
 747     if (typeof Set === 'function') {
 748       var obj = new Set();
 749       obj.add(1).add('string').add(false).add({});
 750       assert.ok(_.isSet(obj), 'but a set is');
 751     }
 752   });
 753
 754   QUnit.test('isWeakSet', function(assert) {
 755
 756     assert.ok(!_.isWeakSet('string'), 'a string is not a weakset');
 757     assert.ok(!_.isWeakSet(2), 'a number is not a weakset');
 758     assert.ok(!_.isWeakSet({}), 'an object is not a weakset');
 759     assert.ok(!_.isWeakSet(false), 'a boolean is not a weakset');
 760     assert.ok(!_.isWeakSet(void 0), 'undefined is not a weakset');
 761     assert.ok(!_.isWeakSet([1, 2, 3]), 'an array is not a weakset');
 762     if (typeof Map === 'function') {
 763       assert.ok(!_.isWeakSet(new Map()), 'a map is not a weakset');
 764     }
 765     if (typeof WeakMap === 'function') {
 766       assert.ok(!_.isWeakSet(new WeakMap()), 'a weakmap is not a weakset');
 767     }
 768     if (typeof Set === 'function') {
 769       assert.ok(!_.isWeakSet(new Set()), 'a set is not a weakset');
 770     }
 771     if (typeof WeakSet === 'function') {
 772       var obj = new WeakSet();
 773       obj.add({x: 1}, {y: 'string'}).add({y: 'string'}).add({z: [1, 2, 3]});
 774       assert.ok(_.isWeakSet(obj), 'but a weakset is');
 775     }
 776   });
 777
 778   QUnit.test('isFunction', function(assert) {
 779     assert.ok(!_.isFunction(void 0), 'undefined vars are not functions');
 780     assert.ok(!_.isFunction([1, 2, 3]), 'arrays are not functions');
 781     assert.ok(!_.isFunction('moe'), 'strings are not functions');
 782     assert.ok(_.isFunction(_.isFunction), 'but functions are');
 783     assert.ok(_.isFunction(function(){}), 'even anonymous ones');
 784
 785     if (testElement) {
 786       assert.ok(!_.isFunction(testElement), 'elements are not functions');
 787     }
 788
 789     var nodelist = typeof document != 'undefined' && document.childNodes;
 790     if (nodelist) {
 791       assert.ok(!_.isFunction(nodelist));
 792     }
 793   });
 794
 795   if (typeof Int8Array !== 'undefined') {
 796     QUnit.test('#1929 Typed Array constructors are functions', function(assert) {
 797       _.chain(['Float32Array', 'Float64Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array'])
 798       .map(_.propertyOf(typeof GLOBAL != 'undefined' ? GLOBAL : window))
 799       .compact()
 800       .each(function(TypedArray) {
 801         // PhantomJS reports `typeof UInt8Array == 'object'` and doesn't report toString TypeArray
 802         // as a function
 803         assert.strictEqual(_.isFunction(TypedArray), Object.prototype.toString.call(TypedArray) === '[object Function]');
 804       });
 805     });
 806   }
 807
 808   QUnit.test('isDate', function(assert) {
 809     assert.ok(!_.isDate(100), 'numbers are not dates');
 810     assert.ok(!_.isDate({}), 'objects are not dates');
 811     assert.ok(_.isDate(new Date()), 'but dates are');
 812   });
 813
 814   QUnit.test('isRegExp', function(assert) {
 815     assert.ok(!_.isRegExp(_.identity), 'functions are not RegExps');
 816     assert.ok(_.isRegExp(/identity/), 'but RegExps are');
 817   });
 818
 819   QUnit.test('isFinite', function(assert) {
 820     assert.ok(!_.isFinite(void 0), 'undefined is not finite');
 821     assert.ok(!_.isFinite(null), 'null is not finite');
 822     assert.ok(!_.isFinite(NaN), 'NaN is not finite');
 823     assert.ok(!_.isFinite(Infinity), 'Infinity is not finite');
 824     assert.ok(!_.isFinite(-Infinity), '-Infinity is not finite');
 825     assert.ok(_.isFinite('12'), 'Numeric strings are numbers');
 826     assert.ok(!_.isFinite('1a'), 'Non numeric strings are not numbers');
 827     assert.ok(!_.isFinite(''), 'Empty strings are not numbers');
 828     var obj = new Number(5);
 829     assert.ok(_.isFinite(obj), 'Number instances can be finite');
 830     assert.ok(_.isFinite(0), '0 is finite');
 831     assert.ok(_.isFinite(123), 'Ints are finite');
 832     assert.ok(_.isFinite(-12.44), 'Floats are finite');
 833     if (typeof Symbol === 'function') {
 834       assert.ok(!_.isFinite(Symbol()), 'symbols are not numbers');
 835       assert.ok(!_.isFinite(Symbol('description')), 'described symbols are not numbers');
 836       assert.ok(!_.isFinite(Object(Symbol())), 'boxed symbols are not numbers');
 837     }
 838   });
 839
 840   QUnit.test('isNaN', function(assert) {
 841     assert.ok(!_.isNaN(void 0), 'undefined is not NaN');
 842     assert.ok(!_.isNaN(null), 'null is not NaN');
 843     assert.ok(!_.isNaN(0), '0 is not NaN');
 844     assert.ok(!_.isNaN(new Number(0)), 'wrapped 0 is not NaN');
 845     assert.ok(_.isNaN(NaN), 'but NaN is');
 846     assert.ok(_.isNaN(new Number(NaN)), 'wrapped NaN is still NaN');
 847   });
 848
 849   QUnit.test('isNull', function(assert) {
 850     assert.ok(!_.isNull(void 0), 'undefined is not null');
 851     assert.ok(!_.isNull(NaN), 'NaN is not null');
 852     assert.ok(_.isNull(null), 'but null is');
 853   });
 854
 855   QUnit.test('isUndefined', function(assert) {
 856     assert.ok(!_.isUndefined(1), 'numbers are defined');
 857     assert.ok(!_.isUndefined(null), 'null is defined');
 858     assert.ok(!_.isUndefined(false), 'false is defined');
 859     assert.ok(!_.isUndefined(NaN), 'NaN is defined');
 860     assert.ok(_.isUndefined(), 'nothing is undefined');
 861     assert.ok(_.isUndefined(void 0), 'undefined is undefined');
 862   });
 863
 864   QUnit.test('isError', function(assert) {
 865     assert.ok(!_.isError(1), 'numbers are not Errors');
 866     assert.ok(!_.isError(null), 'null is not an Error');
 867     assert.ok(!_.isError(Error), 'functions are not Errors');
 868     assert.ok(_.isError(new Error()), 'Errors are Errors');
 869     assert.ok(_.isError(new EvalError()), 'EvalErrors are Errors');
 870     assert.ok(_.isError(new RangeError()), 'RangeErrors are Errors');
 871     assert.ok(_.isError(new ReferenceError()), 'ReferenceErrors are Errors');
 872     assert.ok(_.isError(new SyntaxError()), 'SyntaxErrors are Errors');
 873     assert.ok(_.isError(new TypeError()), 'TypeErrors are Errors');
 874     assert.ok(_.isError(new URIError()), 'URIErrors are Errors');
 875   });
 876
 877   QUnit.test('tap', function(assert) {
 878     var intercepted = null;
 879     var interceptor = function(obj) { intercepted = obj; };
 880     var returned = _.tap(1, interceptor);
 881     assert.equal(intercepted, 1, 'passes tapped object to interceptor');
 882     assert.equal(returned, 1, 'returns tapped object');
 883
 884     returned = _([1, 2, 3]).chain().
 885       map(function(n){ return n * 2; }).
 886       max().
 887       tap(interceptor).
 888       value();
 889     assert.equal(returned, 6, 'can use tapped objects in a chain');
 890     assert.equal(intercepted, returned, 'can use tapped objects in a chain');
 891   });
 892
 893   QUnit.test('has', function(assert) {
 894     var obj = {foo: 'bar', func: function(){}};
 895     assert.ok(_.has(obj, 'foo'), 'has() checks that the object has a property.');
 896     assert.ok(!_.has(obj, 'baz'), "has() returns false if the object doesn't have the property.");
 897     assert.ok(_.has(obj, 'func'), 'has() works for functions too.');
 898     obj.hasOwnProperty = null;
 899     assert.ok(_.has(obj, 'foo'), 'has() works even when the hasOwnProperty method is deleted.');
 900     var child = {};
 901     child.prototype = obj;
 902     assert.ok(!_.has(child, 'foo'), 'has() does not check the prototype chain for a property.');
 903     assert.strictEqual(_.has(null, 'foo'), false, 'has() returns false for null');
 904     assert.strictEqual(_.has(void 0, 'foo'), false, 'has() returns false for undefined');
 905   });
 906
 907   QUnit.test('isMatch', function(assert) {
 908     var moe = {name: 'Moe Howard', hair: true};
 909     var curly = {name: 'Curly Howard', hair: false};
 910
 911     assert.equal(_.isMatch(moe, {hair: true}), true, 'Returns a boolean');
 912     assert.equal(_.isMatch(curly, {hair: true}), false, 'Returns a boolean');
 913
 914     assert.equal(_.isMatch(5, {__x__: void 0}), false, 'can match undefined props on primitives');
 915     assert.equal(_.isMatch({__x__: void 0}, {__x__: void 0}), true, 'can match undefined props');
 916
 917     assert.equal(_.isMatch(null, {}), true, 'Empty spec called with null object returns true');
 918     assert.equal(_.isMatch(null, {a: 1}), false, 'Non-empty spec called with null object returns false');
 919
 920     _.each([null, void 0], function(item) { assert.strictEqual(_.isMatch(item, null), true, 'null matches null'); });
 921     _.each([null, void 0], function(item) { assert.strictEqual(_.isMatch(item, null), true, 'null matches {}'); });
 922     assert.strictEqual(_.isMatch({b: 1}, {a: void 0}), false, 'handles undefined values (1683)');
 923
 924     _.each([true, 5, NaN, null, void 0], function(item) {
 925       assert.strictEqual(_.isMatch({a: 1}, item), true, 'treats primitives as empty');
 926     });
 927
 928     function Prototest() {}
 929     Prototest.prototype.x = 1;
 930     var specObj = new Prototest;
 931     assert.equal(_.isMatch({x: 2}, specObj), true, 'spec is restricted to own properties');
 932
 933     specObj.y = 5;
 934     assert.equal(_.isMatch({x: 1, y: 5}, specObj), true);
 935     assert.equal(_.isMatch({x: 1, y: 4}, specObj), false);
 936
 937     assert.ok(_.isMatch(specObj, {x: 1, y: 5}), 'inherited and own properties are checked on the test object');
 938
 939     Prototest.x = 5;
 940     assert.ok(_.isMatch({x: 5, y: 1}, Prototest), 'spec can be a function');
 941
 942     //null edge cases
 943     var oCon = {constructor: Object};
 944     assert.deepEqual(_.map([null, void 0, 5, {}], _.partial(_.isMatch, _, oCon)), [false, false, false, true], 'doesnt falsey match constructor on undefined/null');
 945   });
 946
 947   QUnit.test('matcher', function(assert) {
 948     var moe = {name: 'Moe Howard', hair: true};
 949     var curly = {name: 'Curly Howard', hair: false};
 950     var stooges = [moe, curly];
 951
 952     assert.equal(_.matcher({hair: true})(moe), true, 'Returns a boolean');
 953     assert.equal(_.matcher({hair: true})(curly), false, 'Returns a boolean');
 954
 955     assert.equal(_.matcher({__x__: void 0})(5), false, 'can match undefined props on primitives');
 956     assert.equal(_.matcher({__x__: void 0})({__x__: void 0}), true, 'can match undefined props');
 957
 958     assert.equal(_.matcher({})(null), true, 'Empty spec called with null object returns true');
 959     assert.equal(_.matcher({a: 1})(null), false, 'Non-empty spec called with null object returns false');
 960
 961     assert.ok(_.find(stooges, _.matcher({hair: false})) === curly, 'returns a predicate that can be used by finding functions.');
 962     assert.ok(_.find(stooges, _.matcher(moe)) === moe, 'can be used to locate an object exists in a collection.');
 963     assert.deepEqual(_.filter([null, void 0], _.matcher({a: 1})), [], 'Do not throw on null values.');
 964
 965     assert.deepEqual(_.filter([null, void 0], _.matcher(null)), [null, void 0], 'null matches null');
 966     assert.deepEqual(_.filter([null, void 0], _.matcher({})), [null, void 0], 'null matches {}');
 967     assert.deepEqual(_.filter([{b: 1}], _.matcher({a: void 0})), [], 'handles undefined values (1683)');
 968
 969     _.each([true, 5, NaN, null, void 0], function(item) {
 970       assert.equal(_.matcher(item)({a: 1}), true, 'treats primitives as empty');
 971     });
 972
 973     function Prototest() {}
 974     Prototest.prototype.x = 1;
 975     var specObj = new Prototest;
 976     var protospec = _.matcher(specObj);
 977     assert.equal(protospec({x: 2}), true, 'spec is restricted to own properties');
 978
 979     specObj.y = 5;
 980     protospec = _.matcher(specObj);
 981     assert.equal(protospec({x: 1, y: 5}), true);
 982     assert.equal(protospec({x: 1, y: 4}), false);
 983
 984     assert.ok(_.matcher({x: 1, y: 5})(specObj), 'inherited and own properties are checked on the test object');
 985
 986     Prototest.x = 5;
 987     assert.ok(_.matcher(Prototest)({x: 5, y: 1}), 'spec can be a function');
 988
 989     // #1729
 990     var o = {b: 1};
 991     var m = _.matcher(o);
 992
 993     assert.equal(m({b: 1}), true);
 994     o.b = 2;
 995     o.a = 1;
 996     assert.equal(m({b: 1}), true, 'changing spec object doesnt change matches result');
 997
 998
 999     //null edge cases
1000     var oCon = _.matcher({constructor: Object});
1001     assert.deepEqual(_.map([null, void 0, 5, {}], oCon), [false, false, false, true], 'doesnt falsey match constructor on undefined/null');
1002   });
1003
1004   QUnit.test('matches', function(assert) {
1005     assert.strictEqual(_.matches, _.matcher, 'is an alias for matcher');
1006   });
1007
1008   QUnit.test('findKey', function(assert) {
1009     var objects = {
1010       a: {a: 0, b: 0},
1011       b: {a: 1, b: 1},
1012       c: {a: 2, b: 2}
1013     };
1014
1015     assert.equal(_.findKey(objects, function(obj) {
1016       return obj.a === 0;
1017     }), 'a');
1018
1019     assert.equal(_.findKey(objects, function(obj) {
1020       return obj.b * obj.a === 4;
1021     }), 'c');
1022
1023     assert.equal(_.findKey(objects, 'a'), 'b', 'Uses lookupIterator');
1024
1025     assert.equal(_.findKey(objects, function(obj) {
1026       return obj.b * obj.a === 5;
1027     }), void 0);
1028
1029     assert.strictEqual(_.findKey([1, 2, 3, 4, 5, 6], function(obj) {
1030       return obj === 3;
1031     }), '2', 'Keys are strings');
1032
1033     assert.strictEqual(_.findKey(objects, function(a) {
1034       return a.foo === null;
1035     }), void 0);
1036
1037     _.findKey({a: {a: 1}}, function(a, key, obj) {
1038       assert.equal(key, 'a');
1039       assert.deepEqual(obj, {a: {a: 1}});
1040       assert.strictEqual(this, objects, 'called with context');
1041     }, objects);
1042
1043     var array = [1, 2, 3, 4];
1044     array.match = 55;
1045     assert.strictEqual(_.findKey(array, function(x) { return x === 55; }), 'match', 'matches array-likes keys');
1046   });
1047
1048
1049   QUnit.test('mapObject', function(assert) {
1050     var obj = {a: 1, b: 2};
1051     var objects = {
1052       a: {a: 0, b: 0},
1053       b: {a: 1, b: 1},
1054       c: {a: 2, b: 2}
1055     };
1056
1057     assert.deepEqual(_.mapObject(obj, function(val) {
1058       return val * 2;
1059     }), {a: 2, b: 4}, 'simple objects');
1060
1061     assert.deepEqual(_.mapObject(objects, function(val) {
1062       return _.reduce(val, function(memo, v){
1063         return memo + v;
1064       }, 0);
1065     }), {a: 0, b: 2, c: 4}, 'nested objects');
1066
1067     assert.deepEqual(_.mapObject(obj, function(val, key, o) {
1068       return o[key] * 2;
1069     }), {a: 2, b: 4}, 'correct keys');
1070
1071     assert.deepEqual(_.mapObject([1, 2], function(val) {
1072       return val * 2;
1073     }), {0: 2, 1: 4}, 'check behavior for arrays');
1074
1075     assert.deepEqual(_.mapObject(obj, function(val) {
1076       return val * this.multiplier;
1077     }, {multiplier: 3}), {a: 3, b: 6}, 'keep context');
1078
1079     assert.deepEqual(_.mapObject({a: 1}, function() {
1080       return this.length;
1081     }, [1, 2]), {a: 2}, 'called with context');
1082
1083     var ids = _.mapObject({length: 2, 0: {id: '1'}, 1: {id: '2'}}, function(n){
1084       return n.id;
1085     });
1086     assert.deepEqual(ids, {length: void 0, 0: '1', 1: '2'}, 'Check with array-like objects');
1087
1088     // Passing a property name like _.pluck.
1089     var people = {a: {name: 'moe', age: 30}, b: {name: 'curly', age: 50}};
1090     assert.deepEqual(_.mapObject(people, 'name'), {a: 'moe', b: 'curly'}, 'predicate string map to object properties');
1091
1092     _.each([null, void 0, 1, 'abc', [], {}, void 0], function(val){
1093       assert.deepEqual(_.mapObject(val, _.identity), {}, 'mapValue identity');
1094     });
1095
1096     var Proto = function(){ this.a = 1; };
1097     Proto.prototype.b = 1;
1098     var protoObj = new Proto();
1099     assert.deepEqual(_.mapObject(protoObj, _.identity), {a: 1}, 'ignore inherited values from prototypes');
1100
1101   });
1102 }());