cucumber.js

'use strict'

const { performance } = require('node:perf_hooks')

const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverage')
const shimmer = require('../../datadog-shimmer')
const log = require('../../dd-trace/src/log')
const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
const { getSegment } = require('../../dd-trace/src/util')
const {
  EMPTY_EFD_RETRY_POLICY,
  getEfdRetryCountForDuration,
  hasEfdRetries,
} = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
const {
  getCoveredFilesFromCoverage,
  getExecutableFilesFromCoverage,
  resetCoverage,
  mergeCoverage,
  fromCoverageMapToCoverage,
  getTestSuitePath,
  getRelativeCoverageFiles,
  CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
  CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE,
  getIsFaultyEarlyFlakeDetection,
  applySkippedCoverageToCoverage,
  getTestCoverageLinesPercentage,
  recordTestManagementExecution,
  recordAttemptToFixExecution,
  collectTestOptimizationSummariesFromTraces,
  logAttemptToFixTestExecution,
  logTestOptimizationSummary,
  TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
  getTestOptimizationRequestResults,
} = require('../../dd-trace/src/plugins/util/test')
const { writeCoverageBackfillToCache } = require('../../dd-trace/src/ci-visibility/test-optimization-cache')
const satisfies = require('../../../vendor/dist/semifies')
const { getChannelPromise } = require('./helpers/channel')
const { addHook, channel } = require('./helpers/instrument')

const cucumberWorkerThreadsPatchModule = require.resolve('./cucumber-worker-threads')

const testStartCh = channel('ci:cucumber:test:start')
const testRetryCh = channel('ci:cucumber:test:retry')
const testFinishCh = channel('ci:cucumber:test:finish') // used for test steps too
const testFnCh = channel('ci:cucumber:test:fn')

const testStepStartCh = channel('ci:cucumber:test-step:start')

const errorCh = channel('ci:cucumber:error')

const testSuiteStartCh = channel('ci:cucumber:test-suite:start')
const testSuiteFinishCh = channel('ci:cucumber:test-suite:finish')
const testSuiteCodeCoverageCh = channel('ci:cucumber:test-suite:code-coverage')

const libraryConfigurationCh = channel('ci:cucumber:library-configuration')
const knownTestsCh = channel('ci:cucumber:known-tests')
const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
const sessionStartCh = channel('ci:cucumber:session:start')
const sessionFinishCh = channel('ci:cucumber:session:finish')
const testManagementTestsCh = channel('ci:cucumber:test-management-tests')
const modifiedFilesCh = channel('ci:cucumber:modified-files')
const isModifiedCh = channel('ci:cucumber:is-modified-test')

const workerReportTraceCh = channel('ci:cucumber:worker-report:trace')
const workerReportTelemetryCh = channel('ci:cucumber:worker-report:telemetry')

const itrSkippedSuitesCh = channel('ci:cucumber:itr:skipped-suites')

const getCodeCoverageCh = channel('ci:nyc:get-coverage')

const DD_EFD_RETRY_COUNT_MESSAGE = '_ddEfdRetryCount'
const CUCUMBER_RETRY_NAME_SUFFIX = / ?\(attempt \d+(?:, retried)?\) ?$/

/**
 * Removes Cucumber's generated retry suffix without changing literal scenario names.
 *
 * @param {string} testName
 * @param {boolean} isRetry
 * @returns {string}
 */
function getCucumberTestName (testName, isRetry) {
  return isRetry ? testName.replace(CUCUMBER_RETRY_NAME_SUFFIX, '') : testName
}

const isMarkedAsUnskippable = (pickle) => {
  return pickle.tags.some(tag => tag.name === '@datadog:unskippable')
}

// We'll preserve the original coverage here
const originalCoverageMap = createCoverageMap()

// TODO: remove in a later major version
const patched = new WeakSet()
const patchedCucumberWorkers = new WeakSet()

const lastStatusByPickleId = new Map()
/** For ATR: statuses keyed by stable scenario id (uri:name) so retries accumulate correctly */
const atrStatusesByScenarioKey = new Map()
const numRetriesByPickleId = new Map()
const efdRetryCountByPickleId = new Map()
const efdSlowAbortedPickleIds = new Set()
const finishedParallelSuites = new Set()
const numAttemptToCtx = new Map()
const newTestsByTestFullname = new Map()
const attemptToFixTestsByTestFullname = new Map()
const modifiedTestsByPickleId = new Map()
const runnerToRetryState = new WeakMap()
// Pickle IDs for tests that are genuinely new (not in known tests list).
const newTestPickleIds = new Set()
const attemptToFixExecutions = new Map()
const loggedAttemptToFixTests = new Set()

let eventDataCollector = null
let pickleByFile = {}
const pickleResultByFile = {}

let skippableSuites = []
let skippableSuitesCoverage
let skippedSuitesCoverage = {}
let itrCorrelationId = ''
let isForcedToRun = false
let isUnskippable = false
let isItrEnabled = false
let isSuitesSkippingEnabled = false
let isCoverageReportUploadEnabled = false
let isEarlyFlakeDetectionEnabled = false
let earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
let earlyFlakeDetectionFaultyThreshold = 0
let isEarlyFlakeDetectionFaulty = false
let isFlakyTestRetriesEnabled = false
let isKnownTestsEnabled = false
let isTestManagementTestsEnabled = false
let isImpactedTestsEnabled = false
let testManagementAttemptToFixRetries = 0
let testManagementTests = {}
let modifiedFiles = {}
let numTestRetries = 0
let knownTests = {}
let skippedSuites = []
let isSuitesSkipped = false
let areAllSuitesSkipped = false
let repositoryRoot

/**
 * @returns {boolean}
 */
function shouldRunEarlyFlakeDetection () {
  return isEarlyFlakeDetectionEnabled && hasEfdRetries(earlyFlakeDetectionRetryPolicy)
}

function isValidKnownTests (receivedKnownTests) {
  return !!receivedKnownTests.cucumber
}

function isTiaCoverageBackfillEnabled () {
  return isItrEnabled && isCoverageReportUploadEnabled
}

function getCoverageRootDir () {
  return repositoryRoot || process.cwd()
}

function shouldReportCodeCoverageLinesPct (hasBackfilledCoverage) {
  return !isSuitesSkipped || hasBackfilledCoverage
}

function getSkippedSuitesCoverageForRun () {
  return isSuitesSkipped && isTiaCoverageBackfillEnabled() && skippableSuitesCoverage !== undefined
    ? skippableSuitesCoverage
    : {}
}

function applySkippedCoverageToCucumberCoverageMap () {
  if (!isTiaCoverageBackfillEnabled()) return false
  return applySkippedCoverageToCoverage(originalCoverageMap, skippedSuitesCoverage, getCoverageRootDir())
}

function getCucumberTestSessionCoverageFiles () {
  return getRelativeCoverageFiles(getExecutableFilesFromCoverage(originalCoverageMap), getCoverageRootDir())
}

function resetSuiteSkippingRunState () {
  skippableSuites = []
  skippableSuitesCoverage = undefined
  skippedSuitesCoverage = {}
  skippedSuites = []
  isSuitesSkipped = false
  areAllSuitesSkipped = false
  repositoryRoot = undefined
  writeCoverageBackfillToCache({})
}

function getSuiteStatusFromTestStatuses (testStatuses) {
  if (testStatuses.includes('fail')) {
    return 'fail'
  }
  if (testStatuses.every(status => status === 'skip')) {
    return 'skip'
  }
  return 'pass'
}

function publishWorkerEfdRetryCount (pickle, retryCount) {
  const message = {
    [DD_EFD_RETRY_COUNT_MESSAGE]: {
      pickleId: pickle.id,
      retryCount,
      testFileAbsolutePath: pickle.uri,
      testName: pickle.name,
    },
  }

  if (typeof process.send === 'function') {
    try {
      process.send(message)
    } catch {
      // ignore IPC errors
    }
    return
  }

  try {
    const { isMainThread, parentPort } = require('node:worker_threads')
    if (isMainThread || !parentPort) return

    parentPort.postMessage(message)
  } catch {
    // ignore IPC errors
  }
}

function configureParallelWorkerWorldParameters (options) {
  options.worldParameters ??= {}

  if (isKnownTestsEnabled && isValidKnownTests(knownTests)) {
    options.worldParameters._ddIsKnownTestsEnabled = true
    options.worldParameters._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
    options.worldParameters._ddKnownTests = knownTests
    options.worldParameters._ddEarlyFlakeDetectionRetryPolicy = earlyFlakeDetectionRetryPolicy
  } else {
    isEarlyFlakeDetectionEnabled = false
    isKnownTestsEnabled = false
    options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
    options.worldParameters._ddIsKnownTestsEnabled = false
    options.worldParameters._ddEarlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
  }

  if (isImpactedTestsEnabled) {
    options.worldParameters._ddImpactedTestsEnabled = isImpactedTestsEnabled
    options.worldParameters._ddModifiedFiles = modifiedFiles
  }

  options.worldParameters._ddIsFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
  options.worldParameters._ddNumTestRetries = numTestRetries

  if (isTestManagementTestsEnabled) {
    options.worldParameters._ddIsTestManagementTestsEnabled = true
    options.worldParameters._ddTestManagementTests = testManagementTests
    options.worldParameters._ddTestManagementAttemptToFixRetries = testManagementAttemptToFixRetries
  }
}

function readParallelWorkerWorldParameters (options) {
  const worldParameters = options?.worldParameters
  if (!worldParameters) return

  isKnownTestsEnabled = !!worldParameters._ddIsKnownTestsEnabled
  if (isKnownTestsEnabled) {
    knownTests = worldParameters._ddKnownTests
    // if for whatever reason the worker does not receive valid known tests, we disable EFD and known tests
    if (!isValidKnownTests(knownTests)) {
      isKnownTestsEnabled = false
      knownTests = {}
    }
  }
  isEarlyFlakeDetectionEnabled = !!worldParameters._ddIsEarlyFlakeDetectionEnabled
  earlyFlakeDetectionRetryPolicy = isEarlyFlakeDetectionEnabled
    ? worldParameters._ddEarlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
    : EMPTY_EFD_RETRY_POLICY
  isImpactedTestsEnabled = !!worldParameters._ddImpactedTestsEnabled
  if (isImpactedTestsEnabled) {
    modifiedFiles = worldParameters._ddModifiedFiles
  }
  isFlakyTestRetriesEnabled = !!worldParameters._ddIsFlakyTestRetriesEnabled
  numTestRetries = worldParameters._ddNumTestRetries ?? 0
  isTestManagementTestsEnabled = !!worldParameters._ddIsTestManagementTestsEnabled
  if (isTestManagementTestsEnabled) {
    testManagementTests = worldParameters._ddTestManagementTests
    testManagementAttemptToFixRetries = worldParameters._ddTestManagementAttemptToFixRetries
  }
}

function handleDdWorkerMessage (message) {
  if (Array.isArray(message)) {
    const [messageCode, payload] = message
    if (messageCode === CUCUMBER_WORKER_TRACE_PAYLOAD_CODE) {
      collectTestOptimizationSummariesFromTraces(payload, { attemptToFixExecutions })
      workerReportTraceCh.publish(payload)
      return true
    }
    if (messageCode === CUCUMBER_WORKER_TELEMETRY_PAYLOAD_CODE) {
      workerReportTelemetryCh.publish(payload)
      return true
    }
  }

  if (message?.[DD_EFD_RETRY_COUNT_MESSAGE]) {
    handleEfdRetryCountMessage(message[DD_EFD_RETRY_COUNT_MESSAGE])
    return true
  }

  return false
}

function onCucumberWorkerThreadMessage (message) {
  if (!testSuiteFinishCh.hasSubscribers) return

  handleDdWorkerMessage(message)
}

function registerWorkerThreadMessageHandlers (workers) {
  if (!workers) return

  for (const worker of workers) {
    worker.workerThread.on('message', onCucumberWorkerThreadMessage)
  }
}

function registerWorkerThreadPatchModule (supportCodeLibrary) {
  const requireModules = supportCodeLibrary?.originalCoordinates?.requireModules
  if (!Array.isArray(requireModules) || requireModules.includes(cucumberWorkerThreadsPatchModule)) return

  requireModules.unshift(cucumberWorkerThreadsPatchModule)
}

function getRunningAssembledTestCase (adapter, worker) {
  const command = adapter.running?.get(worker)
  return command?.assembledTestCase
}

function maybeStartParallelSuite (pickle) {
  if (!pickle) return

  const testFileAbsolutePath = pickle.uri
  if (pickleResultByFile[testFileAbsolutePath]) return

  pickleResultByFile[testFileAbsolutePath] = []
  testSuiteStartCh.publish({
    testFileAbsolutePath,
  })
}

function handleParallelTestCaseFinished (pickle, worstTestStepResult, usesNumericStatus = false) {
  const { status } = usesNumericStatus
    ? getStatusFromResult(worstTestStepResult)
    : getStatusFromResultLatest(worstTestStepResult)
  let isNew = false

  if (isKnownTestsEnabled) {
    isNew = isNewTest(pickle.uri, pickle.name)
  }

  const testFileAbsolutePath = pickle.uri
  const finished = (pickleResultByFile[testFileAbsolutePath] ||= [])

  if (shouldRunEarlyFlakeDetection() && isNew) {
    const testFullname = `${pickle.uri}:${pickle.name}`
    let testStatuses = newTestsByTestFullname.get(testFullname)
    if (testStatuses) {
      testStatuses.push(status)
    } else {
      testStatuses = [status]
      newTestsByTestFullname.set(testFullname, testStatuses)
    }
    let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
    if (efdRetryCount === undefined) {
      efdRetryCount = status === 'skip'
        ? 0
        : earlyFlakeDetectionRetryPolicy.schedulingRetryCount
      efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
      if (efdRetryCount === 0 && status !== 'skip') {
        efdSlowAbortedPickleIds.add(pickle.id)
      }
    }
    maybeRecordFinalParallelEfdStatus({ pickleId: pickle.id, testFileAbsolutePath, testFullname })
  } else if (
    isTestManagementTestsEnabled &&
    getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
  ) {
    const testFullname = `${pickle.uri}:${pickle.name}`
    let testStatuses = attemptToFixTestsByTestFullname.get(testFullname)
    if (testStatuses) {
      testStatuses.push(status)
    } else {
      testStatuses = [status]
      attemptToFixTestsByTestFullname.set(testFullname, testStatuses)
    }

    if (status === 'skip' || testStatuses.length === testManagementAttemptToFixRetries + 1) {
      finished.push(getTestStatusFromAttemptToFixExecutions(testStatuses))
      attemptToFixTestsByTestFullname.delete(testFullname)
    }
  } else {
    // TODO: can we get error message?
    finished.push(status)
  }

  finishParallelSuiteIfDone(testFileAbsolutePath)
}

function getWrappedHandleWorkerThreadEvent (handleEventFromWorker) {
  return function (worker, event) {
    if (!testSuiteFinishCh.hasSubscribers) {
      return handleEventFromWorker.apply(this, arguments)
    }

    if (handleDdWorkerMessage(event)) return

    const envelope = event?.type === 'ENVELOPE' && event.envelope
    if (!envelope) {
      return handleEventFromWorker.apply(this, arguments)
    }

    const assembledTestCase = getRunningAssembledTestCase(this, worker)

    if (envelope.testCaseStarted) {
      maybeStartParallelSuite(assembledTestCase?.pickle)
    }

    const result = handleEventFromWorker.apply(this, arguments)

    if (envelope.testCaseFinished && assembledTestCase?.pickle && eventDataCollector) {
      const worstTestStepResult =
        eventDataCollector.getTestCaseAttempt(envelope.testCaseFinished.testCaseStartedId).worstTestStepResult
      handleParallelTestCaseFinished(assembledTestCase.pickle, worstTestStepResult)
    }

    return result
  }
}

function getWrappedWorkerThreadsSetup (setup) {
  return async function () {
    if (testSuiteFinishCh.hasSubscribers) {
      configureParallelWorkerWorldParameters(this.options)
      registerWorkerThreadPatchModule(this.supportCodeLibrary)
    }

    const result = await setup.apply(this, arguments)

    if (testSuiteFinishCh.hasSubscribers) {
      registerWorkerThreadMessageHandlers(this.workers)
    }

    return result
  }
}

function getWrappedWorkerThreadsTeardown (teardown) {
  return function () {
    if (testSuiteFinishCh.hasSubscribers && this.workers) {
      for (const worker of this.workers) {
        worker.workerThread.removeListener('message', onCucumberWorkerThreadMessage)
      }
    }

    return teardown.apply(this, arguments)
  }
}

function finishParallelSuiteIfDone (testFileAbsolutePath) {
  const finished = pickleResultByFile[testFileAbsolutePath]
  const expectedPickles = pickleByFile[testFileAbsolutePath]

  if (!finished || !expectedPickles || finished.length !== expectedPickles.length) return
  if (finishedParallelSuites.has(testFileAbsolutePath)) return

  finishedParallelSuites.add(testFileAbsolutePath)
  testSuiteFinishCh.publish({
    status: getSuiteStatusFromTestStatuses(finished),
    testSuitePath: getTestSuitePath(testFileAbsolutePath, process.cwd()),
  })
}

function maybeRecordFinalParallelEfdStatus ({ pickleId, testFileAbsolutePath, testFullname }) {
  const efdRetryCount = efdRetryCountByPickleId.get(pickleId)
  const testStatuses = newTestsByTestFullname.get(testFullname)
  const finished = pickleResultByFile[testFileAbsolutePath]

  if (efdRetryCount === undefined || !testStatuses || !finished) return
  if (testStatuses.length !== efdRetryCount + 1) return

  finished.push(getTestStatusFromRetries(testStatuses))
  newTestsByTestFullname.delete(testFullname)
  finishParallelSuiteIfDone(testFileAbsolutePath)
}

function handleEfdRetryCountMessage (message) {
  const { pickleId, retryCount, testFileAbsolutePath, testName } = message

  if (!pickleId || typeof retryCount !== 'number' || !testFileAbsolutePath || !testName) return

  efdRetryCountByPickleId.set(pickleId, retryCount)
  maybeRecordFinalParallelEfdStatus({
    pickleId,
    testFileAbsolutePath,
    testFullname: `${testFileAbsolutePath}:${testName}`,
  })
}

function getStatusFromResult (result) {
  if (result.status === 1) {
    return { status: 'pass' }
  }
  if (result.status === 2) {
    return { status: 'skip' }
  }
  if (result.status === 4) {
    return { status: 'skip', skipReason: 'not implemented' }
  }
  return { status: 'fail', errorMessage: result.message }
}

function getStatusFromResultLatest (result) {
  if (result.status === 'PASSED') {
    return { status: 'pass' }
  }
  if (result.status === 'SKIPPED' || result.status === 'PENDING') {
    return { status: 'skip' }
  }
  if (result.status === 'UNDEFINED') {
    return { status: 'skip', skipReason: 'not implemented' }
  }
  return { status: 'fail', errorMessage: result.message }
}

function isNewTest (testSuite, testName) {
  if (!isValidKnownTests(knownTests)) {
    return false
  }
  const testsForSuite = knownTests.cucumber[testSuite] || []
  return !testsForSuite.includes(testName)
}

function getTestProperties (testSuite, testName) {
  const { attempt_to_fix: attemptToFix, disabled, quarantined } =
    testManagementTests?.cucumber?.suites?.[testSuite]?.tests?.[testName]?.properties || {}

  return { attemptToFix, disabled, quarantined }
}

function getTestStatusFromRetries (testStatuses) {
  if (testStatuses.every(status => status === 'fail')) {
    return 'fail'
  }
  if (testStatuses.includes('pass')) {
    return 'pass'
  }
  return 'pass'
}

function getTestStatusFromAttemptToFixExecutions (testStatuses) {
  if (testStatuses.every(status => status === 'pass')) {
    return 'pass'
  }
  if (testStatuses.every(status => status === 'skip')) {
    return 'skip'
  }
  return 'fail'
}

function getErrorFromCucumberResult (cucumberResult) {
  if (!cucumberResult.message) {
    return
  }

  const error = new Error(getSegment(cucumberResult.message, '\n', 0))
  if (cucumberResult.exception) {
    error.type = cucumberResult.exception.type
  }
  error.stack = cucumberResult.message
  return error
}

function getShouldBeSkippedSuite (pickle, suitesToSkip) {
  const testSuitePath = getTestSuitePath(pickle.uri, process.cwd())
  const isUnskippable = isMarkedAsUnskippable(pickle)
  const isSkipped = suitesToSkip.includes(testSuitePath)

  return [isSkipped && !isUnskippable, testSuitePath]
}

// From cucumber@>=11
function getFilteredPicklesNew (coordinator, suitesToSkip) {
  return coordinator.sourcedPickles.reduce((acc, sourcedPickle) => {
    const { pickle } = sourcedPickle
    const [shouldBeSkipped, testSuitePath] = getShouldBeSkippedSuite(pickle, suitesToSkip)

    if (shouldBeSkipped) {
      acc.skippedSuites.add(testSuitePath)
    } else {
      acc.picklesToRun.push(sourcedPickle)
    }
    return acc
  }, { skippedSuites: new Set(), picklesToRun: [] })
}

function getFilteredPickles (runtime, suitesToSkip) {
  return runtime.pickleIds.reduce((acc, pickleId) => {
    const pickle = runtime.eventDataCollector.getPickle(pickleId)
    const [shouldBeSkipped, testSuitePath] = getShouldBeSkippedSuite(pickle, suitesToSkip)

    if (shouldBeSkipped) {
      acc.skippedSuites.add(testSuitePath)
    } else {
      acc.picklesToRun.push(pickleId)
    }
    return acc
  }, { skippedSuites: new Set(), picklesToRun: [] })
}

// From cucumber@>=11
function getPickleByFileNew (coordinator) {
  return coordinator.sourcedPickles.reduce((acc, { pickle }) => {
    if (acc[pickle.uri]) {
      acc[pickle.uri].push(pickle)
    } else {
      acc[pickle.uri] = [pickle]
    }
    return acc
  }, {})
}

function getPickleByFile (runtimeOrCoodinator) {
  return runtimeOrCoodinator.pickleIds.reduce((acc, pickleId) => {
    const test = runtimeOrCoodinator.eventDataCollector.getPickle(pickleId)
    if (acc[test.uri]) {
      acc[test.uri].push(test)
    } else {
      acc[test.uri] = [test]
    }
    return acc
  }, {})
}

function getFinalStatus ({
  status,
  hasFailedAllRetries,
  isLastAtrRetry,
  isLastEfdRetry,
  isLastAttemptToFix,
  hasPassedAllRetries,
  isQuarantined,
  isDisabled,
}) {
  // Note that intermediate executions DO NOT report a final status tag

  // If the test is quarantined or disabled, its final status is skip unless attempt-to-fix takes precedence.
  if (status === 'skip' || (!isLastAttemptToFix && (isQuarantined || isDisabled))) {
    return 'skip'
  }

  // When no retry feature is active, every execution is final
  if (!isLastAtrRetry && !isLastEfdRetry && !isLastAttemptToFix) {
    return status
  }

  // ATR and EFD: pass unless every attempt failed
  if (isLastAtrRetry || isLastEfdRetry) {
    return hasFailedAllRetries ? 'fail' : 'pass'
  }

  // Branch for ATF (We need to check hasPassedAllRetries)
  if (isLastAttemptToFix) {
    return hasPassedAllRetries ? 'pass' : 'fail'
  }
}

async function handleRetriedAttempt (runner, state) {
  const { promises } = state
  if (promises.hitBreakpointPromise) {
    await promises.hitBreakpointPromise
  }

  const setProbePromise = publishRetriedAttempt(runner, state)
  if (setProbePromise) {
    await setProbePromise
    promises.setProbePromise = undefined
  }

  startRetriedAttempt(state)
}

function handleRetriedAttemptFromEnvelope (runner, state) {
  publishRetriedAttempt(runner, state)
  startRetriedAttempt(state)
}

function publishRetriedAttempt (runner, state) {
  const { promises } = state
  let error
  try {
    const cucumberResult = runner.getWorstStepResult()
    error = getErrorFromCucumberResult(cucumberResult)
  } catch {
    // ignore error
  }

  const currentAttempt = state.numAttempt
  const nextAttempt = currentAttempt + 1
  const failedAttemptCtx = numAttemptToCtx.get(currentAttempt)
  const isFirstAttempt = currentAttempt === 0
  const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled

  // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
  if (isFlakyTestRetriesEnabled) {
    const nameForKey = getCucumberTestName(runner.pickle.name, currentAttempt > 0)
    const atrKey = `${runner.pickle.uri}:${nameForKey}`
    if (atrStatusesByScenarioKey.has(atrKey)) {
      atrStatusesByScenarioKey.get(atrKey).push('fail')
    } else {
      atrStatusesByScenarioKey.set(atrKey, ['fail'])
    }
  }

  // the current span will be finished and a new one will be created
  testRetryCh.publish({
    isFirstAttempt,
    error,
    isAtrRetry,
    promises,
    canWaitForDi: state.testStartPayload.canWaitForDi,
    ...failedAttemptCtx.currentStore,
  })

  state.numAttempt = nextAttempt
  return promises.setProbePromise
}

function startRetriedAttempt (state) {
  const { promises, testStartPayload } = state
  const newCtx = { ...testStartPayload, promises }
  numAttemptToCtx.set(state.numAttempt, newCtx)

  testStartCh.runStores(newCtx, () => {})
}

function wrapRun (pl, isLatestVersion, version) {
  if (patched.has(pl)) return

  patched.add(pl)

  const canAwaitRetries = typeof pl.prototype.runAttempt === 'function'
  if (canAwaitRetries) {
    shimmer.wrap(pl.prototype, 'runAttempt', runAttempt => async function (...args) {
      const willBeRetried = await runAttempt.apply(this, args)
      const state = runnerToRetryState.get(this)
      if (willBeRetried && state) {
        await handleRetriedAttempt(this, state)
      }
      return willBeRetried
    })
  }

  shimmer.wrap(pl.prototype, 'run', run => function (...args) {
    if (!testFinishCh.hasSubscribers) {
      return run.apply(this, args)
    }

    const testFileAbsolutePath = this.pickle.uri
    const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())

    const testSourceLine = this.gherkinDocument?.feature?.location?.line

    const testStartPayload = {
      testName: this.pickle.name,
      testFileAbsolutePath,
      testSourceLine,
      isParallel: !!getEnvironmentVariable('CUCUMBER_WORKER_ID'),
      // Older Cucumber runners do not expose an awaited retry boundary. Failed Test Replay
      // intentionally skips DI setup there instead of bringing back the synchronous wait.
      canWaitForDi: canAwaitRetries,
    }
    const ctx = testStartPayload
    const promises = {}
    const state = { numAttempt: 0, promises, testStartPayload }
    numAttemptToCtx.set(state.numAttempt, ctx)
    runnerToRetryState.set(this, state)
    if (isTestManagementTestsEnabled && getTestProperties(testSuitePath, this.pickle.name).attemptToFix) {
      logAttemptToFixTestExecution(testSuitePath, this.pickle.name, loggedAttemptToFixTests)
    }
    testStartCh.runStores(ctx, () => {})
    try {
      const onEnvelope = (testCase) => {
        if (canAwaitRetries) return

        // Only supported from >=8.0.0
        if (testCase?.testCaseFinished) {
          const { testCaseFinished: { willBeRetried } } = testCase
          if (willBeRetried) { // test case failed and will be retried
            handleRetriedAttemptFromEnvelope(this, state)
          }
        }
      }
      if (!canAwaitRetries) {
        this.eventBroadcaster.on('envelope', onEnvelope)
      }
      let promise
      const executionStart = performance.now()

      testFnCh.runStores(ctx, () => {
        promise = run.apply(this, args)
      })
      const finalize = async () => {
        if (!canAwaitRetries) {
          this.eventBroadcaster.removeListener('envelope', onEnvelope)
        }
        runnerToRetryState.delete(this)
        const result = this.getWorstStepResult()
        const { status, skipReason } = isLatestVersion
          ? getStatusFromResultLatest(result)
          : getStatusFromResult(result)
        const testName = getCucumberTestName(this.pickle.name, state.numAttempt > 0)

        if (lastStatusByPickleId.has(this.pickle.id)) {
          lastStatusByPickleId.get(this.pickle.id).push(status)
        } else {
          lastStatusByPickleId.set(this.pickle.id, [status])
        }
        let isNew = false
        let isEfdRetry = false
        let isAttemptToFix = false
        let isAttemptToFixRetry = false
        let hasFailedAllRetries = false
        let hasPassedAllRetries = false
        let hasFailedAttemptToFix = false
        let isDisabled = false
        let isQuarantined = false
        let isModified = false

        if (isTestManagementTestsEnabled) {
          const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
          const testProperties = getTestProperties(testSuitePath, testName)
          const numRetries = numRetriesByPickleId.get(this.pickle.id)
          isAttemptToFix = testProperties.attemptToFix
          isAttemptToFixRetry = isAttemptToFix && numRetries > 0
          isDisabled = testProperties.disabled
          isQuarantined = testProperties.quarantined

          if (isAttemptToFixRetry) {
            const statuses = lastStatusByPickleId.get(this.pickle.id)
            if (statuses.length === testManagementAttemptToFixRetries + 1) {
              const { pass, fail } = statuses.reduce((acc, status) => {
                acc[status]++
                return acc
              }, { pass: 0, fail: 0 })
              hasFailedAllRetries = fail === testManagementAttemptToFixRetries + 1
              hasPassedAllRetries = pass === testManagementAttemptToFixRetries + 1
              hasFailedAttemptToFix = fail > 0
            }
          }
        }

        const numRetries = numRetriesByPickleId.get(this.pickle.id)

        if (isImpactedTestsEnabled) {
          isModified = modifiedTestsByPickleId.get(this.pickle.id)
        }

        if (isKnownTestsEnabled && status !== 'skip') {
          isNew = newTestPickleIds.has(this.pickle.id)
        }

        if (isNew || isModified) {
          isEfdRetry = numRetries > 0
        }

        if (
          shouldRunEarlyFlakeDetection() &&
          status !== 'skip' &&
          (isNew || isModified) &&
          !isEfdRetry &&
          !efdRetryCountByPickleId.has(this.pickle.id)
        ) {
          const retryCount = getEfdRetryCountForDuration(
            performance.now() - executionStart,
            earlyFlakeDetectionRetryPolicy
          )
          efdRetryCountByPickleId.set(this.pickle.id, retryCount)
          if (retryCount === 0) {
            efdSlowAbortedPickleIds.add(this.pickle.id)
          }
        }

        const efdRetryCount = efdRetryCountByPickleId.get(this.pickle.id) ??
          earlyFlakeDetectionRetryPolicy.schedulingRetryCount

        // Check if all EFD retries failed
        if (isEfdRetry && (isNew || isModified)) {
          const statuses = lastStatusByPickleId.get(this.pickle.id)
          if (statuses.length === efdRetryCount + 1) {
            const { fail } = statuses.reduce((acc, status) => {
              acc[status]++
              return acc
            }, { pass: 0, fail: 0 })
            if (fail === efdRetryCount + 1) {
              hasFailedAllRetries = true
            }
          }
        }

        // ATR: accumulate statuses by stable scenario key (uri:name) so retries are grouped.
        // Cucumber appends " (attempt N)" or " (attempt N, retried)" to the scenario name; normalize for keying.
        if (isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0) {
          const atrKey = `${this.pickle.uri}:${testName}`
          if (atrStatusesByScenarioKey.has(atrKey)) {
            atrStatusesByScenarioKey.get(atrKey).push(status)
          } else {
            atrStatusesByScenarioKey.set(atrKey, [status])
          }
          const atrStatuses = atrStatusesByScenarioKey.get(atrKey)
          const pickleStatuses = lastStatusByPickleId.get(this.pickle.id)
          const statusesToCheck = atrStatuses?.length >= (numTestRetries + 1) ? atrStatuses : pickleStatuses
          if (statusesToCheck && statusesToCheck.length === numTestRetries + 1 &&
            statusesToCheck.every(s => s === 'fail')) {
            hasFailedAllRetries = true
          }
        }

        const attemptCtx = numAttemptToCtx.get(state.numAttempt)

        const error = getErrorFromCucumberResult(result)

        if (!testStartPayload.isParallel) {
          recordTestManagementExecution({
            testSuite: testSuitePath,
            testName,
            status,
            isAttemptToFix,
            isDisabled,
            isQuarantined,
          })
        }

        if (isAttemptToFix) {
          recordAttemptToFixExecution(attemptToFixExecutions, {
            testSuite: testSuitePath,
            testName,
            status,
            isDisabled,
            isQuarantined,
          })
        }

        if (promises.hitBreakpointPromise) {
          await promises.hitBreakpointPromise
        }

        // Notice that ATR is handled using cucumber native retries features.
        // Therefore, if we reach this point, we are certain that it's the last ATR execution
        const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0

        const statuses = lastStatusByPickleId.get(this.pickle.id)
        const isLastEfdRetry = isEfdRetry && statuses?.length === efdRetryCount + 1
        const isLastAttemptToFixRetry = isAttemptToFix && statuses?.length === testManagementAttemptToFixRetries + 1

        // Intermediate (non-last EFD or ATF retries) executions do not report a final status
        const isIntermediateExecution = (isEfdRetry && !isLastEfdRetry) || (isAttemptToFix && !isLastAttemptToFixRetry)

        const finalStatus = isIntermediateExecution
          ? undefined
          : getFinalStatus({
            status,
            hasFailedAllRetries,
            isLastAtrRetry,
            isLastEfdRetry,
            isLastAttemptToFix: isLastAttemptToFixRetry,
            hasPassedAllRetries,
            isQuarantined,
            isDisabled,
          })

        testFinishCh.publish({
          status,
          skipReason,
          error,
          isNew,
          isEfdRetry,
          isFlakyRetry: state.numAttempt > 0 && isFlakyTestRetriesEnabled,
          isExternalRetry: state.numAttempt > 0 && !isFlakyTestRetriesEnabled,
          isAttemptToFix,
          isAttemptToFixRetry,
          hasFailedAllRetries,
          hasPassedAllRetries,
          hasFailedAttemptToFix,
          isDisabled,
          isQuarantined,
          isModified,
          earlyFlakeAbortReason: efdSlowAbortedPickleIds.has(this.pickle.id) ? 'slow' : undefined,
          ...attemptCtx.currentStore,
          finalStatus,
        })
      }
      promise.then(finalize, finalize).catch(error => {
        log.error('Cucumber test finalization error', error)
      })
      return promise
    } catch (err) {
      ctx.err = err
      errorCh.runStores(ctx, () => {
        throw err
      })
    }
  })
  shimmer.wrap(pl.prototype, 'runStep', runStep => function (...args) {
    if (!testFinishCh.hasSubscribers) {
      return runStep.apply(this, args)
    }
    const testStep = args[0]
    let resource

    if (isLatestVersion) {
      resource = testStep.text
    } else {
      resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
    }

    const ctx = { resource }
    return testStepStartCh.runStores(ctx, () => {
      try {
        const promise = runStep.apply(this, args)

        promise.then((result) => {
          const finalResult = satisfies(version, '>=12.0.0') ? result.result : result
          const getStatus = satisfies(version, '>=7.3.0') ? getStatusFromResultLatest : getStatusFromResult

          const { status, skipReason, errorMessage } = getStatus(finalResult)

          testFinishCh.publish({ isStep: true, status, skipReason, errorMessage, ...ctx.currentStore })
        })
        return promise
      } catch (err) {
        ctx.err = err
        errorCh.runStores(ctx, () => {
          throw err
        })
      }
    })
  })
}

function pickleHook (PickleRunner, version) {
  const pl = PickleRunner.default

  wrapRun(pl, false, version)

  return PickleRunner
}

function testCaseHook (TestCaseRunner, version) {
  const pl = TestCaseRunner.default

  wrapRun(pl, true, version)

  return TestCaseRunner
}

// Valid for old and new cucumber versions
function getCucumberOptions (adapterOrCoordinator) {
  if (adapterOrCoordinator.adapter) {
    return adapterOrCoordinator.adapter.worker?.options ||
      adapterOrCoordinator.adapter.executor?.options ||
      adapterOrCoordinator.adapter.options
  }
  return adapterOrCoordinator.options
}

function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordinator = false) {
  return async function () {
    if (!libraryConfigurationCh.hasSubscribers) {
      return start.apply(this, arguments)
    }
    resetSuiteSkippingRunState()
    const options = getCucumberOptions(this)

    if (!isParallel && this.adapter?.options) {
      isParallel = options.parallel > 0
    }
    let errorSkippableRequest

    const configurationResponse = await getChannelPromise(libraryConfigurationCh, { frameworkVersion }) || {}

    repositoryRoot = configurationResponse.repositoryRoot
    isItrEnabled = configurationResponse.libraryConfig?.isItrEnabled
    isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
    earlyFlakeDetectionRetryPolicy = configurationResponse.libraryConfig?.earlyFlakeDetectionRetryPolicy ??
      EMPTY_EFD_RETRY_POLICY
    earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
    isSuitesSkippingEnabled = isItrEnabled && configurationResponse.libraryConfig?.isSuitesSkippingEnabled
    isCoverageReportUploadEnabled = configurationResponse.libraryConfig?.isCoverageReportUploadEnabled
    isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
    const configRetryCount = configurationResponse.libraryConfig?.flakyTestRetriesCount
    numTestRetries = (typeof configRetryCount === 'number' && configRetryCount > 0) ? configRetryCount : 0
    isKnownTestsEnabled = configurationResponse.libraryConfig?.isKnownTestsEnabled
    isTestManagementTestsEnabled = configurationResponse.libraryConfig?.isTestManagementEnabled
    testManagementAttemptToFixRetries = configurationResponse.libraryConfig?.testManagementAttemptToFixRetries
    isImpactedTestsEnabled = configurationResponse.libraryConfig?.isImpactedTestsEnabled

    const {
      knownTestsResponse,
      testManagementTestsResponse,
      skippableSuitesResponse,
    } = await getTestOptimizationRequestResults({
      isKnownTestsEnabled,
      isTestManagementTestsEnabled,
      isSuitesSkippingEnabled,
      getKnownTests: () => getChannelPromise(knownTestsCh),
      getTestManagementTests: () => getChannelPromise(testManagementTestsCh),
      getSkippableSuites: () => getChannelPromise(skippableSuitesCh),
    })

    if (isKnownTestsEnabled) {
      const currentKnownTestsResponse = knownTestsResponse || await getChannelPromise(knownTestsCh)
      if (!currentKnownTestsResponse || currentKnownTestsResponse.err) {
        isEarlyFlakeDetectionEnabled = false
        isKnownTestsEnabled = false
      } else {
        knownTests = currentKnownTestsResponse.knownTests
      }
    }

    if (isSuitesSkippingEnabled) {
      const skippableResponse = skippableSuitesResponse ||
        await getChannelPromise(skippableSuitesCh) ||
        { err: true }

      errorSkippableRequest = skippableResponse.err
      skippableSuites = skippableResponse.skippableSuites ?? []
      skippableSuitesCoverage = skippableResponse.skippableSuitesCoverage

      if (!errorSkippableRequest) {
        const filteredPickles = isCoordinator
          ? getFilteredPicklesNew(this, skippableSuites)
          : getFilteredPickles(this, skippableSuites)

        const { picklesToRun } = filteredPickles
        const oldPickles = isCoordinator ? this.sourcedPickles : this.pickleIds

        isSuitesSkipped = picklesToRun.length !== oldPickles.length
        areAllSuitesSkipped = oldPickles.length > 0 && picklesToRun.length === 0

        log.debug('%s out of %s suites are going to run.', picklesToRun.length, oldPickles.length)

        if (isCoordinator) {
          this.sourcedPickles = picklesToRun
        } else {
          this.pickleIds = picklesToRun
        }

        skippedSuites = [...filteredPickles.skippedSuites]
        skippedSuitesCoverage = getSkippedSuitesCoverageForRun()
        writeCoverageBackfillToCache(skippedSuitesCoverage, getCoverageRootDir())
        itrCorrelationId = skippableResponse.itrCorrelationId
      }
    }

    pickleByFile = isCoordinator ? getPickleByFileNew(this) : getPickleByFile(this)

    if (isKnownTestsEnabled) {
      const isFaulty = !isValidKnownTests(knownTests) || getIsFaultyEarlyFlakeDetection(
        Object.keys(pickleByFile),
        knownTests.cucumber,
        earlyFlakeDetectionFaultyThreshold
      )
      if (isFaulty) {
        isEarlyFlakeDetectionEnabled = false
        isKnownTestsEnabled = false
        isEarlyFlakeDetectionFaulty = true
      }
    }

    if (isTestManagementTestsEnabled) {
      const currentTestManagementTestsResponse =
        testManagementTestsResponse || await getChannelPromise(testManagementTestsCh)
      if (!currentTestManagementTestsResponse || currentTestManagementTestsResponse.err) {
        isTestManagementTestsEnabled = false
      } else {
        testManagementTests = currentTestManagementTestsResponse.testManagementTests
      }
    }

    if (isImpactedTestsEnabled) {
      const impactedTestsResponse = await getChannelPromise(modifiedFilesCh)
      if (impactedTestsResponse && !impactedTestsResponse.err) {
        modifiedFiles = impactedTestsResponse.modifiedFiles
      }
    }

    const processArgv = process.argv.slice(2).join(' ')
    const command = getEnvironmentVariable('npm_lifecycle_script') || `cucumber-js ${processArgv}`

    if (isFlakyTestRetriesEnabled && !options.retry && numTestRetries > 0) {
      options.retry = numTestRetries
    }

    atrStatusesByScenarioKey.clear()
    attemptToFixTestsByTestFullname.clear()
    efdRetryCountByPickleId.clear()
    efdSlowAbortedPickleIds.clear()
    finishedParallelSuites.clear()
    newTestsByTestFullname.clear()
    sessionStartCh.publish({ command, frameworkVersion })

    if (!errorSkippableRequest && skippedSuites.length) {
      itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
    }

    let result
    try {
      result = await start.apply(this, arguments)
    } catch (error) {
      try {
        await getChannelPromise(sessionFinishCh, {
          status: 'fail',
          error,
          isSuitesSkipped,
          numSkippedSuites: skippedSuites.length,
          hasUnskippableSuites: isUnskippable,
          hasForcedToRunSuites: isForcedToRun,
          isEarlyFlakeDetectionEnabled,
          isEarlyFlakeDetectionFaulty,
          isTestManagementTestsEnabled,
          isParallel,
        })
      } catch (finalizationError) {
        log.error('Cucumber test session finalization error: %s', finalizationError)
      }
      throw error
    }
    const success = satisfies(frameworkVersion, '>=13.1.0') ? result.success : result

    let untestedCoverage
    if (getCodeCoverageCh.hasSubscribers) {
      untestedCoverage = await getChannelPromise(getCodeCoverageCh)
    }

    let testCodeCoverageLinesTotal
    let testSessionCoverageFiles

    if (global.__coverage__ || untestedCoverage) {
      try {
        let hasBackfilledCoverage = false
        if (untestedCoverage) {
          originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
        }
        hasBackfilledCoverage = applySkippedCoverageToCucumberCoverageMap()
        if (shouldReportCodeCoverageLinesPct(hasBackfilledCoverage)) {
          testCodeCoverageLinesTotal = getTestCoverageLinesPercentage(
            originalCoverageMap,
            undefined,
            getCoverageRootDir()
          )
        }
        if (isTiaCoverageBackfillEnabled()) {
          testSessionCoverageFiles = getCucumberTestSessionCoverageFiles()
        }
      } catch {
        // ignore errors
      }
      // restore the original coverage
      global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
    }

    const flushPromise = getChannelPromise(sessionFinishCh, {
      status: success ? 'pass' : 'fail',
      isSuitesSkipped,
      testCodeCoverageLinesTotal,
      testSessionCoverageFiles,
      numSkippedSuites: skippedSuites.length,
      hasUnskippableSuites: isUnskippable,
      hasForcedToRunSuites: isForcedToRun,
      isEarlyFlakeDetectionEnabled,
      isEarlyFlakeDetectionFaulty,
      isTestManagementTestsEnabled,
      isParallel,
    })

    logTestOptimizationSummary({
      attemptToFixExecutions,
      extraSections: areAllSuitesSkipped ? [TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE] : [],
    })
    loggedAttemptToFixTests.clear()
    eventDataCollector = null
    await flushPromise
    return result
  }
}

// Generates suite start and finish events in the main process.
// Handles EFD in both the main process and the worker process.
function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = false, isWorker = false) {
  return async function () {
    if (!testSuiteFinishCh.hasSubscribers) {
      return runTestCaseFunction.apply(this, arguments)
    }
    if (isWorker) {
      readParallelWorkerWorldParameters(this.options)
    }
    const pickle = isNewerCucumberVersion
      ? arguments[0].pickle
      : this.eventDataCollector.getPickle(arguments[0])
    const testCase = isNewerCucumberVersion
      ? arguments[0].testCase
      : arguments[1]
    const gherkinDocument = isNewerCucumberVersion
      ? arguments[0].gherkinDocument
      : this.eventDataCollector.getGherkinDocument(pickle.uri)

    const testFileAbsolutePath = pickle.uri
    const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())

    // If it's a worker, suite events are handled in `getWrappedParseWorkerMessage`
    if (!isWorker && !pickleResultByFile[testFileAbsolutePath]) { // first test in suite
      isUnskippable = isMarkedAsUnskippable(pickle)
      isForcedToRun = isUnskippable && skippableSuites.includes(testSuitePath)

      testSuiteStartCh.publish({
        testFileAbsolutePath,
        isUnskippable,
        isForcedToRun,
        itrCorrelationId,
      })
    }

    let isNew = false
    let isAttemptToFix = false
    let isDisabled = false
    let isQuarantined = false
    let isModified = false

    const originalDryRun = this.options.dryRun
    if (isTestManagementTestsEnabled) {
      const testProperties = getTestProperties(testSuitePath, pickle.name)
      isAttemptToFix = testProperties.attemptToFix
      isDisabled = testProperties.disabled
      isQuarantined = testProperties.quarantined
      // If attempt to fix is enabled, we run even if the test is disabled
      if (!isAttemptToFix && isDisabled) {
        this.options.dryRun = true
      }
    }

    if (isImpactedTestsEnabled) {
      const setIsModified = (receivedIsModified) => { isModified = receivedIsModified }
      const scenarios = gherkinDocument.feature?.children?.filter(
        children => pickle.astNodeIds.includes(children.scenario.id)
      ).map(scenario => scenario.scenario)
      const stepIds = testCase?.testSteps?.flatMap(testStep => testStep.stepDefinitionIds)

      isModifiedCh.publish({
        scenarios,
        testFileAbsolutePath: gherkinDocument.uri,
        modifiedFiles,
        stepIds,
        stepDefinitions: this.supportCodeLibrary.stepDefinitions,
        setIsModified,
      })
      modifiedTestsByPickleId.set(pickle.id, isModified)
    }

    if (isKnownTestsEnabled && !isAttemptToFix) {
      isNew = isNewTest(testSuitePath, pickle.name)
      if (isNew) {
        newTestPickleIds.add(pickle.id)
        numRetriesByPickleId.set(pickle.id, 0)
      }
    }
    const originalRetry = this.options.retry
    const isManagedRetry = isAttemptToFix || (shouldRunEarlyFlakeDetection() && (isNew || isModified))
    if (isManagedRetry) {
      this.options.retry = 0
    }
    // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
    const firstExecutionStart = performance.now()
    let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
    const firstExecutionDurationMs = performance.now() - firstExecutionStart

    // Restore dryRun so it doesn't affect subsequent tests in the same worker
    this.options.dryRun = originalDryRun

    const testStatuses = lastStatusByPickleId.get(pickle.id)
    const lastTestStatus = testStatuses.at(-1)

    // New tests should not be marked as attempt to fix, so EFD + Attempt to fix should not be enabled at the same time
    if (isAttemptToFix && lastTestStatus !== 'skip') {
      for (let retryIndex = 0; retryIndex < testManagementAttemptToFixRetries; retryIndex++) {
        numRetriesByPickleId.set(pickle.id, retryIndex + 1)
        // eslint-disable-next-line no-await-in-loop
        runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
      }
    }

    // If it's a new test and it hasn't been skipped, we run it again
    if (shouldRunEarlyFlakeDetection() && lastTestStatus !== 'skip' && (isNew || isModified)) {
      let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
      if (efdRetryCount === undefined) {
        efdRetryCount = getEfdRetryCountForDuration(firstExecutionDurationMs, earlyFlakeDetectionRetryPolicy)
        efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
        if (efdRetryCount === 0) {
          efdSlowAbortedPickleIds.add(pickle.id)
        }
      }
      if (isWorker) {
        publishWorkerEfdRetryCount(pickle, efdRetryCount)
      }
      for (let retryIndex = 0; retryIndex < efdRetryCount; retryIndex++) {
        numRetriesByPickleId.set(pickle.id, retryIndex + 1)
        // eslint-disable-next-line no-await-in-loop
        runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
      }
    }
    let testStatus = lastTestStatus
    let shouldBePassedByEFD = false
    let shouldBePassedByTestManagement = false
    let shouldBeFailedByAttemptToFix = false
    if ((isNew || isModified) && shouldRunEarlyFlakeDetection()) {
      /**
       * If Early Flake Detection (EFD) is enabled the logic is as follows:
       * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
       * - If just a single attempt passes, we will prevent the test process from failing.
       * The rationale behind is the following: you may still be able to block your CI pipeline by gating
       * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
       */
      testStatus = getTestStatusFromRetries(testStatuses)
      if (testStatus === 'pass') {
        // for cucumber@>=11, setting `this.success` does not work, so we have to change the returned value
        shouldBePassedByEFD = true
        this.success = true
      }
    }

    if (isAttemptToFix && testStatuses.length === testManagementAttemptToFixRetries + 1) {
      testStatus = getTestStatusFromAttemptToFixExecutions(testStatuses)
      if (testStatus === 'fail') {
        this.success = false
        shouldBeFailedByAttemptToFix = true
      }
    }

    if (isTestManagementTestsEnabled && !isAttemptToFix && (isDisabled || isQuarantined)) {
      this.success = true
      shouldBePassedByTestManagement = true
    }

    if (pickleResultByFile[testFileAbsolutePath]) {
      pickleResultByFile[testFileAbsolutePath].push(testStatus)
    } else {
      pickleResultByFile[testFileAbsolutePath] = [testStatus]
    }

    // If it's a worker, suite events are handled in `getWrappedParseWorkerMessage`
    if (!isWorker && pickleResultByFile[testFileAbsolutePath].length === pickleByFile[testFileAbsolutePath].length) {
      // last test in suite
      const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testFileAbsolutePath])
      if (global.__coverage__) {
        const coverageFiles = getCoveredFilesFromCoverage(global.__coverage__)

        testSuiteCodeCoverageCh.publish({
          coverageFiles,
          suiteFile: testFileAbsolutePath,
          testSuitePath,
        })
        // We need to reset coverage to get a code coverage per suite
        // Before that, we preserve the original coverage
        mergeCoverage(global.__coverage__, originalCoverageMap)
        resetCoverage(global.__coverage__)
      }

      testSuiteFinishCh.publish({ status: testSuiteStatus, testSuitePath })
    }

    this.options.retry = originalRetry

    if (isNewerCucumberVersion && shouldRunEarlyFlakeDetection() && (isNew || isModified)) {
      return shouldBePassedByEFD
    }

    if (isNewerCucumberVersion && isTestManagementTestsEnabled && !isAttemptToFix && (isQuarantined || isDisabled)) {
      return shouldBePassedByTestManagement
    }

    if (isNewerCucumberVersion && isAttemptToFix && shouldBeFailedByAttemptToFix) {
      return false
    }

    return runTestCaseResult
  }
}

function patchCucumberWorkerRunTestCase (runtimeExecutorPackage, isWorker) {
  const runtimeExecutorPrototype =
    runtimeExecutorPackage?.Worker?.prototype || runtimeExecutorPackage?.Executor?.prototype
  if (!runtimeExecutorPrototype || patchedCucumberWorkers.has(runtimeExecutorPrototype)) return

  patchedCucumberWorkers.add(runtimeExecutorPrototype)
  shimmer.wrap(
    runtimeExecutorPrototype,
    'runTestCase',
    runTestCase => getWrappedRunTestCase(runTestCase, true, isWorker)
  )
}

function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion, usesNumericStatus = false) {
  return function (worker, message) {
    if (!testSuiteFinishCh.hasSubscribers) {
      return parseWorkerMessageFunction.apply(this, arguments)
    }
    // If it's a dd-trace message, stop cucumber processing or cucumber will throw an error.
    if (handleDdWorkerMessage(message)) return

    const envelope = isNewVersion ? message.envelope : message.jsonEnvelope

    if (!envelope) {
      return parseWorkerMessageFunction.apply(this, arguments)
    }
    let parsed = envelope

    if (typeof parsed === 'string') {
      try {
        parsed = JSON.parse(envelope)
      } catch {
        // ignore errors and continue
        return parseWorkerMessageFunction.apply(this, arguments)
      }
    }
    if (handleDdWorkerMessage(parsed)) return
    let pickle

    if (parsed.testCaseStarted) {
      if (isNewVersion) {
        pickle = this.inProgress[worker.id].pickle
      } else {
        const { pickleId } = this.eventDataCollector.testCaseMap[parsed.testCaseStarted.testCaseId]
        pickle = this.eventDataCollector.getPickle(pickleId)
      }
      maybeStartParallelSuite(pickle)
    }

    const parseWorkerResponse = parseWorkerMessageFunction.apply(this, arguments)

    // after calling `parseWorkerMessageFunction`, the test status can already be read
    if (parsed.testCaseFinished) {
      let worstTestStepResult
      if (isNewVersion && eventDataCollector) {
        pickle = this.inProgress[worker.id].pickle
        worstTestStepResult =
          eventDataCollector.getTestCaseAttempt(parsed.testCaseFinished.testCaseStartedId).worstTestStepResult
      } else {
        const testCase = this.eventDataCollector.getTestCaseAttempt(parsed.testCaseFinished.testCaseStartedId)
        worstTestStepResult = testCase.worstTestStepResult
        pickle = testCase.pickle
      }

      handleParallelTestCaseFinished(pickle, worstTestStepResult, usesNumericStatus)
    }

    return parseWorkerResponse
  }
}

/**
 * Adapts Cucumber 7's callback-based parallel coordinator to the Promise contract used by getWrappedStart.
 *
 * @param {Function} run
 * @param {string} frameworkVersion
 * @returns {Function}
 */
function getWrappedCoordinatorRun (run, frameworkVersion) {
  const runAsPromise = function (numberOfWorkers) {
    return new Promise(resolve => run.call(this, numberOfWorkers, resolve))
  }
  const wrappedStart = getWrappedStart(runAsPromise, frameworkVersion, true)

  return function (numberOfWorkers, done) {
    return wrappedStart.call(this, numberOfWorkers).then(done)
  }
}

module.exports.patchCucumberWorkerRunTestCase = patchCucumberWorkerRunTestCase

// Test start / finish for older versions. The only hook executed in workers when in parallel mode
addHook({
  name: '@cucumber/cucumber',
  versions: ['7.0.0 - 7.2.1'],
  file: 'lib/runtime/pickle_runner.js',
}, pickleHook)

// Test start / finish for newer versions. The only hook executed in workers when in parallel mode
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=7.3.0'],
  file: 'lib/runtime/test_case_runner.js',
}, testCaseHook)

// From 7.3.0 onwards, runPickle becomes runTestCase. Not executed in parallel mode.
// `getWrappedStart` generates session start and finish events
// `getWrappedRunTestCase` generates suite start and finish events and handles EFD.
// TODO (fix): there is a lib/runtime/index in >=11.0.0, but we don't instrument it because it's not useful for us
// This causes a info log saying "Found incompatible integration version".
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=7.3.0 <11.0.0'],
  file: 'lib/runtime/index.js',
}, (runtimePackage, frameworkVersion) => {
  shimmer.wrap(runtimePackage.default.prototype, 'runTestCase', runTestCase => getWrappedRunTestCase(runTestCase))

  shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))

  return runtimePackage
})

// Not executed in parallel mode.
// `getWrappedStart` generates session start and finish events
// `getWrappedRunTestCase` generates suite start and finish events and handles EFD.
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=7.0.0 <7.3.0'],
  file: 'lib/runtime/index.js',
}, (runtimePackage, frameworkVersion) => {
  shimmer.wrap(runtimePackage.default.prototype, 'runPickle', runPickle => getWrappedRunTestCase(runPickle))
  shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))

  return runtimePackage
})

// Only executed in parallel mode in Cucumber 7 through 10.
// `getWrappedCoordinatorRun` or `getWrappedStart` generates session start and finish events
// `getWrappedParseWorkerMessage` generates suite start and finish events
// Shimmer is required because the coordinator must be changed before it starts workers and exposes no lifecycle hook.
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=7.0.0 <11.0.0'],
  file: 'lib/runtime/parallel/coordinator.js',
}, (coordinatorPackage, frameworkVersion) => {
  const isCucumber7 = satisfies(frameworkVersion, '<8.0.0')
  if (isCucumber7) {
    shimmer.wrap(
      coordinatorPackage.default.prototype,
      'run',
      run => getWrappedCoordinatorRun(run, frameworkVersion)
    )
  } else {
    shimmer.wrap(
      coordinatorPackage.default.prototype,
      'start',
      start => getWrappedStart(start, frameworkVersion, true)
    )
  }
  shimmer.wrap(
    coordinatorPackage.default.prototype,
    'parseWorkerMessage',
    parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, false, isCucumber7)
  )
  return coordinatorPackage
})

// >=11.0.0 hooks
// `getWrappedRunTestCase` does two things:
// - generates suite start and finish events in the main process,
// - handles EFD in both the main process and the worker process.
// Shimmer is required because this wrapper may invoke the original test case multiple times and mutate runtime options.
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=11.0.0 <13.2.0'],
  file: 'lib/runtime/worker.js',
}, (workerPackage) => {
  patchCucumberWorkerRunTestCase(workerPackage, !!getEnvironmentVariable('CUCUMBER_WORKER_ID'))
  return workerPackage
})

addHook({
  name: '@cucumber/cucumber',
  versions: ['>=13.2.0'],
  file: 'lib/runtime/executor.js',
}, (executorPackage) => {
  patchCucumberWorkerRunTestCase(executorPackage, !!getEnvironmentVariable('CUCUMBER_WORKER_ID'))
  return executorPackage
})

// `getWrappedStart` generates session start and finish events
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=11.0.0'],
  file: 'lib/runtime/coordinator.js',
}, (coordinatorPackage, frameworkVersion) => {
  shimmer.wrap(
    coordinatorPackage.Coordinator.prototype,
    'run',
    run => getWrappedStart(run, frameworkVersion, false, true)
  )
  return coordinatorPackage
})

// Necessary because `eventDataCollector` is no longer available in the runtime instance
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=11.0.0'],
  file: 'lib/formatter/helpers/event_data_collector.js',
}, (eventDataCollectorPackage) => {
  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function (...args) {
    eventDataCollector = this
    return parseEnvelope.apply(this, args)
  })
  return eventDataCollectorPackage
})

// Only executed in parallel mode for >=11, in the main process.
// `getWrappedParseWorkerMessage` generates suite start and finish events
// In `startWorker` we pass early flake detection info to the worker.
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=11.0.0 <13.0.0'],
  file: 'lib/runtime/parallel/adapter.js',
}, (adapterPackage) => {
  shimmer.wrap(
    adapterPackage.ChildProcessAdapter.prototype,
    'parseWorkerMessage',
    parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, true)
  )
  // EFD in parallel mode only supported in >=11.0.0
  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function (...args) {
    configureParallelWorkerWorldParameters(this.options)
    return startWorker.apply(this, args)
  })
  return adapterPackage
})

// Only executed in parallel mode for >=13, in the main process.
// Cucumber v13 uses worker_threads and receives worker events via MessagePort.
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=13.0.0'],
  file: 'lib/runtime/parallel/adapter.js',
}, (adapterPackage) => {
  shimmer.wrap(
    adapterPackage.WorkerThreadsAdapter.prototype,
    'setup',
    setup => getWrappedWorkerThreadsSetup(setup)
  )
  shimmer.wrap(
    adapterPackage.WorkerThreadsAdapter.prototype,
    'handleEventFromWorker',
    handleEventFromWorker => getWrappedHandleWorkerThreadEvent(handleEventFromWorker)
  )
  shimmer.wrap(
    adapterPackage.WorkerThreadsAdapter.prototype,
    'teardown',
    teardown => getWrappedWorkerThreadsTeardown(teardown)
  )
  return adapterPackage
})

// Hook executed in the worker process when in parallel mode.
// In this hook we read the information passed in `worldParameters` and make it available for
// `getWrappedRunTestCase`.
addHook({
  name: '@cucumber/cucumber',
  versions: ['>=11.0.0 <13.0.0'],
  file: 'lib/runtime/parallel/worker.js',
}, (workerPackage) => {
  shimmer.wrap(
    workerPackage.ChildProcessWorker.prototype,
    'initialize',
    initialize => async function () {
      await initialize.apply(this, arguments)
      readParallelWorkerWorldParameters(this.options)
    }
  )
  return workerPackage
})