Brunobkr/llama.cpp_AlgMor24_github

1"use strict";2var __defProp = Object.defineProperty;3var __getOwnPropDesc = Object.getOwnPropertyDescriptor;4var __getOwnPropNames = Object.getOwnPropertyNames;5var __hasOwnProp = Object.prototype.hasOwnProperty;6var __export = (target, all) => {7  for (var name in all)8    __defProp(target, name, { get: all[name], enumerable: true });9};10var __copyProps = (to, from, except, desc) => {11  if (from && typeof from === "object" || typeof from === "function") {12    for (let key of __getOwnPropNames(from))13      if (!__hasOwnProp.call(to, key) && key !== except)14        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });15  }16  return to;17};18var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);19var workerMain_exports = {};20__export(workerMain_exports, {21  WorkerMain: () => WorkerMain,22  create: () => create23});24module.exports = __toCommonJS(workerMain_exports);25var import_utils = require("playwright-core/lib/utils");26var import_utils2 = require("playwright-core/lib/utils");27var import_configLoader = require("../common/configLoader");28var import_globals = require("../common/globals");29var import_ipc = require("../common/ipc");30var import_util = require("../util");31var import_fixtureRunner = require("./fixtureRunner");32var import_testInfo = require("./testInfo");33var import_util2 = require("./util");34var import_fixtures = require("../common/fixtures");35var import_poolBuilder = require("../common/poolBuilder");36var import_process = require("../common/process");37var import_suiteUtils = require("../common/suiteUtils");38var import_testLoader = require("../common/testLoader");39class WorkerMain extends import_process.ProcessRunner {40  constructor(params) {41    super();42    // Accumulated fatal errors that cannot be attributed to a test.43    this._fatalErrors = [];44    // The stage of the full cleanup. Once "finished", we can safely stop running anything.45    this._didRunFullCleanup = false;46    // Whether the worker was stopped due to an unhandled error in a test marked with test.fail().47    // This should force dispatcher to use a new worker instead.48    this._stoppedDueToUnhandledErrorInTestFail = false;49    // Whether the worker was requested to stop.50    this._isStopped = false;51    // This promise resolves once the single "run test group" call finishes.52    this._runFinished = new import_utils.ManualPromise();53    this._currentTest = null;54    this._lastRunningTests = [];55    this._totalRunningTests = 0;56    // Suites that had their beforeAll hooks, but not afterAll hooks executed.57    // These suites still need afterAll hooks to be executed for the proper cleanup.58    // Contains dynamic annotations originated by modifiers with a callback, e.g. `test.skip(() => true)`.59    this._activeSuites = /* @__PURE__ */ new Map();60    process.env.TEST_WORKER_INDEX = String(params.workerIndex);61    process.env.TEST_PARALLEL_INDEX = String(params.parallelIndex);62    (0, import_globals.setIsWorkerProcess)();63    this._params = params;64    this._fixtureRunner = new import_fixtureRunner.FixtureRunner();65    this._runFinished.resolve();66    process.on("unhandledRejection", (reason) => this.unhandledError(reason));67    process.on("uncaughtException", (error) => this.unhandledError(error));68    process.stdout.write = (chunk, cb) => {69      this.dispatchEvent("stdOut", (0, import_ipc.stdioChunkToParams)(chunk));70      this._currentTest?._tracing.appendStdioToTrace("stdout", chunk);71      if (typeof cb === "function")72        process.nextTick(cb);73      return true;74    };75    if (!process.env.PW_RUNNER_DEBUG) {76      process.stderr.write = (chunk, cb) => {77        this.dispatchEvent("stdErr", (0, import_ipc.stdioChunkToParams)(chunk));78        this._currentTest?._tracing.appendStdioToTrace("stderr", chunk);79        if (typeof cb === "function")80          process.nextTick(cb);81        return true;82      };83    }84  }85  _stop() {86    if (!this._isStopped) {87      this._isStopped = true;88      this._currentTest?._interrupt();89    }90    return this._runFinished;91  }92  async gracefullyClose() {93    try {94      await this._stop();95      if (!this._config) {96        return;97      }98      const fakeTestInfo = new import_testInfo.TestInfoImpl(this._config, this._project, this._params, void 0, 0, () => {99      }, () => {100      }, () => {101      });102      const runnable = { type: "teardown" };103      await fakeTestInfo._runWithTimeout(runnable, () => this._loadIfNeeded()).catch(() => {104      });105      await this._fixtureRunner.teardownScope("test", fakeTestInfo, runnable).catch(() => {106      });107      await this._fixtureRunner.teardownScope("worker", fakeTestInfo, runnable).catch(() => {108      });109      await fakeTestInfo._runWithTimeout(runnable, () => (0, import_utils.gracefullyCloseAll)()).catch(() => {110      });111      this._fatalErrors.push(...fakeTestInfo.errors);112    } catch (e) {113      this._fatalErrors.push((0, import_util2.testInfoError)(e));114    }115    if (this._fatalErrors.length) {116      this._appendProcessTeardownDiagnostics(this._fatalErrors[this._fatalErrors.length - 1]);117      const payload = { fatalErrors: this._fatalErrors };118      this.dispatchEvent("teardownErrors", payload);119    }120  }121  _appendProcessTeardownDiagnostics(error) {122    if (!this._lastRunningTests.length)123      return;124    const count = this._totalRunningTests === 1 ? "1 test" : `${this._totalRunningTests} tests`;125    let lastMessage = "";126    if (this._lastRunningTests.length < this._totalRunningTests)127      lastMessage = `, last ${this._lastRunningTests.length} tests were`;128    const message = [129      "",130      "",131      import_utils2.colors.red(`Failed worker ran ${count}${lastMessage}:`),132      ...this._lastRunningTests.map((test) => formatTestTitle(test, this._project.project.name))133    ].join("\n");134    if (error.message) {135      if (error.stack) {136        let index = error.stack.indexOf(error.message);137        if (index !== -1) {138          index += error.message.length;139          error.stack = error.stack.substring(0, index) + message + error.stack.substring(index);140        }141      }142      error.message += message;143    } else if (error.value) {144      error.value += message;145    }146  }147  unhandledError(error) {148    if (!this._currentTest) {149      if (!this._fatalErrors.length)150        this._fatalErrors.push((0, import_util2.testInfoError)(error));151      void this._stop();152      return;153    }154    if (!this._currentTest._hasUnhandledError) {155      this._currentTest._hasUnhandledError = true;156      this._currentTest._failWithError(error);157    }158    const isExpectError = error instanceof Error && !!error.matcherResult;159    const shouldContinueInThisWorker = this._currentTest.expectedStatus === "failed" && isExpectError;160    if (!shouldContinueInThisWorker) {161      this._stoppedDueToUnhandledErrorInTestFail = true;162      void this._stop();163    }164  }165  async _loadIfNeeded() {166    if (this._config)167      return;168    const config = await (0, import_configLoader.deserializeConfig)(this._params.config);169    const project = config.projects.find((p) => p.id === this._params.projectId);170    if (!project)171      throw new Error(`Project "${this._params.projectId}" not found in the worker process. Make sure project name does not change.`);172    this._config = config;173    this._project = project;174    this._poolBuilder = import_poolBuilder.PoolBuilder.createForWorker(this._project);175  }176  async runTestGroup(runPayload) {177    this._runFinished = new import_utils.ManualPromise();178    const entries = new Map(runPayload.entries.map((e) => [e.testId, e]));179    let fatalUnknownTestIds;180    try {181      await this._loadIfNeeded();182      const fileSuite = await (0, import_testLoader.loadTestFile)(runPayload.file, this._config.config.rootDir);183      const suite = (0, import_suiteUtils.bindFileSuiteToProject)(this._project, fileSuite);184      if (this._params.repeatEachIndex)185        (0, import_suiteUtils.applyRepeatEachIndex)(this._project, suite, this._params.repeatEachIndex);186      const hasEntries = (0, import_suiteUtils.filterTestsRemoveEmptySuites)(suite, (test) => entries.has(test.id));187      if (hasEntries) {188        this._poolBuilder.buildPools(suite);189        this._activeSuites = /* @__PURE__ */ new Map();190        this._didRunFullCleanup = false;191        const tests = suite.allTests();192        for (let i = 0; i < tests.length; i++) {193          if (this._isStopped && this._didRunFullCleanup)194            break;195          const entry = entries.get(tests[i].id);196          entries.delete(tests[i].id);197          (0, import_util.debugTest)(`test started "${tests[i].title}"`);198          await this._runTest(tests[i], entry.retry, tests[i + 1]);199          (0, import_util.debugTest)(`test finished "${tests[i].title}"`);200        }201      } else {202        fatalUnknownTestIds = runPayload.entries.map((e) => e.testId);203        void this._stop();204      }205    } catch (e) {206      this._fatalErrors.push((0, import_util2.testInfoError)(e));207      void this._stop();208    } finally {209      const donePayload = {210        fatalErrors: this._fatalErrors,211        skipTestsDueToSetupFailure: [],212        fatalUnknownTestIds,213        stoppedDueToUnhandledErrorInTestFail: this._stoppedDueToUnhandledErrorInTestFail214      };215      for (const test of this._skipRemainingTestsInSuite?.allTests() || []) {216        if (entries.has(test.id))217          donePayload.skipTestsDueToSetupFailure.push(test.id);218      }219      this.dispatchEvent("done", donePayload);220      this._fatalErrors = [];221      this._skipRemainingTestsInSuite = void 0;222      this._runFinished.resolve();223    }224  }225  async _runTest(test, retry, nextTest) {226    const testInfo = new import_testInfo.TestInfoImpl(227      this._config,228      this._project,229      this._params,230      test,231      retry,232      (stepBeginPayload) => this.dispatchEvent("stepBegin", stepBeginPayload),233      (stepEndPayload) => this.dispatchEvent("stepEnd", stepEndPayload),234      (attachment) => this.dispatchEvent("attach", attachment)235    );236    const processAnnotation = (annotation) => {237      testInfo.annotations.push(annotation);238      switch (annotation.type) {239        case "fixme":240        case "skip":241          testInfo.expectedStatus = "skipped";242          break;243        case "fail":244          if (testInfo.expectedStatus !== "skipped")245            testInfo.expectedStatus = "failed";246          break;247        case "slow":248          testInfo._timeoutManager.slow();249          break;250      }251    };252    if (!this._isStopped)253      this._fixtureRunner.setPool(test._pool);254    const suites = getSuites(test);255    const reversedSuites = suites.slice().reverse();256    const nextSuites = new Set(getSuites(nextTest));257    testInfo._timeoutManager.setTimeout(test.timeout);258    for (const annotation of test.annotations)259      processAnnotation(annotation);260    for (const suite of suites) {261      const extraAnnotations = this._activeSuites.get(suite) || [];262      for (const annotation of extraAnnotations)263        processAnnotation(annotation);264    }265    this._currentTest = testInfo;266    (0, import_globals.setCurrentTestInfo)(testInfo);267    this.dispatchEvent("testBegin", buildTestBeginPayload(testInfo));268    const isSkipped = testInfo.expectedStatus === "skipped";269    const hasAfterAllToRunBeforeNextTest = reversedSuites.some((suite) => {270      return this._activeSuites.has(suite) && !nextSuites.has(suite) && suite._hooks.some((hook) => hook.type === "afterAll");271    });272    if (isSkipped && nextTest && !hasAfterAllToRunBeforeNextTest) {273      testInfo.status = "skipped";274      this.dispatchEvent("testEnd", buildTestEndPayload(testInfo));275      return;276    }277    this._totalRunningTests++;278    this._lastRunningTests.push(test);279    if (this._lastRunningTests.length > 10)280      this._lastRunningTests.shift();281    let shouldRunAfterEachHooks = false;282    testInfo._allowSkips = true;283    await (async () => {284      await testInfo._runWithTimeout({ type: "test" }, async () => {285        const traceFixtureRegistration = test._pool.resolve("trace");286        if (!traceFixtureRegistration)287          return;288        if (typeof traceFixtureRegistration.fn === "function")289          throw new Error(`"trace" option cannot be a function`);290        await testInfo._tracing.startIfNeeded(traceFixtureRegistration.fn);291      });292      if (this._isStopped || isSkipped) {293        testInfo.status = "skipped";294        return;295      }296      await (0, import_utils.removeFolders)([testInfo.outputDir]);297      let testFunctionParams = null;298      await testInfo._runAsStep({ title: "Before Hooks", category: "hook" }, async () => {299        for (const suite of suites)300          await this._runBeforeAllHooksForSuite(suite, testInfo);301        shouldRunAfterEachHooks = true;302        await this._runEachHooksForSuites(suites, "beforeEach", testInfo);303        testFunctionParams = await this._fixtureRunner.resolveParametersForFunction(test.fn, testInfo, "test", { type: "test" });304      });305      if (testFunctionParams === null) {306        return;307      }308      await testInfo._runWithTimeout({ type: "test" }, async () => {309        const fn = test.fn;310        await fn(testFunctionParams, testInfo);311      });312    })().catch(() => {313    });314    testInfo.duration = testInfo._timeoutManager.defaultSlot().elapsed | 0;315    testInfo._allowSkips = true;316    const afterHooksTimeout = calculateMaxTimeout(this._project.project.timeout, testInfo.timeout);317    const afterHooksSlot = { timeout: afterHooksTimeout, elapsed: 0 };318    await testInfo._runAsStep({ title: "After Hooks", category: "hook" }, async () => {319      let firstAfterHooksError;320      try {321        await testInfo._runWithTimeout({ type: "test", slot: afterHooksSlot }, async () => {322          for (const fn of testInfo._onDidFinishTestFunctions)323            await fn();324        });325      } catch (error) {326        firstAfterHooksError = firstAfterHooksError ?? error;327      }328      try {329        if (shouldRunAfterEachHooks)330          await this._runEachHooksForSuites(reversedSuites, "afterEach", testInfo, afterHooksSlot);331      } catch (error) {332        firstAfterHooksError = firstAfterHooksError ?? error;333      }334      testInfo._tracing.didFinishTestFunctionAndAfterEachHooks();335      try {336        await this._fixtureRunner.teardownScope("test", testInfo, { type: "test", slot: afterHooksSlot });337      } catch (error) {338        firstAfterHooksError = firstAfterHooksError ?? error;339      }340      for (const suite of reversedSuites) {341        if (!nextSuites.has(suite) || testInfo._isFailure()) {342          try {343            await this._runAfterAllHooksForSuite(suite, testInfo);344          } catch (error) {345            firstAfterHooksError = firstAfterHooksError ?? error;346          }347        }348      }349      if (firstAfterHooksError)350        throw firstAfterHooksError;351    }).catch(() => {352    });353    if (testInfo._isFailure())354      this._isStopped = true;355    if (this._isStopped) {356      this._didRunFullCleanup = true;357      await testInfo._runAsStep({ title: "Worker Cleanup", category: "hook" }, async () => {358        let firstWorkerCleanupError;359        const teardownSlot = { timeout: this._project.project.timeout, elapsed: 0 };360        try {361          await this._fixtureRunner.teardownScope("test", testInfo, { type: "test", slot: teardownSlot });362        } catch (error) {363          firstWorkerCleanupError = firstWorkerCleanupError ?? error;364        }365        for (const suite of reversedSuites) {366          try {367            await this._runAfterAllHooksForSuite(suite, testInfo);368          } catch (error) {369            firstWorkerCleanupError = firstWorkerCleanupError ?? error;370          }371        }372        try {373          await this._fixtureRunner.teardownScope("worker", testInfo, { type: "teardown", slot: teardownSlot });374        } catch (error) {375          firstWorkerCleanupError = firstWorkerCleanupError ?? error;376        }377        if (firstWorkerCleanupError)378          throw firstWorkerCleanupError;379      }).catch(() => {380      });381    }382    const tracingSlot = { timeout: this._project.project.timeout, elapsed: 0 };383    await testInfo._runWithTimeout({ type: "test", slot: tracingSlot }, async () => {384      await testInfo._tracing.stopIfNeeded();385    }).catch(() => {386    });387    testInfo.duration = testInfo._timeoutManager.defaultSlot().elapsed + afterHooksSlot.elapsed | 0;388    this._currentTest = null;389    (0, import_globals.setCurrentTestInfo)(null);390    this.dispatchEvent("testEnd", buildTestEndPayload(testInfo));391    const preserveOutput = this._config.config.preserveOutput === "always" || this._config.config.preserveOutput === "failures-only" && testInfo._isFailure();392    if (!preserveOutput)393      await (0, import_utils.removeFolders)([testInfo.outputDir]);394  }395  _collectHooksAndModifiers(suite, type, testInfo) {396    const runnables = [];397    for (const modifier of suite._modifiers) {398      const modifierType = this._fixtureRunner.dependsOnWorkerFixturesOnly(modifier.fn, modifier.location) ? "beforeAll" : "beforeEach";399      if (modifierType !== type)400        continue;401      const fn = async (fixtures) => {402        const result = await modifier.fn(fixtures);403        testInfo._modifier(modifier.type, modifier.location, [!!result, modifier.description]);404      };405      (0, import_fixtures.inheritFixtureNames)(modifier.fn, fn);406      runnables.push({407        title: `${modifier.type} modifier`,408        location: modifier.location,409        type: modifier.type,410        fn411      });412    }413    runnables.push(...suite._hooks.filter((hook) => hook.type === type));414    return runnables;415  }416  async _runBeforeAllHooksForSuite(suite, testInfo) {417    if (this._activeSuites.has(suite))418      return;419    const extraAnnotations = [];420    this._activeSuites.set(suite, extraAnnotations);421    await this._runAllHooksForSuite(suite, testInfo, "beforeAll", extraAnnotations);422  }423  async _runAllHooksForSuite(suite, testInfo, type, extraAnnotations) {424    let firstError;425    for (const hook of this._collectHooksAndModifiers(suite, type, testInfo)) {426      try {427        await testInfo._runAsStep({ title: hook.title, category: "hook", location: hook.location }, async () => {428          const timeSlot = { timeout: this._project.project.timeout, elapsed: 0 };429          const runnable = { type: hook.type, slot: timeSlot, location: hook.location };430          const existingAnnotations = new Set(testInfo.annotations);431          try {432            await this._fixtureRunner.resolveParametersAndRunFunction(hook.fn, testInfo, "all-hooks-only", runnable);433          } finally {434            if (extraAnnotations) {435              const newAnnotations = testInfo.annotations.filter((a) => !existingAnnotations.has(a));436              extraAnnotations.push(...newAnnotations);437            }438            await this._fixtureRunner.teardownScope("test", testInfo, runnable);439          }440        });441      } catch (error) {442        firstError = firstError ?? error;443        if (type === "beforeAll" && error instanceof import_testInfo.TestSkipError)444          break;445        if (type === "beforeAll" && !this._skipRemainingTestsInSuite) {446          this._skipRemainingTestsInSuite = suite;447        }448      }449    }450    if (firstError)451      throw firstError;452  }453  async _runAfterAllHooksForSuite(suite, testInfo) {454    if (!this._activeSuites.has(suite))455      return;456    this._activeSuites.delete(suite);457    await this._runAllHooksForSuite(suite, testInfo, "afterAll");458  }459  async _runEachHooksForSuites(suites, type, testInfo, slot) {460    let firstError;461    const hooks = suites.map((suite) => this._collectHooksAndModifiers(suite, type, testInfo)).flat();462    for (const hook of hooks) {463      const runnable = { type: hook.type, location: hook.location, slot };464      if (testInfo._timeoutManager.isTimeExhaustedFor(runnable)) {465        continue;466      }467      try {468        await testInfo._runAsStep({ title: hook.title, category: "hook", location: hook.location }, async () => {469          await this._fixtureRunner.resolveParametersAndRunFunction(hook.fn, testInfo, "test", runnable);470        });471      } catch (error) {472        firstError = firstError ?? error;473        if (error instanceof import_testInfo.TestSkipError)474          break;475      }476    }477    if (firstError)478      throw firstError;479  }480}481function buildTestBeginPayload(testInfo) {482  return {483    testId: testInfo.testId,484    startWallTime: testInfo._startWallTime485  };486}487function buildTestEndPayload(testInfo) {488  return {489    testId: testInfo.testId,490    duration: testInfo.duration,491    status: testInfo.status,492    errors: testInfo.errors,493    hasNonRetriableError: testInfo._hasNonRetriableError,494    expectedStatus: testInfo.expectedStatus,495    annotations: testInfo.annotations,496    timeout: testInfo.timeout497  };498}499function getSuites(test) {500  const suites = [];501  for (let suite = test?.parent; suite; suite = suite.parent)502    suites.push(suite);503  suites.reverse();504  return suites;505}506function formatTestTitle(test, projectName) {507  const [, ...titles] = test.titlePath();508  const location = `${(0, import_util.relativeFilePath)(test.location.file)}:${test.location.line}:${test.location.column}`;509  const projectTitle = projectName ? `[${projectName}] \u203A ` : "";510  return `${projectTitle}${location} \u203A ${titles.join(" \u203A ")}`;511}512function calculateMaxTimeout(t1, t2) {513  return !t1 || !t2 ? 0 : Math.max(t1, t2);514}515const create = (params) => new WorkerMain(params);516// Annotate the CommonJS export names for ESM import in node:5170 && (module.exports = {518  WorkerMain,519  create520});521