@flemist/test-variants 3.0.2 → 5.0.0

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

@@ -1,355 +0,0 @@
-/** Find last index of value in array; uses custom equals or strict equality */
-function findLastIndex(values, value, equals) {
-    if (equals) {
-        for (let i = values.length - 1; i >= 0; i--) {
-            if (equals(values[i], value)) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    for (let i = values.length - 1; i >= 0; i--) {
-        if (values[i] === value) {
-            return i;
-        }
-    }
-    return -1;
-}
-/** Calculate template values for given key index */
-function calcTemplateValues(templates, args, keyIndex) {
-    const template = templates[keyIndex];
-    if (typeof template === 'function') {
-        return template(args);
-    }
-    return template;
-}
-/** Reset iterator state for new cycle */
-function resetIteratorState(state, templates, keysCount) {
-    state.index = -1;
-    state.repeatIndex = 0;
-    for (let i = 0; i < keysCount; i++) {
-        state.indexes[i] = -1;
-        state.variants[i] = [];
-    }
-    if (keysCount > 0) {
-        state.variants[0] = calcTemplateValues(templates, state.args, 0);
-    }
-}
-/** Get effective max index for an arg (considering argLimit) */
-function getMaxIndex(state, keyIndex) {
-    const variantsLen = state.variants[keyIndex].length;
-    const argLimit = state.argLimits[keyIndex];
-    if (argLimit == null) {
-        return variantsLen;
-    }
-    return argLimit < variantsLen ? argLimit : variantsLen;
-}
-/** Advance to next variant in cartesian product; returns true if successful */
-function advanceVariant(state, templates, keys, keysCount) {
-    var _a;
-    for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
-        const valueIndex = state.indexes[keyIndex] + 1;
-        const maxIndex = getMaxIndex(state, keyIndex);
-        if (valueIndex < maxIndex) {
-            const key = keys[keyIndex];
-            const value = state.variants[keyIndex][valueIndex];
-            state.indexes[keyIndex] = valueIndex;
-            state.args[key] = value;
-            for (keyIndex++; keyIndex < keysCount; keyIndex++) {
-                const keyVariants = calcTemplateValues(templates, state.args, keyIndex);
-                const keyMaxIndex = (_a = state.argLimits[keyIndex]) !== null && _a !== void 0 ? _a : keyVariants.length;
-                if (keyVariants.length === 0 || keyMaxIndex <= 0) {
-                    break;
-                }
-                state.indexes[keyIndex] = 0;
-                state.variants[keyIndex] = keyVariants;
-                const key = keys[keyIndex];
-                const value = keyVariants[0];
-                state.args[key] = value;
-            }
-            if (keyIndex >= keysCount) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/** Validate saved args keys match iterator's arg names (ignoring "seed" key) */
-function validateArgsKeys(savedArgs, keysSet, keysCount) {
-    const savedKeys = Object.keys(savedArgs).filter(k => k !== 'seed');
-    if (savedKeys.length !== keysCount) {
-        return false;
-    }
-    for (const key of savedKeys) {
-        if (!keysSet.has(key)) {
-            return false;
-        }
-    }
-    return true;
-}
-/** For static templates, verify arg value exists in template values */
-function validateStaticArgsValues(savedArgs, templates, keys, keysCount, equals) {
-    for (let i = 0; i < keysCount; i++) {
-        const template = templates[i];
-        if (typeof template !== 'function') {
-            const value = savedArgs[keys[i]];
-            if (findLastIndex(template, value, equals) < 0) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/** Check if current position >= pending args position; returns false if current < pending or all args skipped */
-function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
-    let anyCompared = false;
-    for (let i = 0; i < keysCount; i++) {
-        const currentValueIndex = state.indexes[i];
-        const pendingValue = pendingArgs[keys[i]];
-        const pendingValueIndex = findLastIndex(state.variants[i], pendingValue, equals);
-        // Dynamic template value not found - skip this arg from comparison
-        if (pendingValueIndex < 0) {
-            continue;
-        }
-        anyCompared = true;
-        if (currentValueIndex < pendingValueIndex) {
-            return false;
-        }
-        if (currentValueIndex > pendingValueIndex) {
-            return true;
-        }
-    }
-    // All compared args are equal - position reached; or all args skipped - keep pending
-    return anyCompared;
-}
-/** Update per-arg limits from args values */
-function updateArgLimits(state, limitArgs, templates, keys, keysCount, equals, limitArgOnError) {
-    if (!limitArgOnError) {
-        return;
-    }
-    for (let i = 0; i < keysCount; i++) {
-        const key = keys[i];
-        const value = limitArgs[key];
-        const values = state.variants[i].length > 0
-            ? state.variants[i]
-            : calcTemplateValues(templates, state.args, i);
-        const valueIndex = findLastIndex(values, value, equals);
-        // Skip if value not found or already at index 0
-        if (valueIndex <= 0) {
-            continue;
-        }
-        // Check callback if provided
-        if (typeof limitArgOnError === 'function') {
-            const shouldLimit = limitArgOnError({
-                name: key,
-                valueIndex,
-                values,
-                maxValueIndex: state.argLimits[i],
-            });
-            if (!shouldLimit) {
-                continue;
-            }
-        }
-        // Update limit: argLimit = min(current argLimit, valueIndex)
-        const currentLimit = state.argLimits[i];
-        if (currentLimit == null || valueIndex < currentLimit) {
-            state.argLimits[i] = valueIndex;
-        }
-    }
-}
-/** Process pending limits; returns true if any limit was applied */
-function processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError) {
-    let applied = false;
-    for (let i = state.pendingLimits.length - 1; i >= 0; i--) {
-        const pending = state.pendingLimits[i];
-        if (isPositionReached(state, pending.args, keys, keysCount, equals)) {
-            // Current position >= pending position: apply limit
-            if (state.count == null || state.index < state.count) {
-                state.count = state.index;
-                state.limit = typeof pending.error !== 'undefined'
-                    ? { args: pending.args, error: pending.error }
-                    : { args: pending.args };
-                updateArgLimits(state, pending.args, templates, keys, keysCount, equals, limitArgOnError);
-                applied = true;
-            }
-            // Remove from pending
-            state.pendingLimits.splice(i, 1);
-        }
-    }
-    return applied;
-}
-/** Creates test variants iterator with limiting capabilities */
-function testVariantsIterator(options) {
-    const { argsTemplates, getSeed, repeatsPerVariant: _repeatsPerVariant, equals, limitArgOnError } = options;
-    const repeatsPerVariant = _repeatsPerVariant !== null && _repeatsPerVariant !== void 0 ? _repeatsPerVariant : 1;
-    const keys = Object.keys(argsTemplates);
-    const templates = Object.values(argsTemplates);
-    const keysCount = keys.length;
-    const keysSet = new Set(keys);
-    // Initialize state
-    const indexes = [];
-    const variants = [];
-    const argLimits = [];
-    for (let i = 0; i < keysCount; i++) {
-        indexes[i] = -1;
-        variants[i] = [];
-        argLimits[i] = null;
-    }
-    const state = {
-        args: {},
-        indexes,
-        variants,
-        argLimits,
-        index: -1,
-        cycleIndex: -1,
-        repeatIndex: 0,
-        count: null,
-        limit: null,
-        started: false,
-        currentArgs: null,
-        pendingLimits: [],
-    };
-    const iterator = {
-        get index() {
-            return state.index;
-        },
-        get cycleIndex() {
-            return state.cycleIndex;
-        },
-        get count() {
-            return state.count;
-        },
-        get limit() {
-            return state.limit;
-        },
-        addLimit(_options) {
-            const hasArgs = typeof (_options === null || _options === void 0 ? void 0 : _options.args) !== 'undefined' && _options.args !== null;
-            const hasIndex = (_options === null || _options === void 0 ? void 0 : _options.index) != null;
-            // addLimit() or addLimit({error}) - uses current args and index
-            if (!hasArgs && !hasIndex) {
-                if (state.index < 0) {
-                    throw new Error('[testVariantsIterator] addLimit() requires at least one next() call');
-                }
-                if (state.count == null || state.index < state.count) {
-                    state.count = state.index;
-                    state.limit = typeof (_options === null || _options === void 0 ? void 0 : _options.error) !== 'undefined'
-                        ? { args: state.currentArgs, error: _options.error }
-                        : { args: state.currentArgs };
-                    updateArgLimits(state, state.args, templates, keys, keysCount, equals, limitArgOnError);
-                }
-                return;
-            }
-            // addLimit({index}) - only index limiting, no args
-            if (hasIndex && !hasArgs) {
-                if (state.count == null || _options.index < state.count) {
-                    state.count = _options.index;
-                }
-                return;
-            }
-            // addLimit({args}) or addLimit({args, error}) - pending limit + immediate per-arg limits
-            if (hasArgs && !hasIndex) {
-                // Validate args keys match iterator's arg names
-                if (!validateArgsKeys(_options.args, keysSet, keysCount)) {
-                    return; // Discard - unreproducible (templates changed)
-                }
-                // For static templates, verify arg value exists
-                if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
-                    return; // Discard - unreproducible (value not in template)
-                }
-                // Apply per-arg limits immediately for static templates
-                updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
-                // Store as pending limit for count/position-based limiting
-                const pending = typeof _options.error !== 'undefined'
-                    ? { args: _options.args, error: _options.error }
-                    : { args: _options.args };
-                state.pendingLimits.push(pending);
-                return;
-            }
-            // addLimit({args, index}) or addLimit({args, index, error}) - immediate index + pending args
-            if (hasArgs && hasIndex) {
-                // Check if this is earliest (before potentially updating count)
-                const isEarliest = state.count == null || _options.index < state.count;
-                // Always apply index limit
-                if (isEarliest) {
-                    state.count = _options.index;
-                }
-                // Validate args for limit property update
-                if (!validateArgsKeys(_options.args, keysSet, keysCount)) {
-                    return; // Skip per-arg limits and limit property update
-                }
-                if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
-                    return; // Skip per-arg limits and limit property update
-                }
-                // Update limit if this is earliest
-                if (isEarliest) {
-                    state.limit = typeof _options.error !== 'undefined'
-                        ? { args: _options.args, error: _options.error }
-                        : { args: _options.args };
-                    updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
-                }
-            }
-        },
-        start() {
-            state.cycleIndex++;
-            resetIteratorState(state, templates, keysCount);
-            state.started = true;
-        },
-        next() {
-            if (!state.started) {
-                throw new Error('[testVariantsIterator] start() must be called before next()');
-            }
-            // Try next repeat for current variant
-            if (state.index >= 0 && state.repeatIndex + 1 < repeatsPerVariant) {
-                // Check if current variant is still within limit
-                if (state.count == null || state.index < state.count) {
-                    state.repeatIndex++;
-                    if (getSeed) {
-                        const seed = getSeed({
-                            variantIndex: state.index,
-                            cycleIndex: state.cycleIndex,
-                            repeatIndex: state.repeatIndex,
-                        });
-                        state.currentArgs = Object.assign(Object.assign({}, state.args), { seed });
-                    }
-                    else {
-                        state.currentArgs = Object.assign({}, state.args);
-                    }
-                    return state.currentArgs;
-                }
-            }
-            // Move to next variant
-            state.repeatIndex = 0;
-            if (!advanceVariant(state, templates, keys, keysCount)) {
-                // First complete cycle sets count to total variant count
-                if (state.count == null) {
-                    state.count = state.index + 1;
-                }
-                return null;
-            }
-            state.index++;
-            // Process pending limits at new position
-            if (state.pendingLimits.length > 0) {
-                processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError);
-            }
-            // Check count limit (may have been updated by pending limit)
-            if (state.count != null && state.index >= state.count) {
-                return null;
-            }
-            if (getSeed) {
-                const seed = getSeed({
-                    variantIndex: state.index,
-                    cycleIndex: state.cycleIndex,
-                    repeatIndex: state.repeatIndex,
-                });
-                state.currentArgs = Object.assign(Object.assign({}, state.args), { seed });
-            }
-            else {
-                state.currentArgs = Object.assign({}, state.args);
-            }
-            return state.currentArgs;
-        },
-    };
-    return iterator;
-}
-
-export { testVariantsIterator };

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

@@ -1,289 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var abortControllerFast = require('@flemist/abort-controller-fast');
-var asyncUtils = require('@flemist/async-utils');
-var timeLimits = require('@flemist/time-limits');
-var garbageCollect_garbageCollect = require('../garbage-collect/garbageCollect.cjs');
-var testVariants_saveErrorVariants = require('./saveErrorVariants.cjs');
-var path = require('path');
-require('fs');
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n["default"] = e;
-    return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-
-function formatDuration(ms) {
-    const seconds = ms / 1000;
-    if (seconds < 60) {
-        return `${seconds.toFixed(1)}s`;
-    }
-    const minutes = seconds / 60;
-    if (minutes < 60) {
-        return `${minutes.toFixed(1)}m`;
-    }
-    const hours = minutes / 60;
-    return `${hours.toFixed(1)}h`;
-}
-function testVariantsRun(testRun, variants, options = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    return tslib.__awaiter(this, void 0, void 0, function* () {
-        const saveErrorVariants = options.saveErrorVariants;
-        const retriesPerVariant = (_a = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.retriesPerVariant) !== null && _a !== void 0 ? _a : 1;
-        const useToFindBestError = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.useToFindBestError;
-        const sessionDate = new Date();
-        const errorVariantFilePath = saveErrorVariants
-            ? path__namespace.resolve(saveErrorVariants.dir, (_c = (_b = saveErrorVariants.getFilePath) === null || _b === void 0 ? void 0 : _b.call(saveErrorVariants, { sessionDate })) !== null && _c !== void 0 ? _c : testVariants_saveErrorVariants.generateErrorVariantFilePath({ sessionDate }))
-            : null;
-        const GC_Iterations = (_d = options.GC_Iterations) !== null && _d !== void 0 ? _d : 1000000;
-        const GC_IterationsAsync = (_e = options.GC_IterationsAsync) !== null && _e !== void 0 ? _e : 10000;
-        const GC_Interval = (_f = options.GC_Interval) !== null && _f !== void 0 ? _f : 1000;
-        const logInterval = (_g = options.logInterval) !== null && _g !== void 0 ? _g : 5000;
-        const logCompleted = (_h = options.logCompleted) !== null && _h !== void 0 ? _h : true;
-        const abortSignalExternal = options.abortSignal;
-        const findBestError = options.findBestError;
-        const cycles = (_j = findBestError === null || findBestError === void 0 ? void 0 : findBestError.cycles) !== null && _j !== void 0 ? _j : 1;
-        const dontThrowIfError = findBestError === null || findBestError === void 0 ? void 0 : findBestError.dontThrowIfError;
-        const limitTime = options.limitTime;
-        const parallel = options.parallel === true
-            ? Math.pow(2, 31)
-            : !options.parallel || options.parallel <= 0
-                ? 1
-                : options.parallel;
-        // Apply initial limits
-        if (options.limitVariantsCount != null) {
-            variants.addLimit({ index: options.limitVariantsCount });
-        }
-        // Replay phase: run previously saved error variants before normal iteration
-        if (saveErrorVariants) {
-            const files = yield testVariants_saveErrorVariants.readErrorVariantFiles(saveErrorVariants.dir);
-            for (const filePath of files) {
-                const args = yield testVariants_saveErrorVariants.parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
-                for (let retry = 0; retry < retriesPerVariant; retry++) {
-                    try {
-                        const promiseOrResult = testRun(args, -1, null);
-                        if (asyncUtils.isPromiseLike(promiseOrResult)) {
-                            yield promiseOrResult;
-                        }
-                    }
-                    catch (error) {
-                        if (useToFindBestError && findBestError) {
-                            // Store as pending limit for findBestError cycle
-                            variants.addLimit({ args, error });
-                            break; // Exit retry loop, continue to next file
-                        }
-                        else {
-                            throw error;
-                        }
-                    }
-                }
-                // If no error occurred during replays, the saved variant is no longer reproducible
-                // (templates may have changed) - silently skip
-            }
-        }
-        let prevCycleVariantsCount = null;
-        let prevCycleDuration = null;
-        const startTime = Date.now();
-        let cycleStartTime = startTime;
-        const abortControllerParallel = new abortControllerFast.AbortControllerFast();
-        const abortSignalParallel = asyncUtils.combineAbortSignals(abortSignalExternal, abortControllerParallel.signal);
-        const abortSignalAll = abortSignalParallel;
-        let debug = false;
-        let iterations = 0;
-        let iterationsAsync = 0;
-        let prevLogTime = Date.now();
-        let prevGC_Time = prevLogTime;
-        let prevGC_Iterations = iterations;
-        let prevGC_IterationsAsync = iterationsAsync;
-        const pool = parallel <= 1
-            ? null
-            : new timeLimits.Pool(parallel);
-        function onCompleted() {
-            if (logCompleted) {
-                console.log(`[test-variants] variants: ${variants.index}, iterations: ${iterations}, async: ${iterationsAsync}`);
-            }
-        }
-        // Main iteration using iterator
-        let timeLimitExceeded = false;
-        variants.start();
-        while (variants.cycleIndex < cycles && !timeLimitExceeded) {
-            let args;
-            while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || (args = variants.next()) != null)) {
-                const _index = variants.index;
-                const _args = args;
-                const now = (logInterval || GC_Interval || limitTime) && Date.now();
-                if (limitTime && now - startTime >= limitTime) {
-                    timeLimitExceeded = true;
-                    break;
-                }
-                if (logInterval && now - prevLogTime >= logInterval) {
-                    // the log is required to prevent the karma browserNoActivityTimeout
-                    let log = '';
-                    const cycleElapsed = now - cycleStartTime;
-                    const totalElapsed = now - startTime;
-                    if (findBestError) {
-                        log += `cycle: ${variants.cycleIndex}, variant: ${variants.index}`;
-                        let max = variants.count;
-                        if (max != null) {
-                            if (prevCycleVariantsCount != null && prevCycleVariantsCount < max) {
-                                max = prevCycleVariantsCount;
-                            }
-                        }
-                        if (max != null && variants.index > 0) {
-                            let estimatedCycleTime;
-                            if (prevCycleDuration != null && prevCycleVariantsCount != null
-                                && variants.index < prevCycleVariantsCount && cycleElapsed < prevCycleDuration) {
-                                const adjustedDuration = prevCycleDuration - cycleElapsed;
-                                const adjustedCount = prevCycleVariantsCount - variants.index;
-                                const speedForRemaining = adjustedDuration / adjustedCount;
-                                const remainingTime = (max - variants.index) * speedForRemaining;
-                                estimatedCycleTime = cycleElapsed + remainingTime;
-                            }
-                            else {
-                                estimatedCycleTime = cycleElapsed * max / variants.index;
-                            }
-                            log += `/${max} (${formatDuration(cycleElapsed)}/${formatDuration(estimatedCycleTime)})`;
-                        }
-                        else {
-                            log += ` (${formatDuration(cycleElapsed)})`;
-                        }
-                    }
-                    else {
-                        log += `variant: ${variants.index} (${formatDuration(cycleElapsed)})`;
-                    }
-                    log += `, total: ${iterations} (${formatDuration(totalElapsed)})`;
-                    console.log(log);
-                    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_garbageCollect.garbageCollect(1);
-                }
-                if (abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) {
-                    continue;
-                }
-                if (!pool || abortSignalParallel.aborted) {
-                    try {
-                        let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
-                        if (asyncUtils.isPromiseLike(promiseOrIterations)) {
-                            promiseOrIterations = yield promiseOrIterations;
-                        }
-                        if (!promiseOrIterations) {
-                            debug = true;
-                            abortControllerParallel.abort();
-                            continue;
-                        }
-                        const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
-                        iterationsAsync += _iterationsAsync;
-                        iterations += _iterationsSync + _iterationsAsync;
-                    }
-                    catch (err) {
-                        if (errorVariantFilePath) {
-                            yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
-                        }
-                        if (findBestError) {
-                            variants.addLimit({ error: err });
-                            debug = false;
-                        }
-                        else {
-                            throw err;
-                        }
-                    }
-                }
-                else {
-                    if (!pool.hold(1)) {
-                        yield pool.holdWait(1);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    void (() => tslib.__awaiter(this, void 0, void 0, function* () {
-                        try {
-                            if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
-                                return;
-                            }
-                            let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
-                            if (asyncUtils.isPromiseLike(promiseOrIterations)) {
-                                promiseOrIterations = yield promiseOrIterations;
-                            }
-                            if (!promiseOrIterations) {
-                                debug = true;
-                                abortControllerParallel.abort();
-                                return;
-                            }
-                            const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
-                            iterationsAsync += _iterationsAsync;
-                            iterations += _iterationsSync + _iterationsAsync;
-                        }
-                        catch (err) {
-                            if (errorVariantFilePath) {
-                                yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
-                            }
-                            if (findBestError) {
-                                variants.addLimit({ error: err });
-                                debug = false;
-                            }
-                            else {
-                                throw err;
-                            }
-                        }
-                        finally {
-                            void pool.release(1);
-                        }
-                    }))();
-                }
-            }
-            // Track cycle metrics for logging
-            prevCycleVariantsCount = variants.count;
-            prevCycleDuration = Date.now() - cycleStartTime;
-            cycleStartTime = Date.now();
-            variants.start();
-        }
-        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_garbageCollect.garbageCollect(1);
-        // Construct bestError from iterator state
-        const bestError = variants.limit
-            ? {
-                error: variants.limit.error,
-                args: variants.limit.args,
-                index: variants.count,
-            }
-            : null;
-        if (bestError && !dontThrowIfError) {
-            throw bestError.error;
-        }
-        return {
-            iterations,
-            bestError,
-        };
-    });
-}
-
-exports.testVariantsRun = testVariantsRun;