@flemist/test-variants 1.0.7 → 2.0.0

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

@@ -1,199 +1,82 @@
 import { __awaiter } from 'tslib';
-import { garbageCollect } from '../garbage-collect/garbageCollect.mjs';
-import { AbortControllerFast } from '@flemist/abort-controller-fast';
-import { Pool } from '@flemist/time-limits';
-import { combineAbortSignals } from '@flemist/async-utils';
+import { testVariantsIterable } from './testVariantsIterable.mjs';
+import { testVariantsCreateTestRun } from './testVariantsCreateTestRun.mjs';
+import { testVariantsRun } from './testVariantsRun.mjs';
+import '@flemist/async-utils';
+import './argsToString.mjs';
+import '@flemist/abort-controller-fast';
+import '@flemist/time-limits';
+import '../garbage-collect/garbageCollect.mjs';
+import './saveErrorVariants.mjs';
+import 'fs';
+import 'path';
 
-/* eslint-disable @typescript-eslint/no-shadow */
-function isPromiseLike(value) {
-    return typeof value === 'object'
-        && value
-        && typeof value.then === 'function';
-}
 function createTestVariants(test) {
     return function testVariantsArgs(args) {
-        return function testVariantsCall({ GC_Iterations = 1000000, GC_IterationsAsync = 10000, GC_Interval = 1000, logInterval = 5000, logCompleted = true, onError: onErrorCallback = null, abortSignal: abortSignalExternal = null, parallel: _parallel, } = {}) {
-            const abortControllerParallel = new AbortControllerFast();
-            const abortSignalParallel = combineAbortSignals(abortSignalExternal, abortControllerParallel.signal);
-            const abortSignalAll = abortSignalParallel;
-            const argsKeys = Object.keys(args);
-            const argsValues = Object.values(args);
-            const argsLength = argsKeys.length;
-            const variantArgs = {};
-            function getArgValues(nArg) {
-                let argValues = argsValues[nArg];
-                if (typeof argValues === 'function') {
-                    argValues = argValues(variantArgs);
-                }
-                return argValues;
-            }
-            const indexes = [];
-            const values = [];
-            for (let nArg = 0; nArg < argsLength; nArg++) {
-                indexes[nArg] = -1;
-                values[nArg] = [];
-            }
-            values[0] = getArgValues(0);
-            function nextVariant() {
-                for (let nArg = argsLength - 1; nArg >= 0; nArg--) {
-                    const index = indexes[nArg] + 1;
-                    if (index < values[nArg].length) {
-                        indexes[nArg] = index;
-                        variantArgs[argsKeys[nArg]] = values[nArg][index];
-                        for (nArg++; nArg < argsLength; nArg++) {
-                            const argValues = getArgValues(nArg);
-                            if (argValues.length === 0) {
-                                break;
-                            }
-                            indexes[nArg] = 0;
-                            values[nArg] = argValues;
-                            variantArgs[argsKeys[nArg]] = argValues[0];
-                        }
-                        if (nArg >= argsLength) {
-                            return true;
-                        }
-                    }
-                }
-                return false;
-            }
-            let iterations = 0;
-            let iterationsAsync = 0;
-            let debug = false;
-            let debugIteration = 0;
-            let isNewError = true;
-            function onError(error, iterations, variantArgs) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const _isNewError = isNewError;
-                    isNewError = false;
-                    if (_isNewError) {
-                        abortControllerParallel.abort(error);
-                        console.error(`error variant: ${iterations}\r\n${JSON.stringify(variantArgs, (_, value) => {
-                            if (value
-                                && typeof value === 'object'
-                                && !Array.isArray(value)
-                                && value.constructor !== Object) {
-                                return value + '';
-                            }
-                            return value;
-                        }, 2)}`);
-                        console.error(error);
-                    }
-                    // rerun failed variant 5 times for debug
-                    const time0 = Date.now();
-                    // eslint-disable-next-line no-debugger
-                    debugger;
-                    if (Date.now() - time0 > 50 && debugIteration < 5) {
-                        console.log('DEBUG ITERATION: ' + debugIteration);
-                        debug = true;
-                        yield next();
-                        debugIteration++;
-                    }
-                    if (_isNewError) {
-                        if (onErrorCallback) {
-                            onErrorCallback({
-                                iteration: iterations,
-                                variant: variantArgs,
-                                error,
-                            });
-                        }
-                        throw error;
-                    }
-                });
-            }
-            function onCompleted() {
-                if (logCompleted) {
-                    console.log('variants: ' + iterations);
-                }
-            }
-            let prevLogTime = Date.now();
-            let prevGC_Time = prevLogTime;
-            let prevGC_Iterations = iterations;
-            let prevGC_IterationsAsync = iterationsAsync;
-            const parallel = _parallel === true
-                ? Math.pow(2, 31)
-                : !_parallel || _parallel <= 0
-                    ? 1
-                    : _parallel;
-            const pool = parallel <= 1
-                ? null
-                : new Pool(parallel);
-            function runTest(_iterations, variantArgs, abortSignal) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const promiseOrIterations = test(variantArgs, abortSignal);
-                        if (isPromiseLike(promiseOrIterations)) {
-                            const value = yield promiseOrIterations;
-                            const newIterations = typeof value === 'number' ? value : 1;
-                            iterationsAsync += newIterations;
-                            iterations += newIterations;
-                            return;
-                        }
-                        iterations += typeof promiseOrIterations === 'number' ? promiseOrIterations : 1;
-                    }
-                    catch (err) {
-                        yield onError(err, _iterations, variantArgs);
-                    }
+        return function testVariantsCall(options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const testRun = testVariantsCreateTestRun(test, {
+                    onError: options === null || options === void 0 ? void 0 : options.onError,
                 });
-            }
-            function next() {
-                return __awaiter(this, void 0, void 0, function* () {
-                    while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
-                        const _iterations = iterations;
-                        const _variantArgs = !pool
-                            ? variantArgs
-                            : Object.assign({}, variantArgs);
-                        const now = (logInterval || GC_Interval) && Date.now();
-                        if (logInterval && now - prevLogTime >= logInterval) {
-                            // the log is required to prevent the karma browserNoActivityTimeout
-                            console.log(iterations);
-                            prevLogTime = now;
-                        }
-                        if (GC_Iterations && iterations - prevGC_Iterations >= GC_Iterations
-                            || GC_IterationsAsync && iterationsAsync - prevGC_IterationsAsync >= GC_IterationsAsync
-                            || GC_Interval && now - prevGC_Time >= GC_Interval) {
-                            prevGC_Iterations = iterations;
-                            prevGC_IterationsAsync = iterationsAsync;
-                            prevGC_Time = now;
-                            yield garbageCollect(1);
-                        }
-                        if (abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) {
-                            continue;
-                        }
-                        if (!pool || abortSignalParallel.aborted) {
-                            yield runTest(_iterations, _variantArgs, abortSignalExternal);
-                        }
-                        else {
-                            if (!pool.hold(1)) {
-                                yield pool.holdWait(1);
-                            }
-                            void (() => __awaiter(this, void 0, void 0, function* () {
-                                try {
-                                    if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
-                                        return;
-                                    }
-                                    yield runTest(_iterations, _variantArgs, abortSignalParallel);
-                                }
-                                finally {
-                                    void pool.release(1);
-                                }
-                            }))();
-                        }
-                    }
-                    if (pool) {
-                        yield pool.holdWait(parallel);
-                        void pool.release(parallel);
-                    }
-                    if (abortSignalAll === null || abortSignalAll === void 0 ? void 0 : abortSignalAll.aborted) {
-                        throw abortSignalAll.reason;
-                    }
-                    onCompleted();
-                    yield garbageCollect(1);
-                    return iterations;
+                const variants = testVariantsIterable({
+                    argsTemplates: args,
                 });
-            }
-            return next();
+                return testVariantsRun(testRun, variants, options);
+            });
         };
     };
 }
+/*
+export class TestVariants<Args extends Obj> {
+  private readonly _test: TestVariantsTest<Args>
+  test(args: Args, abortSignal: IAbortSignalFast) {
+    return this._test(args, abortSignal)
+  }
+
+  constructor(
+    test: TestVariantsTest<Args>,
+  ) {
+    this.test = test
+  }
+
+  createVariants<ArgsExtra extends Obj>(
+    argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>,
+  ): Iterable<Args> {
+    return testVariantsIterable<Args, ArgsExtra>(argsTemplates)
+  }
+
+  createTestRun(
+    options?: null | TestVariantsCreateTestRunOptions<Args>,
+  ) {
+    return testVariantsCreateTestRun<Args>(this._test, options)
+  }
+
+  testAll<ArgsExtra extends Obj>(
+    argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>,
+  ): TestVariantsCall<Args>
+  testAll(
+    variants: Iterable<Args>,
+  ): TestVariantsCall<Args>
+  testAll<ArgsExtra extends Obj>(
+    variantsOrTemplates: Iterable<Args> | TestVariantsTemplatesExt<Args, ArgsExtra>,
+  ): TestVariantsCall<Args> {
+    const variants = Symbol.iterator in variantsOrTemplates
+      ? variantsOrTemplates as Iterable<Args>
+      : this.createVariants(variantsOrTemplates as TestVariantsTemplatesExt<Args, ArgsExtra>)
+
+    const _this = this
+
+    return function testVariantsCall(
+      options?: null | TestVariantsRunOptions & TestVariantsCreateTestRunOptions<Args>,
+    ) {
+      const testRun = _this.createTestRun({
+        onError: options?.onError,
+      })
+
+      return testVariantsRun<Args>(testRun, variants, options)
+    }
+  }
+}
+*/
 
 export { createTestVariants };

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

@@ -1,32 +1,44 @@
 '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');
+require('./saveErrorVariants.cjs');
+require('fs');
+require('path');
 
 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,42 @@
-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';
+import './saveErrorVariants.mjs';
+import 'fs';
+import 'path';
 
 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);
+    });
+});