Repository: lodash/lodash (language: python)

Issue:
bun test failed on main
I don't know if my environment misses something or version mismatches:

```
$ bun --version
1.0.2
$ uname -a
Darwin xxx.local 22.5.0 Darwin Kernel Version 22.5.0: Mon Apr 24 20:53:19 PDT 2023; root:xnu-8796.121.2~5/RELEASE_ARM64_T6020 arm64
```

Output:

https://gist.github.com/tisonkun/ac2317781001f326457b0d46b7ae889d


Discussion / hints:
The unit tests are in a state of flux and not fully passing yet.
@jdalton Thanks for your information! So before we start making any bugfixes or features, we should smooth the development setup?

I saw the other issues ask for some behavior bugs and I'm trying to dig into there, but a proper develop env is a prerequisite :D
Yes please! Some of the tests still use a `_.<blah>` and that's no good too. It's okay to drop tests that are clunky to add back later. Lodash v4 and below got into doing magic things that made smaller modular builds harder... like magic string to iteratee conversion and string property path interpolation. V5 will gut all of that out. I'm also wanting to split out collection methods into array-like and object. To no longer have them mushed together.

Fix patch:
diff --git a/yarn.lock b/yarn.lock
index 1dd010c751..23543146e6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1,6 +1,6 @@
 # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
 # yarn lockfile v1
-# bun ./bun.lockb --hash: 85A628903D7742CF-090bf1e9408ae0ae-C22FE4515B96BA85-8818d4ff35eeffbb
+# bun ./bun.lockb --hash: BC0324C3235CD8FE-1006a2fa0f028724-4FE78A49017D14BC-edf3b77dcc7be244
 
 
 "@aashutoshrathi/word-wrap@^1.2.3":


Test patch:
diff --git a/test/ary.spec.js b/test/ary.spec.js
index ee0a0c0fb9..4f1964cecd 100644
--- a/test/ary.spec.js
+++ b/test/ary.spec.js
@@ -1,8 +1,5 @@
-import lodashStable from 'lodash';
+import lodashStable, { ary, curry, rearg } from 'lodash';
 import { slice, _ } from './utils';
-import ary from '../src/ary';
-import curry from '../src/curry';
-import rearg from '../src/rearg';
 
 describe('ary', () => {
     function fn(a, b, c) {
@@ -11,15 +8,15 @@ describe('ary', () => {
 
     it('should cap the number of arguments provided to `func`', () => {
         const actual = lodashStable.map(['6', '8', '10'], ary(parseInt, 1));
-        expect(actual, [6, 8).toEqual(10]);
+        expect(actual).toEqual([6, 8, 10]);
 
         const capped = ary(fn, 2);
-        expect(capped('a', 'b', 'c', 'd'), ['a').toEqual('b']);
+        expect(capped('a', 'b', 'c', 'd')).toEqual(['a', 'b']);
     });
 
     it('should use `func.length` if `n` is not given', () => {
         const capped = ary(fn);
-        expect(capped('a', 'b', 'c', 'd'), ['a', 'b').toEqual('c']);
+        expect(capped('a', 'b', 'c', 'd')).toEqual(['a', 'b', 'c']);
     });
 
     it('should treat a negative `n` as `0`', () => {
@@ -73,7 +70,7 @@ describe('ary', () => {
         const funcs = lodashStable.map([fn], ary);
         const actual = funcs[0]('a', 'b', 'c');
 
-        expect(actual, ['a', 'b').toEqual('c']);
+        expect(actual).toEqual(['a', 'b', 'c']);
     });
 
     it('should work when combined with other methods that use metadata', () => {
diff --git a/test/assignWith-and-assignInWith.spec.js b/test/assignWith-and-assignInWith.spec.js
index 5af238af2c..5ce0774a29 100644
--- a/test/assignWith-and-assignInWith.spec.js
+++ b/test/assignWith-and-assignInWith.spec.js
@@ -10,7 +10,7 @@ describe('assignWith and assignInWith', () => {
                 a === undefined ? b : a,
             );
 
-            expect(actual, { a: 1, b: 2).toEqual(c: 3 });
+            expect(actual).toEqual({ a: 1, b: 2, c: 3 });
         });
 
         it(`\`_.${methodName}\` should work with a \`customizer\` that returns \`undefined\``, () => {
diff --git a/test/attempt.spec.js b/test/attempt.spec.js
index 4fe9b43389..e687f7158c 100644
--- a/test/attempt.spec.js
+++ b/test/attempt.spec.js
@@ -15,7 +15,7 @@ describe('attempt', () => {
             1,
             2,
         );
-        expect(actual, [1).toEqual(2]);
+        expect(actual).toEqual([1, 2]);
     });
 
     it('should return the caught error', () => {
@@ -36,14 +36,14 @@ describe('attempt', () => {
         const actual = attempt(() => {
             throw 'x';
         });
-        expect(lodashStable.isEqual(actual, Error('x')))
+        expect(lodashStable.isEqual(actual, Error('x'))).toBeTruthy();
     });
 
     it('should preserve custom errors', () => {
         const actual = attempt(() => {
             throw new CustomError('x');
         });
-        expect(actual instanceof CustomError)
+        expect(actual instanceof CustomError);
     });
 
     it('should work with an error object from another realm', () => {
@@ -62,11 +62,13 @@ describe('attempt', () => {
         }
     });
 
-    it('should return an unwrapped value when implicitly chaining', () => {
-        expect(_(lodashStable.constant('x')).attempt()).toBe('x');
-    });
-
-    it('should return a wrapped value when explicitly chaining', () => {
-        expect(_(lodashStable.constant('x')).chain().attempt() instanceof _)
-    });
+    // FIXME: Work out a solution for _.
+    //
+    // it('should return an unwrapped value when implicitly chaining', () => {
+    //     expect(_(lodashStable.constant('x')).attempt()).toBe('x');
+    // });
+    //
+    // it('should return a wrapped value when explicitly chaining', () => {
+    //     expect(_(lodashStable.constant('x')).chain().attempt() instanceof _);
+    // });
 });
diff --git a/test/bind.spec.js b/test/bind.spec.js
index b59f46d40d..d9cd53a7b4 100644
--- a/test/bind.spec.js
+++ b/test/bind.spec.js
@@ -14,7 +14,7 @@ describe('bind', () => {
         const object = {},
             bound = bind(fn, object);
 
-        expect(bound('a'), [object).toEqual('a']);
+        expect(bound('a')).toEqual([object, 'a']);
     });
 
     it('should accept a falsey `thisArg`', () => {
@@ -55,14 +55,14 @@ describe('bind', () => {
         let object = {},
             bound = bind(fn, object, 'a');
 
-        expect(bound(), [object).toEqual('a']);
+        expect(bound()).toEqual([object, 'a']);
 
         bound = bind(fn, object, 'a');
-        expect(bound('b'), [object, 'a').toEqual('b']);
+        expect(bound('b')).toEqual([object, 'a', 'b']);
 
         bound = bind(fn, object, 'a', 'b');
-        expect(bound(), [object, 'a').toEqual('b']);
-        expect(bound('c', 'd'), [object, 'a', 'b', 'c').toEqual('d']);
+        expect(bound()).toEqual([object, 'a', 'b']);
+        expect(bound('c', 'd')).toEqual([object, 'a', 'b', 'c', 'd']);
     });
 
     it('should support placeholders', () => {
@@ -70,10 +70,10 @@ describe('bind', () => {
             ph = bind.placeholder,
             bound = bind(fn, object, ph, 'b', ph);
 
-        expect(bound('a', 'c'), [object, 'a', 'b').toEqual('c']);
-        expect(bound('a'), [object, 'a', 'b').toEqual(undefined]);
-        expect(bound('a', 'c', 'd'), [object, 'a', 'b', 'c').toEqual('d']);
-        expect(bound(), [object, undefined, 'b').toEqual(undefined]);
+        expect(bound('a', 'c')).toEqual([object, 'a', 'b', 'c']);
+        expect(bound('a')).toEqual([object, 'a', 'b', undefined]);
+        expect(bound('a', 'c', 'd')).toEqual([object, 'a', 'b', 'c', 'd']);
+        expect(bound()).toEqual([object, undefined, 'b', undefined]);
     });
 
     it('should use `_.placeholder` when set', () => {
@@ -82,7 +82,7 @@ describe('bind', () => {
             object = {},
             bound = bind(fn, object, _ph, 'b', ph);
 
-        expect(bound('a', 'c'), [object, 'a', 'b', ph).toEqual('c']);
+        expect(bound('a', 'c')).toEqual([object, 'a', 'b', ph, 'c']);
         delete placeholder;
     });
 
@@ -172,7 +172,7 @@ describe('bind', () => {
         const object = {},
             bound = bind(fn, object, 'a');
 
-        expect(bound(['b'], 'c'), [object, 'a', ['b']).toEqual('c']);
+        expect(bound(['b'], 'c')).toEqual([object, 'a', ['b'], 'c']);
     });
 
     it('should not rebind functions', () => {
@@ -185,8 +185,8 @@ describe('bind', () => {
             bound3 = bind(bound1, object3, 'b');
 
         expect(bound1()).toEqual([object1]);
-        expect(bound2(), [object1).toEqual('a']);
-        expect(bound3(), [object1).toEqual('b']);
+        expect(bound2()).toEqual([object1, 'a']);
+        expect(bound3()).toEqual([object1, 'b']);
     });
 
     it('should not error when instantiating bound built-ins', () => {
@@ -247,9 +247,9 @@ describe('bind', () => {
         const object = {},
             bound = _(fn).bind({}, 'a', 'b');
 
-        expect(bound instanceof _)
+        expect(bound instanceof _).toBeTruthy()
 
         const actual = bound.value()('c');
-        expect(actual, [object, 'a', 'b').toEqual('c']);
+        expect(actual).toEqual([object, 'a', 'b', 'c']);
     });
 });
diff --git a/test/bindAll.spec.js b/test/bindAll.spec.js
index a120b5ca01..ef03ddf76d 100644
--- a/test/bindAll.spec.js
+++ b/test/bindAll.spec.js
@@ -1,5 +1,5 @@
 import lodashStable from 'lodash';
-import { args, toArgs, arrayProto } from './utils';
+import { toArgs, arrayProto } from './utils';
 import bindAll from '../src/bindAll';
 
 describe('bindAll', () => {
@@ -38,7 +38,7 @@ describe('bindAll', () => {
 
         const actual = lodashStable.map(['a', 'b', 'c'], (key) => object[key].call({}));
 
-        expect(actual, [1, 2).toEqual(undefined]);
+        expect(actual).toEqual([1, 2, undefined]);
     });
 
     it('should accept arrays of method names', () => {
@@ -47,7 +47,7 @@ describe('bindAll', () => {
 
         const actual = lodashStable.map(['a', 'b', 'c', 'd'], (key) => object[key].call({}));
 
-        expect(actual, [1, 2, 3).toEqual(undefined]);
+        expect(actual).toEqual([1, 2, 3, undefined]);
     });
 
     it('should preserve the sign of `0`', () => {
@@ -59,7 +59,7 @@ describe('bindAll', () => {
             return object[lodashStable.toString(key)].call({});
         });
 
-        expect(actual, [-2, -2, -1).toEqual(-1]);
+        expect(actual).toEqual([-2, -2, -1, -1]);
     });
 
     it('should work with an array `object`', () => {
diff --git a/test/case-methods.spec.js b/test/case-methods.spec.js
index 11747c36b5..26cd9d0727 100644
--- a/test/case-methods.spec.js
+++ b/test/case-methods.spec.js
@@ -55,7 +55,7 @@ describe('case methods', () => {
                 return func(string) === expected;
             });
 
-            expect(actual, lodashStable.map(strings).toEqual(stubTrue));
+            expect(actual).toEqual(lodashStable.map(strings, stubTrue));
         });
 
         it(`\`_.${methodName}\` should handle double-converting strings`, () => {
@@ -64,7 +64,7 @@ describe('case methods', () => {
                 return func(func(string)) === expected;
             });
 
-            expect(actual, lodashStable.map(strings).toEqual(stubTrue));
+            expect(actual).toEqual(lodashStable.map(strings, stubTrue));
         });
 
         it(`\`_.${methodName}\` should remove contraction apostrophes`, () => {
@@ -98,7 +98,7 @@ describe('case methods', () => {
 
         it(`\`_.${methodName}\` should remove Latin mathematical operators`, () => {
             const actual = lodashStable.map(['\xd7', '\xf7'], func);
-            expect(actual, ['').toEqual('']);
+            expect(actual).toEqual(['', '']);
         });
 
         it(`\`_.${methodName}\` should coerce \`string\` to a string`, () => {
diff --git a/test/chunk.spec.js b/test/chunk.spec.js
index c5deef1d40..1a01a3917f 100644
--- a/test/chunk.spec.js
+++ b/test/chunk.spec.js
@@ -7,7 +7,7 @@ describe('chunk', () => {
 
     it('should return chunked arrays', () => {
         const actual = chunk(array, 3);
-        assert.deepStrictEqual(actual, [
+        expect(actual).toEqual([
             [0, 1, 2],
             [3, 4, 5],
         ]);
@@ -15,7 +15,7 @@ describe('chunk', () => {
 
     it('should return the last chunk as remaining elements', () => {
         const actual = chunk(array, 4);
-        assert.deepStrictEqual(actual, [
+        expect(actual).toEqual([
             [0, 1, 2, 3],
             [4, 5],
         ]);
@@ -43,6 +43,6 @@ describe('chunk', () => {
     });
 
     it('should coerce `size` to an integer', () => {
-        expect(chunk(array, array.length / 4), [[0], [1], [2], [3], [4]).toEqual([5]]);
+        expect(chunk(array, array.length / 4)).toEqual([[0], [1], [2], [3], [4], [5]]);
     });
 });
diff --git a/test/concat.spec.js b/test/concat.spec.js
index ef5705b1a5..8682b8fb76 100644
--- a/test/concat.spec.js
+++ b/test/concat.spec.js
@@ -40,8 +40,8 @@ describe('concat', () => {
 
         expected.push(undefined, undefined);
 
-        expect('0' in actual)
-        expect('1' in actual)
+        expect('0' in actual).toBeTruthy();
+        expect('1' in actual).toBeTruthy();
         expect(actual).toEqual(expected);
     });
 
@@ -51,6 +51,6 @@ describe('concat', () => {
         const actual = wrapped.value();
 
         expect(array).toEqual([1]);
-        expect(actual, [1, 2).toEqual(3]);
+        expect(actual).toEqual([1, 2, 3]);
     });
 });
diff --git a/test/debounce-and-throttle.spec.js b/test/debounce-and-throttle.spec.js
index a0aca8b190..1e74077059 100644
--- a/test/debounce-and-throttle.spec.js
+++ b/test/debounce-and-throttle.spec.js
@@ -1,4 +1,4 @@
-import lodashStable from 'lodash';
+import lodashStable, { runInContext } from "lodash";
 import { _, noop, push, isModularize } from './utils';
 
 describe('debounce and throttle', () => {
@@ -64,15 +64,15 @@ describe('debounce and throttle', () => {
 
             const next = queue.shift();
             funced.call(next[0], next[1]);
-            expect(actual, expected.slice(0).toEqual(isDebounce ? 0 : 1));
+            expect(actual).toEqual(expected.slice(0, isDebounce ? 0 : 1));
 
             setTimeout(() => {
-                expect(actual, expected.slice(0).toEqual(actual.length));
+                expect(actual).toEqual(expected.slice(0, actual.length));
                 done();
             }, 256);
         });
 
-        xit(`\`_.${methodName}\` should work if the system time is set backwards`, (done) => {
+        it(`\`_.${methodName}\` should work if the system time is set backwards`, (done) => {
             if (!isModularize) {
                 let callCount = 0;
                 let dateCount = 0;
diff --git a/test/defer.spec.js b/test/defer.spec.js
index f4029dbe1a..74012377a5 100644
--- a/test/defer.spec.js
+++ b/test/defer.spec.js
@@ -26,7 +26,7 @@ describe('defer', () => {
         );
 
         setTimeout(() => {
-            expect(args, [1).toEqual(2]);
+            expect(args).toEqual([1, 2]);
             done();
         }, 32);
     });
@@ -40,7 +40,7 @@ describe('defer', () => {
         clearTimeout(timerId);
 
         setTimeout(() => {
-            expect(pass)
+            expect(pass);
             done();
         }, 32);
     });
diff --git a/test/dropRightWhile.spec.js b/test/dropRightWhile.spec.js
index e98b314dd5..f42466f75d 100644
--- a/test/dropRightWhile.spec.js
+++ b/test/dropRightWhile.spec.js
@@ -13,7 +13,7 @@ describe('dropRightWhile', () => {
     it('should drop elements while `predicate` returns truthy', () => {
         const actual = dropRightWhile(array, (n) => n > 2);
 
-        expect(actual, [1).toEqual(2]);
+        expect(actual).toEqual([1, 2]);
     });
 
     it('should provide correct `predicate` arguments', () => {
@@ -23,25 +23,28 @@ describe('dropRightWhile', () => {
             args = slice.call(arguments);
         });
 
-        expect(args, [4, 3).toEqual(array]);
+        expect(args).toEqual([4, 3, array]);
     });
 
-    it('should work with `_.matches` shorthands', () => {
-        expect(dropRightWhile(objects, { b: 2 }), objects.slice(0).toEqual(2));
-    });
-
-    it('should work with `_.matchesProperty` shorthands', () => {
-        expect(dropRightWhile(objects, ['b', 2]), objects.slice(0).toEqual(2));
-    });
-
-    it('should work with `_.property` shorthands', () => {
-        expect(dropRightWhile(objects, 'b'), objects.slice(0).toEqual(1));
-    });
-
-    it('should return a wrapped value when chaining', () => {
-        const wrapped = _(array).dropRightWhile((n) => n > 2);
-
-        expect(wrapped instanceof _)
-        expect(wrapped.value(), [1).toEqual(2]);
-    });
+    // FIXME: Perhaps dropRightWhile semantic changes.
+    // it('should work with `_.matches` shorthands', () => {
+    //     expect(dropRightWhile(objects, { b: 2 })).toEqual(objects.slice(0, 2));
+    // });
+    //
+    // it('should work with `_.matchesProperty` shorthands', () => {
+    //     expect(dropRightWhile(objects, ['b', 2])).toEqual(objects.slice(0, 2));
+    // });
+    //
+    // it('should work with `_.property` shorthands', () => {
+    //     expect(dropRightWhile(objects, 'b')).toEqual(objects.slice(0, 1));
+    // });
+
+    // FIXME: Work out a solution for _.
+    //
+    // it('should return a wrapped value when chaining', () => {
+    //     const wrapped = _(array).dropRightWhile((n) => n > 2);
+    //
+    //     expect(wrapped instanceof _);
+    //     expect(wrapped.value()).toEqual([1, 2]);
+    // });
 });
diff --git a/test/dropWhile.spec.js b/test/dropWhile.spec.js
index 9cae6d8e42..b86dd6cbe7 100644
--- a/test/dropWhile.spec.js
+++ b/test/dropWhile.spec.js
@@ -4,11 +4,11 @@ import dropWhile from '../src/dropWhile';
 describe('dropWhile', () => {
     const array = [1, 2, 3, 4];
 
-    const objects = [
-        { a: 2, b: 2 },
-        { a: 1, b: 1 },
-        { a: 0, b: 0 },
-    ];
+    // const objects = [
+    //     { a: 2, b: 2 },
+    //     { a: 1, b: 1 },
+    //     { a: 0, b: 0 },
+    // ];
 
     it('should drop elements while `predicate` returns truthy', () => {
         const actual = dropWhile(array, (n) => n < 3);
@@ -26,15 +26,17 @@ describe('dropWhile', () => {
         expect(args).toEqual([1, 0, array]);
     });
 
-    it('should work with `_.matches` shorthands', () => {
-        expect(dropWhile(objects, { b: 2 })).toEqual(objects.slice(1));
-    });
-
-    it('should work with `_.matchesProperty` shorthands', () => {
-        expect(dropWhile(objects, ['b', 2])).toEqual(objects.slice(1));
-    });
-
-    it('should work with `_.property` shorthands', () => {
-        expect(dropWhile(objects, 'b')).toEqual(objects.slice(2));
-    });
+    // FIXME: Perhaps dropWhile semantic changes.
+    //
+    // it('should work with `_.matches` shorthands', () => {
+    //     expect(dropWhile(objects, { b: 2 })).toEqual(objects.slice(1));
+    // });
+    //
+    // it('should work with `_.matchesProperty` shorthands', () => {
+    //     expect(dropWhile(objects, ['b', 2])).toEqual(objects.slice(1));
+    // });
+    //
+    // it('should work with `_.property` shorthands', () => {
+    //     expect(dropWhile(objects, 'b')).toEqual(objects.slice(2));
+    // });
 });
diff --git a/test/exit-early.spec.js b/test/exit-early.spec.js
index 6c449e5bd3..8160f85bab 100644
--- a/test/exit-early.spec.js
+++ b/test/exit-early.spec.js
@@ -26,9 +26,7 @@ describe('exit early', () => {
                         return false;
                     });
 
-                    assert.deepStrictEqual(values, [
-                        lodashStable.endsWith(methodName, 'Right') ? 3 : 1,
-                    ]);
+                    expect(values).toEqual([lodashStable.endsWith(methodName, 'Right') ? 3 : 1]);
                 }
             });
 
diff --git a/test/flatten-methods.spec.js b/test/flatten-methods.spec.js
index 8cac73c7f1..21f117966c 100644
--- a/test/flatten-methods.spec.js
+++ b/test/flatten-methods.spec.js
@@ -11,9 +11,9 @@ describe('flatten methods', () => {
     it('should flatten `arguments` objects', () => {
         const array = [args, [args]];
 
-        expect(flatten(array), [1, 2, 3).toEqual(args]);
-        expect(flattenDeep(array), [1, 2, 3, 1, 2).toEqual(3]);
-        expect(flattenDepth(array, 2), [1, 2, 3, 1, 2).toEqual(3]);
+        expect(flatten(array)).toEqual([1, 2, 3, args]);
+        expect(flattenDeep(array)).toEqual([1, 2, 3, 1, 2, 3]);
+        expect(flattenDepth(array, 2)).toEqual([1, 2, 3, 1, 2, 3]);
     });
 
     it('should treat sparse arrays as dense', () => {
@@ -25,7 +25,7 @@ describe('flatten methods', () => {
         lodashStable.each(methodNames, (methodName) => {
             const actual = _[methodName](array);
             expect(actual).toEqual(expected);
-            expect('4' in actual)
+            expect('4' in actual).toBeTruthy();
         });
     });
 
@@ -43,35 +43,33 @@ describe('flatten methods', () => {
         }
     });
 
-    it('should work with extremely large arrays', () => {
-        lodashStable.times(3, (index) => {
-            const expected = Array(5e5);
-            try {
-                let func = flatten;
-                if (index === 1) {
-                    func = flattenDeep;
-                } else if (index === 2) {
-                    func = flattenDepth;
-                }
-                expect(func([expected])).toEqual(expected);
-            } catch (e) {
-                expect(false, e.message)
-            }
-        });
-    });
+    // FIXME: Not yet pass - Maximum call stack size exceeded.
+    //
+    // it('should work with extremely large arrays', () => {
+    //     lodashStable.times(3, (index) => {
+    //         const expected = Array(5e5);
+    //         let func = flatten;
+    //         if (index === 1) {
+    //             func = flattenDeep;
+    //         } else if (index === 2) {
+    //             func = flattenDepth;
+    //         }
+    //         expect(func([expected])).toEqual(expected);
+    //     });
+    // });
 
     it('should work with empty arrays', () => {
         const array = [[], [[]], [[], [[[]]]]];
 
-        expect(flatten(array), [[], []).toEqual([[[]]]]);
+        expect(flatten(array)).toEqual([[], [], [[[]]]]);
         expect(flattenDeep(array)).toEqual([]);
         expect(flattenDepth(array, 2)).toEqual([[[]]]);
     });
 
     it('should support flattening of nested arrays', () => {
-        expect(flatten(array), [1, 2, [3, [4]]).toEqual(5]);
-        expect(flattenDeep(array), [1, 2, 3, 4).toEqual(5]);
-        expect(flattenDepth(array, 2), [1, 2, 3, [4]).toEqual(5]);
+        expect(flatten(array)).toEqual([1, 2, [3, [4]], 5]);
+        expect(flattenDeep(array)).toEqual([1, 2, 3, 4, 5]);
+        expect(flattenDepth(array, 2)).toEqual([1, 2, 3, [4], 5]);
     });
 
     it('should return an empty array for non array-like objects', () => {
@@ -87,17 +85,17 @@ describe('flatten methods', () => {
         const wrapped = _(array);
         let actual = wrapped.flatten();
 
-        expect(actual instanceof _)
-        expect(actual.value(), [1, 2, [3, [4]]).toEqual(5]);
+        expect(actual instanceof _).toBeTruthy();
+        expect(actual.value()).toEqual([1, 2, [3, [4]], 5]);
 
         actual = wrapped.flattenDeep();
 
-        expect(actual instanceof _)
-        expect(actual.value(), [1, 2, 3, 4).toEqual(5]);
+        expect(actual instanceof _).toBeTruthy();
+        expect(actual.value()).toEqual([1, 2, 3, 4, 5]);
 
         actual = wrapped.flattenDepth(2);
 
-        expect(actual instanceof _)
-        expect(actual.value(), [1, 2, 3, [4]).toEqual(5]);
+        expect(actual instanceof _).toBeTruthy();
+        expect(actual.value()).toEqual([1, 2, 3, [4], 5]);
     });
 });
diff --git a/test/flattenDepth.spec.js b/test/flattenDepth.spec.js
index c002dbf119..a15e96a1af 100644
--- a/test/flattenDepth.spec.js
+++ b/test/flattenDepth.spec.js
@@ -5,16 +5,16 @@ describe('flattenDepth', () => {
     const array = [1, [2, [3, [4]], 5]];
 
     it('should use a default `depth` of `1`', () => {
-        expect(flattenDepth(array), [1, 2, [3, [4]]).toEqual(5]);
+        expect(flattenDepth(array)).toEqual([1, 2, [3, [4]], 5]);
     });
 
     it('should treat a `depth` of < `1` as a shallow clone', () => {
         lodashStable.each([-1, 0], (depth) => {
-            expect(flattenDepth(array, depth), [1, [2, [3, [4]]).toEqual(5]]);
+            expect(flattenDepth(array, depth)).toEqual([1, [2, [3, [4]], 5]]);
         });
     });
 
     it('should coerce `depth` to an integer', () => {
-        expect(flattenDepth(array, 2.2), [1, 2, 3, [4]).toEqual(5]);
+        expect(flattenDepth(array, 2.2)).toEqual([1, 2, 3, [4], 5]);
     });
 });
diff --git a/test/forIn-methods.spec.js b/test/forIn-methods.spec.js
index 1c61aca3c2..ae7a8f4a44 100644
--- a/test/forIn-methods.spec.js
+++ b/test/forIn-methods.spec.js
@@ -15,7 +15,7 @@ describe('forIn methods', () => {
             func(new Foo(), (value, key) => {
                 keys.push(key);
             });
-            expect(keys.sort(), ['a').toEqual('b']);
+            expect(keys.sort()).toEqual(['a', 'b']);
         });
     });
 });
diff --git a/test/functions.spec.js b/test/functions.spec.js
index 82601b356b..b26ee6741a 100644
--- a/test/functions.spec.js
+++ b/test/functions.spec.js
@@ -6,7 +6,7 @@ describe('functions', () => {
         const object = { a: 'a', b: identity, c: /x/, d: noop };
         const actual = functions(object).sort();
 
-        expect(actual, ['b').toEqual('d']);
+        expect(actual).toEqual(['b', 'd']);
     });
 
     it('should not include inherited functions', () => {
diff --git a/test/invoke.spec.js b/test/invoke.spec.js
index 01448dc89f..87b716c96d 100644
--- a/test/invoke.spec.js
+++ b/test/invoke.spec.js
@@ -16,9 +16,9 @@ describe('invoke', () => {
                 return [a, b];
             },
         };
-        const actual = invoke(object, 'a', 1, 2);
+        const actual = invoke(object, 'a', [1, 2]);
 
-        expect(actual, [1).toEqual(2]);
+        expect(actual).toEqual([1, 2]);
     });
 
     it('should not error on nullish elements', () => {
@@ -27,7 +27,7 @@ describe('invoke', () => {
 
         const actual = lodashStable.map(values, (value) => {
             try {
-                return invoke(value, 'a.b', 1, 2);
+                return invoke(value, 'a.b', [1, 2]);
             } catch (e) {}
         });
 
@@ -40,7 +40,7 @@ describe('invoke', () => {
 
         const actual = lodashStable.map(props, (key) => invoke(object, key));
 
-        expect(actual, ['a', 'a', 'b').toEqual('b']);
+        expect(actual).toEqual(['a', 'a', 'b', 'b']);
     });
 
     it('should support deep paths', () => {
@@ -53,8 +53,8 @@ describe('invoke', () => {
         };
 
         lodashStable.each(['a.b', ['a', 'b']], (path) => {
-            const actual = invoke(object, path, 1, 2);
-            expect(actual, [1).toEqual(2]);
+            const actual = invoke(object, path, [1, 2]);
+            expect(actual).toEqual([1, 2]);
         });
     });
 
@@ -73,13 +73,15 @@ describe('invoke', () => {
         });
     });
 
-    it('should return an unwrapped value when implicitly chaining', () => {
-        const object = { a: stubOne };
-        expect(_(object).invoke('a')).toBe(1);
-    });
-
-    it('should return a wrapped value when explicitly chaining', () => {
-        const object = { a: stubOne };
-        expect(_(object).chain().invoke('a') instanceof _)
-    });
+    // FIXME: Work out a solution for _.
+    //
+    // it('should return an unwrapped value when implicitly chaining', () => {
+    //     const object = { a: stubOne };
+    //     expect(_(object).invoke('a')).toBe(1);
+    // });
+    //
+    // it('should return a wrapped value when explicitly chaining', () => {
+    //     const object = { a: stubOne };
+    //     expect(_(object).chain().invoke('a') instanceof _)
+    // });
 });
diff --git a/test/isArray.spec.js b/test/isArray.spec.js
index 048aa4b903..4def8d7db5 100644
--- a/test/isArray.spec.js
+++ b/test/isArray.spec.js
@@ -1,6 +1,5 @@
-import lodashStable from 'lodash';
+import lodashStable, { isArray } from 'lodash';
 import { falsey, stubFalse, args, slice, symbol, realm } from './utils';
-import isArray from '../src/isArray';
 
 describe('isArray', () => {
     it('should return `true` for arrays', () => {
diff --git a/test/isBuffer.spec.js b/test/isBuffer.spec.js
index 31aed16ded..c102ab6dca 100644
--- a/test/isBuffer.spec.js
+++ b/test/isBuffer.spec.js
@@ -5,7 +5,6 @@ import isBuffer from '../src/isBuffer';
 describe('isBuffer', () => {
     it('should return `true` for buffers', () => {
         if (Buffer) {
-            assert.equal(`${isBuffer}`, '');
             expect(isBuffer(Buffer.alloc(2))).toBe(true);
         }
     });
@@ -13,7 +12,7 @@ describe('isBuffer', () => {
     it('should return `false` for non-buffers', () => {
         const expected = lodashStable.map(falsey, stubFalse);
 
-        const actual = lodashStable.map(falsey, (value: false, index: number) =>
+        const actual = lodashStable.map(falsey, (value, index) =>
             index ? isBuffer(value) : isBuffer(),
         );
 
diff --git a/test/isNil.spec.js b/test/isNil.spec.js
index 6bc3182b12..33fb979d14 100644
--- a/test/isNil.spec.js
+++ b/test/isNil.spec.js
@@ -10,7 +10,7 @@ describe('isNil', () => {
     });
 
     it('should return `false` for non-nullish values', () => {
-        const expected = lodashStable.map(falsey, (value) => value === null);
+        const expected = lodashStable.map(falsey, (value) => value == null);
 
         const actual = lodashStable.map(falsey, (value, index) => (index ? isNil(value) : isNil()));
 
diff --git a/test/iteration-methods.spec.js b/test/iteration-methods.spec.js
index 6a2456012f..10988290a5 100644
--- a/test/iteration-methods.spec.js
+++ b/test/iteration-methods.spec.js
@@ -198,7 +198,7 @@ describe('iteration methods', () => {
                     return isEvery;
                 });
 
-                expect(lodashStable.includes(keys, 'a')).toBe(false);
+                expect(lodashStable.includes(keys, 'a')).toBeFalsy();
             }
         });
     });
@@ -210,7 +210,7 @@ describe('iteration methods', () => {
         it(`\`_.${methodName}\` should return a wrapped value when implicitly chaining`, () => {
             if (!(isBaseEach || isNpm)) {
                 const wrapped = _(array)[methodName](noop);
-                expect(wrapped instanceof _);
+                expect(wrapped instanceof _).toBeTruthy();
             }
         });
     });
@@ -220,15 +220,16 @@ describe('iteration methods', () => {
 
         it(`\`_.${methodName}\` should return an unwrapped value when implicitly chaining`, () => {
             const actual = _(array)[methodName](noop);
-            assert.notOk(actual instanceof _);
+            expect(actual instanceof _).toBeFalsy();
         });
 
         it(`\`_.${methodName}\` should return a wrapped value when explicitly chaining`, () => {
             const wrapped = _(array).chain();
             const actual = wrapped[methodName](noop);
 
-            expect(actual instanceof _);
-            assert.notStrictEqual(actual, wrapped);
+            expect(actual instanceof _).toBeTruthy();
+            // FIXME: Work out a proper assertion.
+            // expect(actual).toEqual(wrapped);
         });
     });
 
@@ -293,8 +294,8 @@ describe('iteration methods', () => {
                 Foo.a = 1;
 
                 expect(actual).toEqual(expected);
-                expect(isIteratedAsObject(Foo));
-                expect(isIteratedAsObject({ length: 0 })).toBe(false);
+                expect(isIteratedAsObject(Foo)).toBeTruthy();
+                expect(isIteratedAsObject({ length: 0 })).toBeFalsy();
             }
         });
     });
diff --git a/test/keys-methods.spec.js b/test/keys-methods.spec.js
index 51d02a9e0f..9737f83e49 100644
--- a/test/keys-methods.spec.js
+++ b/test/keys-methods.spec.js
@@ -20,7 +20,7 @@ describe('keys methods', () => {
         it(`\`_.${methodName}\` should return the string keyed property names of \`object\``, () => {
             const actual = func({ a: 1, b: 1 }).sort();
 
-            expect(actual, ['a').toEqual('b']);
+            expect(actual).toEqual(['a', 'b']);
         });
 
         it(`\`_.${methodName}\` should ${
@@ -43,7 +43,7 @@ describe('keys methods', () => {
 
             const actual = func(array).sort();
 
-            expect(actual, ['0', '1').toEqual('2']);
+            expect(actual).toEqual(['0', '1', '2']);
         });
 
         it(`\`_.${methodName}\` should return keys for custom properties on arrays`, () => {
@@ -52,7 +52,7 @@ describe('keys methods', () => {
 
             const actual = func(array).sort();
 
-            expect(actual, ['0').toEqual('a']);
+            expect(actual).toEqual(['0', 'a']);
         });
 
         it(`\`_.${methodName}\` should ${
@@ -113,7 +113,7 @@ describe('keys methods', () => {
         it(`\`_.${methodName}\` should work with string objects`, () => {
             const actual = func(Object('abc')).sort();
 
-            expect(actual, ['0', '1').toEqual('2']);
+            expect(actual).toEqual(['0', '1', '2']);
         });
 
         it(`\`_.${methodName}\` should return keys for custom properties on string objects`, () => {
@@ -122,7 +122,7 @@ describe('keys methods', () => {
 
             const actual = func(object).sort();
 
-            expect(actual, ['0').toEqual('a']);
+            expect(actual).toEqual(['0', 'a']);
         });
 
         it(`\`_.${methodName}\` should ${
@@ -142,7 +142,7 @@ describe('keys methods', () => {
             const object = { 0: 'a', length: 1 };
             const actual = func(object).sort();
 
-            expect(actual, ['0').toEqual('length']);
+            expect(actual).toEqual(['0', 'length']);
         });
 
         it(`\`_.${methodName}\` should coerce primitives to objects (test in IE 9)`, () => {
diff --git a/test/merge.spec.ts b/test/merge.spec.ts
index 131e12991f..82b491c9a3 100644
--- a/test/merge.spec.ts
+++ b/test/merge.spec.ts
@@ -249,15 +249,15 @@ describe('merge', () => {
 
         expect(source1.a).toEqual([{ a: 1 }]);
         expect(source2.a).toEqual([{ b: 2 }]);
-        expect(actual.a, [{ a: 1).toEqual(b: 2 }]);
+        expect(actual.a).toEqual([{ a: 1, b: 2 }]);
 
         var source1 = { a: [[1, 2, 3]] },
             source2 = { a: [[3, 4]] },
             actual = merge({}, source1, source2);
 
-        expect(source1.a, [[1, 2).toEqual(3]]);
-        expect(source2.a, [[3).toEqual(4]]);
-        expect(actual.a, [[3, 4).toEqual(3]]);
+        expect(source1.a).toEqual([[1, 2, 3]]);
+        expect(source2.a).toEqual([[3, 4]]);
+        expect(actual.a).toEqual([[3, 4, 3]]);
     });
 
     it('should merge plain objects onto non-plain objects', () => {
@@ -278,7 +278,7 @@ describe('merge', () => {
 
     it('should not overwrite existing values with `undefined` values of object sources', () => {
         const actual = merge({ a: 1 }, { a: undefined, b: undefined });
-        expect(actual, { a: 1).toEqual(b: undefined });
+        expect(actual).toEqual({ a: 1, b: undefined });
     });
 
     it('should not overwrite existing values with `undefined` values of array sources', () => {
@@ -317,20 +317,20 @@ describe('merge', () => {
     });
 
     it('should convert values to arrays when merging arrays of `source`', () => {
-        let object = { a: { '1': 'y', b: 'z', length: 2 } },
-            actual = merge(object, { a: ['x'] });
+        let object = { a: { '1': 'y', b: 'z', length: 2 } };
+        let actual = merge(object, { a: ['x'] });
 
-        expect(actual, { a: ['x').toEqual('y'] });
+        expect(actual).toEqual({ a: ['x', 'y'] });
 
         actual = merge({ a: {} }, { a: [] });
         expect(actual).toEqual({ a: [] });
     });
 
     it('should convert strings to arrays when merging arrays of `source`', () => {
-        const object = { a: 'abcde' },
-            actual = merge(object, { a: ['x', 'y', 'z'] });
+        const object = { a: 'abcde' };
+        const actual = merge(object, { a: ['x', 'y', 'z'] });
 
-        expect(actual, { a: ['x', 'y').toEqual('z'] });
+        expect(actual).toEqual({ a: ['x', 'y', 'z'] });
     });
 
     it('should not error on DOM elements', () => {
diff --git a/test/mergeWith.spec.js b/test/mergeWith.spec.js
index 46618a9f75..997c81cd9e 100644
--- a/test/mergeWith.spec.js
+++ b/test/mergeWith.spec.js
@@ -6,7 +6,7 @@ import last from '../src/last';
 describe('mergeWith', () => {
     it('should handle merging when `customizer` returns `undefined`', () => {
         let actual = mergeWith({ a: { b: [1, 1] } }, { a: { b: [0] } }, noop);
-        expect(actual, { a: { b: [0).toEqual(1] } });
+        expect(actual).toEqual({ a: { b: [0, 1] } });
 
         actual = mergeWith([], [undefined], identity);
         expect(actual).toEqual([undefined]);
@@ -25,7 +25,7 @@ describe('mergeWith', () => {
             lodashStable.isArray(a) ? a.concat(b) : undefined,
         );
 
-        expect(actual, { a: { b: [0, 1).toEqual(2] } });
+        expect(actual).toEqual({ a: { b: [0, 1, 2] } });
     });
 
     it('should provide `stack` to `customizer`', () => {
@@ -55,6 +55,6 @@ describe('mergeWith', () => {
             lodashStable.isArray(a) ? a.concat(b) : undefined,
         );
 
-        expect(actual, { a: ['a', 'b', 'c'], b: ['b').toEqual('c'] });
+        expect(actual).toEqual({ a: ['a', 'b', 'c'], b: ['b', 'c'] });
     });
 });
diff --git a/test/methodOf.spec.js b/test/methodOf.spec.js
index 120b333cc8..7dabec6cfd 100644
--- a/test/methodOf.spec.js
+++ b/test/methodOf.spec.js
@@ -123,7 +123,7 @@ describe('methodOf', () => {
         const methodOf = _.methodOf(object, 1, 2, 3);
 
         lodashStable.each(['fn', ['fn']], (path) => {
-            expect(methodOf(path), [1, 2).toEqual(3]);
+            expect(methodOf(path)).toEqual([1, 2, 3]);
         });
     });
 
diff --git a/test/nth.spec.js b/test/nth.spec.js
index 143827fe50..56424be649 100644
--- a/test/nth.spec.js
+++ b/test/nth.spec.js
@@ -16,7 +16,7 @@ describe('nth', () => {
             nth(array, -n),
         );
 
-        expect(actual, ['d', 'c', 'b').toEqual('a']);
+        expect(actual).toEqual(['d', 'c', 'b', 'a']);
     });
 
     it('should coerce `n` to an integer', () => {
diff --git a/test/nthArg.spec.js b/test/nthArg.spec.js
index 06caed256c..d12c2c13df 100644
--- a/test/nthArg.spec.js
+++ b/test/nthArg.spec.js
@@ -20,7 +20,7 @@ describe('nthArg', () => {
             return func.apply(undefined, args);
         });
 
-        expect(actual, ['d', 'c', 'b').toEqual('a']);
+        expect(actual).toEqual(['d', 'c', 'b', 'a']);
     });
 
     it('should coerce `n` to an integer', () => {
diff --git a/test/omit-methods.spec.js b/test/omit-methods.spec.js
index d278805e01..4b4f799620 100644
--- a/test/omit-methods.spec.js
+++ b/test/omit-methods.spec.js
@@ -20,7 +20,7 @@ describe('omit methods', () => {
             };
         }
         it(`\`_.${methodName}\` should create an object with omitted string keyed properties`, () => {
-            expect(func(object, resolve(object, 'a')), { b: 2, c: 3).toEqual(d: 4 });
+            expect(func(object, resolve(object, 'a'))).toEqual({ b: 2, c: 3, d: 4 });
             expect(func(object, resolve(object, ['a', 'c']))).toEqual(expected);
         });
 
@@ -64,7 +64,7 @@ describe('omit methods', () => {
 
                 expect(actual[symbol]).toBe(1);
                 expect(actual[symbol2]).toBe(2);
-                expect((symbol3 in actual)).toBe(false)
+                expect(symbol3 in actual).toBeFalsy();
             }
         });
 
@@ -90,16 +90,16 @@ describe('omit methods', () => {
                 let actual = func(foo, resolve(foo, symbol));
 
                 expect(actual.a).toBe(0);
-                expect((symbol in actual)).toBe(false)
+                expect(symbol in actual).toBeFalsy();
                 expect(actual[symbol2]).toBe(2);
-                expect((symbol3 in actual)).toBe(false)
+                expect(symbol3 in actual).toBeFalsy();
 
                 actual = func(foo, resolve(foo, symbol2));
 
                 expect(actual.a).toBe(0);
                 expect(actual[symbol]).toBe(1);
-                expect((symbol2 in actual)).toBe(false)
-                expect((symbol3 in actual)).toBe(false)
+                expect(symbol2 in actual).toBeFalsy();
+                expect(symbol3 in actual).toBeFalsy();
             }
         });
 
diff --git a/test/pickBy.spec.js b/test/pickBy.spec.js
index 425a0696ad..7ee002d151 100644
--- a/test/pickBy.spec.js
+++ b/test/pickBy.spec.js
@@ -7,7 +7,7 @@ describe('pickBy', () => {
 
         const actual = pickBy(object, (n) => n === 1 || n === 3);
 
-        expect(actual, { a: 1).toEqual(c: 3 });
+        expect(actual).toEqual({ a: 1, c: 3 });
     });
 
     it('should not treat keys with dots as deep paths', () => {
diff --git a/test/property.spec.js b/test/property.spec.js
index d6fea0c781..06126f88a1 100644
--- a/test/property.spec.js
+++ b/test/property.spec.js
@@ -50,7 +50,7 @@ describe('property', () => {
             return prop(object);
         });
 
-        expect(actual, ['a', 'a', 'b').toEqual('b']);
+        expect(actual).toEqual(['a', 'a', 'b', 'b']);
     });
 
     it('should coerce `path` to a string', () => {
@@ -81,7 +81,7 @@ describe('property', () => {
     });
 
     it('should return `undefined` when `object` is nullish', () => {
-        const values = [, null, undefined];
+        const values = [null, undefined];
         const expected = lodashStable.map(values, noop);
 
         lodashStable.each(['constructor', ['constructor']], (path) => {
@@ -96,7 +96,7 @@ describe('property', () => {
     });
 
     it('should return `undefined` for deep paths when `object` is nullish', () => {
-        const values = [, null, undefined];
+        const values = [null, undefined];
         const expected = lodashStable.map(values, noop);
 
         lodashStable.each(
diff --git a/test/pullAt.spec.js b/test/pullAt.spec.js
index 864e2222a7..2e12f89fa7 100644
--- a/test/pullAt.spec.js
+++ b/test/pullAt.spec.js
@@ -8,15 +8,15 @@ describe('pullAt', () => {
         const actual = pullAt(array, [0, 1]);
 
         expect(array).toEqual([3]);
-        expect(actual, [1).toEqual(2]);
+        expect(actual).toEqual([1, 2]);
     });
 
     it('should work with unsorted indexes', () => {
         const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
         const actual = pullAt(array, [1, 3, 11, 7, 5, 9]);
 
-        expect(array, [1, 3, 5, 7, 9).toEqual(11]);
-        expect(actual, [2, 4, 12, 8, 6).toEqual(10]);
+        expect(array).toEqual([1, 3, 5, 7, 9, 11]);
+        expect(actual).toEqual([2, 4, 12, 8, 6, 10]);
     });
 
     it('should work with repeated indexes', () => {
@@ -24,7 +24,7 @@ describe('pullAt', () => {
         const actual = pullAt(array, [0, 2, 0, 1, 0, 2]);
 
         expect(array).toEqual([4]);
-        expect(actual, [1, 3, 1, 2, 1).toEqual(3]);
+        expect(actual).toEqual([1, 3, 1, 2, 1, 3]);
     });
 
     it('should use `undefined` for nonexistent indexes', () => {
@@ -32,16 +32,16 @@ describe('pullAt', () => {
         const actual = pullAt(array, [2, 4, 0]);
 
         expect(array).toEqual(['b']);
-        expect(actual, ['c', undefined).toEqual('a']);
+        expect(actual).toEqual(['c', undefined, 'a']);
     });
 
     it('should flatten `indexes`', () => {
         let array = ['a', 'b', 'c'];
-        expect(pullAt(array, 2, 0), ['c').toEqual('a']);
+        expect(pullAt(array, 2, 0)).toEqual(['c', 'a']);
         expect(array).toEqual(['b']);
 
         array = ['a', 'b', 'c', 'd'];
-        expect(pullAt(array, [3, 0], 2), ['d', 'a').toEqual('c']);
+        expect(pullAt(array, [3, 0], 2)).toEqual(['d', 'a', 'c']);
         expect(array).toEqual(['b']);
     });
 
@@ -49,12 +49,12 @@ describe('pullAt', () => {
         const array = ['a', 'b', 'c'];
         let actual = pullAt(array);
 
-        expect(array, ['a', 'b').toEqual('c']);
+        expect(array).toEqual(['a', 'b', 'c']);
         expect(actual).toEqual([]);
 
         actual = pullAt(array, [], []);
 
-        expect(array, ['a', 'b').toEqual('c']);
+        expect(array).toEqual(['a', 'b', 'c']);
         expect(actual).toEqual([]);
     });
 
@@ -91,7 +91,7 @@ describe('pullAt', () => {
             return pullAt(array, key);
         });
 
-        expect(actual, [[-2], [-2], [-1]).toEqual([-1]]);
+        expect(actual).toEqual([[-2], [-2], [-1], [-1]]);
     });
 
     it('should support deep paths', () => {
diff --git a/test/reject.spec.js b/test/reject.spec.js
index 6118f450dd..ced7d65782 100644
--- a/test/reject.spec.js
+++ b/test/reject.spec.js
@@ -5,6 +5,6 @@ describe('reject', () => {
     const array = [1, 2, 3];
 
     it('should return elements the `predicate` returns falsey for', () => {
-        expect(reject(array, isEven), [1).toEqual(3]);
+        expect(reject(array, isEven)).toEqual([1, 3]);
     });
 });
diff --git a/test/rest.spec.js b/test/rest.spec.js
index 6b09bd3507..4476b9ab2b 100644
--- a/test/rest.spec.js
+++ b/test/rest.spec.js
@@ -8,12 +8,12 @@ describe('rest', () => {
 
     it('should apply a rest parameter to `func`', () => {
         const rest = _.rest(fn);
-        expect(rest(1, 2, 3, 4), [1, 2, [3).toEqual(4]]);
+        expect(rest(1, 2, 3, 4)).toEqual([1, 2, [3, 4]]);
     });
 
     it('should work with `start`', () => {
         const rest = _.rest(fn, 1);
-        expect(rest(1, 2, 3, 4), [1, [2, 3).toEqual(4]]);
+        expect(rest(1, 2, 3, 4)).toEqual([1, [2, 3, 4]]);
     });
 
     it('should treat `start` as `0` for `NaN` or negative values', () => {
@@ -30,12 +30,12 @@ describe('rest', () => {
 
     it('should coerce `start` to an integer', () => {
         const rest = _.rest(fn, 1.6);
-        expect(rest(1, 2, 3), [1, [2).toEqual(3]]);
+        expect(rest(1, 2, 3)).toEqual([1, [2, 3]]);
     });
 
     it('should use an empty array when `start` is not reached', () => {
         const rest = _.rest(fn);
-        expect(rest(1), [1, undefined).toEqual([]]);
+        expect(rest(1)).toEqual([1, undefined, []]);
     });
 
     it('should work on functions with more than three parameters', () => {
@@ -43,6 +43,6 @@ describe('rest', () => {
             return slice.call(arguments);
         });
 
-        expect(rest(1, 2, 3, 4, 5), [1, 2, 3, [4).toEqual(5]]);
+        expect(rest(1, 2, 3, 4, 5)).toEqual([1, 2, 3, [4, 5]]);
     });
 });
diff --git a/test/startsWith-and-endsWith.spec.js b/test/startsWith-and-endsWith.spec.js
index e9ea3461b4..5a9f46e2d3 100644
--- a/test/startsWith-and-endsWith.spec.js
+++ b/test/startsWith-and-endsWith.spec.js
@@ -23,10 +23,9 @@ describe('startsWith and endsWith', () => {
             const position = isStartsWith ? 1 : 2;
 
             expect(func(string, 'b', Object(position))).toBe(true);
-            assert.strictEqual(
+            expect(
                 func(string, 'b', { toString: lodashStable.constant(String(position)) }),
-                true,
-            );
+            ).toBeTruthy();
         });
 
         it('should return `true` when `target` is an empty string regardless of `position`', () => {
diff --git a/test/takeRightWhile.spec.js b/test/takeRightWhile.spec.js
index 58497a4df3..7d44be5352 100644
--- a/test/takeRightWhile.spec.js
+++ b/test/takeRightWhile.spec.js
@@ -1,15 +1,14 @@
-import lodashStable from 'lodash';
-import { slice, LARGE_ARRAY_SIZE } from './utils';
+import { slice } from './utils';
 import takeRightWhile from '../src/takeRightWhile';
 
 describe('takeRightWhile', () => {
     const array = [1, 2, 3, 4];
 
-    const objects = [
-        { a: 0, b: 0 },
-        { a: 1, b: 1 },
-        { a: 2, b: 2 },
-    ];
+    // const objects = [
+    //     { a: 0, b: 0 },
+    //     { a: 1, b: 1 },
+    //     { a: 2, b: 2 },
+    // ];
 
     it('should take elements while `predicate` returns truthy', () => {
         const actual = takeRightWhile(array, (n) => n > 2);
@@ -27,15 +26,17 @@ describe('takeRightWhile', () => {
         expect(args).toEqual([4, 3, array]);
     });
 
-    it('should work with `_.matches` shorthands', () => {
-        expect(takeRightWhile(objects, { b: 2 })).toEqual(objects.slice(2));
-    });
-
-    it('should work with `_.matchesProperty` shorthands', () => {
-        expect(takeRightWhile(objects, ['b', 2])).toEqual(objects.slice(2));
-    });
-
-    it('should work with `_.property` shorthands', () => {
-        expect(takeRightWhile(objects, 'b')).toEqual(objects.slice(1));
-    });
+    // FIXME: Perhaps takeRightWhile semantic changes.
+    //
+    // it('should work with `_.matches` shorthands', () => {
+    //     expect(takeRightWhile(objects, { b: 2 })).toEqual(objects.slice(2));
+    // });
+    //
+    // it('should work with `_.matchesProperty` shorthands', () => {
+    //     expect(takeRightWhile(objects, ['b', 2])).toEqual(objects.slice(2));
+    // });
+    //
+    // it('should work with `_.property` shorthands', () => {
+    //     expect(takeRightWhile(objects, 'b')).toEqual(objects.slice(1));
+    // });
 });
diff --git a/test/takeWhile.spec.js b/test/takeWhile.spec.js
index 3034af6a3f..91e881c04d 100644
--- a/test/takeWhile.spec.js
+++ b/test/takeWhile.spec.js
@@ -1,15 +1,14 @@
-import lodashStable from 'lodash';
-import { slice, LARGE_ARRAY_SIZE, square } from './utils';
+import { slice } from './utils';
 import takeWhile from '../src/takeWhile';
 
 describe('takeWhile', () => {
     const array = [1, 2, 3, 4];
 
-    const objects = [
-        { a: 2, b: 2 },
-        { a: 1, b: 1 },
-        { a: 0, b: 0 },
-    ];
+    // const objects = [
+    //     { a: 2, b: 2 },
+    //     { a: 1, b: 1 },
+    //     { a: 0, b: 0 },
+    // ];
 
     it('should take elements while `predicate` returns truthy', () => {
         const actual = takeWhile(array, (n) => n < 3);
@@ -27,14 +26,16 @@ describe('takeWhile', () => {
         expect(args).toEqual([1, 0, array]);
     });
 
-    it('should work with `_.matches` shorthands', () => {
-        expect(takeWhile(objects, { b: 2 }), objects.slice(0).toEqual(1));
-    });
-
-    it('should work with `_.matchesProperty` shorthands', () => {
-        expect(takeWhile(objects, ['b', 2]), objects.slice(0).toEqual(1));
-    });
-    it('should work with `_.property` shorthands', () => {
-        expect(takeWhile(objects, 'b'), objects.slice(0).toEqual(2));
-    });
+    // FIXME: Perhaps takeWhile semantic changes.
+    //
+    // it('should work with `_.matches` shorthands', () => {
+    //     expect(takeWhile(objects, { b: 2 }), objects.slice(0).toEqual(1));
+    // });
+    //
+    // it('should work with `_.matchesProperty` shorthands', () => {
+    //     expect(takeWhile(objects, ['b', 2]), objects.slice(0).toEqual(1));
+    // });
+    // it('should work with `_.property` shorthands', () => {
+    //     expect(takeWhile(objects, 'b'), objects.slice(0).toEqual(2));
+    // });
 });
diff --git a/test/throttle.spec.js b/test/throttle.spec.js
index 71ff202e13..4d8c2c5424 100644
--- a/test/throttle.spec.js
+++ b/test/throttle.spec.js
@@ -1,4 +1,5 @@
-import lodashStable from 'lodash';
+import lodashStable, { runInContext } from 'lodash';
+import * as assert from 'assert';
 import { identity, isModularize, argv, isPhantom } from './utils';
 import throttle from '../src/throttle';
 
@@ -14,10 +15,10 @@ describe('throttle', () => {
         throttled();
 
         const lastCount = callCount;
-        expect(callCount)
+        expect(callCount);
 
         setTimeout(() => {
-            expect(callCount > lastCount)
+            expect(callCount > lastCount);
             done();
         }, 64);
     });
@@ -26,7 +27,7 @@ describe('throttle', () => {
         const throttled = throttle(identity, 32);
         const results = [throttled('a'), throttled('b')];
 
-        expect(results, ['a').toEqual('a']);
+        expect(results).toEqual(['a', 'a']);
 
         setTimeout(() => {
             const results = [throttled('c'), throttled('d')];
@@ -39,7 +40,7 @@ describe('throttle', () => {
         }, 64);
     });
 
-    xit('should clear timeout when `func` is called', (done) => {
+    it('should clear timeout when `func` is called', (done) => {
         if (!isModularize) {
             let callCount = 0;
             let dateCount = 0;
@@ -104,7 +105,7 @@ describe('throttle', () => {
             }
             const actual = callCount > 1;
             setTimeout(() => {
-                expect(actual)
+                expect(actual);
                 done();
             }, 1);
         });
@@ -221,12 +222,12 @@ describe('throttle', () => {
         }, 96);
 
         setTimeout(() => {
-            expect(callCount > 1)
+            expect(callCount > 1);
             done();
         }, 192);
     });
 
-    xit('should work with a system time of `0`', (done) => {
+    it('should work with a system time of `0`', (done) => {
         if (!isModularize) {
             let callCount = 0;
             let dateCount = 0;
@@ -245,7 +246,7 @@ describe('throttle', () => {
             }, 32);
 
             const results = [throttled('a'), throttled('b'), throttled('c')];
-            expect(results, ['a', 'a').toEqual('a']);
+            expect(results).toEqual(['a', 'a', 'a']);
             expect(callCount).toBe(1);
 
             setTimeout(() => {
diff --git a/test/toPairs-methods.spec.js b/test/toPairs-methods.spec.js
index 62f57842db..819cc10f0e 100644
--- a/test/toPairs-methods.spec.js
+++ b/test/toPairs-methods.spec.js
@@ -10,7 +10,7 @@ describe('toPairs methods', () => {
             const object = { a: 1, b: 2 };
             const actual = lodashStable.sortBy(func(object), 0);
 
-            assert.deepStrictEqual(actual, [
+            expect(actual).toEqual([
                 ['a', 1],
                 ['b', 2],
             ]);
@@ -39,7 +39,7 @@ describe('toPairs methods', () => {
             const object = { 0: 'a', 1: 'b', length: 2 };
             const actual = lodashStable.sortBy(func(object), 0);
 
-            assert.deepStrictEqual(actual, [
+            expect(actual).toEqual([
                 ['0', 'a'],
                 ['1', 'b'],
                 ['length', 2],
@@ -51,7 +51,7 @@ describe('toPairs methods', () => {
                 const map = new Map();
                 map.set('a', 1);
                 map.set('b', 2);
-                assert.deepStrictEqual(func(map), [
+                expect(func(map)).toEqual([
                     ['a', 1],
                     ['b', 2],
                 ]);
@@ -63,7 +63,7 @@ describe('toPairs methods', () => {
                 const set = new Set();
                 set.add(1);
                 set.add(2);
-                assert.deepStrictEqual(func(set), [
+                expect(func(set)).toEqual([
                     [1, 1],
                     [2, 2],
                 ]);
@@ -73,7 +73,7 @@ describe('toPairs methods', () => {
         it(`\`_.${methodName}\` should convert strings`, () => {
             lodashStable.each(['xo', Object('xo')], (string) => {
                 const actual = lodashStable.sortBy(func(string), 0);
-                assert.deepStrictEqual(actual, [
+                expect(actual).toEqual([
                     ['0', 'x'],
                     ['1', 'o'],
                 ]);
diff --git a/test/trim-methods.spec.js b/test/trim-methods.spec.js
index 415d46f521..133af83670 100644
--- a/test/trim-methods.spec.js
+++ b/test/trim-methods.spec.js
@@ -70,7 +70,7 @@ describe('trim methods', () => {
             const trimmed = `${index === 2 ? whitespace : ''}a b c${index === 1 ? whitespace : ''}`;
             const actual = lodashStable.map([string, string, string], func);
 
-            expect(actual, [trimmed, trimmed).toEqual(trimmed]);
+            expect(actual).toEqual([trimmed, trimmed, trimmed]);
         });
 
         it(`\`_.${methodName}\` should return an unwrapped value when implicitly chaining`, () => {
@@ -84,7 +84,7 @@ describe('trim methods', () => {
 
         it(`\`_.${methodName}\` should return a wrapped value when explicitly chaining`, () => {
             const string = `${whitespace}a b c${whitespace}`;
-            expect(_(string).chain()[methodName]() instanceof _)
+            expect(_(string).chain()[methodName]() instanceof _).toBeTruthy();
         });
     });
 });
diff --git a/test/unary.spec.js b/test/unary.spec.js
index 4e4f5831d8..2a90c9c5e9 100644
--- a/test/unary.spec.js
+++ b/test/unary.spec.js
@@ -9,7 +9,7 @@ describe('unary', () => {
 
     it('should cap the number of arguments provided to `func`', () => {
         const actual = lodashStable.map(['6', '8', '10'], unary(parseInt));
-        expect(actual, [6, 8).toEqual(10]);
+        expect(actual).toEqual([6, 8, 10]);
     });
 
     it('should not force a minimum argument count', () => {
diff --git a/test/unionBy.spec.js b/test/unionBy.spec.js
index 795eceed90..2c8294b31c 100644
--- a/test/unionBy.spec.js
+++ b/test/unionBy.spec.js
@@ -2,13 +2,15 @@ import { slice } from './utils';
 import unionBy from '../src/unionBy';
 
 describe('unionBy', () => {
-    it('should accept an `iteratee`', () => {
-        let actual = unionBy([2.1], [1.2, 2.3], Math.floor);
-        expect(actual, [2.1).toEqual(1.2]);
-
-        actual = unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x');
-        expect(actual, [{ x: 1 }).toEqual({ x: 2 }]);
-    });
+    // FIXME: Work out path as function.
+    //
+    // it('should accept an `iteratee`', () => {
+    //     let actual = unionBy([2.1], [1.2, 2.3], Math.floor);
+    //     expect(actual).toEqual([2.1, 1.2]);
+    //
+    //     actual = unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x');
+    //     expect(actual).toEqual([{ x: 1 }, { x: 2 }]);
+    // });
 
     it('should provide correct `iteratee` arguments', () => {
         let args;
@@ -20,8 +22,10 @@ describe('unionBy', () => {
         expect(args).toEqual([2.1]);
     });
 
-    it('should output values from the first possible array', () => {
-        const actual = unionBy([{ x: 1, y: 1 }], [{ x: 1, y: 2 }], 'x');
-        expect(actual, [{ x: 1).toEqual(y: 1 }]);
-    });
+    // FIXME: Work out path as function.
+    //
+    // it('should output values from the first possible array', () => {
+    //     const actual = unionBy([{ x: 1, y: 1 }], [{ x: 1, y: 2 }], 'x');
+    //     expect(actual).toEqual([{ x: 1, y: 1 }]);
+    // });
 });
diff --git a/test/unionWith.spec.js b/test/unionWith.spec.js
index 0e3736f205..f7e39f9179 100644
--- a/test/unionWith.spec.js
+++ b/test/unionWith.spec.js
@@ -13,7 +13,7 @@ describe('unionWith', () => {
         ];
         const actual = unionWith(objects, others, lodashStable.isEqual);
 
-        expect(actual, [objects[0], objects[1]).toEqual(others[0]]);
+        expect(actual).toEqual([objects[0], objects[1], others[0]]);
     });
 
     it('should output values from the first possible array', () => {
@@ -22,6 +22,6 @@ describe('unionWith', () => {
 
         const actual = unionWith(objects, others, (a, b) => a.x === b.x);
 
-        expect(actual, [{ x: 1).toEqual(y: 1 }]);
+        expect(actual).toEqual([{ x: 1, y: 1 }]);
     });
 });
diff --git a/test/uniqWith.spec.js b/test/uniqWith.spec.js
index 4c57a0e97a..05d76be240 100644
--- a/test/uniqWith.spec.js
+++ b/test/uniqWith.spec.js
@@ -11,7 +11,7 @@ describe('uniqWith', () => {
         ];
         const actual = uniqWith(objects, lodashStable.isEqual);
 
-        expect(actual, [objects[0]).toEqual(objects[1]]);
+        expect(actual).toEqual([objects[0], objects[1]]);
     });
 
     it('should preserve the sign of `0`', () => {
diff --git a/test/unzip-and-zip.spec.js b/test/unzip-and-zip.spec.js
index be15c072cd..6882036eae 100644
--- a/test/unzip-and-zip.spec.js
+++ b/test/unzip-and-zip.spec.js
@@ -54,12 +54,12 @@ describe('unzip and zip', () => {
             ];
 
             let actual = func(pair[0]);
-            expect('0' in actual[2]);
+            expect('0' in actual[2]).toBeTruthy();
             expect(actual).toEqual(pair[1]);
 
             actual = func(actual);
-            expect('2' in actual[0]);
-            assert.deepStrictEqual(actual, [
+            expect('2' in actual[0]).toBeTruthy();
+            expect(actual).toEqual([
                 ['barney', 36, undefined],
                 ['fred', 40, false],
             ]);
@@ -75,7 +75,7 @@ describe('unzip and zip', () => {
 
         it(`\`_.${methodName}\` should ignore values that are not arrays or \`arguments\` objects`, () => {
             const array = [[1, 2], [3, 4], null, undefined, { 0: 1 }];
-            assert.deepStrictEqual(func(array), [
+            expect(func(array)).toEqual([
                 [1, 3],
                 [2, 4],
             ]);
diff --git a/test/unzipWith.spec.js b/test/unzipWith.spec.js
index 790721b0ba..27c1e0ecf8 100644
--- a/test/unzipWith.spec.js
+++ b/test/unzipWith.spec.js
@@ -13,7 +13,7 @@ describe('unzipWith', () => {
 
         const actual = unzipWith(array, (a, b, c) => a + b + c);
 
-        expect(actual, [6).toEqual(15]);
+        expect(actual).toEqual([6, 15]);
     });
 
     it('should provide correct `iteratee` arguments', () => {
@@ -29,7 +29,7 @@ describe('unzipWith', () => {
             },
         );
 
-        expect(args, [1).toEqual(2]);
+        expect(args).toEqual([1, 2]);
     });
 
     it('should perform a basic unzip when `iteratee` is nullish', () => {
diff --git a/test/words.spec.js b/test/words.spec.js
index 00237acdb2..3c8e35e494 100644
--- a/test/words.spec.js
+++ b/test/words.spec.js
@@ -1,5 +1,5 @@
 import lodashStable from 'lodash';
-import { burredLetters, _, stubArray } from './utils';
+import { burredLetters, stubArray } from './utils';
 import words from '../src/words';
 
 describe('words', () => {
@@ -12,34 +12,29 @@ describe('words', () => {
     });
 
     it('should support a `pattern`', () => {
-        expect(words('abcd', /ab|cd/g), ['ab').toEqual('cd']);
+        expect(words('abcd', /ab|cd/g)).toEqual(['ab', 'cd']);
         expect(Array.from(words('abcd', 'ab|cd'))).toEqual(['ab']);
     });
 
     it('should work with compound words', () => {
-        expect(words('12ft'), ['12').toEqual('ft']);
-        expect(words('aeiouAreVowels'), ['aeiou', 'Are').toEqual('Vowels']);
-        expect(words('enable 6h format'), ['enable', '6', 'h').toEqual('format']);
-        expect(words('enable 24H format'), ['enable', '24', 'H').toEqual('format']);
-        expect(words('isISO8601'), ['is', 'ISO').toEqual('8601']);
-        assert.deepStrictEqual(words('LETTERSAeiouAreVowels'), [
-            'LETTERS',
-            'Aeiou',
-            'Are',
-            'Vowels',
-        ]);
-        expect(words('tooLegit2Quit'), ['too', 'Legit', '2').toEqual('Quit']);
-        expect(words('walk500Miles'), ['walk', '500').toEqual('Miles']);
-        expect(words('xhr2Request'), ['xhr', '2').toEqual('Request']);
-        expect(words('XMLHttp'), ['XML').toEqual('Http']);
-        expect(words('XmlHTTP'), ['Xml').toEqual('HTTP']);
-        expect(words('XmlHttp'), ['Xml').toEqual('Http']);
+        expect(words('12ft')).toEqual(['12', 'ft']);
+        expect(words('aeiouAreVowels')).toEqual(['aeiou', 'Are', 'Vowels']);
+        expect(words('enable 6h format')).toEqual(['enable', '6', 'h', 'format']);
+        expect(words('enable 24H format')).toEqual(['enable', '24', 'H', 'format']);
+        expect(words('isISO8601')).toEqual(['is', 'ISO', '8601']);
+        expect(words('LETTERSAeiouAreVowels')).toEqual(['LETTERS', 'Aeiou', 'Are', 'Vowels']);
+        expect(words('tooLegit2Quit')).toEqual(['too', 'Legit', '2', 'Quit']);
+        expect(words('walk500Miles')).toEqual(['walk', '500', 'Miles']);
+        expect(words('xhr2Request')).toEqual(['xhr', '2', 'Request']);
+        expect(words('XMLHttp')).toEqual(['XML', 'Http']);
+        expect(words('XmlHTTP')).toEqual(['Xml', 'HTTP']);
+        expect(words('XmlHttp')).toEqual(['Xml', 'Http']);
     });
 
     it('should work with compound words containing diacritical marks', () => {
-        expect(words('LETTERSÆiouAreVowels'), ['LETTERS', 'Æiou', 'Are').toEqual('Vowels']);
-        expect(words('æiouAreVowels'), ['æiou', 'Are').toEqual('Vowels']);
-        expect(words('æiou2Consonants'), ['æiou', '2').toEqual('Consonants']);
+        expect(words('LETTERSÆiouAreVowels')).toEqual(['LETTERS', 'Æiou', 'Are', 'Vowels']);
+        expect(words('æiouAreVowels')).toEqual(['æiou', 'Are', 'Vowels']);
+        expect(words('æiou2Consonants')).toEqual(['æiou', '2', 'Consonants']);
     });
 
     it('should not treat contractions as separate words', () => {
@@ -111,16 +106,11 @@ describe('words', () => {
         const maxMs = 1000;
         const startTime = lodashStable.now();
 
-        assert.deepStrictEqual(words(`${largeWord}ÆiouAreVowels`), [
-            largeWord,
-            'Æiou',
-            'Are',
-            'Vowels',
-        ]);
+        expect(words(`${largeWord}ÆiouAreVowels`)).toEqual([largeWord, 'Æiou', 'Are', 'Vowels']);
 
         const endTime = lodashStable.now();
         const timeSpent = endTime - startTime;
 
-        expect(timeSpent < maxMs, `operation took ${timeSpent}ms`)
+        expect(timeSpent).toBeLessThan(maxMs);
     });
 });
diff --git a/test/wrap.spec.js b/test/wrap.spec.js
index 8e6e73f49b..1d12230eff 100644
--- a/test/wrap.spec.js
+++ b/test/wrap.spec.js
@@ -6,7 +6,7 @@ describe('wrap', () => {
     it('should create a wrapped function', () => {
         const p = wrap(lodashStable.escape, (func, text) => `<p>${func(text)}</p>`);
 
-        expect(p('fred, barney, & pebbles'), '<p>fred, barney).toBe(&amp; pebbles</p>');
+        expect(p('fred, barney, & pebbles')).toBe('<p>fred, barney &amp; pebbles</p>');
     });
 
     it('should provide correct `wrapper` arguments', () => {
@@ -17,7 +17,7 @@ describe('wrap', () => {
         });
 
         wrapped(1, 2, 3);
-        expect(args, [noop, 1, 2).toEqual(3]);
+        expect(args).toEqual([noop, 1, 2, 3]);
     });
 
     it('should use `_.identity` when `wrapper` is nullish', () => {
@@ -38,6 +38,6 @@ describe('wrap', () => {
         });
 
         const object = { p: p, text: 'fred, barney, & pebbles' };
-        expect(object.p(), '<p>fred, barney).toBe(&amp; pebbles</p>');
+        expect(object.p()).toBe('<p>fred, barney &amp; pebbles</p>');
     });
 });
diff --git a/test/xor-methods.spec.js b/test/xor-methods.spec.js
index a097b0349a..7111b49700 100644
--- a/test/xor-methods.spec.js
+++ b/test/xor-methods.spec.js
@@ -7,12 +7,12 @@ describe('xor methods', () => {
 
         it(`\`_.${methodName}\` should return the symmetric difference of two arrays`, () => {
             const actual = func([2, 1], [2, 3]);
-            expect(actual, [1).toEqual(3]);
+            expect(actual).toEqual([1, 3]);
         });
 
         it(`\`_.${methodName}\` should return the symmetric difference of multiple arrays`, () => {
             let actual = func([2, 1], [2, 3], [3, 4]);
-            expect(actual, [1).toEqual(4]);
+            expect(actual).toEqual([1, 4]);
 
             actual = func([1, 2], [2, 1], [1, 2]);
             expect(actual).toEqual([]);
@@ -27,7 +27,7 @@ describe('xor methods', () => {
 
         it(`\`_.${methodName}\` should return an array of unique values`, () => {
             let actual = func([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);
-            expect(actual, [1).toEqual(4]);
+            expect(actual).toEqual([1, 4]);
 
             actual = func([1, 1]);
             expect(actual).toEqual([1]);
@@ -46,13 +46,13 @@ describe('xor methods', () => {
         it(`\`_.${methodName}\` should ignore values that are not arrays or \`arguments\` objects`, () => {
             const array = [1, 2];
             expect(func(array, 3, { 0: 1 }, null)).toEqual(array);
-            expect(func(null, array, null, [2, 3]), [1).toEqual(3]);
+            expect(func(null, array, null, [2, 3])).toEqual([1, 3]);
             expect(func(array, null, args, null)).toEqual([3]);
         });
 
         it(`\`_.${methodName}\` should return a wrapped value when chaining`, () => {
             const wrapped = _([1, 2, 3])[methodName]([5, 2, 1, 4]);
-            expect(wrapped instanceof _)
+            expect(wrapped instanceof _).toBeTruthy();
         });
 
         it(`\`_.${methodName}\` should work when in a lazy sequence before \`head\` or \`last\``, () => {
@@ -65,7 +65,7 @@ describe('xor methods', () => {
                 wrapped[methodName](),
             );
 
-            expect(actual, [1).toEqual(LARGE_ARRAY_SIZE + 1]);
+            expect(actual).toEqual([1, LARGE_ARRAY_SIZE + 1]);
         });
     });
 });
diff --git a/test/xorBy.spec.js b/test/xorBy.spec.js
index b31481d51a..7eff0a1765 100644
--- a/test/xorBy.spec.js
+++ b/test/xorBy.spec.js
@@ -4,7 +4,7 @@ import xorBy from '../src/xorBy';
 describe('xorBy', () => {
     it('should accept an `iteratee`', () => {
         let actual = xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
-        expect(actual, [1.2).toEqual(3.4]);
+        expect(actual).toEqual([1.2, 3.4]);
 
         actual = xorBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x');
         expect(actual).toEqual([{ x: 2 }]);
diff --git a/test/zipWith.spec.js b/test/zipWith.spec.js
index 8632121cbe..087a86e6a1 100644
--- a/test/zipWith.spec.js
+++ b/test/zipWith.spec.js
@@ -9,13 +9,11 @@ describe('zipWith', () => {
         const array2 = [4, 5, 6];
         const array3 = [7, 8, 9];
 
-        var actual = zipWith(array1, array2, array3, (a, b, c) => a + b + c);
+        let actual = zipWith(array1, array2, array3, (a, b, c) => a + b + c);
+        expect(actual).toEqual([12, 15, 18]);
 
-        expect(actual, [12, 15).toEqual(18]);
-
-        var actual = zipWith(array1, [], (a, b) => a + (b || 0));
-
-        expect(actual, [1, 2).toEqual(3]);
+        actual = zipWith(array1, [], (a, b) => a + (b || 0));
+        expect(actual).toEqual([1, 2, 3]);
     });
 
     it('should provide correct `iteratee` arguments', () => {
@@ -25,7 +23,7 @@ describe('zipWith', () => {
             args || (args = slice.call(arguments));
         });
 
-        expect(args, [1, 3).toEqual(5]);
+        expect(args).toEqual([1, 3, 5]);
     });
 
     it('should perform a basic zip when `iteratee` is nullish', () => {