Brunobkr/llama.cpp_AlgMor24_github

1"use strict";2var __create = Object.create;3var __defProp = Object.defineProperty;4var __getOwnPropDesc = Object.getOwnPropertyDescriptor;5var __getOwnPropNames = Object.getOwnPropertyNames;6var __getProtoOf = Object.getPrototypeOf;7var __hasOwnProp = Object.prototype.hasOwnProperty;8var __export = (target, all) => {9  for (var name in all)10    __defProp(target, name, { get: all[name], enumerable: true });11};12var __copyProps = (to, from, except, desc) => {13  if (from && typeof from === "object" || typeof from === "function") {14    for (let key of __getOwnPropNames(from))15      if (!__hasOwnProp.call(to, key) && key !== except)16        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });17  }18  return to;19};20var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(21  // If the importer is in node compatibility mode or this is not an ESM22  // file that has been converted to a CommonJS file using a Babel-23  // compatible transform (i.e. "__esModule" has not been set), then set24  // "default" to the CommonJS "module.exports" for node compatibility.25  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,26  mod27));28var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);29var tasks_exports = {};30__export(tasks_exports, {31  TestRun: () => TestRun,32  createApplyRebaselinesTask: () => createApplyRebaselinesTask,33  createClearCacheTask: () => createClearCacheTask,34  createGlobalSetupTasks: () => createGlobalSetupTasks,35  createListFilesTask: () => createListFilesTask,36  createLoadTask: () => createLoadTask,37  createPluginSetupTasks: () => createPluginSetupTasks,38  createReportBeginTask: () => createReportBeginTask,39  createRunTestsTasks: () => createRunTestsTasks,40  createStartDevServerTask: () => createStartDevServerTask,41  runTasks: () => runTasks,42  runTasksDeferCleanup: () => runTasksDeferCleanup43});44module.exports = __toCommonJS(tasks_exports);45var import_fs = __toESM(require("fs"));46var import_path = __toESM(require("path"));47var import_util = require("util");48var import_utils = require("playwright-core/lib/utils");49var import_utilsBundle = require("playwright-core/lib/utilsBundle");50var import_dispatcher = require("./dispatcher");51var import_failureTracker = require("./failureTracker");52var import_loadUtils = require("./loadUtils");53var import_projectUtils = require("./projectUtils");54var import_rebase = require("./rebase");55var import_taskRunner = require("./taskRunner");56var import_vcs = require("./vcs");57var import_test = require("../common/test");58var import_testGroups = require("../runner/testGroups");59var import_compilationCache = require("../transform/compilationCache");60var import_util2 = require("../util");61const readDirAsync = (0, import_util.promisify)(import_fs.default.readdir);62class TestRun {63  constructor(config, reporter, options) {64    this.rootSuite = void 0;65    this.phases = [];66    this.projectFiles = /* @__PURE__ */ new Map();67    this.projectSuites = /* @__PURE__ */ new Map();68    this.topLevelProjects = [];69    this.config = config;70    this.reporter = reporter;71    this.failureTracker = new import_failureTracker.FailureTracker(config, options);72  }73}74async function runTasks(testRun, tasks, globalTimeout, cancelPromise) {75  const deadline = globalTimeout ? (0, import_utils.monotonicTime)() + globalTimeout : 0;76  const taskRunner = new import_taskRunner.TaskRunner(testRun.reporter, globalTimeout || 0);77  for (const task of tasks)78    taskRunner.addTask(task);79  testRun.reporter.onConfigure(testRun.config.config);80  const status = await taskRunner.run(testRun, deadline, cancelPromise);81  return await finishTaskRun(testRun, status);82}83async function runTasksDeferCleanup(testRun, tasks) {84  const taskRunner = new import_taskRunner.TaskRunner(testRun.reporter, 0);85  for (const task of tasks)86    taskRunner.addTask(task);87  testRun.reporter.onConfigure(testRun.config.config);88  const { status, cleanup } = await taskRunner.runDeferCleanup(testRun, 0);89  return { status: await finishTaskRun(testRun, status), cleanup };90}91async function finishTaskRun(testRun, status) {92  if (status === "passed")93    status = testRun.failureTracker.result();94  const modifiedResult = await testRun.reporter.onEnd({ status });95  if (modifiedResult && modifiedResult.status)96    status = modifiedResult.status;97  await testRun.reporter.onExit();98  return status;99}100function createGlobalSetupTasks(config) {101  const tasks = [];102  if (!config.configCLIOverrides.preserveOutputDir)103    tasks.push(createRemoveOutputDirsTask());104  tasks.push(105    ...createPluginSetupTasks(config),106    ...config.globalTeardowns.map((file) => createGlobalTeardownTask(file, config)).reverse(),107    ...config.globalSetups.map((file) => createGlobalSetupTask(file, config))108  );109  return tasks;110}111function createRunTestsTasks(config) {112  return [113    createPhasesTask(),114    createReportBeginTask(),115    ...config.plugins.map((plugin) => createPluginBeginTask(plugin)),116    createRunTestsTask()117  ];118}119function createClearCacheTask(config) {120  return {121    title: "clear cache",122    setup: async () => {123      await (0, import_util2.removeDirAndLogToConsole)(import_compilationCache.cacheDir);124      for (const plugin of config.plugins)125        await plugin.instance?.clearCache?.();126    }127  };128}129function createReportBeginTask() {130  return {131    title: "report begin",132    setup: async (testRun) => {133      testRun.reporter.onBegin?.(testRun.rootSuite);134    },135    teardown: async ({}) => {136    }137  };138}139function createPluginSetupTasks(config) {140  return config.plugins.map((plugin) => ({141    title: "plugin setup",142    setup: async ({ reporter }) => {143      if (typeof plugin.factory === "function")144        plugin.instance = await plugin.factory();145      else146        plugin.instance = plugin.factory;147      await plugin.instance?.setup?.(config.config, config.configDir, reporter);148    },149    teardown: async () => {150      await plugin.instance?.teardown?.();151    }152  }));153}154function createPluginBeginTask(plugin) {155  return {156    title: "plugin begin",157    setup: async (testRun) => {158      await plugin.instance?.begin?.(testRun.rootSuite);159    },160    teardown: async () => {161      await plugin.instance?.end?.();162    }163  };164}165function createGlobalSetupTask(file, config) {166  let title = "global setup";167  if (config.globalSetups.length > 1)168    title += ` (${file})`;169  let globalSetupResult;170  return {171    title,172    setup: async ({ config: config2 }) => {173      const setupHook = await (0, import_loadUtils.loadGlobalHook)(config2, file);174      globalSetupResult = await setupHook(config2.config);175    },176    teardown: async () => {177      if (typeof globalSetupResult === "function")178        await globalSetupResult();179    }180  };181}182function createGlobalTeardownTask(file, config) {183  let title = "global teardown";184  if (config.globalTeardowns.length > 1)185    title += ` (${file})`;186  return {187    title,188    teardown: async ({ config: config2 }) => {189      const teardownHook = await (0, import_loadUtils.loadGlobalHook)(config2, file);190      await teardownHook(config2.config);191    }192  };193}194function createRemoveOutputDirsTask() {195  return {196    title: "clear output",197    setup: async ({ config }) => {198      const outputDirs = /* @__PURE__ */ new Set();199      const projects = (0, import_projectUtils.filterProjects)(config.projects, config.cliProjectFilter);200      projects.forEach((p) => outputDirs.add(p.project.outputDir));201      await Promise.all(Array.from(outputDirs).map((outputDir) => (0, import_utils.removeFolders)([outputDir]).then(async ([error]) => {202        if (!error)203          return;204        if (error.code === "EBUSY") {205          const entries = await readDirAsync(outputDir).catch((e) => []);206          await Promise.all(entries.map((entry) => (0, import_utils.removeFolders)([import_path.default.join(outputDir, entry)])));207        } else {208          throw error;209        }210      })));211    }212  };213}214function createListFilesTask() {215  return {216    title: "load tests",217    setup: async (testRun, errors) => {218      const { rootSuite, topLevelProjects } = await (0, import_loadUtils.createRootSuite)(testRun, errors, false);219      testRun.rootSuite = rootSuite;220      testRun.failureTracker.onRootSuite(rootSuite, topLevelProjects);221      await (0, import_loadUtils.collectProjectsAndTestFiles)(testRun, false);222      for (const [project, files] of testRun.projectFiles) {223        const projectSuite = new import_test.Suite(project.project.name, "project");224        projectSuite._fullProject = project;225        testRun.rootSuite._addSuite(projectSuite);226        const suites = files.map((file) => {227          const title = import_path.default.relative(testRun.config.config.rootDir, file);228          const suite = new import_test.Suite(title, "file");229          suite.location = { file, line: 0, column: 0 };230          projectSuite._addSuite(suite);231          return suite;232        });233        testRun.projectSuites.set(project, suites);234      }235    }236  };237}238function createLoadTask(mode, options) {239  return {240    title: "load tests",241    setup: async (testRun, errors, softErrors) => {242      await (0, import_loadUtils.collectProjectsAndTestFiles)(testRun, !!options.doNotRunDepsOutsideProjectFilter);243      await (0, import_loadUtils.loadFileSuites)(testRun, mode, options.failOnLoadErrors ? errors : softErrors);244      if (testRun.config.cliOnlyChanged || options.populateDependencies) {245        for (const plugin of testRun.config.plugins)246          await plugin.instance?.populateDependencies?.();247      }248      if (testRun.config.cliOnlyChanged) {249        const changedFiles = await (0, import_vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir);250        testRun.config.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file));251      }252      if (testRun.config.cliTestList) {253        const testListFilter = await (0, import_loadUtils.loadTestList)(testRun.config, testRun.config.cliTestList);254        testRun.config.preOnlyTestFilters.push(testListFilter);255      }256      if (testRun.config.cliTestListInvert) {257        const testListInvertFilter = await (0, import_loadUtils.loadTestList)(testRun.config, testRun.config.cliTestListInvert);258        testRun.config.preOnlyTestFilters.push((test) => !testListInvertFilter(test));259      }260      const { rootSuite, topLevelProjects } = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly);261      testRun.rootSuite = rootSuite;262      testRun.failureTracker.onRootSuite(rootSuite, topLevelProjects);263      if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged && !testRun.config.cliTestList && !testRun.config.cliTestListInvert) {264        if (testRun.config.cliArgs.length) {265          throw new Error([266            `No tests found.`,267            `Make sure that arguments are regular expressions matching test files.`,268            `You may need to escape symbols like "$" or "*" and quote the arguments.`269          ].join("\n"));270        }271        throw new Error(`No tests found`);272      }273    }274  };275}276function createApplyRebaselinesTask() {277  return {278    title: "apply rebaselines",279    setup: async () => {280      (0, import_rebase.clearSuggestedRebaselines)();281    },282    teardown: async ({ config, reporter }) => {283      await (0, import_rebase.applySuggestedRebaselines)(config, reporter);284    }285  };286}287function createPhasesTask() {288  return {289    title: "create phases",290    setup: async (testRun) => {291      let maxConcurrentTestGroups = 0;292      const processed = /* @__PURE__ */ new Set();293      const projectToSuite = new Map(testRun.rootSuite.suites.map((suite) => [suite._fullProject, suite]));294      const allProjects = [...projectToSuite.keys()];295      const teardownToSetups = (0, import_projectUtils.buildTeardownToSetupsMap)(allProjects);296      const teardownToSetupsDependents = /* @__PURE__ */ new Map();297      for (const [teardown, setups] of teardownToSetups) {298        const closure = (0, import_projectUtils.buildDependentProjects)(setups, allProjects);299        closure.delete(teardown);300        teardownToSetupsDependents.set(teardown, [...closure]);301      }302      for (let i = 0; i < projectToSuite.size; i++) {303        const phaseProjects = [];304        for (const project of projectToSuite.keys()) {305          if (processed.has(project))306            continue;307          const projectsThatShouldFinishFirst = [...project.deps, ...teardownToSetupsDependents.get(project) || []];308          if (projectsThatShouldFinishFirst.find((p) => !processed.has(p)))309            continue;310          phaseProjects.push(project);311        }312        for (const project of phaseProjects)313          processed.add(project);314        if (phaseProjects.length) {315          let testGroupsInPhase = 0;316          const phase = { dispatcher: new import_dispatcher.Dispatcher(testRun.config, testRun.reporter, testRun.failureTracker), projects: [] };317          testRun.phases.push(phase);318          for (const project of phaseProjects) {319            const projectSuite = projectToSuite.get(project);320            const testGroups = (0, import_testGroups.createTestGroups)(projectSuite, testRun.config.config.workers);321            phase.projects.push({ project, projectSuite, testGroups });322            testGroupsInPhase += Math.min(project.workers ?? Number.MAX_SAFE_INTEGER, testGroups.length);323          }324          (0, import_utilsBundle.debug)("pw:test:task")(`created phase #${testRun.phases.length} with ${phase.projects.map((p) => p.project.project.name).sort()} projects, ${testGroupsInPhase} testGroups`);325          maxConcurrentTestGroups = Math.max(maxConcurrentTestGroups, testGroupsInPhase);326        }327      }328      testRun.config.config.metadata.actualWorkers = Math.min(testRun.config.config.workers, maxConcurrentTestGroups);329    }330  };331}332function createRunTestsTask() {333  return {334    title: "test suite",335    setup: async ({ phases, failureTracker }) => {336      const successfulProjects = /* @__PURE__ */ new Set();337      const extraEnvByProjectId = /* @__PURE__ */ new Map();338      const teardownToSetups = (0, import_projectUtils.buildTeardownToSetupsMap)(phases.map((phase) => phase.projects.map((p) => p.project)).flat());339      for (const { dispatcher, projects } of phases) {340        const phaseTestGroups = [];341        for (const { project, testGroups } of projects) {342          let extraEnv = {};343          for (const dep of project.deps)344            extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(dep.id) };345          for (const setup of teardownToSetups.get(project) || [])346            extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(setup.id) };347          extraEnvByProjectId.set(project.id, extraEnv);348          const hasFailedDeps = project.deps.some((p) => !successfulProjects.has(p));349          if (!hasFailedDeps)350            phaseTestGroups.push(...testGroups);351        }352        if (phaseTestGroups.length) {353          await dispatcher.run(phaseTestGroups, extraEnvByProjectId);354          await dispatcher.stop();355          for (const [projectId, envProduced] of dispatcher.producedEnvByProjectId()) {356            const extraEnv = extraEnvByProjectId.get(projectId) || {};357            extraEnvByProjectId.set(projectId, { ...extraEnv, ...envProduced });358          }359        }360        if (!failureTracker.hasWorkerErrors()) {361          for (const { project, projectSuite } of projects) {362            const hasFailedDeps = project.deps.some((p) => !successfulProjects.has(p));363            if (!hasFailedDeps && !projectSuite.allTests().some((test) => !test.ok()))364              successfulProjects.add(project);365          }366        }367      }368    },369    teardown: async ({ phases }) => {370      for (const { dispatcher } of phases.reverse())371        await dispatcher.stop();372    }373  };374}375function createStartDevServerTask() {376  return {377    title: "start dev server",378    setup: async ({ config }, errors, softErrors) => {379      if (config.plugins.some((plugin) => !!plugin.devServerCleanup)) {380        errors.push({ message: `DevServer is already running` });381        return;382      }383      for (const plugin of config.plugins)384        plugin.devServerCleanup = await plugin.instance?.startDevServer?.();385      if (!config.plugins.some((plugin) => !!plugin.devServerCleanup))386        errors.push({ message: `DevServer is not available in the package you are using. Did you mean to use component testing?` });387    },388    teardown: async ({ config }) => {389      for (const plugin of config.plugins) {390        await plugin.devServerCleanup?.();391        plugin.devServerCleanup = void 0;392      }393    }394  };395}396// Annotate the CommonJS export names for ESM import in node:3970 && (module.exports = {398  TestRun,399  createApplyRebaselinesTask,400  createClearCacheTask,401  createGlobalSetupTasks,402  createListFilesTask,403  createLoadTask,404  createPluginSetupTasks,405  createReportBeginTask,406  createRunTestsTasks,407  createStartDevServerTask,408  runTasks,409  runTasksDeferCleanup410});411