import { assert } from 'chai';
import {
    isObject,
    isArrayLike,
    isIterable,
    isNull,
    isUndefined,
    isString,
    isNumber,
    isFunction,
    isBoolean,
    isSymbol,
    isArray
} from '../../../lib/core/traits';

describe('core.traits', () => {
    describe('isObject', () => {
        test.each([
            [undefined, false],
            [null, false],
            [{}, true],
            [{ a: 1, b: 2, c: 3 }, true],
            [[], true],
            [[1, 2, 3], true],
            ['123', false],
            [123, false],
            [new Number(123), true],
            [Object.create(null), true]
        ])('isObject#%#', (arg: any, result: boolean) => {
            assert.strictEqual(isObject(arg), result);
        });
    });

    describe('isArrayLike', () => {
        test.each([
            [undefined, false],
            [null, false],
            ['123', true],
            [new String('123'), true],
            [123, false],
            [[], true],
            [[1, 2, 3], true],
            [new Array(3), true],
            [{}, false],
            [{ 0: 1, 1: 2, 2: 3, length: 3 }, true],
            [{ a: 1, b: 2, c: 3, length: 3 }, true], // sic!
            [{ 0: 1, 1: 2, 2: 3 }, false],
            [function () {}, false],
        ])('isArrayLike#%#', (arg: any, result: boolean) => {
            assert.strictEqual(isArrayLike(arg), result);
        });
    });

    describe('isIterable', () => {
        test.each([
            [undefined, false],
            [null, false],
            [123, false],
            ['123', true],
            [new String('123'), true],
            [[], true],
            [[1, 2, 3], true],
            [new Array(3), true],
            [{}, false],
            [{ a: 1, b: 2, c: 3 }, false],
            [{ 0: 1, 1: 2, 2: 3 }, false],
            [{ 0: 1, 1: 2, 2: 3, length: 3 }, false],
            [
                {
                    [Symbol.iterator]() {
                        let i = 0;
                        return {
                            next() {
                                return i < 3 ? { value: i++, done: false } : { value: undefined, done: true };
                            }
                        };
                    }
                },
                true
            ],
            [
                (function* () {
                    yield 1;
                    yield 2;
                    yield 3;
                }()),
                true
            ]
        ])('isIterable#%#', (arg: any, result: boolean) => {
            assert.strictEqual(isIterable(arg), result);
        });
    });

    describe('helpers', () => {
        const values: any[] = [
            /* [0] */ 123,
            /* [1] */ '123',
            /* [2] */ false,
            /* [3] */ [1, 2, 3],
            /* [4] */ {},
            /* [5] */ null,
            /* [6] */ undefined,
            /* [7] */ function foo() {},
            /* [8] */ Symbol('foo')
        ];

        const results = (...truthyIndecies: number[]) => {
            const ret = new Array<boolean>(values.length).fill(false);
            truthyIndecies.forEach(index => {
                ret[index] = true;
            });
            return ret;
        };

        test.each([
            [isNumber, values, results(0)],
            [isString, values, results(1)],
            [isBoolean, values, results(2)],
            [isArray, values, results(3)],
            [isObject, values, results(3, 4)],
            [isNull, values, results(5)],
            [isUndefined, values, results(6)],
            [isFunction, values, results(7)],
            [isSymbol, values, results(8)],
        ])('helpers#%#', (helper: (arg: any) => boolean, values: any[], results: boolean[]) => {
            assert.deepEqual(values.map(helper), results);
        });
    });
});