741     var path = require('path'),
742         basePath = path.dirname(filePath);
751         _['_' + funcName] = interopRequire(path.join(basePath, '_' + funcName));
7837       lodashStable.each(['a', ['a']], function(path) {  argument
7838         assert.strictEqual(func(object, path), true);
7854       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
7855         assert.strictEqual(func(object, path), true);
7858       lodashStable.each(['a.a', ['a', 'a']], function(path) {  argument
7859         assert.strictEqual(func(object, path), false);
7874         var actual = lodashStable.map(paths, function(path) {  argument
7875           return func(object, index ? [path] : path);
7893       lodashStable.each([1, [1]], function(path) {  argument
7894         assert.strictEqual(func(array, path), true);
7942       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
7943         assert.strictEqual(func(object, path), true);
7967         return lodashStable.map(['a[0]', ['a', '0']], function(path) {  argument
7968           return func({ 'a': value }, path);
7981       lodashStable.each(['a', ['a']], function(path) {  argument
7982         assert.strictEqual(func(new Foo, path), !isHas);
7992       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
7993         assert.strictEqual(func(new Foo, path), !isHas);
8003       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
8005           return func(value, path);
8018 …e.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {  argument
8020           return func(value, path);
8033       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
8036           return func(object, path);
8050         return lodashStable.map(['a[0].b', ['a', '0', 'b']], function(path) {  argument
8051           return func({ 'a': value }, path);
8771       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
8772         var actual = _.invoke(object, path, 1, 2);
8782       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
8783         assert.deepEqual(_.invoke(object, path), 1);
8897       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
8898         assert.deepEqual(_.invokeMap([object], path), [1]);
11141         var path = require('path'),
11142             basePath = path.dirname(filePath),
11150         var baseIsNative = interopRequire(path.join(basePath, '_baseIsNative'));
14155       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
14156         var matches = _.matchesProperty(path, 2);
14166       lodashStable.each([1, [1]], function(path) {  argument
14167         var matches = _.matchesProperty(path, 2);
14203         var actual = lodashStable.map(paths, function(path) {  argument
14204           var matches = _.matchesProperty(index ? [path] : path, object[path]);
14217       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
14218         var matches = _.matchesProperty(path, 1);
14229       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
14230         var matches = _.matchesProperty(path, 1);
14248 …e.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {  argument
14249         var matches = _.matchesProperty(path, 1);
14266       lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {  argument
14267         var matches = _.matchesProperty(path, 1);
14280       lodashStable.each(['a', ['a']], function(path) {  argument
14281         var matches = _.matchesProperty(path, { 'b': 2 });
14297       lodashStable.each(['a', ['a']], function(path) {  argument
14298         assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
14476       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
14477         var matches = _.matchesProperty(path, undefined);
14481       lodashStable.each(['a.a', ['a', 'a']], function(path) {  argument
14482         var matches = _.matchesProperty(path, undefined);
15346       lodashStable.each(['a', ['a']], function(path) {  argument
15347         var method = _.method(path);
15358       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
15359         var method = _.method(path);
15369       lodashStable.each([1, [1]], function(path) {  argument
15370         var method = _.method(path);
15386         var actual = lodashStable.map(paths, function(path) {  argument
15387           var method = _.method(index ? [path] : path);
15401       lodashStable.each(['a', ['a']], function(path) {  argument
15402         var method = _.method(path);
15412       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
15413         var method = _.method(path);
15424       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
15425         var method = _.method(path);
15441 …e.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {  argument
15442         var method = _.method(path);
15457       lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {  argument
15458         var method = _.method(path);
15472       lodashStable.each(['fn', ['fn']], function(path) {  argument
15473         var method = _.method(path, 1, 2, 3);
15483       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
15484         var method = _.method(path);
15500       lodashStable.each(['a', ['a']], function(path) {  argument
15503         assert.strictEqual(methodOf(path), 1);
15512       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
15514         assert.strictEqual(methodOf(path), 2);
15523       lodashStable.each([1, [1]], function(path) {  argument
15525         assert.strictEqual(methodOf(path), 1);
15540         var actual = lodashStable.map(paths, function(path) {  argument
15542           return methodOf(index ? [path] : path);
15555       lodashStable.each(['a', ['a']], function(path) {  argument
15557         assert.strictEqual(methodOf(path), 1);
15566       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
15568         assert.strictEqual(methodOf(path), 1);
15578       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
15581           return methodOf(path);
15594 …e.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {  argument
15597           return methodOf(path);
15610       lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {  argument
15611         assert.strictEqual(methodOf(path), undefined);
15626       lodashStable.each(['fn', ['fn']], function(path) {  argument
15627         assert.deepEqual(methodOf(path), [1, 2, 3]);
15637       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
15638         assert.strictEqual(methodOf(path), 1);
16492       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
16493         assert.deepEqual(_.omit(object, path), { 'a': { 'b': 2 } });
16535       lodashStable.each(['a', ['a'], 'a.b', ['a.b']], function(path) {  argument
16537         _.omit(object, path);
17778       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
17779         assert.deepEqual(_.pick(object, path), { 'a.b': 1 });
17944       lodashStable.each(['a', ['a']], function(path) {  argument
17945         var prop = _.property(path);
17956       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
17957         var prop = _.property(path);
17968       lodashStable.each(['a', ['a']], function(path) {  argument
17969         var prop = _.property(path);
17979       lodashStable.each([1, [1]], function(path) {  argument
17980         var prop = _.property(path);
18010         var actual = lodashStable.map(paths, function(path) {  argument
18011           var prop = _.property(index ? [path] : path);
18024       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
18025         var prop = _.property(path);
18036       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
18037         var prop = _.property(path);
18053 …e.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {  argument
18054         var prop = _.property(path);
18069       lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {  argument
18070         var prop = _.property(path);
18088       lodashStable.each(['a', ['a']], function(path) {  argument
18089         assert.strictEqual(propOf(path), 1);
18099       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
18100         assert.strictEqual(propOf(path), 2);
18114       lodashStable.each(['b', ['b']], function(path) {  argument
18115         assert.strictEqual(propOf(path), 2);
18125       lodashStable.each([1, [1]], function(path) {  argument
18126         assert.strictEqual(propOf(path), 2);
18155         var actual = lodashStable.map(paths, function(path) {  argument
18157           return propOf(index ? [path] : path);
18170       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
18171         assert.strictEqual(propOf(path), 1);
18181       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
18184           return propOf(path);
18197 …e.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {  argument
18200           return propOf(path);
18212       lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {  argument
18213         assert.strictEqual(propOf(path), undefined);
19341       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
19342         assert.strictEqual(_.result(value, path), 'b');
19351       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
19352         assert.strictEqual(_.result(value, path), 1);
19369       lodashStable.each(['a', ['a']], function(path) {  argument
19370         assert.strictEqual(func(object, path), 1);
19406       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
19407         assert.strictEqual(func(object, path), 2);
19416       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
19417         assert.strictEqual(func(object, path), 1);
19454       lodashStable.each(paths, function(path) {  argument
19455         assert.strictEqual(func(object, path), 8);
19462       lodashStable.each(['constructor', ['constructor']], function(path) {  argument
19463         assert.strictEqual(func(null, path), undefined);
19464         assert.strictEqual(func(undefined, path), undefined);
19475       lodashStable.each(paths, function(path) {  argument
19477           return func(value, path);
19489       lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {  argument
19490         assert.strictEqual(func(object, path), undefined);
19499       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
19500         assert.strictEqual(func(object, path), null);
19509       lodashStable.each(paths, function(path) {  argument
19511         assert.strictEqual(func(0, path), 2);
19523       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
19525           return [func(object, path, value), func(null, path, value)];
20105       lodashStable.each(['a', ['a']], function(path) {  argument
20107             actual = func(object, path, updater);
20147       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
20149             actual = func(object, path, updater);
20159       lodashStable.each(['a.b', ['a.b']], function(path) {  argument
20161             actual = func(object, path, updater);
20210       lodashStable.each(paths, function(path) {  argument
20211         func(object, path, updater);
20222       lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {  argument
20223         var actual = func(object, path, updater);
20253       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
20256         func(object, path, updater);
25010       lodashStable.each(['a', ['a']], function(path) {  argument
25012         assert.strictEqual(_.unset(object, path), true);
25049       lodashStable.each(['a.b', ['a', 'b']], function(path) {  argument
25051         assert.strictEqual(_.unset(object, path), true);
25064       lodashStable.each(paths, function(path) {  argument
25066         assert.strictEqual(_.unset(object, path), true);
25076       lodashStable.each(['z', 'a.z', 'a.b.z', 'a.b.c.z'], function(path) {  argument
25077         assert.strictEqual(_.unset(object, path), true);
25106       lodashStable.each(paths, function(path) {  argument
25109         var actual = _.unset(0, path);
25116       lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {  argument
25119         var actual = _.unset(object, path);
25228       lodashStable.each(['a[0].b.c', ['a', '0', 'b', 'c']], function(path) {  argument
25229         func(object, path, function(n) {
25723       lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path, index) {  argument
25725         assert.deepEqual(func([path], [1]), expected);