@dev-blinq/cucumber-js 1.0.36 → 1.0.38

package/lib/runtime/parallel/worker.js

@@ -1,87 +1,87 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const messages_1 = require("@cucumber/messages");
-const events_1 = require("events");
-const url_1 = require("url");
-const support_code_library_builder_1 = __importDefault(require("../../support_code_library_builder"));
-const value_checker_1 = require("../../value_checker");
-const run_test_run_hooks_1 = require("../run_test_run_hooks");
-const stopwatch_1 = require("../stopwatch");
-const test_case_runner_1 = __importDefault(require("../test_case_runner"));
-const try_require_1 = __importDefault(require("../../try_require"));
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { importer } = require('../../importer');
-const { uuid } = messages_1.IdGenerator;
-class Worker {
-    constructor({ cwd, exit, id, sendMessage, }) {
-        this.id = id;
-        this.newId = uuid();
-        this.cwd = cwd;
-        this.exit = exit;
-        this.sendMessage = sendMessage;
-        this.eventBroadcaster = new events_1.EventEmitter();
-        this.eventBroadcaster.on('envelope', (envelope) => {
-            // assign `workerId` property only for the `testCaseStarted` message
-            if (envelope.testCaseStarted) {
-                envelope.testCaseStarted.workerId = this.id;
-            }
-            this.sendMessage({ jsonEnvelope: JSON.stringify(envelope) });
-        });
-    }
-    async initialize({ filterStacktraces, requireModules, requirePaths, importPaths, supportCodeIds, options, }) {
-        support_code_library_builder_1.default.reset(this.cwd, this.newId, {
-            requireModules,
-            requirePaths,
-            importPaths,
-        });
-        requireModules.map((module) => (0, try_require_1.default)(module));
-        requirePaths.map((module) => (0, try_require_1.default)(module));
-        for (const path of importPaths) {
-            await importer((0, url_1.pathToFileURL)(path));
-        }
-        this.supportCodeLibrary = support_code_library_builder_1.default.finalize(supportCodeIds);
-        this.worldParameters = options.worldParameters;
-        this.filterStacktraces = filterStacktraces;
-        this.runTestRunHooks = (0, run_test_run_hooks_1.makeRunTestRunHooks)(options.dryRun, this.supportCodeLibrary.defaultTimeout, (name, location) => `${name} hook errored on worker ${this.id}, process exiting: ${location}`);
-        await this.runTestRunHooks(this.supportCodeLibrary.beforeTestRunHookDefinitions, 'a BeforeAll');
-        this.sendMessage({ ready: true });
-    }
-    async finalize() {
-        await this.runTestRunHooks(this.supportCodeLibrary.afterTestRunHookDefinitions, 'an AfterAll');
-        this.exit(0);
-    }
-    async receiveMessage(message) {
-        if ((0, value_checker_1.doesHaveValue)(message.initialize)) {
-            await this.initialize(message.initialize);
-        }
-        else if (message.finalize) {
-            await this.finalize();
-        }
-        else if ((0, value_checker_1.doesHaveValue)(message.run)) {
-            await this.runTestCase(message.run);
-        }
-    }
-    async runTestCase({ gherkinDocument, pickle, testCase, elapsed, retries, skip, }) {
-        const stopwatch = (0, stopwatch_1.create)(elapsed);
-        const testCaseRunner = new test_case_runner_1.default({
-            eventBroadcaster: this.eventBroadcaster,
-            stopwatch,
-            gherkinDocument,
-            newId: this.newId,
-            pickle,
-            testCase,
-            retries,
-            skip,
-            filterStackTraces: this.filterStacktraces,
-            supportCodeLibrary: this.supportCodeLibrary,
-            worldParameters: this.worldParameters,
-        });
-        await testCaseRunner.run();
-        this.sendMessage({ ready: true });
-    }
-}
-exports.default = Worker;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_1 = require("@cucumber/messages");
+const events_1 = require("events");
+const url_1 = require("url");
+const support_code_library_builder_1 = __importDefault(require("../../support_code_library_builder"));
+const value_checker_1 = require("../../value_checker");
+const run_test_run_hooks_1 = require("../run_test_run_hooks");
+const stopwatch_1 = require("../stopwatch");
+const test_case_runner_1 = __importDefault(require("../test_case_runner"));
+const try_require_1 = __importDefault(require("../../try_require"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { importer } = require('../../importer');
+const { uuid } = messages_1.IdGenerator;
+class Worker {
+    constructor({ cwd, exit, id, sendMessage, }) {
+        this.id = id;
+        this.newId = uuid();
+        this.cwd = cwd;
+        this.exit = exit;
+        this.sendMessage = sendMessage;
+        this.eventBroadcaster = new events_1.EventEmitter();
+        this.eventBroadcaster.on('envelope', (envelope) => {
+            // assign `workerId` property only for the `testCaseStarted` message
+            if (envelope.testCaseStarted) {
+                envelope.testCaseStarted.workerId = this.id;
+            }
+            this.sendMessage({ jsonEnvelope: JSON.stringify(envelope) });
+        });
+    }
+    async initialize({ filterStacktraces, requireModules, requirePaths, importPaths, supportCodeIds, options, }) {
+        support_code_library_builder_1.default.reset(this.cwd, this.newId, {
+            requireModules,
+            requirePaths,
+            importPaths,
+        });
+        requireModules.map((module) => (0, try_require_1.default)(module));
+        requirePaths.map((module) => (0, try_require_1.default)(module));
+        for (const path of importPaths) {
+            await importer((0, url_1.pathToFileURL)(path));
+        }
+        this.supportCodeLibrary = support_code_library_builder_1.default.finalize(supportCodeIds);
+        this.worldParameters = options.worldParameters;
+        this.filterStacktraces = filterStacktraces;
+        this.runTestRunHooks = (0, run_test_run_hooks_1.makeRunTestRunHooks)(options.dryRun, this.supportCodeLibrary.defaultTimeout, (name, location) => `${name} hook errored on worker ${this.id}, process exiting: ${location}`);
+        await this.runTestRunHooks(this.supportCodeLibrary.beforeTestRunHookDefinitions, 'a BeforeAll');
+        this.sendMessage({ ready: true });
+    }
+    async finalize() {
+        await this.runTestRunHooks(this.supportCodeLibrary.afterTestRunHookDefinitions, 'an AfterAll');
+        this.exit(0);
+    }
+    async receiveMessage(message) {
+        if ((0, value_checker_1.doesHaveValue)(message.initialize)) {
+            await this.initialize(message.initialize);
+        }
+        else if (message.finalize) {
+            await this.finalize();
+        }
+        else if ((0, value_checker_1.doesHaveValue)(message.run)) {
+            await this.runTestCase(message.run);
+        }
+    }
+    async runTestCase({ gherkinDocument, pickle, testCase, elapsed, retries, skip, }) {
+        const stopwatch = (0, stopwatch_1.create)(elapsed);
+        const testCaseRunner = new test_case_runner_1.default({
+            eventBroadcaster: this.eventBroadcaster,
+            stopwatch,
+            gherkinDocument,
+            newId: this.newId,
+            pickle,
+            testCase,
+            retries,
+            skip,
+            filterStackTraces: this.filterStacktraces,
+            supportCodeLibrary: this.supportCodeLibrary,
+            worldParameters: this.worldParameters,
+        });
+        await testCaseRunner.run();
+        this.sendMessage({ ready: true });
+    }
+}
+exports.default = Worker;
 //# sourceMappingURL=worker.js.map

package/lib/runtime/run_test_run_hooks.d.ts

@@ -1,3 +1,3 @@
-import TestRunHookDefinition from '../models/test_run_hook_definition';
-export type RunsTestRunHooks = (definitions: TestRunHookDefinition[], name: string) => Promise<void>;
-export declare const makeRunTestRunHooks: (dryRun: boolean, defaultTimeout: number, errorMessage: (name: string, location: string) => string) => RunsTestRunHooks;
+import TestRunHookDefinition from '../models/test_run_hook_definition';
+export type RunsTestRunHooks = (definitions: TestRunHookDefinition[], name: string) => Promise<void>;
+export declare const makeRunTestRunHooks: (dryRun: boolean, defaultTimeout: number, errorMessage: (name: string, location: string) => string) => RunsTestRunHooks;

package/lib/runtime/run_test_run_hooks.js

@@ -1,28 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeRunTestRunHooks = void 0;
-const user_code_runner_1 = __importDefault(require("../user_code_runner"));
-const verror_1 = __importDefault(require("verror"));
-const helpers_1 = require("../formatter/helpers");
-const value_checker_1 = require("../value_checker");
-const makeRunTestRunHooks = (dryRun, defaultTimeout, errorMessage) => dryRun
-    ? async () => { }
-    : async (definitions, name) => {
-        for (const hookDefinition of definitions) {
-            const { error } = await user_code_runner_1.default.run({
-                argsArray: [],
-                fn: hookDefinition.code,
-                thisArg: null,
-                timeoutInMilliseconds: (0, value_checker_1.valueOrDefault)(hookDefinition.options.timeout, defaultTimeout),
-            });
-            if ((0, value_checker_1.doesHaveValue)(error)) {
-                const location = (0, helpers_1.formatLocation)(hookDefinition);
-                throw new verror_1.default(error, errorMessage(name, location));
-            }
-        }
-    };
-exports.makeRunTestRunHooks = makeRunTestRunHooks;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRunTestRunHooks = void 0;
+const user_code_runner_1 = __importDefault(require("../user_code_runner"));
+const verror_1 = __importDefault(require("verror"));
+const helpers_1 = require("../formatter/helpers");
+const value_checker_1 = require("../value_checker");
+const makeRunTestRunHooks = (dryRun, defaultTimeout, errorMessage) => dryRun
+    ? async () => { }
+    : async (definitions, name) => {
+        for (const hookDefinition of definitions) {
+            const { error } = await user_code_runner_1.default.run({
+                argsArray: [],
+                fn: hookDefinition.code,
+                thisArg: null,
+                timeoutInMilliseconds: (0, value_checker_1.valueOrDefault)(hookDefinition.options.timeout, defaultTimeout),
+            });
+            if ((0, value_checker_1.doesHaveValue)(error)) {
+                const location = (0, helpers_1.formatLocation)(hookDefinition);
+                throw new verror_1.default(error, errorMessage(name, location));
+            }
+        }
+    };
+exports.makeRunTestRunHooks = makeRunTestRunHooks;
 //# sourceMappingURL=run_test_run_hooks.js.map

package/lib/runtime/step_runner.d.ts

@@ -1,16 +1,16 @@
-import * as messages from '@cucumber/messages';
-import { ITestCaseHookParameter } from '../support_code_library_builder/types';
-import { IDefinition } from '../models/definition';
-export interface IRunOptions {
-    defaultTimeout: number;
-    filterStackTraces: boolean;
-    hookParameter: ITestCaseHookParameter;
-    step: messages.PickleStep;
-    stepDefinition: IDefinition;
-    world: any;
-}
-export declare function run({ defaultTimeout, filterStackTraces, hookParameter, step, stepDefinition, world, }: IRunOptions): Promise<messages.TestStepResult>;
-declare const _default: {
-    run: typeof run;
-};
-export default _default;
+import * as messages from '@cucumber/messages';
+import { ITestCaseHookParameter } from '../support_code_library_builder/types';
+import { IDefinition } from '../models/definition';
+export interface IRunOptions {
+    defaultTimeout: number;
+    filterStackTraces: boolean;
+    hookParameter: ITestCaseHookParameter;
+    step: messages.PickleStep;
+    stepDefinition: IDefinition;
+    world: any;
+}
+export declare function run({ defaultTimeout, filterStackTraces, hookParameter, step, stepDefinition, world, }: IRunOptions): Promise<messages.TestStepResult>;
+declare const _default: {
+    run: typeof run;
+};
+export default _default;

package/lib/runtime/step_runner.js

@@ -1,88 +1,88 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-const stopwatch_1 = require("./stopwatch");
-const user_code_runner_1 = __importDefault(require("../user_code_runner"));
-const messages = __importStar(require("@cucumber/messages"));
-const value_checker_1 = require("../value_checker");
-const format_error_1 = require("./format_error");
-async function run({ defaultTimeout, filterStackTraces, hookParameter, step, stepDefinition, world, }) {
-    const stopwatch = (0, stopwatch_1.create)().start();
-    let error, result, invocationData;
-    try {
-        invocationData = await stepDefinition.getInvocationParameters({
-            hookParameter,
-            step,
-            world,
-        });
-    }
-    catch (err) {
-        error = err;
-    }
-    if ((0, value_checker_1.doesNotHaveValue)(error)) {
-        const timeoutInMilliseconds = (0, value_checker_1.valueOrDefault)(stepDefinition.options.timeout, defaultTimeout);
-        if (invocationData.validCodeLengths.includes(stepDefinition.code.length)) {
-            const data = await user_code_runner_1.default.run({
-                argsArray: invocationData.parameters,
-                fn: stepDefinition.code,
-                thisArg: world,
-                timeoutInMilliseconds,
-            });
-            error = data.error;
-            result = data.result;
-        }
-        else {
-            error = invocationData.getInvalidCodeLengthMessage();
-        }
-    }
-    const duration = stopwatch.stop().duration();
-    let status;
-    let details = {};
-    if (result === 'skipped') {
-        status = messages.TestStepResultStatus.SKIPPED;
-    }
-    else if (result === 'pending') {
-        status = messages.TestStepResultStatus.PENDING;
-    }
-    else if ((0, value_checker_1.doesHaveValue)(error)) {
-        details = (0, format_error_1.formatError)(error, filterStackTraces);
-        status = messages.TestStepResultStatus.FAILED;
-    }
-    else {
-        status = messages.TestStepResultStatus.PASSED;
-    }
-    return {
-        duration,
-        status,
-        ...details,
-    };
-}
-exports.run = run;
-exports.default = { run };
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const stopwatch_1 = require("./stopwatch");
+const user_code_runner_1 = __importDefault(require("../user_code_runner"));
+const messages = __importStar(require("@cucumber/messages"));
+const value_checker_1 = require("../value_checker");
+const format_error_1 = require("./format_error");
+async function run({ defaultTimeout, filterStackTraces, hookParameter, step, stepDefinition, world, }) {
+    const stopwatch = (0, stopwatch_1.create)().start();
+    let error, result, invocationData;
+    try {
+        invocationData = await stepDefinition.getInvocationParameters({
+            hookParameter,
+            step,
+            world,
+        });
+    }
+    catch (err) {
+        error = err;
+    }
+    if ((0, value_checker_1.doesNotHaveValue)(error)) {
+        const timeoutInMilliseconds = (0, value_checker_1.valueOrDefault)(stepDefinition.options.timeout, defaultTimeout);
+        if (invocationData.validCodeLengths.includes(stepDefinition.code.length)) {
+            const data = await user_code_runner_1.default.run({
+                argsArray: invocationData.parameters,
+                fn: stepDefinition.code,
+                thisArg: world,
+                timeoutInMilliseconds,
+            });
+            error = data.error;
+            result = data.result;
+        }
+        else {
+            error = invocationData.getInvalidCodeLengthMessage();
+        }
+    }
+    const duration = stopwatch.stop().duration();
+    let status;
+    let details = {};
+    if (result === 'skipped') {
+        status = messages.TestStepResultStatus.SKIPPED;
+    }
+    else if (result === 'pending') {
+        status = messages.TestStepResultStatus.PENDING;
+    }
+    else if ((0, value_checker_1.doesHaveValue)(error)) {
+        details = (0, format_error_1.formatError)(error, filterStackTraces);
+        status = messages.TestStepResultStatus.FAILED;
+    }
+    else {
+        status = messages.TestStepResultStatus.PASSED;
+    }
+    return {
+        duration,
+        status,
+        ...details,
+    };
+}
+exports.run = run;
+exports.default = { run };
 //# sourceMappingURL=step_runner.js.map

package/lib/runtime/stopwatch.d.ts

@@ -1,12 +1,12 @@
-import { Duration, Timestamp } from '@cucumber/messages';
-/**
- * A utility for timing test run operations and returning duration and
- * timestamp objects in messages-compatible formats
- */
-export interface IStopwatch {
-    start: () => IStopwatch;
-    stop: () => IStopwatch;
-    duration: () => Duration;
-    timestamp: () => Timestamp;
-}
-export declare const create: (base?: Duration) => IStopwatch;
+import { Duration, Timestamp } from '@cucumber/messages';
+/**
+ * A utility for timing test run operations and returning duration and
+ * timestamp objects in messages-compatible formats
+ */
+export interface IStopwatch {
+    start: () => IStopwatch;
+    stop: () => IStopwatch;
+    duration: () => Duration;
+    timestamp: () => Timestamp;
+}
+export declare const create: (base?: Duration) => IStopwatch;

package/lib/runtime/stopwatch.js

@@ -1,34 +1,34 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const messages_1 = require("@cucumber/messages");
-const time_1 = __importDefault(require("../time"));
-class StopwatchImpl {
-    constructor(base = { seconds: 0, nanos: 0 }) {
-        this.base = base;
-    }
-    start() {
-        this.started = time_1.default.performance.now();
-        return this;
-    }
-    stop() {
-        this.base = this.duration();
-        this.started = undefined;
-        return this;
-    }
-    duration() {
-        if (typeof this.started !== 'number') {
-            return this.base;
-        }
-        return messages_1.TimeConversion.addDurations(this.base, messages_1.TimeConversion.millisecondsToDuration(time_1.default.performance.now() - this.started));
-    }
-    timestamp() {
-        return messages_1.TimeConversion.millisecondsSinceEpochToTimestamp(time_1.default.Date.now());
-    }
-}
-const create = (base) => new StopwatchImpl(base);
-exports.create = create;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const messages_1 = require("@cucumber/messages");
+const time_1 = __importDefault(require("../time"));
+class StopwatchImpl {
+    constructor(base = { seconds: 0, nanos: 0 }) {
+        this.base = base;
+    }
+    start() {
+        this.started = time_1.default.performance.now();
+        return this;
+    }
+    stop() {
+        this.base = this.duration();
+        this.started = undefined;
+        return this;
+    }
+    duration() {
+        if (typeof this.started !== 'number') {
+            return this.base;
+        }
+        return messages_1.TimeConversion.addDurations(this.base, messages_1.TimeConversion.millisecondsToDuration(time_1.default.performance.now() - this.started));
+    }
+    timestamp() {
+        return messages_1.TimeConversion.millisecondsSinceEpochToTimestamp(time_1.default.Date.now());
+    }
+}
+const create = (base) => new StopwatchImpl(base);
+exports.create = create;
 //# sourceMappingURL=stopwatch.js.map

package/lib/runtime/test_case_runner.d.ts

@@ -1,54 +1,54 @@
-/// <reference types="node" />
-import * as messages from '@cucumber/messages';
-import { IdGenerator } from '@cucumber/messages';
-import { EventEmitter } from 'events';
-import { ISupportCodeLibrary, ITestCaseHookParameter } from '../support_code_library_builder/types';
-import TestCaseHookDefinition from '../models/test_case_hook_definition';
-import TestStepHookDefinition from '../models/test_step_hook_definition';
-import { IDefinition } from '../models/definition';
-import { IStopwatch } from './stopwatch';
-export interface INewTestCaseRunnerOptions {
-    eventBroadcaster: EventEmitter;
-    stopwatch: IStopwatch;
-    gherkinDocument: messages.GherkinDocument;
-    newId: IdGenerator.NewId;
-    pickle: messages.Pickle;
-    testCase: messages.TestCase;
-    retries: number;
-    skip: boolean;
-    filterStackTraces: boolean;
-    supportCodeLibrary: ISupportCodeLibrary;
-    worldParameters: any;
-}
-export default class TestCaseRunner {
-    private readonly attachmentManager;
-    private currentTestCaseStartedId;
-    private currentTestStepId;
-    private readonly eventBroadcaster;
-    private readonly stopwatch;
-    private readonly gherkinDocument;
-    private readonly newId;
-    private readonly pickle;
-    private readonly testCase;
-    private readonly maxAttempts;
-    private readonly skip;
-    private readonly filterStackTraces;
-    private readonly supportCodeLibrary;
-    private testStepResults;
-    private world;
-    private readonly worldParameters;
-    constructor({ eventBroadcaster, stopwatch, gherkinDocument, newId, pickle, testCase, retries, skip, filterStackTraces, supportCodeLibrary, worldParameters, }: INewTestCaseRunnerOptions);
-    resetTestProgressData(): void;
-    getBeforeStepHookDefinitions(): TestStepHookDefinition[];
-    getAfterStepHookDefinitions(): TestStepHookDefinition[];
-    getWorstStepResult(): messages.TestStepResult;
-    invokeStep(step: messages.PickleStep, stepDefinition: IDefinition, hookParameter?: any): Promise<messages.TestStepResult>;
-    isSkippingSteps(): boolean;
-    shouldSkipHook(isBeforeHook: boolean): boolean;
-    aroundTestStep(testStepId: string, runStepFn: () => Promise<messages.TestStepResult>): Promise<void>;
-    run(): Promise<messages.TestStepResultStatus>;
-    runAttempt(attempt: number, moreAttemptsRemaining: boolean): Promise<boolean>;
-    runHook(hookDefinition: TestCaseHookDefinition, hookParameter: ITestCaseHookParameter, isBeforeHook: boolean): Promise<messages.TestStepResult>;
-    runStepHooks(stepHooks: TestStepHookDefinition[], pickleStep: messages.PickleStep, stepResult?: messages.TestStepResult): Promise<messages.TestStepResult[]>;
-    runStep(pickleStep: messages.PickleStep, testStep: messages.TestStep): Promise<messages.TestStepResult>;
-}
+/// <reference types="node" />
+import * as messages from '@cucumber/messages';
+import { IdGenerator } from '@cucumber/messages';
+import { EventEmitter } from 'events';
+import { ISupportCodeLibrary, ITestCaseHookParameter } from '../support_code_library_builder/types';
+import TestCaseHookDefinition from '../models/test_case_hook_definition';
+import TestStepHookDefinition from '../models/test_step_hook_definition';
+import { IDefinition } from '../models/definition';
+import { IStopwatch } from './stopwatch';
+export interface INewTestCaseRunnerOptions {
+    eventBroadcaster: EventEmitter;
+    stopwatch: IStopwatch;
+    gherkinDocument: messages.GherkinDocument;
+    newId: IdGenerator.NewId;
+    pickle: messages.Pickle;
+    testCase: messages.TestCase;
+    retries: number;
+    skip: boolean;
+    filterStackTraces: boolean;
+    supportCodeLibrary: ISupportCodeLibrary;
+    worldParameters: any;
+}
+export default class TestCaseRunner {
+    private readonly attachmentManager;
+    private currentTestCaseStartedId;
+    private currentTestStepId;
+    private readonly eventBroadcaster;
+    private readonly stopwatch;
+    private readonly gherkinDocument;
+    private readonly newId;
+    private readonly pickle;
+    private readonly testCase;
+    private readonly maxAttempts;
+    private readonly skip;
+    private readonly filterStackTraces;
+    private readonly supportCodeLibrary;
+    private testStepResults;
+    private world;
+    private readonly worldParameters;
+    constructor({ eventBroadcaster, stopwatch, gherkinDocument, newId, pickle, testCase, retries, skip, filterStackTraces, supportCodeLibrary, worldParameters, }: INewTestCaseRunnerOptions);
+    resetTestProgressData(): void;
+    getBeforeStepHookDefinitions(): TestStepHookDefinition[];
+    getAfterStepHookDefinitions(): TestStepHookDefinition[];
+    getWorstStepResult(): messages.TestStepResult;
+    invokeStep(step: messages.PickleStep, stepDefinition: IDefinition, hookParameter?: any): Promise<messages.TestStepResult>;
+    isSkippingSteps(): boolean;
+    shouldSkipHook(isBeforeHook: boolean): boolean;
+    aroundTestStep(testStepId: string, runStepFn: () => Promise<messages.TestStepResult>): Promise<void>;
+    run(): Promise<messages.TestStepResultStatus>;
+    runAttempt(attempt: number, moreAttemptsRemaining: boolean): Promise<boolean>;
+    runHook(hookDefinition: TestCaseHookDefinition, hookParameter: ITestCaseHookParameter, isBeforeHook: boolean): Promise<messages.TestStepResult>;
+    runStepHooks(stepHooks: TestStepHookDefinition[], pickleStep: messages.PickleStep, stepResult?: messages.TestStepResult): Promise<messages.TestStepResult[]>;
+    runStep(pickleStep: messages.PickleStep, testStep: messages.TestStep): Promise<messages.TestStepResult>;
+}