11     var a = []; a[1] = 0;
12     assert.deepEqual(_.keys(a), ['1'], 'is not fooled by sparse arrays; see issue #95');
41     var a = []; a[1] = 0;
42     assert.deepEqual(_.allKeys(a), ['1'], 'is not fooled by sparse arrays; see issue #95');
44     a.a = a;
45 …assert.deepEqual(_.allKeys(a), ['1', 'a'], 'is not fooled by sparse arrays with additional propert…
96     var obj = {a: 'dash', b: _.map, c: /yo/, d: _.reduce};  property in AnonymousFunction235956210700.obj
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 tru…
117     result = _.extend({}, {a: void 0, b: null});
121     F.prototype = {a: 'b'};  property in F
124 …assert.deepEqual(_.extend({}, subObj), {a: 'b', c: 'd'}, 'extend copies all properties from source…
130       _.extend(result, null, void 0, {a: 1});
133     assert.equal(result.a, 1, 'should not error on `null` or `undefined` sources');
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');
141 …assert.equal(_.extendOwn({}, {a: 'b'}).a, 'b', 'can extend an object with the attributes of anothe…
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 tru…
148 …assert.deepEqual(_.extendOwn({}, {a: void 0, b: null}), {a: void 0, b: null}, 'copies undefined va…
151     F.prototype = {a: 'b'};  property in F
157 …assert.deepEqual(_.extendOwn(result, null, void 0, {a: 1}), {a: 1}, 'should not error on `null` or…
160 …assert.strictEqual(_.extendOwn(val, {a: 1}), val, 'extending non-objects results in returning the …
163 …assert.strictEqual(_.extendOwn(void 0, {a: 1}), void 0, 'extending undefined results in undefined'…
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 norm…
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']);
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');
190     var data = {a: 1, b: 2, c: 3};  property in AnonymousFunction235956210d00.data
197     assert.deepEqual(result, {a: 1, c: 3}, 'can accept a predicate and context');
200     Obj.prototype = {a: 1, b: 2, c: 3};  property in Obj
202     assert.deepEqual(_.pick(instance, 'a', 'c'), {a: 1, c: 3}, 'include prototype props');
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');
220     result = _.omit({a: 1, b: 2, c: 3}, ['b', 'c']);
221     assert.deepEqual(result, {a: 1}, 'can omit properties named in an array');
229     var data = {a: 1, b: 2, c: 3};  property in AnonymousFunction235956211100.data
239     Obj.prototype = {a: 1, b: 2, c: 3};  property in Obj
241     assert.deepEqual(_.omit(instance, 'b'), {a: 1, c: 3}, 'include prototype props');
245     }, instance), {a: 1, b: 2}, 'function is given context');
264       _.defaults(options, null, void 0, {a: 1});
267     assert.equal(options.a, 1, 'should not error on `null` or `undefined` sources');
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');
416 …var a = [new Number(47), false, 'Larry', /Moe/, new Date(2009, 11, 13), ['running', 'biking', new …
417 …'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');
421 …a.forEach = a.map = a.filter = a.every = a.indexOf = a.lastIndexOf = a.some = a.reduce = a.reduceR…
425 …assert.ok(_.isEqual(a, b), 'Arrays containing equivalent elements and different non-numeric proper…
426     a.push('White Rocks');
427     assert.notOk(_.isEqual(a, b), 'Arrays of different lengths are not equal');
428     a.push('East Boulder');
430 …assert.notOk(_.isEqual(a, b), 'Arrays of identical lengths containing different elements are not e…
441 …assert.ok(_.isEqual({a: 'Curly', b: 1, c: true}, {a: 'Curly', b: 1, c: true}), 'Objects containing…
442 …assert.ok(_.isEqual({a: /Curly/g, b: new Date(2009, 11, 13)}, {a: /Curly/g, b: new Date(2009, 11, …
443 …assert.notOk(_.isEqual({a: 63, b: 75}, {a: 61, b: 55}), 'Objects of identical sizes with different…
444 …assert.notOk(_.isEqual({a: 63, b: 75}, {a: 61, c: 55}), 'Objects of identical sizes with different…
445     assert.notOk(_.isEqual({a: 1, b: 2}, {a: 1}), 'Objects of different sizes are not equal');
446 …  assert.notOk(_.isEqual({a: 1}, {a: 1, b: 2}), 'Commutative equality is implemented for objects');
450     a = {  class in AnonymousFunction235956211700
478     assert.ok(_.isEqual(a, b), 'Objects with nested equivalent members are recursively compared');
487     (a = []).push(a);
489     assert.ok(_.isEqual(a, b), 'Arrays containing circular references are equal');
490     a.push(new String('Larry'));
492 …assert.ok(_.isEqual(a, b), 'Arrays containing circular references and equivalent properties are eq…
493     a.push('Shemp');
495 …assert.notOk(_.isEqual(a, b), 'Arrays containing circular references and different properties are …
498     a = ['everything is checked but', 'this', 'is not'];
499     a[1] = a;
501 …assert.notOk(_.isEqual(a, b), 'Comparison of circular references with non-circular references are …
504     a = {abc: null};  class in AnonymousFunction235956211700
506     a.abc = a;
508     assert.ok(_.isEqual(a, b), 'Objects containing circular references are equal');
509     a.def = 75;
511 …assert.ok(_.isEqual(a, b), 'Objects containing circular references and equivalent properties are e…
512     a.def = new Number(75);
514 …assert.notOk(_.isEqual(a, b), 'Objects containing circular references and different properties are…
517     a = {everything: 'is checked', but: 'this', is: 'not'};  class in AnonymousFunction235956211700
518     a.but = a;
520 …assert.notOk(_.isEqual(a, b), 'Comparison of circular references with non-circular object referenc…
523     a = [{abc: null}];
525     (a[0].abc = a).push(a);
527     assert.ok(_.isEqual(a, b), 'Cyclic structures are equal');
528     a[0].def = 'Larry';
530     assert.ok(_.isEqual(a, b), 'Cyclic structures containing equivalent properties are equal');
531     a[0].def = new String('Larry');
533 …  assert.notOk(_.isEqual(a, b), 'Cyclic structures containing different properties are not equal');
536     a = {foo: {b: {foo: {c: {foo: null}}}}};  class in AnonymousFunction235956211700
538     a.foo.b.foo.c.foo = a;
540 …assert.ok(_.isEqual(a, b), 'Cyclic structures with nested and identically-named properties are equ…
545     a = _({x: 1, y: 2}).chain();
547     assert.equal(_.isEqual(a.isEqual(b), _(true)), true, '`isEqual` can be chained');
551       a = Object.create(null, {x: {value: 1, enumerable: true}});
553       assert.ok(_.isEqual(a, b), 'Handles objects without a constructor (e.g. from Object.create');
556     function Foo() { this.a = 1; }
559     var other = {a: 1};  property in AnonymousFunction235956211700.other
565     assert.equal(_.isEqual({a: 0}, {a: -0}), false);
567     assert.equal(_.isEqual({a: NaN}, {a: NaN}), true);
921 …assert.equal(_.isMatch(null, {a: 1}), false, 'Non-empty spec called with null object returns false…
925     assert.strictEqual(_.isMatch({b: 1}, {a: void 0}), false, 'handles undefined values (1683)');
928       assert.strictEqual(_.isMatch({a: 1}, item), true, 'treats primitives as empty');
962 …assert.equal(_.matcher({a: 1})(null), false, 'Non-empty spec called with null object returns false…
966 … assert.deepEqual(_.filter([null, void 0], _.matcher({a: 1})), [], 'Do not throw on null values.');
970 …assert.deepEqual(_.filter([{b: 1}], _.matcher({a: void 0})), [], 'handles undefined values (1683)'…
973       assert.equal(_.matcher(item)({a: 1}), true, 'treats primitives as empty');
998     o.a = 1;
1013       a: {a: 0, b: 0},  class in AnonymousFunction235956213e00.objects
1014       b: {a: 1, b: 1},  property in AnonymousFunction235956213e00.objects.b
1015       c: {a: 2, b: 2}  property in AnonymousFunction235956213e00.objects.c
1019       return obj.a === 0;
1023       return obj.b * obj.a === 4;
1029       return obj.b * obj.a === 5;
1036     assert.strictEqual(_.findKey(objects, function(a) {  argument
1037       return a.foo === null;
1040     _.findKey({a: {a: 1}}, function(a, key, obj) {  argument
1042       assert.deepEqual(obj, {a: {a: 1}});
1053     var obj = {a: 1, b: 2};  property in AnonymousFunction235956214600.obj
1055       a: {a: 0, b: 0},  property in AnonymousFunction235956214600.objects.a
1056       b: {a: 1, b: 1},  property in AnonymousFunction235956214600.objects.b
1057       c: {a: 2, b: 2}  property in AnonymousFunction235956214600.objects.c
1062     }), {a: 2, b: 4}, 'simple objects');
1068     }), {a: 0, b: 2, c: 4}, 'nested objects');
1072     }), {a: 2, b: 4}, 'correct keys');
1080     }, {multiplier: 3}), {a: 3, b: 6}, 'keep context');
1082     assert.deepEqual(_.mapObject({a: 1}, function() {
1084     }, [1, 2]), {a: 2}, 'called with context');
1092     var people = {a: {name: 'moe', age: 30}, b: {name: 'curly', age: 50}};  class in AnonymousFunction235956214600.people
1093 …assert.deepEqual(_.mapObject(people, 'name'), {a: 'moe', b: 'curly'}, 'predicate string map to obj…
1099     var Proto = function(){ this.a = 1; };
1102 …assert.deepEqual(_.mapObject(protoObj, _.identity), {a: 1}, 'ignore inherited values from prototyp…