pokeedex 0.1.0

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

@@ -0,0 +1,147 @@
+"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

@@ -0,0 +1,407 @@
+"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

@@ -0,0 +1,136 @@
+"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;
+}