@zajno/common 2.0.3 → 2.0.5

package/src/logger/__tests__/logger.test.ts

@@ -1,206 +0,0 @@
-import { faker } from '@faker-js/faker';
-import logger, { batchLoggers, createLogger, getMode, ILogger, setMode } from '..';
-import fc from 'fast-check';
-import { toArbitrary } from '../../__tests__/helpers/main';
-import { Getter } from '../../types';
-
-const CONSOLE = console;
-
-describe('#logger-tests', () => {
-
-  const customLogger = {
-    log: jest.fn().mockImplementation(),
-    warn: jest.fn().mockImplementation(),
-    error: jest.fn().mockImplementation(),
-  };
-  const customLoggerGetter = () => customLogger;
-
-  const consoleMocks: Record<keyof ILogger, jest.SpyInstance> = {
-    log: jest.spyOn(CONSOLE, 'log').mockImplementation(),
-    warn: jest.spyOn(CONSOLE, 'warn').mockImplementation(),
-    error: jest.spyOn(CONSOLE, 'error').mockImplementation(),
-  } as const;
-  const loggerMethods = Object.keys(consoleMocks) as (keyof ILogger)[];
-
-  it('use logger without mode (default logger)', () => {
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.internet.url());
-    let iteration = 0;
-
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-        const methodName = loggerMethods[iteration];
-        logger[methodName](textToLog);
-
-        expect(getMode()).toBe(false);
-        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
-
-        ++iteration;
-      }), {
-        numRuns: loggerMethods.length,
-      });
-  });
-
-  it('use logger with runtime mode disabling', () => {
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
-
-    let iteration = 0;
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-        // set mode before or after creating a new logger
-
-        if (iteration % 2 === 0) { setMode('console'); setMode(customLoggerGetter); setMode(false); }
-        const logger = createLogger(faker.random.word());
-        if (iteration % 2 === 1) { setMode('console'); setMode(customLoggerGetter); setMode(false); }
-
-        const methodName = loggerMethods[iteration % 3];
-        logger[methodName](textToLog);
-
-        expect(getMode()).toBe(false);
-        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
-        ++iteration;
-    }), {
-      numRuns: loggerMethods.length * 2,
-    });
-  });
-
-  it('use logger with \'null\' mode', () => {
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.internet.url());
-
-    let iteration = 0;
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-        if (iteration % 2 === 0) setMode(null);
-        const logger = createLogger(faker.random.word());
-        if (iteration % 2 === 1) setMode(null);
-
-        const methodName = loggerMethods[iteration % 3];
-        logger[methodName](textToLog);
-
-        const spyLogger = jest.spyOn(CONSOLE, methodName);
-
-        expect(getMode()).toBeNull();
-        expect(spyLogger).not.toHaveBeenCalled();
-        ++iteration;
-      }), {
-        numRuns: loggerMethods.length * 2,
-      });
-  });
-
-  it('use logger with \'console\' mode', () => {
-    const loggerName = `[${faker.random.word()}]`;
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
-
-    let iteration = 0;
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-
-        if (iteration % 2 === 0) setMode('console');
-        const logger = createLogger(loggerName);
-        if (iteration % 2 === 1) setMode('console');
-        const methodName = loggerMethods[iteration % 3];
-        logger[methodName](textToLog);
-
-        expect(getMode()).toBe('console');
-        expect(consoleMocks[methodName]).toHaveBeenCalledWith(loggerName, textToLog);
-        consoleMocks[methodName].mockClear();
-
-        ++iteration;
-      }), {
-        numRuns: loggerMethods.length * 2,
-      });
-  });
-
-  it('use logger with custom mode', () => {
-    const loggerName = `[${faker.random.word()}]`;
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
-
-    let iteration = 0;
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-        if (iteration % 2 === 0) setMode(customLoggerGetter);
-        const logger = createLogger(loggerName);
-        if (iteration % 2 === 1) setMode(customLoggerGetter);
-
-        const methodName = loggerMethods[iteration % 3];
-        logger[methodName](textToLog);
-
-        const impl = customLogger[methodName];
-
-        expect(getMode()).toBe(customLoggerGetter);
-        expect(impl).toHaveBeenCalledWith(loggerName, textToLog);
-        impl.mockClear();
-        ++iteration;
-      }), {
-        numRuns: loggerMethods.length * 2,
-      });
-  });
-
-  it('use logger with override mode #override', () => {
-
-    const loggerName = `[${faker.random.word()}]`;
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
-
-    expect(Getter.getValue(customLoggerGetter as Getter<ILogger>)).toBe(customLogger);
-
-    setMode('console');
-
-    let iteration = 0;
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-        const loggerDisabled = createLogger(loggerName, false);
-        const loggerCustom = createLogger(loggerName, customLoggerGetter);
-
-        const methodName = loggerMethods[iteration % 3];
-        loggerDisabled[methodName](textToLog);
-        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
-
-        loggerCustom[methodName](textToLog);
-
-        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
-
-        const impl = customLogger[methodName];
-        expect(impl).toHaveBeenCalledWith(loggerName, textToLog);
-        impl.mockClear();
-
-        ++iteration;
-      }), {
-        numRuns: loggerMethods.length,
-      });
-
-    expect(getMode()).toBe('console');
-
-  });
-
-  it('batches loggers', () => {
-
-    const loggerName = `[${faker.random.word()}]`;
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
-
-    setMode(false);
-
-    let iteration = 0;
-    fc.assert(
-      fc.property(_textToLog, (textToLog) => {
-        const logger = batchLoggers(
-          createLogger(loggerName, 'console'),
-          createLogger(loggerName, customLoggerGetter),
-        );
-
-        const methodName = loggerMethods[iteration % 3];
-        logger[methodName](textToLog);
-
-        expect(consoleMocks[methodName]).toHaveBeenCalledWith(loggerName, textToLog);
-        const impl = customLogger[methodName];
-        expect(impl).toHaveBeenCalledWith(loggerName, textToLog);
-        impl.mockClear();
-
-        ++iteration;
-      }), {
-        numRuns: loggerMethods.length,
-      });
-
-    expect(getMode()).toBe(false);
-
-  });
-
-});

package/src/logger/abstractions.ts

@@ -1,13 +0,0 @@
-
-export type LoggerFunction = (...args: any[]) => void;
-
-export interface ILogger {
-    log: LoggerFunction;
-    warn: LoggerFunction;
-    error: LoggerFunction;
-}
-
-export interface ILoggerSwitchable {
-    enable(): void;
-    disable(): void;
-}

package/src/logger/batch.ts

@@ -1,9 +0,0 @@
-import { ILogger } from './abstractions';
-
-export function batchLoggers(...loggers: ILogger[]): ILogger {
-    return {
-        log: (...args) => loggers.forEach(l => l.log(...args)),
-        warn: (...args) => loggers.forEach(l => l.warn(...args)),
-        error: (...args) => loggers.forEach(l => l.error(...args)),
-    };
-}

package/src/logger/console.ts

@@ -1,52 +0,0 @@
-import { ILogger } from './abstractions';
-import { NamedLogger } from './named';
-
-export const CONSOLE: ILogger = console;
-
-export class ConsoleLogger extends NamedLogger {
-    protected get implementation() { return CONSOLE; }
-}
-
-export class BufferedConsoleLogger implements ILogger {
-    private readonly _name: string = null;
-    private readonly _logs: string[] = [];
-    private _level = 1;
-
-    private _log = CONSOLE.log;
-
-    constructor(name: string) {
-        this._name = name || '';
-    }
-
-    log(...args: any[]) {
-        this._logs.push('\t--->', ...args);
-    }
-
-    warn(...args: any[]) {
-        this._logs.push('\t---> [WARN]', ...args);
-        this._raiseLevel(2);
-    }
-
-    error(...args: any[]) {
-        this._logs.push('\t---> [ERROR]', ...args);
-        this._raiseLevel(3);
-    }
-
-    flush() {
-        if (this._logs.length > 0) {
-            this._log(this._name, ...this._logs);
-            this._logs.length = 0;
-        }
-    }
-
-    private _raiseLevel(l: number) {
-        if (l > this._level) {
-            this._level = l;
-            if (l >= 3) {
-                this._log = CONSOLE.error;
-            } else if (l >= 2) {
-                this._log = CONSOLE.warn;
-            }
-        }
-    }
-}

package/src/logger/file.ts

@@ -1,66 +0,0 @@
-
-/* eslint-disable no-console */
-import * as Path from 'path';
-import * as FS from 'fs';
-import * as Util from 'util';
-
-import { ILogger } from './abstractions';
-
-export class FileLoggerNode implements ILogger {
-    private readonly _buffer: string[] = [];
-    private _logFilePath: string = null;
-
-    constructor(readonly extraLogger: ILogger = console, readonly instantFlush = false) {
-        this.setLogName('');
-    }
-
-    setLogFilePath(path: string) {
-        this._logFilePath = path;
-        return this;
-    }
-
-    setLogName(name: string) {
-        const n = name ? `-${name}` : '';
-        this._logFilePath = Path.resolve(__dirname, `../run${n}.${new Date().toISOString()}.log`);
-        return this;
-    }
-
-    private append(..._args: any[]) {
-        // @ts-ignore
-        const str = Util.format.apply(null, arguments) + '\n';
-        this._buffer.push(str);
-
-        if (this.instantFlush) {
-            this.flush();
-        }
-    }
-
-    log = (...args: any[]) => {
-        this.extraLogger?.log(...args);
-        this.append(...args);
-    };
-
-    warn = (...args: any[]) => {
-        this.extraLogger?.warn(...args);
-        this.append(...args);
-    };
-
-    error = (...args: any[]) => {
-        this.extraLogger?.error(...args);
-        this.append(...args);
-    };
-
-    flush() {
-        if (!this._buffer.length) {
-            return;
-        }
-
-        try {
-            FS.appendFileSync(this._logFilePath, this._buffer.join(''));
-        } catch (err) {
-            console.warn('Failed to flush file, error', err);
-        } finally {
-            this._buffer.length = 0;
-        }
-    }
-}

package/src/logger/index.ts

@@ -1,71 +0,0 @@
-import { Getter } from '../types';
-import { ILogger, LoggerFunction } from './abstractions';
-import { CONSOLE, ConsoleLogger } from './console';
-import { ProxyLogger } from './proxy';
-import { batchLoggers } from './batch';
-import { removeItem } from '../math';
-
-export { NamedLogger } from './named';
-export { ILogger, LoggerFunction, ConsoleLogger, batchLoggers };
-
-// TBD Introduce more logger types ?
-export type LoggerTypes = 'console';
-
-let Mode: LoggerTypes | false | Getter<ILogger> = false;
-
-const proxies: ProxyLogger[] = [];
-
-export function createLogger(name: string, mode: typeof Mode = undefined): ILogger {
-    const result = _createImplementation(mode);
-    const proxy = new ProxyLogger(result, name);
-    proxies.push(proxy);
-    return proxy;
-}
-
-export function detachLogger(instance: ILogger, terminate = false) {
-    const item = removeItem(proxies, instance as ProxyLogger);
-    if (item) {
-        if (terminate) {
-            item.disable();
-        }
-        return true;
-    }
-    return false;
-}
-
-export function setMode(mode: typeof Mode) {
-    if (Mode === mode) {
-        return;
-    }
-
-    Mode = mode;
-
-    if (!Mode) {
-        proxies.forEach(l => l.disable());
-    } else {
-        proxies.forEach(l => l.setLogger(_createImplementation()));
-    }
-}
-
-export function getMode() { return Mode; }
-
-const logger: ILogger = createLogger(null, false);
-
-export default logger;
-
-function _createImplementation(overrideMode: typeof Mode = undefined): ILogger {
-    const mode = overrideMode !== undefined ? overrideMode : Mode;
-    switch (mode) {
-        case 'console': {
-            return CONSOLE;
-        }
-
-        case false: {
-            return null;
-        }
-
-        default: {
-            return Getter.getValue(mode as Getter<ILogger>);
-        }
-    }
-}

package/src/logger/named.ts

@@ -1,47 +0,0 @@
-import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions';
-
-export const EMPTY_FUNCTION = () => { /* no-op */ };
-
-export abstract class NamedLogger implements ILogger, ILoggerSwitchable {
-    public log: LoggerFunction = null;
-    public warn: LoggerFunction = null;
-    public error: LoggerFunction = null;
-
-    private _name: string = null;
-
-    get name() { return this._name; }
-
-    protected abstract get implementation(): ILogger;
-
-    constructor(name?: string, enabled = true) {
-        this._name = name;
-
-        if (enabled) {
-            this.enable();
-        } else {
-            this.disable();
-        }
-    }
-
-    enable(overrideName = null) {
-        this._name = overrideName || this._name;
-
-        this.log = this._name
-            ? (...args) => this.implementation.log(this._name, ...args)
-            : this.implementation.log;
-
-        this.warn = this._name
-            ? (...args) => this.implementation.warn(this._name, ...args)
-            : this.implementation.warn;
-
-        this.error = this._name
-            ? (...args) => this.implementation.error(this._name, ...args)
-            : this.implementation.error;
-    }
-
-    disable() {
-        this.log = EMPTY_FUNCTION;
-        this.warn = EMPTY_FUNCTION;
-        this.error = EMPTY_FUNCTION;
-    }
-}

package/src/logger/proxy.ts

@@ -1,29 +0,0 @@
-import { ILogger } from './abstractions';
-import { EMPTY_FUNCTION, NamedLogger } from './named';
-
-export const EMPTY_LOGGER: ILogger = {
-    log: EMPTY_FUNCTION,
-    warn: EMPTY_FUNCTION,
-    error: EMPTY_FUNCTION,
-};
-
-export class ProxyLogger extends NamedLogger {
-
-    protected get implementation() { return this._logger || EMPTY_LOGGER; }
-
-    private _logger: ILogger = null;
-
-    constructor(logger: ILogger, name: string) {
-        super(name, logger != null);
-        this._logger = logger;
-    }
-
-    public setLogger(logger: ILogger) {
-        this._logger = logger || null;
-        if (this._logger) {
-            this.enable();
-        } else {
-            this.disable();
-        }
-    }
-}

package/src/math/__tests__/arrays.test.ts

@@ -1,196 +0,0 @@
-import * as arrays from '../arrays';
-
-describe('math/arrays', () => {
-    it('arrayCompareG', () => {
-        expect(arrays.arrayCompareG<any>(null, null)).toBeNull();
-        expect(arrays.arrayCompareG<any>([], null)).toBeNull();
-
-        type T = { a: number };
-        const tArr: T[] = [ { a: 1 }, { a: 2 }, { a: 3 } ];
-        expect(arrays.arrayCompareG<T>(tArr, (t, p) => !p || t.a > p.a))
-            .toEqual({ a: 3 });
-    });
-
-    it('arrayCompare', () => {
-        expect(arrays.arrayCompare(null, false, null)).toBeNull();
-        expect(arrays.arrayCompare([], false, null)).toBeNull();
-
-        expect(() => arrays.arrayCompare([1, 2, 3], false, null)).toThrow();
-
-        expect(arrays.arrayCompare([1, 2, 3], false, (i, t) => i > t)).toBe(3);
-        expect(arrays.arrayCompare([1, 2, 3], false, (i, t) => i < t)).toBe(1);
-
-        expect(arrays.arrayCompare([-1, 2, -3], true, (i, t) => i > t)).toBe(3);
-        expect(arrays.arrayCompare([-1, 2, -3], true, (i, t) => i < t)).toEqual(-1);
-    });
-
-    it('arrayMax', () => {
-        expect(arrays.arrayMax([], false)).toBeNull();
-        expect(arrays.arrayMax([1, 2, 3], false)).toBe(3);
-        expect(arrays.arrayMax([-1, 2, -3], true)).toBe(3);
-    });
-
-    it('arrayMin', () => {
-        expect(arrays.arrayMin([], false)).toBeNull();
-        expect(arrays.arrayMin([1, 2, 3], false)).toBe(1);
-        expect(arrays.arrayMin([-1, 2, -3], true)).toEqual(-1);
-    });
-
-    it('arrayAverage', () => {
-        expect(arrays.arrayAverage(null)).toBe(0);
-        expect(arrays.arrayAverage([])).toBe(0);
-        expect(arrays.arrayAverage([1, 2, 3])).toBe(2);
-        expect(arrays.arrayAverage([-2, 2, -3])).toEqual(-1);
-        expect(arrays.arrayAverage([-1, 2, -3], true)).toBe(2);
-    });
-
-    it('arrayCount', () => {
-        expect(arrays.arrayCount(null, null)).toBe(0);
-        expect(arrays.arrayCount([], null)).toBe(0);
-
-        expect(() => arrays.arrayCount([1, 2, 3], null)).toThrow();
-        expect(arrays.arrayCount([1, 2, 3], i => i >= 2)).toBe(2);
-
-        type T = { a: number };
-        const tArr: T[] = [ { a: 1 }, { a: 2 }, { a: 3 } ];
-        expect(arrays.arrayCount(tArr, i => i.a >= 2)).toBe(2);
-    });
-
-    it('arrayFirstResult', () => {
-        expect(arrays.arrayFirstResult(null, null)).toBeFalsy();
-        expect(arrays.arrayFirstResult([], null)).toBeFalsy();
-
-        expect(() => arrays.arrayFirstResult([1, 2, 3], null)).toThrow();
-        expect(arrays.arrayFirstResult([1, 2, 3], i => i == 2 ? 'pass' : false)).toBe('pass');
-    });
-
-    it('arraysCompare', () => {
-        expect(arrays.arraysCompare(null, null)).toBeNull();
-        expect(arrays.arraysCompare([], null)).toBeNull();
-
-        const result = (missing, extra, diff) => ({ missing, extra, diff });
-
-        expect(arrays.arraysCompare([], [])).toStrictEqual(result([], [], 0));
-        expect(arrays.arraysCompare([1], [])).toStrictEqual(result([1], [], 1));
-        expect(arrays.arraysCompare([1, 2], [1])).toStrictEqual(result([2], [], 1));
-        expect(arrays.arraysCompare([1], [1])).toStrictEqual(result([], [], 0));
-        expect(arrays.arraysCompare([], [1])).toStrictEqual(result([], [1], 1));
-        expect(arrays.arraysCompare([1, 2, 3], [3, 2, 1])).toStrictEqual(result([1, 3], [], 2));
-    });
-
-    it('arraysCompareDistinct', () => {
-        expect(arrays.arraysCompareDistinct(null, null)).toBeNull();
-        expect(arrays.arraysCompareDistinct([], null)).toBeNull();
-
-        const result = (missing, extra, diff) => ({ missing, extra, diff });
-
-        expect(arrays.arraysCompareDistinct([], [])).toStrictEqual(result([], [], 0));
-        expect(arrays.arraysCompareDistinct([1], [])).toStrictEqual(result([1], [], 1));
-        expect(arrays.arraysCompareDistinct([1, 2], [1])).toStrictEqual(result([2], [], 1));
-        expect(arrays.arraysCompareDistinct([1], [1])).toStrictEqual(result([], [], 0));
-        expect(arrays.arraysCompareDistinct([], [1])).toStrictEqual(result([], [1], 1));
-        expect(arrays.arraysCompareDistinct([1, 2], [2, 1, 1])).toStrictEqual(result([], [], 0));
-        expect(arrays.arraysCompareDistinct([1, 2, 3], [3, 2, 1])).toStrictEqual(result([], [], 0));
-    });
-
-    it('arrayDistinct', () => {
-        expect(arrays.arrayDistinct(null)).toStrictEqual([]);
-        expect(arrays.arrayDistinct([])).toStrictEqual([]);
-        expect(arrays.arrayDistinct([1])).toStrictEqual([1]);
-        expect(arrays.arrayDistinct([1, 2, 3])).toStrictEqual([1, 2, 3]);
-        expect(arrays.arrayDistinct([1, '2', 3])).toStrictEqual([1, '2', 3]);
-        expect(arrays.arrayDistinct([1, 1, 1])).toStrictEqual([1]);
-        expect(arrays.arrayDistinct(['1', '1', '1'])).toStrictEqual(['1']);
-    });
-
-    it('normalize', () => {
-        expect(arrays.normalize([])).toHaveLength(0);
-
-        expect(arrays.normalize([10, 10])).toEqual([1, 1]);
-        expect(arrays.normalize([1, 2, 3])).toEqual([0, 0.5, 1]);
-    });
-
-    it('randomArrayItem', () => {
-        expect(() => arrays.randomArrayItem(null)).toThrow();
-        expect(arrays.randomArrayItem([])).toBeNull();
-
-        expect(arrays.randomArrayItem([1])).toBe(1);
-        expect([1, 2, 3]).toContain(arrays.randomArrayItem([1, 2, 3]));
-
-        const arr1 = [1, 2, 3], arr2 = arr1.slice();
-        arrays.arraySwap(arr2, 0, 2);
-        expect(arr2[0]).toEqual(arr1[2]);
-        expect(arr2[2]).toEqual(arr1[0]);
-    });
-
-    it('shuffle', () => {
-        expect(arrays.shuffle(null)).toStrictEqual([]);
-        expect(arrays.shuffle(null, true)).toStrictEqual([]);
-
-        const arr1 = [1, 2, 3], arr2 = arr1.slice();
-        arrays.shuffle(arr2);
-        arrays.shuffle(arr2, true);
-        expect(arr2).toHaveLength(arr1.length);
-        arr2.forEach(i => {
-            expect(arr1).toContain(i);
-        });
-    });
-
-    it('groupBy', () => {
-        expect(() => arrays.groupBy(null, null)).toThrow();
-
-        type T = { a: number };
-        const tArr: T[] = [ { a: 1 }, { a: 2 }, { a: 2 }, { a: 3 } ];
-        const result = arrays.groupBy(tArr, i => i.a);
-        expect(result).toBeTruthy();
-
-        expect(result[1]).toHaveLength(1);
-        expect(result[1][0]).toEqual({ a: 1 });
-
-        expect(result[2]).toHaveLength(2);
-        expect(result[2][0]).toEqual({ a: 2 });
-
-        expect(result[3]).toHaveLength(1);
-        expect(result[3][0]).toEqual({ a: 3 });
-    });
-
-    it('groupOneBy', () => {
-        expect(() => arrays.groupOneBy(null, null)).toThrow();
-
-        const result = arrays.groupOneBy([ { a: 1 }, { a: 2 }, { a: 2 }, { a: 3 } ], i => i.a);
-        expect(result).toBeTruthy();
-
-        expect(result[1]).toEqual({ a: 1 });
-        expect(result[2]).toEqual({ a: 2 });
-        expect(result[3]).toEqual({ a: 3 });
-    });
-
-    it('arraySplit', () => {
-        expect(() => arrays.arraySplit(null, null)).toThrow();
-
-        const result = arrays.arraySplit([ { a: 1 }, { a: 2 }, { a: 2 }, { a: 3 } ], i => i.a >= 2);
-        expect(result).toBeTruthy();
-
-        expect(result[0]).toHaveLength(3);
-        expect(result[1]).toHaveLength(1);
-    });
-
-    it('findIndexLeast', () => {
-        expect(() => arrays.findIndexLeast(0, null)).toThrow();
-
-        expect(arrays.findIndexLeast(2, [3, 2, 1])).toBe(0);
-        expect(arrays.findIndexLeast(2, [3, 2, 1], true)).toBe(2);
-        expect(arrays.findIndexLeast(2, [1, 2, 3])).toBe(2);
-    });
-
-    it('removeItem', () => {
-        const check = (input: any[], remove: any, output: any[]) => {
-            arrays.removeItem(input, remove);
-            expect(input).toStrictEqual(output);
-        };
-
-        check([1, 2, 3], 1, [2, 3]);
-        check([1, 2, 3], item => item === 1, [2, 3]);
-        check([1, 2, 3], '1', [1, 2, 3]);
-    });
-});