wip: code formatting nits continued

test/includes.spec.js

@@ -0,0 +1,94 @@
+import lodashStable from 'lodash';
+import { empties, stubFalse } from './utils';
+import includes from '../src/includes';
+
+describe('includes', () => {
+    (function () {
+        lodashStable.each(
+            {
+                'an `arguments` object': arguments,
+                'an array': [1, 2, 3, 4],
+                'an object': { a: 1, b: 2, c: 3, d: 4 },
+                'a string': '1234',
+            },
+            (collection, key) => {
+                it(`should work with ${key} and  return \`true\` for  matched values`, () => {
+                    expect(includes(collection, 3)).toBe(true);
+                });
+
+                it(`should work with ${key} and  return \`false\` for unmatched values`, () => {
+                    expect(includes(collection, 5)).toBe(false);
+                });
+
+                it(`should work with ${key} and floor \`position\` values`, () => {
+                    expect(includes(collection, 2, 1.2)).toBe(true);
+                });
+
+                it(`should work with ${key} and return an unwrapped value implicitly when chaining`, () => {
+                    expect(_(collection).includes(3)).toBe(true);
+                });
+
+                it(`should work with ${key} and return a wrapped value when explicitly chaining`, () => {
+                    expect(_(collection).chain().includes(3) instanceof _);
+                });
+            },
+        );
+
+        lodashStable.each(
+            {
+                literal: 'abc',
+                object: Object('abc'),
+            },
+            (collection, key) => {
+                it(`should work with a string ${key} for \`collection\``, () => {
+                    expect(includes(collection, 'bc')).toBe(true);
+                    expect(includes(collection, 'd')).toBe(false);
+                });
+            },
+        );
+
+        it('should return `false` for empty collections', () => {
+            const expected = lodashStable.map(empties, stubFalse);
+
+            const actual = lodashStable.map(empties, (value) => {
+                try {
+                    return includes(value);
+                } catch (e) {}
+            });
+
+            expect(actual).toEqual(expected);
+        });
+
+        it('should work with a string and a `fromIndex` >= `length`', () => {
+            const string = '1234';
+            const length = string.length;
+            const indexes = [4, 6, 2 ** 32, Infinity];
+
+            const expected = lodashStable.map(indexes, (index) => [false, false, index === length]);
+
+            const actual = lodashStable.map(indexes, (fromIndex) => [
+                includes(string, 1, fromIndex),
+                includes(string, undefined, fromIndex),
+                includes(string, '', fromIndex),
+            ]);
+
+            expect(actual).toEqual(expected);
+        });
+
+        it('should match `NaN`', () => {
+            expect(includes([1, NaN, 3], NaN)).toBe(true);
+        });
+
+        it('should match `-0` as `0`', () => {
+            expect(includes([-0], 0)).toBe(true);
+            expect(includes([0], -0)).toBe(true);
+        });
+
+        it('should work as an iteratee for methods like `_.every`', () => {
+            const array = [2, 3, 1];
+            const values = [1, 2, 3];
+
+            expect(lodashStable.every(values, lodashStable.partial(includes, array)));
+        });
+    })(1, 2, 3, 4);
+});