pokeedex 0.1.0 → 0.1.5

data/node_modules/playwright/lib/runner/taskRunner.js

@@ -1,147 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TaskRunner = void 0;
-var _utilsBundle = require("playwright-core/lib/utilsBundle");
-var _utils = require("playwright-core/lib/utils");
-var _sigIntWatcher = require("./sigIntWatcher");
-var _util = require("../util");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class TaskRunner {
-  static create(reporter, globalTimeoutForError = 0) {
-    return new TaskRunner(reporter, globalTimeoutForError);
-  }
-  constructor(reporter, globalTimeoutForError) {
-    this._tasks = [];
-    this._reporter = void 0;
-    this._hasErrors = false;
-    this._interrupted = false;
-    this._isTearDown = false;
-    this._globalTimeoutForError = void 0;
-    this._reporter = reporter;
-    this._globalTimeoutForError = globalTimeoutForError;
-  }
-  addTask(name, task) {
-    this._tasks.push({
-      name,
-      task
-    });
-  }
-  async run(context, deadline, cancelPromise) {
-    const {
-      status,
-      cleanup
-    } = await this.runDeferCleanup(context, deadline, cancelPromise);
-    const teardownStatus = await cleanup();
-    return status === 'passed' ? teardownStatus : status;
-  }
-  async runDeferCleanup(context, deadline, cancelPromise = new _utils.ManualPromise()) {
-    const sigintWatcher = new _sigIntWatcher.SigIntWatcher();
-    const timeoutWatcher = new TimeoutWatcher(deadline);
-    const teardownRunner = new TaskRunner(this._reporter, this._globalTimeoutForError);
-    teardownRunner._isTearDown = true;
-    let currentTaskName;
-    const taskLoop = async () => {
-      for (const {
-        name,
-        task
-      } of this._tasks) {
-        currentTaskName = name;
-        if (this._interrupted) break;
-        (0, _utilsBundle.debug)('pw:test:task')(`"${name}" started`);
-        const errors = [];
-        const softErrors = [];
-        try {
-          var _task$setup;
-          teardownRunner._tasks.unshift({
-            name: `teardown for ${name}`,
-            task: {
-              setup: task.teardown
-            }
-          });
-          await ((_task$setup = task.setup) === null || _task$setup === void 0 ? void 0 : _task$setup.call(task, this._reporter, context, errors, softErrors));
-        } catch (e) {
-          (0, _utilsBundle.debug)('pw:test:task')(`error in "${name}": `, e);
-          errors.push((0, _util.serializeError)(e));
-        } finally {
-          for (const error of [...softErrors, ...errors]) {
-            var _this$_reporter$onErr, _this$_reporter;
-            (_this$_reporter$onErr = (_this$_reporter = this._reporter).onError) === null || _this$_reporter$onErr === void 0 || _this$_reporter$onErr.call(_this$_reporter, error);
-          }
-          if (errors.length) {
-            if (!this._isTearDown) this._interrupted = true;
-            this._hasErrors = true;
-          }
-        }
-        (0, _utilsBundle.debug)('pw:test:task')(`"${name}" finished`);
-      }
-    };
-    await Promise.race([taskLoop(), cancelPromise, sigintWatcher.promise(), timeoutWatcher.promise]);
-    sigintWatcher.disarm();
-    timeoutWatcher.disarm();
-
-    // Prevent subsequent tasks from running.
-    this._interrupted = true;
-    let status = 'passed';
-    if (sigintWatcher.hadSignal() || cancelPromise !== null && cancelPromise !== void 0 && cancelPromise.isDone()) {
-      status = 'interrupted';
-    } else if (timeoutWatcher.timedOut()) {
-      var _this$_reporter$onErr2, _this$_reporter2;
-      (_this$_reporter$onErr2 = (_this$_reporter2 = this._reporter).onError) === null || _this$_reporter$onErr2 === void 0 || _this$_reporter$onErr2.call(_this$_reporter2, {
-        message: _utilsBundle.colors.red(`Timed out waiting ${this._globalTimeoutForError / 1000}s for the ${currentTaskName} to run`)
-      });
-      status = 'timedout';
-    } else if (this._hasErrors) {
-      status = 'failed';
-    }
-    cancelPromise === null || cancelPromise === void 0 || cancelPromise.resolve();
-    // Note that upon hitting deadline, we "run cleanup", but it exits immediately
-    // because of the same deadline. Essentially, we're not performing any cleanup.
-    const cleanup = () => teardownRunner.runDeferCleanup(context, deadline).then(r => r.status);
-    return {
-      status,
-      cleanup
-    };
-  }
-}
-exports.TaskRunner = TaskRunner;
-class TimeoutWatcher {
-  constructor(deadline) {
-    this._timedOut = false;
-    this.promise = new _utils.ManualPromise();
-    this._timer = void 0;
-    if (!deadline) return;
-    if (deadline - (0, _utils.monotonicTime)() <= 0) {
-      this._timedOut = true;
-      this.promise.resolve();
-      return;
-    }
-    this._timer = setTimeout(() => {
-      this._timedOut = true;
-      this.promise.resolve();
-    }, deadline - (0, _utils.monotonicTime)());
-  }
-  timedOut() {
-    return this._timedOut;
-  }
-  disarm() {
-    clearTimeout(this._timer);
-  }
-}

data/node_modules/playwright/lib/runner/tasks.js

@@ -1,407 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TestRun = void 0;
-exports.createTaskRunner = createTaskRunner;
-exports.createTaskRunnerForDevServer = createTaskRunnerForDevServer;
-exports.createTaskRunnerForList = createTaskRunnerForList;
-exports.createTaskRunnerForListFiles = createTaskRunnerForListFiles;
-exports.createTaskRunnerForTestServer = createTaskRunnerForTestServer;
-exports.createTaskRunnerForWatchSetup = createTaskRunnerForWatchSetup;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-var _util = require("util");
-var _utilsBundle = require("playwright-core/lib/utilsBundle");
-var _utils = require("playwright-core/lib/utils");
-var _dispatcher = require("./dispatcher");
-var _testGroups = require("../runner/testGroups");
-var _taskRunner = require("./taskRunner");
-var _loadUtils = require("./loadUtils");
-var _test = require("../common/test");
-var _projectUtils = require("./projectUtils");
-var _failureTracker = require("./failureTracker");
-var _vcs = require("./vcs");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * Copyright Microsoft Corporation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const readDirAsync = (0, _util.promisify)(_fs.default.readdir);
-class TestRun {
-  constructor(config) {
-    this.config = void 0;
-    this.failureTracker = void 0;
-    this.rootSuite = undefined;
-    this.phases = [];
-    this.projectFiles = new Map();
-    this.projectSuites = new Map();
-    this.config = config;
-    this.failureTracker = new _failureTracker.FailureTracker(config);
-  }
-}
-exports.TestRun = TestRun;
-function createTaskRunner(config, reporter) {
-  const taskRunner = _taskRunner.TaskRunner.create(reporter, config.config.globalTimeout);
-  addGlobalSetupTasks(taskRunner, config);
-  taskRunner.addTask('load tests', createLoadTask('in-process', {
-    filterOnly: true,
-    failOnLoadErrors: true
-  }));
-  addRunTasks(taskRunner, config);
-  return taskRunner;
-}
-function createTaskRunnerForWatchSetup(config, reporter) {
-  const taskRunner = _taskRunner.TaskRunner.create(reporter);
-  addGlobalSetupTasks(taskRunner, config);
-  return taskRunner;
-}
-function createTaskRunnerForTestServer(config, reporter) {
-  const taskRunner = _taskRunner.TaskRunner.create(reporter);
-  taskRunner.addTask('load tests', createLoadTask('out-of-process', {
-    filterOnly: true,
-    failOnLoadErrors: false,
-    doNotRunDepsOutsideProjectFilter: true
-  }));
-  addRunTasks(taskRunner, config);
-  return taskRunner;
-}
-function addGlobalSetupTasks(taskRunner, config) {
-  if (!config.configCLIOverrides.preserveOutputDir && !process.env.PW_TEST_NO_REMOVE_OUTPUT_DIRS) taskRunner.addTask('clear output', createRemoveOutputDirsTask());
-  for (const plugin of config.plugins) taskRunner.addTask('plugin setup', createPluginSetupTask(plugin));
-  if (config.config.globalSetup || config.config.globalTeardown) taskRunner.addTask('global setup', createGlobalSetupTask());
-}
-function addRunTasks(taskRunner, config) {
-  taskRunner.addTask('create phases', createPhasesTask());
-  taskRunner.addTask('report begin', createReportBeginTask());
-  for (const plugin of config.plugins) taskRunner.addTask('plugin begin', createPluginBeginTask(plugin));
-  taskRunner.addTask('test suite', createRunTestsTask());
-  return taskRunner;
-}
-function createTaskRunnerForList(config, reporter, mode, options) {
-  const taskRunner = _taskRunner.TaskRunner.create(reporter, config.config.globalTimeout);
-  taskRunner.addTask('load tests', createLoadTask(mode, {
-    ...options,
-    filterOnly: false
-  }));
-  taskRunner.addTask('report begin', createReportBeginTask());
-  return taskRunner;
-}
-function createTaskRunnerForListFiles(config, reporter) {
-  const taskRunner = _taskRunner.TaskRunner.create(reporter, config.config.globalTimeout);
-  taskRunner.addTask('load tests', createListFilesTask());
-  taskRunner.addTask('report begin', createReportBeginTask());
-  return taskRunner;
-}
-function createTaskRunnerForDevServer(config, reporter, mode, setupAndWait) {
-  const taskRunner = _taskRunner.TaskRunner.create(reporter, config.config.globalTimeout);
-  if (setupAndWait) {
-    for (const plugin of config.plugins) taskRunner.addTask('plugin setup', createPluginSetupTask(plugin));
-  }
-  taskRunner.addTask('load tests', createLoadTask(mode, {
-    failOnLoadErrors: true,
-    filterOnly: false
-  }));
-  taskRunner.addTask('start dev server', createStartDevServerTask());
-  if (setupAndWait) {
-    taskRunner.addTask('wait until interrupted', {
-      setup: async () => new Promise(() => {})
-    });
-  }
-  return taskRunner;
-}
-function createReportBeginTask() {
-  return {
-    setup: async (reporter, {
-      rootSuite
-    }) => {
-      reporter.onBegin(rootSuite);
-    },
-    teardown: async ({}) => {}
-  };
-}
-function createPluginSetupTask(plugin) {
-  return {
-    setup: async (reporter, {
-      config
-    }) => {
-      var _plugin$instance, _plugin$instance$setu;
-      if (typeof plugin.factory === 'function') plugin.instance = await plugin.factory();else plugin.instance = plugin.factory;
-      await ((_plugin$instance = plugin.instance) === null || _plugin$instance === void 0 || (_plugin$instance$setu = _plugin$instance.setup) === null || _plugin$instance$setu === void 0 ? void 0 : _plugin$instance$setu.call(_plugin$instance, config.config, config.configDir, reporter));
-    },
-    teardown: async () => {
-      var _plugin$instance2, _plugin$instance2$tea;
-      await ((_plugin$instance2 = plugin.instance) === null || _plugin$instance2 === void 0 || (_plugin$instance2$tea = _plugin$instance2.teardown) === null || _plugin$instance2$tea === void 0 ? void 0 : _plugin$instance2$tea.call(_plugin$instance2));
-    }
-  };
-}
-function createPluginBeginTask(plugin) {
-  return {
-    setup: async (reporter, {
-      rootSuite
-    }) => {
-      var _plugin$instance3, _plugin$instance3$beg;
-      await ((_plugin$instance3 = plugin.instance) === null || _plugin$instance3 === void 0 || (_plugin$instance3$beg = _plugin$instance3.begin) === null || _plugin$instance3$beg === void 0 ? void 0 : _plugin$instance3$beg.call(_plugin$instance3, rootSuite));
-    },
-    teardown: async () => {
-      var _plugin$instance4, _plugin$instance4$end;
-      await ((_plugin$instance4 = plugin.instance) === null || _plugin$instance4 === void 0 || (_plugin$instance4$end = _plugin$instance4.end) === null || _plugin$instance4$end === void 0 ? void 0 : _plugin$instance4$end.call(_plugin$instance4));
-    }
-  };
-}
-function createGlobalSetupTask() {
-  let globalSetupResult;
-  let globalSetupFinished = false;
-  let teardownHook;
-  return {
-    setup: async (reporter, {
-      config
-    }) => {
-      const setupHook = config.config.globalSetup ? await (0, _loadUtils.loadGlobalHook)(config, config.config.globalSetup) : undefined;
-      teardownHook = config.config.globalTeardown ? await (0, _loadUtils.loadGlobalHook)(config, config.config.globalTeardown) : undefined;
-      globalSetupResult = setupHook ? await setupHook(config.config) : undefined;
-      globalSetupFinished = true;
-    },
-    teardown: async (reporter, {
-      config
-    }) => {
-      var _teardownHook;
-      if (typeof globalSetupResult === 'function') await globalSetupResult();
-      if (globalSetupFinished) await ((_teardownHook = teardownHook) === null || _teardownHook === void 0 ? void 0 : _teardownHook(config.config));
-    }
-  };
-}
-function createRemoveOutputDirsTask() {
-  return {
-    setup: async (reporter, {
-      config
-    }) => {
-      const outputDirs = new Set();
-      const projects = (0, _projectUtils.filterProjects)(config.projects, config.cliProjectFilter);
-      projects.forEach(p => outputDirs.add(p.project.outputDir));
-      await Promise.all(Array.from(outputDirs).map(outputDir => (0, _utils.removeFolders)([outputDir]).then(async ([error]) => {
-        if (!error) return;
-        if (error.code === 'EBUSY') {
-          // We failed to remove folder, might be due to the whole folder being mounted inside a container:
-          //   https://github.com/microsoft/playwright/issues/12106
-          // Do a best-effort to remove all files inside of it instead.
-          const entries = await readDirAsync(outputDir).catch(e => []);
-          await Promise.all(entries.map(entry => (0, _utils.removeFolders)([_path.default.join(outputDir, entry)])));
-        } else {
-          throw error;
-        }
-      })));
-    }
-  };
-}
-function createListFilesTask() {
-  return {
-    setup: async (reporter, testRun, errors) => {
-      testRun.rootSuite = await (0, _loadUtils.createRootSuite)(testRun, errors, false);
-      testRun.failureTracker.onRootSuite(testRun.rootSuite);
-      await (0, _loadUtils.collectProjectsAndTestFiles)(testRun, false);
-      for (const [project, files] of testRun.projectFiles) {
-        const projectSuite = new _test.Suite(project.project.name, 'project');
-        projectSuite._fullProject = project;
-        testRun.rootSuite._addSuite(projectSuite);
-        const suites = files.map(file => {
-          const title = _path.default.relative(testRun.config.config.rootDir, file);
-          const suite = new _test.Suite(title, 'file');
-          suite.location = {
-            file,
-            line: 0,
-            column: 0
-          };
-          projectSuite._addSuite(suite);
-          return suite;
-        });
-        testRun.projectSuites.set(project, suites);
-      }
-    }
-  };
-}
-function createLoadTask(mode, options) {
-  return {
-    setup: async (reporter, testRun, errors, softErrors) => {
-      await (0, _loadUtils.collectProjectsAndTestFiles)(testRun, !!options.doNotRunDepsOutsideProjectFilter);
-      await (0, _loadUtils.loadFileSuites)(testRun, mode, options.failOnLoadErrors ? errors : softErrors);
-      let cliOnlyChangedMatcher = undefined;
-      if (testRun.config.cliOnlyChanged) {
-        for (const plugin of testRun.config.plugins) {
-          var _plugin$instance5, _plugin$instance5$pop;
-          await ((_plugin$instance5 = plugin.instance) === null || _plugin$instance5 === void 0 || (_plugin$instance5$pop = _plugin$instance5.populateDependencies) === null || _plugin$instance5$pop === void 0 ? void 0 : _plugin$instance5$pop.call(_plugin$instance5));
-        }
-        const changedFiles = await (0, _vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir);
-        cliOnlyChangedMatcher = file => changedFiles.has(file);
-      }
-      testRun.rootSuite = await (0, _loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly, cliOnlyChangedMatcher);
-      testRun.failureTracker.onRootSuite(testRun.rootSuite);
-      // Fail when no tests.
-      if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged) {
-        if (testRun.config.cliArgs.length) {
-          throw new Error([`No tests found.`, `Make sure that arguments are regular expressions matching test files.`, `You may need to escape symbols like "$" or "*" and quote the arguments.`].join('\n'));
-        }
-        throw new Error(`No tests found`);
-      }
-    }
-  };
-}
-function createPhasesTask() {
-  return {
-    setup: async (reporter, testRun) => {
-      let maxConcurrentTestGroups = 0;
-      const processed = new Set();
-      const projectToSuite = new Map(testRun.rootSuite.suites.map(suite => [suite._fullProject, suite]));
-      const allProjects = [...projectToSuite.keys()];
-      const teardownToSetups = (0, _projectUtils.buildTeardownToSetupsMap)(allProjects);
-      const teardownToSetupsDependents = new Map();
-      for (const [teardown, setups] of teardownToSetups) {
-        const closure = (0, _projectUtils.buildDependentProjects)(setups, allProjects);
-        closure.delete(teardown);
-        teardownToSetupsDependents.set(teardown, [...closure]);
-      }
-      for (let i = 0; i < projectToSuite.size; i++) {
-        // Find all projects that have all their dependencies processed by previous phases.
-        const phaseProjects = [];
-        for (const project of projectToSuite.keys()) {
-          if (processed.has(project)) continue;
-          const projectsThatShouldFinishFirst = [...project.deps, ...(teardownToSetupsDependents.get(project) || [])];
-          if (projectsThatShouldFinishFirst.find(p => !processed.has(p))) continue;
-          phaseProjects.push(project);
-        }
-
-        // Create a new phase.
-        for (const project of phaseProjects) processed.add(project);
-        if (phaseProjects.length) {
-          let testGroupsInPhase = 0;
-          const phase = {
-            dispatcher: new _dispatcher.Dispatcher(testRun.config, reporter, testRun.failureTracker),
-            projects: []
-          };
-          testRun.phases.push(phase);
-          for (const project of phaseProjects) {
-            const projectSuite = projectToSuite.get(project);
-            const testGroups = (0, _testGroups.createTestGroups)(projectSuite, testRun.config.config.workers);
-            phase.projects.push({
-              project,
-              projectSuite,
-              testGroups
-            });
-            testGroupsInPhase += testGroups.length;
-          }
-          (0, _utilsBundle.debug)('pw:test:task')(`created phase #${testRun.phases.length} with ${phase.projects.map(p => p.project.project.name).sort()} projects, ${testGroupsInPhase} testGroups`);
-          maxConcurrentTestGroups = Math.max(maxConcurrentTestGroups, testGroupsInPhase);
-        }
-      }
-      testRun.config.config.metadata.actualWorkers = Math.min(testRun.config.config.workers, maxConcurrentTestGroups);
-    }
-  };
-}
-function createRunTestsTask() {
-  return {
-    setup: async (reporter, {
-      phases,
-      failureTracker
-    }) => {
-      const successfulProjects = new Set();
-      const extraEnvByProjectId = new Map();
-      const teardownToSetups = (0, _projectUtils.buildTeardownToSetupsMap)(phases.map(phase => phase.projects.map(p => p.project)).flat());
-      for (const {
-        dispatcher,
-        projects
-      } of phases) {
-        // Each phase contains dispatcher and a set of test groups.
-        // We don't want to run the test groups belonging to the projects
-        // that depend on the projects that failed previously.
-        const phaseTestGroups = [];
-        for (const {
-          project,
-          testGroups
-        } of projects) {
-          // Inherit extra environment variables from dependencies.
-          let extraEnv = {};
-          for (const dep of project.deps) extraEnv = {
-            ...extraEnv,
-            ...extraEnvByProjectId.get(dep.id)
-          };
-          for (const setup of teardownToSetups.get(project) || []) extraEnv = {
-            ...extraEnv,
-            ...extraEnvByProjectId.get(setup.id)
-          };
-          extraEnvByProjectId.set(project.id, extraEnv);
-          const hasFailedDeps = project.deps.some(p => !successfulProjects.has(p));
-          if (!hasFailedDeps) phaseTestGroups.push(...testGroups);
-        }
-        if (phaseTestGroups.length) {
-          await dispatcher.run(phaseTestGroups, extraEnvByProjectId);
-          await dispatcher.stop();
-          for (const [projectId, envProduced] of dispatcher.producedEnvByProjectId()) {
-            const extraEnv = extraEnvByProjectId.get(projectId) || {};
-            extraEnvByProjectId.set(projectId, {
-              ...extraEnv,
-              ...envProduced
-            });
-          }
-        }
-
-        // If the worker broke, fail everything, we have no way of knowing which
-        // projects failed.
-        if (!failureTracker.hasWorkerErrors()) {
-          for (const {
-            project,
-            projectSuite
-          } of projects) {
-            const hasFailedDeps = project.deps.some(p => !successfulProjects.has(p));
-            if (!hasFailedDeps && !projectSuite.allTests().some(test => !test.ok())) successfulProjects.add(project);
-          }
-        }
-      }
-    },
-    teardown: async (reporter, {
-      phases
-    }) => {
-      for (const {
-        dispatcher
-      } of phases.reverse()) await dispatcher.stop();
-    }
-  };
-}
-function createStartDevServerTask() {
-  return {
-    setup: async (reporter, testRun, errors, softErrors) => {
-      if (testRun.config.plugins.some(plugin => !!plugin.devServerCleanup)) {
-        errors.push({
-          message: `DevServer is already running`
-        });
-        return;
-      }
-      for (const plugin of testRun.config.plugins) {
-        var _plugin$instance6, _plugin$instance6$sta;
-        plugin.devServerCleanup = await ((_plugin$instance6 = plugin.instance) === null || _plugin$instance6 === void 0 || (_plugin$instance6$sta = _plugin$instance6.startDevServer) === null || _plugin$instance6$sta === void 0 ? void 0 : _plugin$instance6$sta.call(_plugin$instance6));
-      }
-      if (!testRun.config.plugins.some(plugin => !!plugin.devServerCleanup)) errors.push({
-        message: `DevServer is not available in the package you are using. Did you mean to use component testing?`
-      });
-    },
-    teardown: async (reporter, testRun) => {
-      for (const plugin of testRun.config.plugins) {
-        var _plugin$devServerClea;
-        await ((_plugin$devServerClea = plugin.devServerCleanup) === null || _plugin$devServerClea === void 0 ? void 0 : _plugin$devServerClea.call(plugin));
-        plugin.devServerCleanup = undefined;
-      }
-    }
-  };
-}

data/node_modules/playwright/lib/runner/testGroups.js

@@ -1,136 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createTestGroups = createTestGroups;
-exports.filterForShard = filterForShard;
-/**
- * Copyright Microsoft Corporation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-function createTestGroups(projectSuite, workers) {
-  // This function groups tests that can be run together.
-  // Tests cannot be run together when:
-  // - They belong to different projects - requires different workers.
-  // - They have a different repeatEachIndex - requires different workers.
-  // - They have a different set of worker fixtures in the pool - requires different workers.
-  // - They have a different requireFile - reuses the worker, but runs each requireFile separately.
-  // - They belong to a parallel suite.
-
-  // Using the map "workerHash -> requireFile -> group" makes us preserve the natural order
-  // of worker hashes and require files for the simple cases.
-  const groups = new Map();
-  const createGroup = test => {
-    return {
-      workerHash: test._workerHash,
-      requireFile: test._requireFile,
-      repeatEachIndex: test.repeatEachIndex,
-      projectId: test._projectId,
-      tests: []
-    };
-  };
-  for (const test of projectSuite.allTests()) {
-    let withWorkerHash = groups.get(test._workerHash);
-    if (!withWorkerHash) {
-      withWorkerHash = new Map();
-      groups.set(test._workerHash, withWorkerHash);
-    }
-    let withRequireFile = withWorkerHash.get(test._requireFile);
-    if (!withRequireFile) {
-      withRequireFile = {
-        general: createGroup(test),
-        parallel: new Map(),
-        parallelWithHooks: createGroup(test)
-      };
-      withWorkerHash.set(test._requireFile, withRequireFile);
-    }
-
-    // Note that a parallel suite cannot be inside a serial suite. This is enforced in TestType.
-    let insideParallel = false;
-    let outerMostSequentialSuite;
-    let hasAllHooks = false;
-    for (let parent = test.parent; parent; parent = parent.parent) {
-      if (parent._parallelMode === 'serial' || parent._parallelMode === 'default') outerMostSequentialSuite = parent;
-      insideParallel = insideParallel || parent._parallelMode === 'parallel';
-      hasAllHooks = hasAllHooks || parent._hooks.some(hook => hook.type === 'beforeAll' || hook.type === 'afterAll');
-    }
-    if (insideParallel) {
-      if (hasAllHooks && !outerMostSequentialSuite) {
-        withRequireFile.parallelWithHooks.tests.push(test);
-      } else {
-        const key = outerMostSequentialSuite || test;
-        let group = withRequireFile.parallel.get(key);
-        if (!group) {
-          group = createGroup(test);
-          withRequireFile.parallel.set(key, group);
-        }
-        group.tests.push(test);
-      }
-    } else {
-      withRequireFile.general.tests.push(test);
-    }
-  }
-  const result = [];
-  for (const withWorkerHash of groups.values()) {
-    for (const withRequireFile of withWorkerHash.values()) {
-      // Tests without parallel mode should run serially as a single group.
-      if (withRequireFile.general.tests.length) result.push(withRequireFile.general);
-
-      // Parallel test groups without beforeAll/afterAll can be run independently.
-      result.push(...withRequireFile.parallel.values());
-
-      // Tests with beforeAll/afterAll should try to share workers as much as possible.
-      const parallelWithHooksGroupSize = Math.ceil(withRequireFile.parallelWithHooks.tests.length / workers);
-      let lastGroup;
-      for (const test of withRequireFile.parallelWithHooks.tests) {
-        if (!lastGroup || lastGroup.tests.length >= parallelWithHooksGroupSize) {
-          lastGroup = createGroup(test);
-          result.push(lastGroup);
-        }
-        lastGroup.tests.push(test);
-      }
-    }
-  }
-  return result;
-}
-function filterForShard(shard, testGroups) {
-  // Note that sharding works based on test groups.
-  // This means parallel files will be sharded by single tests,
-  // while non-parallel files will be sharded by the whole file.
-  //
-  // Shards are still balanced by the number of tests, not files,
-  // even in the case of non-paralleled files.
-
-  let shardableTotal = 0;
-  for (const group of testGroups) shardableTotal += group.tests.length;
-
-  // Each shard gets some tests.
-  const shardSize = Math.floor(shardableTotal / shard.total);
-  // First few shards get one more test each.
-  const extraOne = shardableTotal - shardSize * shard.total;
-  const currentShard = shard.current - 1; // Make it zero-based for calculations.
-  const from = shardSize * currentShard + Math.min(extraOne, currentShard);
-  const to = from + shardSize + (currentShard < extraOne ? 1 : 0);
-  let current = 0;
-  const result = new Set();
-  for (const group of testGroups) {
-    // Any test group goes to the shard that contains the first test of this group.
-    // So, this shard gets any group that starts at [from; to)
-    if (current >= from && current < to) result.add(group);
-    current += group.tests.length;
-  }
-  return result;
-}