evg_observable 1.0.7 → 1.0.11

package/src/Libraries/Observables/Types.ts

@@ -1,159 +0,0 @@
-export type ICallback<T> = (value?: T) => any;
-
-export type ISubscribe<T> = {
-    subscribe(listener: IListener<T>): ISubscriptionLike<T>;
-};
-
-export type IListener<T> = ICallback<T>;
-
-export type IDestroy = {
-    destroy(): void;
-    isDestroyed: boolean;
-};
-
-export type IOnceMarker = {
-    isOnce: boolean;
-    isFinished: boolean;
-};
-
-export type IOrder = {
-    order: number;
-};
-
-export type IOnce<T> = {
-    setOnce(): ISubscribe<T>;
-};
-
-export type IOrderedOnce<T> = {
-    setOnce(): IOrderedSubscribe<T>;
-};
-
-export type ISetObservableValue = {
-    next(value: any): void;
-};
-
-export type ISubscriptionLike<T> = {
-    unsubscribe(): void;
-};
-
-export type ISetup<T> =
-    IUnsubscribeByNegative<T> &
-    IUnsubscribeByPositive<T> &
-    IEmitByNegative<T> &
-    IEmitByPositive<T> &
-    IEmitMatchCondition<T> &
-    IOnce<T> &
-    ISubscribe<T>;
-
-export type IOrderedSetup<T> =
-    IOrderedUnsubscribeByNegative<T> &
-    IOrderedUnsubscribeByPositive<T> &
-    IOrderedEmitByNegative<T> &
-    IOrderedEmitByPositive<T> &
-    IOrderedEmitMatchCondition<T> &
-    IOrderedOnce<T> &
-    IOrderedSubscribe<T>;
-
-export type ISubscribeObject<T> =
-    ISubscriptionLike<T> &
-    IPause &
-    IOrder &
-    ISend<T> &
-    ISetup<T>;
-
-export type ISubscribeCounter = {
-    size(): number;
-};
-
-export type ISubscriber<T> =
-    {
-        getValue(): T,
-        isEnable: boolean
-    } &
-    ISubscribe<T>;
-
-export type IObserver<T> =
-    ISetObservableValue &
-    ISubscriber<T> &
-    IDestroy &
-    ISubscribeCounter &
-    IObservablePipe<T> &
-    {
-        unSubscribe(ISubscriptionLike): void,
-        unsubscribeAll(): void,
-        disable(): void,
-        enable(): void,
-    };
-
-export type IPause = {
-    pause(): void;
-    resume(): void;
-};
-
-export type IObservablePipe<T> = {
-    pipe(): ISetup<T>
-};
-
-export type ISend<T> = {
-    send(value: T): void;
-};
-
-export type IUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IEmitMatchCondition<T> = {
-    emitMatch(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedEmitMatchCondition<T> = {
-    emitMatch(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type ICollector =
-    IDestroy &
-    ISubscribeCounter &
-    {
-        collect(...subscriptionLikeList: ISubscriptionLike<any>[]): void;
-        unsubscribe(subscriptionLike: ISubscriptionLike<any>): void;
-        unsubscribeAll(): void;
-    };
-
-export type IOrderedObservable = {
-    sortByOrder(): void;
-};
-
-export type IOrdered<T> = IObserver<T> & IOrderedObservable;
-
-export type IOrderedSubscriptionLike<T> = ISubscriptionLike<T> & IOrder;
-export type IOrderedSubscribe<T> = {
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;
-};

package/src/Libraries/TickGenerator.ts

@@ -1,178 +0,0 @@
-import {Observable} from "./Observables/Observable";
-import {cb_function, delay_ms, delay_second, ITick, ITickListener} from "./Types";
-import {ISubscriptionLike} from "./Observables/Types";
-
-let listeners: ITickListener[] = [];
-const tickDelay = 10;
-let tickIndex = <any>0,
-    secondFPSIndex = <any>0,
-    optimizeCounter = 0,
-    optimizeNumber = 1000,
-    tick10$ = new Observable(<any>0),
-    tick100$ = new Observable(<any>0),
-    secondFPS$ = new Observable(<any>0),
-    tick1000$ = new Observable(<any>0);
-
-class TickGenerator implements ITick {
-    private counter100 = 0;
-    private counter1000 = 0;
-    private isDestroyProcessed = false;
-    private _isDestroyed = false;
-
-    constructor() {
-        this.init();
-    }
-
-    private init(): void {
-        if (!secondFPSIndex) {
-            secondFPSIndex = setInterval(() => secondFPS$.next(-1), 1000);
-        }
-        if (!tickIndex) {
-            tickIndex = setInterval(() => {
-                this.counter100 += 10;
-                if (this.counter100 >= 100) this.counter100 = 0;
-
-                this.counter1000 += 10;
-                if (this.counter1000 >= 1000) this.counter1000 = 0;
-
-                tick10$.next(10);
-                if (!this.counter100) tick100$.next(100);
-                if (!this.counter1000) tick1000$.next(1000);
-
-                this.handleTimeOutListeners();
-            }, tickDelay);
-        }
-    }
-
-    executeSecondInterval(cb: cb_function, time: delay_second): ISubscriptionLike<any> {
-        const number = time;
-        return tick1000$.subscribe(() => {
-            if (time > 0) time--;
-
-            if (!time) {
-                cb();
-                time = number;
-            }
-        });
-    }
-
-    execute100MsInterval(cb: cb_function, time: delay_second): ISubscriptionLike<any> {
-        const number = time;
-        return tick100$.subscribe(() => {
-            if (time > 0) time--;
-
-            if (!time) {
-                cb();
-                time = number;
-            }
-        });
-    }
-
-    private handleTimeOutListeners(): void {
-        let isNeedToOptimize = false;
-        for (let i = 0; i < listeners.length; i++) {
-            const listener = listeners[i];
-            if (!listener) {
-                continue;
-            }
-            if (listener.isDestroy) {
-                listeners[i] = <any>0;
-                isNeedToOptimize = true;
-            } else {
-                if (listener.counter >= listener.delay) {
-                    listener.callback();
-                    listeners[i] = <any>0;
-                    isNeedToOptimize = true;
-                } else {
-                    listener.counter += tickDelay;
-                }
-            }
-        }
-        this.optimizeKeys(isNeedToOptimize);
-    }
-
-    private optimizeKeys(isNeedToOptimize: boolean): void {
-        if (!isNeedToOptimize) return;
-
-        optimizeCounter++;
-        if (optimizeCounter < optimizeNumber) return;
-
-        optimizeCounter = 0;
-        const tmpListeners: ITickListener[] = [];
-
-        const length = listeners.length;
-        for (let i = 0; i < length; i++) if (listeners[i]) tmpListeners.push(listeners[i]);
-
-        listeners.length = 0;
-        listeners = tmpListeners;
-        tmpListeners.length = 0;
-    }
-
-    get isDestroyed(): boolean {
-        return this._isDestroyed;
-    }
-
-    get tick10$(): Observable<any> {
-        return tick10$;
-    }
-
-    get tick100$(): Observable<any> {
-        return tick100$;
-    }
-
-    get tick1000$(): Observable<any> {
-        return tick1000$;
-    }
-
-    get secondFPS$(): Observable<any> {
-        return secondFPS$;
-    }
-
-    executeTimeout(cb: cb_function, time: delay_ms): ITickListener {
-        const listener: ITickListener = {
-            counter: 0,
-            delay: time,
-            callback: cb,
-            isDestroy: false
-        };
-        listeners.push(listener);
-        return listener;
-    }
-
-    clearTimeout(id: ITickListener): void {
-        if (!id) return;
-
-        id.isDestroy = true;
-        id.callback = () => console.log('listener has been destroyed');
-    }
-
-    destroy(): void {
-        if (this.isDestroyProcessed) return;
-        this.isDestroyProcessed = true;
-
-        this.counter100 = 0;
-        this.counter1000 = 0;
-        clearInterval(tickIndex);
-        clearInterval(secondFPSIndex);
-        tickIndex = <any>0;
-        secondFPSIndex = <any>0;
-
-        this.resetListeners(tick10$);
-        this.resetListeners(tick100$);
-        this.resetListeners(tick1000$);
-        this.resetListeners(secondFPS$);
-
-        tick10$ = <any>0;
-        tick100$ = <any>0;
-        tick1000$ = <any>0;
-        secondFPS$ = <any>0;
-
-        this._isDestroyed = true;
-    }
-
-    private resetListeners(observable: Observable<any>): void {
-        if (observable) observable.unsubscribeAll();
-    }
-}
-
-export const tickGenerator = new TickGenerator();

package/src/Libraries/Types.ts

@@ -1,27 +0,0 @@
-import {Observable} from "./Observables/Observable";
-import {ISubscriptionLike} from "./Observables/Types";
-
-export type IDestroyed = {
-    isDestroyed: boolean;
-};
-
-export type delay_ms = number;
-export type delay_second = number;
-export type cb_function = () => void;
-export type ITickListener = {
-    counter: number;
-    delay: delay_ms;
-    callback: cb_function;
-    isDestroy: boolean;
-};
-export type ITick = {
-    tick10$: Observable<any>;
-    tick100$: Observable<any>;
-    tick1000$: Observable<any>;
-    secondFPS$: Observable<any>;
-    executeTimeout(cb: cb_function, time: delay_ms): ITickListener;
-    execute100MsInterval(cb: cb_function, time: number): ISubscriptionLike<number>;
-    executeSecondInterval(cb: cb_function, time: delay_second): ISubscriptionLike<number>;
-    clearTimeout(id: ITickListener): void;
-    destroy(): void;
-} & IDestroyed;

package/test/Collector.unit.test.ts

@@ -1,244 +0,0 @@
-import {suite, test} from '@testdeck/mocha';
-import * as _chai from 'chai';
-import {expect} from 'chai';
-import {ICollector} from "../src/Libraries/Observables/Types";
-import {Collector} from "../src/Libraries/Observables/Collector";
-import {Observable} from "../src/Libraries/Observables/Observable";
-
-_chai.should();
-_chai.expect;
-
-@suite
-class CollectorUnitTest {
-    private COLLECTOR: ICollector;
-
-    before() {
-        this.COLLECTOR = new Collector();
-    }
-
-    @test 'collector is created'() {
-        expect(this.COLLECTOR.size()).to.be.eql(0);
-    }
-
-    @test 'collector collect one subscriber'() {
-        const observable$ = new Observable(0);
-        this.COLLECTOR.collect(observable$.subscribe(value => value));
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-    }
-
-    @test 'collector collect two subscribers'() {
-        const observable$ = new Observable(0);
-        this.COLLECTOR.collect(observable$.subscribe(value => value));
-        this.COLLECTOR.collect(observable$.subscribe(value => value));
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-    }
-
-    @test 'collector collect three subscribers'() {
-        const observable$ = new Observable(0);
-        this.COLLECTOR.collect(
-            observable$.subscribe(value => value),
-            observable$.subscribe(value => value),
-            observable$.subscribe(value => value),
-        );
-        expect(this.COLLECTOR.size()).to.be.equal(3);
-    }
-
-    @test 'collector collect ten subscribers'() {
-        const observable$ = new Observable(0);
-        for (let i = 0; i < 10; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-    }
-
-    @test 'collector collect zero subscribers'() {
-        this.COLLECTOR.collect();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect one subscriber and unsubscribe'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-        this.COLLECTOR.unsubscribe(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect one subscriber and unsubscribe all'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect zero subscribers and unsubscribe'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        this.COLLECTOR.unsubscribe(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect((<any>subscriptionLike).observable).to.be.equal(0);
-    }
-
-    @test 'collector collect zero subscribers and unsubscribeAll'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(!!(<any>subscriptionLike).observable).to.be.equal(true);
-    }
-
-    @test 'collector collect two subscribers and unsubscribe one'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-    }
-
-    @test 'collector collect two subscribers and unsubscribe two'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        this.COLLECTOR.unsubscribe(subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect two subscribers and unsubscribe all'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect ten subscribers and unsubscribe one'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        expect(this.COLLECTOR.size()).to.be.equal(9);
-    }
-
-    @test 'collector collect ten subscribers and unsubscribe two'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        this.COLLECTOR.collect(subscriptionLike2);
-        for (let i = 0; i < 8; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        this.COLLECTOR.unsubscribe(subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(8);
-    }
-
-    @test 'collector collect ten subscribers and unsubscribe all'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        this.COLLECTOR.collect(subscriptionLike2);
-        for (let i = 0; i < 8; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect one subscriber and destroy'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-    }
-
-    @test 'collector collect two subscribers and destroy'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-    }
-
-    @test 'collector collect ten subscribers and destroy'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-    }
-
-    @test 'collector collect ten subscribers, destroy and collect '() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-        expect(this.COLLECTOR.collect()).to.be.equal(null);
-    }
-
-    @test 'collector collect ten subscribers, destroy and unsubscribe '() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-        expect(this.COLLECTOR.unsubscribe(subscriptionLike1)).to.be.equal(null);
-    }
-
-    @test 'collector collect ten subscribers, destroy and unsubscribeAll '() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-        expect(this.COLLECTOR.unsubscribeAll()).to.be.equal(null);
-    }
-}

package/test/FunctionLib.unit.test.ts

@@ -1,86 +0,0 @@
-import {suite, test} from '@testdeck/mocha';
-import * as _chai from 'chai';
-import {expect} from 'chai';
-import {deleteFromArray} from "../src/Libraries/FunctionLibs";
-
-_chai.should();
-_chai.expect;
-
-@suite
-class FunctionLibUnitTest {
-    private deleteFromArray: <T>(arr: T[], component: T) => boolean;
-
-    before() {
-        this.deleteFromArray = deleteFromArray;
-    }
-
-    @test 'deleteFromArray: 1 from arr empty'() {
-        expect(this.deleteFromArray([], 1)).to.be.equal(false);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1]'() {
-        const arr = [1];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([]);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1, 2]'() {
-        const arr = [1, 2];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([2]);
-    }
-
-    @test 'deleteFromArray: 2 from arr [1, 2]'() {
-        const arr = [1, 2];
-        expect(this.deleteFromArray(arr, 2)).to.be.equal(true);
-        expect(arr).to.be.eql([1]);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([2, 3]);
-    }
-
-    @test 'deleteFromArray: 2 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 2)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 3]);
-    }
-
-    @test 'deleteFromArray: 3 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 3)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 2]);
-    }
-
-    @test 'deleteFromArray: 4 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 4)).to.be.equal(false);
-        expect(arr).to.be.eql([1, 2, 3]);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 2, 3]);
-    }
-
-    @test 'deleteFromArray: 2 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 2)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 1, 3]);
-    }
-
-    @test 'deleteFromArray: 3 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 3)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 1, 2]);
-    }
-
-    @test 'deleteFromArray: 4 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 4)).to.be.equal(false);
-        expect(arr).to.be.eql([1, 1, 2, 3]);
-    }
-}