@flemist/test-variants 1.0.7 → 2.0.0-alpha

package/dist/lib/test-variants/createTestVariants.perf.cjs

@@ -1,32 +1,41 @@
 'use strict';
 
-var rdtsc = require('rdtsc');
+var tslib = require('tslib');
+var node = require('rdtsc/node');
 var testVariants_createTestVariants = require('./createTestVariants.cjs');
-require('tslib');
-require('../garbage-collect/garbageCollect.cjs');
+require('./testVariantsIterable.cjs');
+require('./testVariantsCreateTestRun.cjs');
+require('@flemist/async-utils');
+require('./argsToString.cjs');
+require('./testVariantsRun.cjs');
 require('@flemist/abort-controller-fast');
 require('@flemist/time-limits');
-require('@flemist/async-utils');
+require('../garbage-collect/garbageCollect.cjs');
 
 describe('test > testVariants perf', function () {
     this.timeout(300000);
     it('sync', function () {
-        let value = 0;
-        const testVariantsSync = testVariants_createTestVariants.createTestVariants(({ a, b, c }) => {
-            if (a === 1 && b === '4' && c === false) {
-                value++;
-            }
-        });
-        const args = {
-            a: [1, 2],
-            b: ['3', '4'],
-            c: [true, false],
-        };
-        const result = rdtsc.calcPerformance(10000, () => {
-        }, () => {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const testVariantsSync = testVariants_createTestVariants.createTestVariants(({ a, b, c }) => {
+            });
+            const args = {
+                a: [1, 2],
+                b: ['3', '4'],
+                c: [true, false],
+            };
+            const perfResult = node.calcPerformance({
+                time: 10000,
+                funcs: [
+                    () => {
+                    },
+                    () => {
+                        testVariantsSync(args)();
+                    },
+                ],
+            });
+            const result = yield testVariantsSync(args)();
+            perfResult.absoluteDiff = perfResult.absoluteDiff.map(o => o / result.iterations);
+            console.log('testVariants perf:', result);
         });
-        const count = testVariantsSync(args)();
-        result.absoluteDiff = result.absoluteDiff.map(o => o / count);
-        console.log('testVariants perf:', result);
     });
 });

package/dist/lib/test-variants/createTestVariants.perf.mjs

@@ -1,30 +1,39 @@
-import { calcPerformance } from 'rdtsc';
+import { __awaiter } from 'tslib';
+import { calcPerformance } from 'rdtsc/node';
 import { createTestVariants } from './createTestVariants.mjs';
-import 'tslib';
-import '../garbage-collect/garbageCollect.mjs';
+import './testVariantsIterable.mjs';
+import './testVariantsCreateTestRun.mjs';
+import '@flemist/async-utils';
+import './argsToString.mjs';
+import './testVariantsRun.mjs';
 import '@flemist/abort-controller-fast';
 import '@flemist/time-limits';
-import '@flemist/async-utils';
+import '../garbage-collect/garbageCollect.mjs';
 
 describe('test > testVariants perf', function () {
     this.timeout(300000);
     it('sync', function () {
-        let value = 0;
-        const testVariantsSync = createTestVariants(({ a, b, c }) => {
-            if (a === 1 && b === '4' && c === false) {
-                value++;
-            }
-        });
-        const args = {
-            a: [1, 2],
-            b: ['3', '4'],
-            c: [true, false],
-        };
-        const result = calcPerformance(10000, () => {
-        }, () => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const testVariantsSync = createTestVariants(({ a, b, c }) => {
+            });
+            const args = {
+                a: [1, 2],
+                b: ['3', '4'],
+                c: [true, false],
+            };
+            const perfResult = calcPerformance({
+                time: 10000,
+                funcs: [
+                    () => {
+                    },
+                    () => {
+                        testVariantsSync(args)();
+                    },
+                ],
+            });
+            const result = yield testVariantsSync(args)();
+            perfResult.absoluteDiff = perfResult.absoluteDiff.map(o => o / result.iterations);
+            console.log('testVariants perf:', result);
         });
-        const count = testVariantsSync(args)();
-        result.absoluteDiff = result.absoluteDiff.map(o => o / count);
-        console.log('testVariants perf:', result);
     });
 });

package/dist/lib/test-variants/prime.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const MAX_NUMBER = (Math.pow(2, 31) - 1) | 0;
+const MAX_NUMBER_PRIME = 2147483647;
+function isPrime(n) {
+    if (n > MAX_NUMBER) {
+        throw new Error(`Number is too large: ${n}, max is ${MAX_NUMBER}`);
+    }
+    // convert number to 32-bit integer for performance
+    n = n | 0;
+    if (n <= 1) {
+        return false;
+    }
+    if (n <= 3) {
+        return true;
+    }
+    if (n % 2 === 0 || n % 3 === 0) {
+        return false;
+    }
+    for (let i = 5; i * i <= n; i += 6) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+function nextPrime(n) {
+    if (n >= MAX_NUMBER_PRIME) {
+        throw new Error(`Number is too large: ${n}, max is ${MAX_NUMBER_PRIME - 1}`);
+    }
+    // convert number to 32-bit integer for performance
+    n = n | 0;
+    if (n < 2) {
+        return 2;
+    }
+    let candidate = n + (n % 2 === 0 ? 1 : 2);
+    while (!isPrime(candidate)) {
+        candidate += 2;
+    }
+    return candidate;
+}
+function prevPrime(n) {
+    if (n > MAX_NUMBER) {
+        throw new Error(`Number is too large: ${n}, max is ${MAX_NUMBER}`);
+    }
+    // convert number to 32-bit integer for performance
+    n = n | 0;
+    if (n <= 2) {
+        return null;
+    }
+    let candidate = n - (n % 2 === 0 ? 1 : 2);
+    while (candidate > 2 && !isPrime(candidate)) {
+        candidate -= 2;
+    }
+    if (candidate > 2) {
+        return candidate;
+    }
+    return 2;
+}
+
+exports.isPrime = isPrime;
+exports.nextPrime = nextPrime;
+exports.prevPrime = prevPrime;

package/dist/lib/test-variants/prime.d.ts

@@ -0,0 +1,3 @@
+export declare function isPrime(n: number): boolean;
+export declare function nextPrime(n: number): number;
+export declare function prevPrime(n: number): number;

package/dist/lib/test-variants/prime.mjs

@@ -0,0 +1,59 @@
+const MAX_NUMBER = (Math.pow(2, 31) - 1) | 0;
+const MAX_NUMBER_PRIME = 2147483647;
+function isPrime(n) {
+    if (n > MAX_NUMBER) {
+        throw new Error(`Number is too large: ${n}, max is ${MAX_NUMBER}`);
+    }
+    // convert number to 32-bit integer for performance
+    n = n | 0;
+    if (n <= 1) {
+        return false;
+    }
+    if (n <= 3) {
+        return true;
+    }
+    if (n % 2 === 0 || n % 3 === 0) {
+        return false;
+    }
+    for (let i = 5; i * i <= n; i += 6) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+function nextPrime(n) {
+    if (n >= MAX_NUMBER_PRIME) {
+        throw new Error(`Number is too large: ${n}, max is ${MAX_NUMBER_PRIME - 1}`);
+    }
+    // convert number to 32-bit integer for performance
+    n = n | 0;
+    if (n < 2) {
+        return 2;
+    }
+    let candidate = n + (n % 2 === 0 ? 1 : 2);
+    while (!isPrime(candidate)) {
+        candidate += 2;
+    }
+    return candidate;
+}
+function prevPrime(n) {
+    if (n > MAX_NUMBER) {
+        throw new Error(`Number is too large: ${n}, max is ${MAX_NUMBER}`);
+    }
+    // convert number to 32-bit integer for performance
+    n = n | 0;
+    if (n <= 2) {
+        return null;
+    }
+    let candidate = n - (n % 2 === 0 ? 1 : 2);
+    while (candidate > 2 && !isPrime(candidate)) {
+        candidate -= 2;
+    }
+    if (candidate > 2) {
+        return candidate;
+    }
+    return 2;
+}
+
+export { isPrime, nextPrime, prevPrime };

package/dist/lib/test-variants/prime.perf.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var node = require('rdtsc/node');
+var testVariants_prime = require('./prime.cjs');
+
+describe('test-variants > prime perf', function () {
+    this.timeout(300000);
+    it('isPrime', function () {
+        let number1 = testVariants_prime.nextPrime(Math.pow(2, 30));
+        let number2 = testVariants_prime.prevPrime(Math.pow(2, 31) - 1);
+        console.log('number:', number1);
+        console.log('number:', number2);
+        const result = node.calcPerformance({
+            time: 10000,
+            funcs: [
+                () => {
+                },
+                () => {
+                    number1 = testVariants_prime.nextPrime(number1);
+                },
+                () => {
+                    number2 = testVariants_prime.prevPrime(number2);
+                },
+            ],
+        });
+        console.log('number1:', number1);
+        console.log('number2:', number2);
+        console.log('perf:', result);
+    });
+});

package/dist/lib/test-variants/prime.perf.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/test-variants/prime.perf.mjs

@@ -0,0 +1,28 @@
+import { calcPerformance } from 'rdtsc/node';
+import { nextPrime, prevPrime } from './prime.mjs';
+
+describe('test-variants > prime perf', function () {
+    this.timeout(300000);
+    it('isPrime', function () {
+        let number1 = nextPrime(Math.pow(2, 30));
+        let number2 = prevPrime(Math.pow(2, 31) - 1);
+        console.log('number:', number1);
+        console.log('number:', number2);
+        const result = calcPerformance({
+            time: 10000,
+            funcs: [
+                () => {
+                },
+                () => {
+                    number1 = nextPrime(number1);
+                },
+                () => {
+                    number2 = prevPrime(number2);
+                },
+            ],
+        });
+        console.log('number1:', number1);
+        console.log('number2:', number2);
+        console.log('perf:', result);
+    });
+});

package/dist/lib/test-variants/testVariantsCreateTestRun.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var asyncUtils = require('@flemist/async-utils');
+var testVariants_argsToString = require('./argsToString.cjs');
+
+function testVariantsCreateTestRun(test, options) {
+    let debugIteration = 0;
+    let errorEvent = null;
+    function onError(error, args, index) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            errorEvent = {
+                error,
+                args,
+                index: index,
+            };
+            console.error(`[test-variants] error variant: ${index}\n${testVariants_argsToString.argsToString(args)}`);
+            console.error(error);
+            // Rerun failed variant 5 times for debug
+            const time0 = Date.now();
+            // Will stop execution right before next error iteration for step-by-step debugging
+            // eslint-disable-next-line no-debugger
+            debugger;
+            if (Date.now() - time0 > 50 && debugIteration < 5) {
+                console.log('[test-variants] DEBUG ITERATION: ' + debugIteration);
+                debugIteration++;
+                return;
+            }
+            if (options.onError) {
+                yield options.onError(errorEvent);
+            }
+            throw errorEvent.error;
+        });
+    }
+    return function testRun(args, index, abortSignal) {
+        try {
+            const promiseOrIterations = test(args, abortSignal);
+            if (asyncUtils.isPromiseLike(promiseOrIterations)) {
+                return promiseOrIterations.then(value => {
+                    if (typeof value === 'number') {
+                        return {
+                            iterationsAsync: value,
+                            iterationsSync: 0,
+                        };
+                    }
+                    if (value !== null && typeof value === 'object') {
+                        return value;
+                    }
+                    return {
+                        iterationsAsync: 1,
+                        iterationsSync: 0,
+                    };
+                }, err => {
+                    return onError(err, args, index);
+                });
+            }
+            const value = promiseOrIterations;
+            if (typeof value === 'number') {
+                return {
+                    iterationsAsync: 0,
+                    iterationsSync: value,
+                };
+            }
+            if (value !== null && typeof value === 'object') {
+                return value;
+            }
+            return {
+                iterationsAsync: 0,
+                iterationsSync: 1,
+            };
+        }
+        catch (err) {
+            return onError(err, args, index);
+        }
+    };
+}
+
+exports.testVariantsCreateTestRun = testVariantsCreateTestRun;

package/dist/lib/test-variants/testVariantsCreateTestRun.d.ts

@@ -0,0 +1,22 @@
+import { type IAbortSignalFast } from '@flemist/abort-controller-fast';
+import { type PromiseOrValue } from '@flemist/async-utils';
+import { Obj } from "./types";
+export declare type ErrorEvent<Args extends Obj> = {
+    error: any;
+    args: Args;
+    index: number;
+};
+export declare type OnErrorCallback<Args extends Obj> = (event: ErrorEvent<Args>) => PromiseOrValue<void>;
+export declare type TestVariantsCreateTestRunOptions<Args extends Obj> = {
+    onError?: null | OnErrorCallback<Args>;
+};
+export declare type TestVariantsTestRunResult = void | {
+    iterationsAsync: number;
+    iterationsSync: number;
+};
+export declare type TestVariantsTestRun<Args extends Obj> = (args: Args, index: number, abortSignal: IAbortSignalFast) => PromiseOrValue<TestVariantsTestRunResult>;
+export declare type TestVariantsTestResult = number | void | TestVariantsTestRunResult;
+export declare type TestVariantsTest<Args extends Obj> = (args: Args & {
+    seed?: null | number;
+}, abortSignal: IAbortSignalFast) => PromiseOrValue<TestVariantsTestResult>;
+export declare function testVariantsCreateTestRun<Args extends Obj>(test: TestVariantsTest<Args>, options?: null | TestVariantsCreateTestRunOptions<Args>): TestVariantsTestRun<Args>;

package/dist/lib/test-variants/testVariantsCreateTestRun.mjs

@@ -0,0 +1,76 @@
+import { __awaiter } from 'tslib';
+import { isPromiseLike } from '@flemist/async-utils';
+import { argsToString } from './argsToString.mjs';
+
+function testVariantsCreateTestRun(test, options) {
+    let debugIteration = 0;
+    let errorEvent = null;
+    function onError(error, args, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            errorEvent = {
+                error,
+                args,
+                index: index,
+            };
+            console.error(`[test-variants] error variant: ${index}\n${argsToString(args)}`);
+            console.error(error);
+            // Rerun failed variant 5 times for debug
+            const time0 = Date.now();
+            // Will stop execution right before next error iteration for step-by-step debugging
+            // eslint-disable-next-line no-debugger
+            debugger;
+            if (Date.now() - time0 > 50 && debugIteration < 5) {
+                console.log('[test-variants] DEBUG ITERATION: ' + debugIteration);
+                debugIteration++;
+                return;
+            }
+            if (options.onError) {
+                yield options.onError(errorEvent);
+            }
+            throw errorEvent.error;
+        });
+    }
+    return function testRun(args, index, abortSignal) {
+        try {
+            const promiseOrIterations = test(args, abortSignal);
+            if (isPromiseLike(promiseOrIterations)) {
+                return promiseOrIterations.then(value => {
+                    if (typeof value === 'number') {
+                        return {
+                            iterationsAsync: value,
+                            iterationsSync: 0,
+                        };
+                    }
+                    if (value !== null && typeof value === 'object') {
+                        return value;
+                    }
+                    return {
+                        iterationsAsync: 1,
+                        iterationsSync: 0,
+                    };
+                }, err => {
+                    return onError(err, args, index);
+                });
+            }
+            const value = promiseOrIterations;
+            if (typeof value === 'number') {
+                return {
+                    iterationsAsync: 0,
+                    iterationsSync: value,
+                };
+            }
+            if (value !== null && typeof value === 'object') {
+                return value;
+            }
+            return {
+                iterationsAsync: 0,
+                iterationsSync: 1,
+            };
+        }
+        catch (err) {
+            return onError(err, args, index);
+        }
+    };
+}
+
+export { testVariantsCreateTestRun };

package/dist/lib/test-variants/testVariantsIterable.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function testVariantsIterable({ argsTemplates, }) {
+    return {
+        [Symbol.iterator]() {
+            const keys = Object.keys(argsTemplates);
+            const templates = Object.values(argsTemplates);
+            const keysCount = keys.length;
+            const args = {};
+            function calcVariants(keyIndex) {
+                let template = templates[keyIndex];
+                if (typeof template === 'function') {
+                    template = template(args);
+                }
+                return template;
+            }
+            const indexes = [];
+            const variants = [];
+            for (let nArg = 0; nArg < keysCount; nArg++) {
+                indexes[nArg] = -1;
+                variants[nArg] = [];
+            }
+            variants[0] = calcVariants(0);
+            function nextVariant() {
+                for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
+                    const valueIndex = indexes[keyIndex] + 1;
+                    if (valueIndex < variants[keyIndex].length) {
+                        const key = keys[keyIndex];
+                        const value = variants[keyIndex][valueIndex];
+                        indexes[keyIndex] = valueIndex;
+                        args[key] = value;
+                        for (keyIndex++; keyIndex < keysCount; keyIndex++) {
+                            const keyVariants = calcVariants(keyIndex);
+                            if (keyVariants.length === 0) {
+                                break;
+                            }
+                            indexes[keyIndex] = 0;
+                            variants[keyIndex] = keyVariants;
+                            const key = keys[keyIndex];
+                            const value = keyVariants[0];
+                            args[key] = value;
+                        }
+                        if (keyIndex >= keysCount) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            return {
+                next() {
+                    if (nextVariant()) {
+                        return {
+                            done: false,
+                            value: Object.assign({}, args),
+                        };
+                    }
+                    return { done: true, value: null };
+                },
+            };
+        },
+    };
+}
+
+exports.testVariantsIterable = testVariantsIterable;

package/dist/lib/test-variants/testVariantsIterable.d.ts

@@ -0,0 +1,12 @@
+import { Obj } from "./types";
+export declare type TestVariantsTemplate<Args extends Obj, Value> = Value[] | ((args: Args) => Value[]);
+export declare type TestVariantsTemplates<Args extends Obj> = {
+    [key in keyof Args]: TestVariantsTemplate<Args, Args[key]>;
+};
+export declare type TestVariantsTemplatesExt<Args extends Obj, ArgsExtra extends Obj> = TestVariantsTemplates<{
+    [key in (keyof ArgsExtra | keyof Args)]: key extends keyof Args ? Args[key] : key extends keyof ArgsExtra ? ArgsExtra[key] : never;
+}>;
+export declare type TestVariantsIterableOptions<Args extends Obj, ArgsExtra extends Obj> = {
+    argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>;
+};
+export declare function testVariantsIterable<Args extends Obj, ArgsExtra extends Obj>({ argsTemplates, }: TestVariantsIterableOptions<Args, ArgsExtra>): Iterable<Args>;

package/dist/lib/test-variants/testVariantsIterable.mjs

@@ -0,0 +1,63 @@
+function testVariantsIterable({ argsTemplates, }) {
+    return {
+        [Symbol.iterator]() {
+            const keys = Object.keys(argsTemplates);
+            const templates = Object.values(argsTemplates);
+            const keysCount = keys.length;
+            const args = {};
+            function calcVariants(keyIndex) {
+                let template = templates[keyIndex];
+                if (typeof template === 'function') {
+                    template = template(args);
+                }
+                return template;
+            }
+            const indexes = [];
+            const variants = [];
+            for (let nArg = 0; nArg < keysCount; nArg++) {
+                indexes[nArg] = -1;
+                variants[nArg] = [];
+            }
+            variants[0] = calcVariants(0);
+            function nextVariant() {
+                for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
+                    const valueIndex = indexes[keyIndex] + 1;
+                    if (valueIndex < variants[keyIndex].length) {
+                        const key = keys[keyIndex];
+                        const value = variants[keyIndex][valueIndex];
+                        indexes[keyIndex] = valueIndex;
+                        args[key] = value;
+                        for (keyIndex++; keyIndex < keysCount; keyIndex++) {
+                            const keyVariants = calcVariants(keyIndex);
+                            if (keyVariants.length === 0) {
+                                break;
+                            }
+                            indexes[keyIndex] = 0;
+                            variants[keyIndex] = keyVariants;
+                            const key = keys[keyIndex];
+                            const value = keyVariants[0];
+                            args[key] = value;
+                        }
+                        if (keyIndex >= keysCount) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            return {
+                next() {
+                    if (nextVariant()) {
+                        return {
+                            done: false,
+                            value: Object.assign({}, args),
+                        };
+                    }
+                    return { done: true, value: null };
+                },
+            };
+        },
+    };
+}
+
+export { testVariantsIterable };