@types/mocha

  • Version 9.0.0
  • Published
  • 95.3 kB
  • No dependencies
  • MIT license

Install

npm i @types/mocha
yarn add @types/mocha
pnpm add @types/mocha

Overview

TypeScript definitions for mocha

Index

Variables

Functions

Namespaces

Variables

variable after

var after: Mocha.HookFunction;
  • Execute after running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#after

variable afterEach

var afterEach: Mocha.HookFunction;
  • Execute after each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#afterEach

variable before

var before: Mocha.HookFunction;
  • Execute before running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#before

variable beforeEach

var beforeEach: Mocha.HookFunction;
  • Execute before each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#beforeEach

variable context

var context: Mocha.SuiteFunction;
  • Describe a "suite" containing nested suites and tests.

    - _Only available when invoked via the mocha CLI._

variable describe

var describe: Mocha.SuiteFunction;
  • Describe a "suite" containing nested suites and tests.

    - _Only available when invoked via the mocha CLI._

variable it

var it: Mocha.TestFunction;
  • Describes a test case.

    - _Only available when invoked via the mocha CLI._

variable mocha

const mocha: BrowserMocha;
  • Mocha global.

    - _Only supported in the browser._

variable setup

var setup: Mocha.HookFunction;
  • Execute before each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#beforeEach

variable specify

var specify: Mocha.TestFunction;
  • Describes a test case.

    - _Only available when invoked via the mocha CLI._

variable suite

var suite: Mocha.SuiteFunction;
  • Describe a "suite" containing nested suites and tests.

    - _Only available when invoked via the mocha CLI._

variable suiteSetup

var suiteSetup: Mocha.HookFunction;
  • Execute before running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#before

variable suiteTeardown

var suiteTeardown: Mocha.HookFunction;
  • Execute after running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#after

variable teardown

var teardown: Mocha.HookFunction;
  • Execute after each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#afterEach

variable test

var test: Mocha.TestFunction;
  • Describes a test case.

    - _Only available when invoked via the mocha CLI._

variable xcontext

var xcontext: Mocha.PendingSuiteFunction;
  • Pending suite.

    - _Only available when invoked via the mocha CLI._

variable xdescribe

var xdescribe: Mocha.PendingSuiteFunction;
  • Pending suite.

    - _Only available when invoked via the mocha CLI._

variable xit

var xit: Mocha.PendingTestFunction;
  • Describes a pending test case.

    - _Only available when invoked via the mocha CLI._

variable xspecify

var xspecify: Mocha.PendingTestFunction;
  • Describes a pending test case.

    - _Only available when invoked via the mocha CLI._

Functions

function run

run: () => void;
  • Triggers root suite execution.

    - _Only available if flag --delay is passed into Mocha._ - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#runWithSuite

Namespaces

namespace mocha

module 'mocha' {}

    variable after

    let after: HookFunction;
    • Execute after running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#after

    variable afterEach

    let afterEach: HookFunction;
    • Execute after each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#afterEach

    variable before

    let before: HookFunction;
    • Execute before running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#before

    variable beforeEach

    let beforeEach: HookFunction;
    • Execute before each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#beforeEach

    variable describe

    let describe: SuiteFunction;
    • Describe a "suite" containing nested suites and tests.

      - _Only available when invoked via the mocha CLI._

    variable it

    let it: TestFunction;
    • Describes a test case.

      - _Only available when invoked via the mocha CLI._

    variable setup

    let setup: HookFunction;
    • Execute before each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#beforeEach

    variable suite

    let suite: SuiteFunction;
    • Describe a "suite" containing nested suites and tests.

      - _Only available when invoked via the mocha CLI._

    variable suiteSetup

    let suiteSetup: HookFunction;
    • Execute before running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#before

    variable suiteTeardown

    let suiteTeardown: HookFunction;
    • Execute after running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#after

    variable teardown

    let teardown: HookFunction;
    • Execute after each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#afterEach

    variable test

    let test: TestFunction;
    • Describes a test case.

      - _Only available when invoked via the mocha CLI._

    variable xit

    let xit: PendingTestFunction;
    • Describes a pending test case.

      - _Only available when invoked via the mocha CLI._

    function run

    run: () => void;
    • Triggers root suite execution.

      - _Only available if flag --delay is passed into Mocha._ - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#runWithSuite

    class Context

    class Context {}
    • Test context

      See Also

      • https://mochajs.org/api/module-Context.html#~Context

    property currentTest

    currentTest?: Test;

      property test

      test?: Runnable;

        method retries

        retries: { (): number; (n: number): this };
        • Get the number of allowed retries on failed tests.

        • Set the number of allowed retries on failed tests.

        method runnable

        runnable: { (): Runnable; (runnable: Runnable): this };
        • Get the context Runnable.

        • Set the context Runnable.

        method skip

        skip: () => never;
        • Mark a test as skipped.

        method slow

        slow: { (): number; (ms: string | number): this };
        • Get test slowness threshold.

        • Set test slowness threshold.

        method timeout

        timeout: { (): number; (ms: string | number): this };
        • Get test timeout.

        • Set test timeout.

        class Hook

        class Hook extends Runnable {}
        • Initialize a new Hook with the given title and callback fn

          See Also

          • https://mochajs.org/api/Hook.html

        property originalTitle

        originalTitle?: string;

          property type

          type: string;

            method error

            error: { (): any; (err: any): void };
            • Get the test err.

              See Also

              • https://mochajs.org/api/Hook.html#error

            • Set the test err.

              See Also

              • https://mochajs.org/api/Hook.html#error

            class Mocha

            class Mocha {}
            • Mocha API

              See Also

              • https://mochajs.org/api/mocha

            constructor

            constructor(options?: Mocha.MochaOptions);

              property files

              files: string[];

                property globalSetup

                globalSetup: Mocha.HookFunction;
                • Configures one or more global setup fixtures. If given no parameters, unsets any previously-set fixtures.

                  See Also

                  • https://mochajs.org/api/mocha#globalSetup

                property globalTeardown

                globalTeardown: Mocha.HookFunction;
                • Configures one or more global teardown fixtures. If given no parameters, unsets any previously-set fixtures.

                  See Also

                  • https://mochajs.org/api/mocha#globalTeardown

                property options

                options: Mocha.MochaInstanceOptions;

                  property suite

                  suite: Mocha.Suite;

                    method addFile

                    addFile: (file: string) => this;
                    • Add test file.

                      See Also

                      • https://mochajs.org/api/mocha#addFile

                    method allowUncaught

                    allowUncaught: () => boolean;
                    • Enable uncaught errors to propagate (in browser).

                      See Also

                      • https://mochajs.org/api/mocha#allowUncaught

                    method asyncOnly

                    asyncOnly: () => this;
                    • Makes all tests async (accepting a callback)

                      See Also

                      • https://mochajs.org/api/mocha#asyncOnly.

                    method bail

                    bail: (bail?: boolean) => this;
                    • Enable or disable bailing on the first failure.

                      See Also

                      • https://mochajs.org/api/mocha#bail

                    method checkLeaks

                    checkLeaks: () => this;
                    • Enable global leak checking.

                      See Also

                      • https://mochajs.org/api/mocha#checkLeaks

                    method delay

                    delay: () => boolean;
                    • Delay root suite execution.

                      See Also

                      • https://mochajs.org/api/mocha#delay

                    method dispose

                    dispose: () => void;
                    • Manually dispose this mocha instance. Mark this instance as disposed and unable to run more tests. It also removes function references to tests functions and hooks, so variables trapped in closures can be cleaned by the garbage collector.

                      See Also

                      • https://mochajs.org/api/mocha#dispose

                    method dryRun

                    dryRun: (dryRun?: boolean) => this;
                    • Whether to activate dry-run mode.

                      Parameter dryRun

                      Whether to activate dry-run mode. Defaults to true.

                    method enableGlobalSetup

                    enableGlobalSetup: (enabled: boolean) => this;
                    • Toggle execution of any global setup fixture(s)

                      See Also

                      • https://mochajs.org/api/mocha#enableGlobalSetup

                    method enableGlobalTeardown

                    enableGlobalTeardown: (enabled: boolean) => this;
                    • Toggle execution of any global teardown fixture(s)

                      See Also

                      • https://mochajs.org/api/mocha#enableGlobalTeardown

                    method fgrep

                    fgrep: (str: string) => this;
                    • Escape string and add it to grep as a RegExp.

                      See Also

                      • https://mochajs.org/api/mocha#fgrep

                    method forbidOnly

                    forbidOnly: () => boolean;
                    • Tests marked only fail the suite

                      See Also

                      • https://mochajs.org/api/mocha#forbidOnly

                    method forbidPending

                    forbidPending: () => boolean;
                    • Pending tests and tests marked skip fail the suite

                      See Also

                      • https://mochajs.org/api/mocha#forbidPending

                    method fullTrace

                    fullTrace: () => this;
                    • Display long stack-trace on failing

                      See Also

                      • https://mochajs.org/api/mocha#fullTrace

                    method globals

                    globals: (globals: string | ReadonlyArray<string>) => this;
                    • Ignore globals array or string.

                      See Also

                      • https://mochajs.org/api/mocha#globals

                    method grep

                    grep: (re: string | RegExp) => this;
                    • Add regexp to grep, if re is a string it is escaped.

                      See Also

                      • https://mochajs.org/api/mocha#grep

                    method growl

                    growl: () => this;
                    • Enable growl support.

                      See Also

                      • https://mochajs.org/api/mocha#growl

                    method hasGlobalSetupFixtures

                    hasGlobalSetupFixtures: () => boolean;
                    • Returns true if one or more global setup fixtures have been supplied

                      See Also

                      • https://mochajs.org/api/mocha#hasGlobalSetupFixtures

                    method hasGlobalTeardownFixtures

                    hasGlobalTeardownFixtures: () => boolean;
                    • Returns true if one or more global teardown fixtures have been supplied

                      See Also

                      • https://mochajs.org/api/mocha#hasGlobalTeardownFixtures

                    method invert

                    invert: () => this;
                    • Invert .grep() matches.

                      See Also

                      • https://mochajs.org/api/mocha#invert

                    method loadFiles

                    protected loadFiles: (fn?: () => void) => void;
                    • Load registered files.

                      See Also

                      • https://mochajs.org/api/mocha#loadFiles

                    method loadFilesAsync

                    loadFilesAsync: () => Promise<void>;
                    • Loads ESM (and CJS) test files asynchronously.

                      See Also

                      • https://mochajs.org/api/mocha#loadFilesAsync

                    method noHighlighting

                    noHighlighting: () => this;
                    • Disable syntax highlighting (in browser).

                      See Also

                      • https://mochajs.org/api/mocha#noHighlighting

                    method parallelMode

                    parallelMode: (enabled?: boolean) => this;
                    • Toggles parallel mode.

                      Must be run before calling run. Changes the Runner class to use; also enables lazy file loading if not already done so.

                      See Also

                      • https://mochajs.org/api/mocha#parallelMode

                    method reporter

                    reporter: {
                    (reporter: Mocha.Reporter, reporterOptions?: any): this;
                    (reporter?: string | Mocha.ReporterConstructor, reporterOptions?: any): this;
                    };
                    • Set reporter to one of the built-in reporters.

                      See Also

                      • https://mochajs.org/api/mocha#reporter

                    • Set reporter to the provided constructor, one of the built-in reporters, or loads a reporter from a module path. Defaults to "spec".

                      See Also

                      • https://mochajs.org/api/mocha#reporter

                    method retries

                    retries: (n: number) => this;
                    • Set the number of times to retry failed tests.

                      See Also

                      • https://mochajs.org/api/mocha#retries

                    method rootHooks

                    rootHooks: (hooks: Mocha.RootHookObject) => this;
                    • Assigns hooks to the root suite.

                      See Also

                      • https://mochajs.org/api/mocha#rootHooks

                    method run

                    run: (fn?: (failures: number) => void) => Mocha.Runner;
                    • Run tests and invoke fn() when complete.

                      Note that run relies on Node's require to execute the test interface functions and will be subject to the cache - if the files are already in the require cache, they will effectively be skipped. Therefore, to run tests multiple times or to run tests in files that are already in the require cache, make sure to clear them from the cache first in whichever manner best suits your needs.

                      See Also

                      • https://mochajs.org/api/mocha#run

                    method slow

                    slow: (slow: string | number) => this;
                    • Set slowness threshold in milliseconds.

                      See Also

                      • https://mochajs.org/api/mocha#slow

                    method timeout

                    timeout: (timeout: string | number) => this;
                    • Set the timeout in milliseconds.

                      See Also

                      • https://mochajs.org/api/mocha#timeout

                    method ui

                    ui: { (name: Mocha.Interface): this; (name?: string): this };
                    • Set test UI to one of the built-in test interfaces.

                      See Also

                      • https://mochajs.org/api/mocha#ui

                    • Set test UI to one of the built-in test interfaces or loads a test interface from a module path. Defaults to "bdd".

                      See Also

                      • https://mochajs.org/api/mocha#ui

                    method unloadFiles

                    unloadFiles: () => this;
                    • Unloads files from Node's require cache.

                      This allows required files to be "freshly" reloaded, providing the ability to reuse a Mocha instance programmatically. Note: does not clear ESM module files from the cache

                    class Runnable

                    class Runnable {}
                    • Initialize a new Runnable with the given title and callback fn.

                      See Also

                      • https://mochajs.org/api/Runnable.html

                    constructor

                    constructor(title: string, fn?: Func | AsyncFunc);

                      property allowUncaught

                      allowUncaught?: boolean;

                        property async

                        async: boolean;

                          property body

                          body: string;

                            property callback

                            callback?: Done;

                              property ctx

                              ctx?: Context;

                                property duration

                                duration?: number;

                                  property file

                                  file?: string;

                                    property fn

                                    fn: Func | AsyncFunc;

                                      property parent

                                      parent?: Suite;

                                        property pending

                                        pending: boolean;

                                          property state

                                          state?: 'failed' | 'passed';

                                            property sync

                                            sync: boolean;

                                              property timedOut

                                              timedOut: boolean;

                                                property timer

                                                timer?: any;

                                                  property title

                                                  title: string;

                                                    method clearTimeout

                                                    clearTimeout: () => void;
                                                    • Clear the timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#clearTimeout

                                                    method currentRetry

                                                    protected currentRetry: { (): number; (n: number): void };
                                                    • Set or get current retry

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#currentRetry

                                                    method fullTitle

                                                    fullTitle: () => string;
                                                    • Return the full title generated by recursively concatenating the parent's full title.

                                                    method globals

                                                    globals: { (): string[]; (globals: readonly string[]): void };
                                                    • Get a list of whitelisted globals for this test run.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#globals

                                                    • Set a list of whitelisted globals for this test run.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#globals

                                                    method inspect

                                                    inspect: () => string;
                                                    • Inspect the runnable void of private properties.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#inspect

                                                    method isFailed

                                                    isFailed: () => boolean;
                                                    • Return true if this Runnable has failed.

                                                    method isPassed

                                                    isPassed: () => boolean;
                                                    • Return true if this Runnable has passed.

                                                    method isPending

                                                    isPending: () => boolean;
                                                    • Check if this runnable or its parent suite is marked as pending.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#isPending

                                                    method resetTimeout

                                                    resetTimeout: () => void;
                                                    • Reset the timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#resetTimeout

                                                    method retries

                                                    retries: { (): number; (n: number): void };
                                                    • Set or get number of retries.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#retries

                                                    method run

                                                    run: (fn: Done) => void;
                                                    • Run the test and invoke fn(err).

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#run

                                                    method skip

                                                    skip: () => never;
                                                    • Halt and mark as pending.

                                                    method slow

                                                    slow: { (): number; (ms: string | number): this };
                                                    • Get test slowness threshold.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#slow

                                                    • Set test slowness threshold.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#slow

                                                    method timeout

                                                    timeout: { (): number; (ms: string | number): this };
                                                    • Get test timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#timeout

                                                    • Set test timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#timeout

                                                    method titlePath

                                                    titlePath: () => string[];
                                                    • Return the title path generated by concatenating the parent's title path with the title.

                                                    class Runner

                                                    class Runner {}
                                                    • Initialize a Runner for the given suite.

                                                      See Also

                                                      • https://mochajs.org/api/Mocha.Runner.html

                                                    constructor

                                                    constructor(suite: Suite, optionsOrDelay?: boolean | RunnerOptions);
                                                    • Initialize a Runner at the Root Suite, which represents a hierarchy of Suites and Tests.

                                                      Parameter suite

                                                      Root suite

                                                      Parameter optionsOrDelay

                                                      Options. If boolean (deprecated), whether or not to delay execution of root suite until ready.

                                                    property allowUncaught

                                                    allowUncaught?: boolean;

                                                      property asyncOnly

                                                      asyncOnly?: boolean;

                                                        property checkLeaks

                                                        checkLeaks?: boolean;

                                                          property constants

                                                          static readonly constants: RunnerConstants;

                                                            property currentRunnable

                                                            currentRunnable?: Runnable;

                                                              property failures

                                                              failures: number;

                                                                property forbidOnly

                                                                forbidOnly?: boolean;

                                                                  property forbidPending

                                                                  forbidPending?: boolean;

                                                                    property fullStackTrace

                                                                    fullStackTrace?: boolean;

                                                                      property started

                                                                      started: boolean;

                                                                        property stats

                                                                        stats?: Stats;

                                                                          property suite

                                                                          suite: Suite;

                                                                            property test

                                                                            test?: Test;

                                                                              property total

                                                                              total: number;

                                                                                method abort

                                                                                abort: () => this;
                                                                                • Cleanly abort execution.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#.Runner#abort

                                                                                method checkGlobals

                                                                                protected checkGlobals: (test: Test) => void;
                                                                                • Check for global variable leaks.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#checkGlobals

                                                                                method dispose

                                                                                dispose: () => void;
                                                                                • Removes all event handlers set during a run on this instance. Remark: this does *not* clean/dispose the tests or suites themselves.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/runner#dispose

                                                                                method fail

                                                                                protected fail: (test: Test, err: any) => void;
                                                                                • Fail the given test.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#fail

                                                                                method failHook

                                                                                protected failHook: (hook: Hook, err: any) => void;
                                                                                • Fail the given hook with err.

                                                                                  Hook failures work in the following pattern: - If bail, then exit - Failed before hook skips all tests in a suite and subsuites, but jumps to corresponding after hook - Failed before each hook skips remaining tests in a suite and jumps to corresponding after each hook, which is run only once - Failed after hook does not alter execution order - Failed after each hook skips remaining tests in a suite and subsuites, but executes other after each hooks

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#failHook

                                                                                method globalProps

                                                                                protected globalProps: () => string[];
                                                                                • Return a list of global properties.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#globalProps

                                                                                method globals

                                                                                globals: { (): string[]; (arr: readonly string[]): this };
                                                                                • Gets the allowed globals.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#.Runner#globals

                                                                                • Allow the given arr of globals.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#.Runner#globals

                                                                                method grep

                                                                                grep: (re: RegExp, invert: boolean) => this;
                                                                                • Run tests with full titles matching re. Updates runner.total with number of tests matched.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#.Runner#grep

                                                                                method grepTotal

                                                                                grepTotal: (suite: Suite) => number;
                                                                                • Returns the number of tests matching the grep search for the given suite.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#.Runner#grepTotal

                                                                                method hook

                                                                                protected hook: (name: string, fn: () => void) => void;
                                                                                • Run hook name callbacks and then invoke fn().

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#hook

                                                                                method hookDown

                                                                                protected hookDown: (
                                                                                name: string,
                                                                                fn: (err?: any, errSuite?: Suite) => void
                                                                                ) => void;
                                                                                • Run hooks from the bottom up.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#hookDown

                                                                                method hooks

                                                                                protected hooks: (
                                                                                name: string,
                                                                                suites: Suite[],
                                                                                fn: (err?: any, errSuite?: Suite) => void
                                                                                ) => void;
                                                                                • Run hook name for the given array of suites in order, and callback fn(err, errSuite).

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#hooks

                                                                                method hookUp

                                                                                protected hookUp: (
                                                                                name: string,
                                                                                fn: (err?: any, errSuite?: Suite) => void
                                                                                ) => void;
                                                                                • Run hooks from the top level down.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#hookUp

                                                                                method immediately

                                                                                protected static immediately: (callback: Function) => void;
                                                                                • Wrapper for setImmediate, process.nextTick, or browser polyfill.

                                                                                method parents

                                                                                protected parents: () => Suite[];
                                                                                • Return an array of parent Suites from closest to furthest.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#parents

                                                                                method run

                                                                                run: (fn?: (failures: number) => void) => this;
                                                                                • Run the root suite and invoke fn(failures) on completion.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#.Runner#run

                                                                                method runSuite

                                                                                protected runSuite: (suite: Suite, fn: (errSuite?: Suite) => void) => void;
                                                                                • Run the given suite and invoke the callback fn() when complete.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#runSuite

                                                                                method runTest

                                                                                protected runTest: (fn: Done) => any;
                                                                                • Run the current test and callback fn(err).

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#runTest

                                                                                method runTests

                                                                                protected runTests: (suite: Suite, fn: (errSuite?: Suite) => void) => void;
                                                                                • Run tests in the given suite and invoke the callback fn() when complete.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#runTests

                                                                                method uncaught

                                                                                uncaught: (err: any) => void;
                                                                                • Handle uncaught exceptions.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Runner.html#uncaught

                                                                                class Suite

                                                                                class Suite {}
                                                                                • Initialize a new Suite with the given title and ctx.

                                                                                  See Also

                                                                                  • https://mochajs.org/api/Mocha.Suite.html

                                                                                constructor

                                                                                constructor(title: string, parentContext?: Context);

                                                                                  property constants

                                                                                  static readonly constants: SuiteConstants;

                                                                                    property ctx

                                                                                    ctx: Context;

                                                                                      property delayed

                                                                                      delayed: boolean;

                                                                                        property file

                                                                                        file?: string;

                                                                                          property parent

                                                                                          parent: Suite;

                                                                                            property pending

                                                                                            pending: boolean;

                                                                                              property root

                                                                                              root: boolean;

                                                                                                property suites

                                                                                                suites: Suite[];

                                                                                                  property tests

                                                                                                  tests: Test[];

                                                                                                    property title

                                                                                                    title: string;

                                                                                                      method addSuite

                                                                                                      addSuite: (suite: Suite) => this;
                                                                                                      • Add a test suite.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#addSuite

                                                                                                      method addTest

                                                                                                      addTest: (test: Test) => this;
                                                                                                      • Add a test to this suite.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#addTest

                                                                                                      method afterAll

                                                                                                      afterAll: {
                                                                                                      (fn?: Func): this;
                                                                                                      (fn?: AsyncFunc): this;
                                                                                                      (title: string, fn?: Func): this;
                                                                                                      (title: string, fn?: AsyncFunc): this;
                                                                                                      };
                                                                                                      • Run fn(test[, done]) after running tests.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#afterAll

                                                                                                      method afterEach

                                                                                                      afterEach: {
                                                                                                      (fn?: Func): this;
                                                                                                      (fn?: AsyncFunc): this;
                                                                                                      (title: string, fn?: Func): this;
                                                                                                      (title: string, fn?: AsyncFunc): this;
                                                                                                      };
                                                                                                      • Run fn(test[, done]) after each test case.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#afterEach

                                                                                                      method bail

                                                                                                      bail: { (): boolean; (bail: boolean): this };
                                                                                                      • Get whether to bail after first error.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#bail

                                                                                                      • Set whether to bail after first error.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#bail

                                                                                                      method beforeAll

                                                                                                      beforeAll: {
                                                                                                      (fn?: Func): this;
                                                                                                      (fn?: AsyncFunc): this;
                                                                                                      (title: string, fn?: Func): this;
                                                                                                      (title: string, fn?: AsyncFunc): this;
                                                                                                      };
                                                                                                      • Run fn(test[, done]) before running tests.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#beforeAll

                                                                                                      method beforeEach

                                                                                                      beforeEach: {
                                                                                                      (fn?: Func): this;
                                                                                                      (fn?: AsyncFunc): this;
                                                                                                      (title: string, fn?: Func): this;
                                                                                                      (title: string, fn?: AsyncFunc): this;
                                                                                                      };
                                                                                                      • Run fn(test[, done]) before each test case.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#beforeEach

                                                                                                      method clone

                                                                                                      clone: () => Suite;
                                                                                                      • Return a clone of this Suite.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#clone

                                                                                                      method create

                                                                                                      static create: (parent: Suite, title: string) => Suite;
                                                                                                      • Create a new Suite with the given title and parent Suite. When a suite with the same title is already present, that suite is returned to provide nicer reporter and more flexible meta-testing.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/mocha#.exports.create

                                                                                                      method dispose

                                                                                                      dispose: () => void;
                                                                                                      • Cleans all references from this suite and all child suites.

                                                                                                        https://mochajs.org/api/suite#dispose

                                                                                                      method eachTest

                                                                                                      eachTest: (fn: (test: Test) => void) => this;
                                                                                                      • Iterates through each suite recursively to find all tests. Applies a function in the format fn(test).

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#eachTest

                                                                                                      method fullTitle

                                                                                                      fullTitle: () => string;
                                                                                                      • Return the full title generated by recursively concatenating the parent's full title.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#.Suite#fullTitle

                                                                                                      method isPending

                                                                                                      isPending: () => boolean;
                                                                                                      • Check if this suite or its parent suite is marked as pending.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#isPending

                                                                                                      method retries

                                                                                                      retries: { (): number; (n: string | number): this };
                                                                                                      • Get number of times to retry a failed test.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#retries

                                                                                                      • Set number of times to retry a failed test.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#retries

                                                                                                      method run

                                                                                                      run: () => void;
                                                                                                      • This will run the root suite if we happen to be running in delayed mode.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#run

                                                                                                      method slow

                                                                                                      slow: { (): number; (ms: string | number): this };
                                                                                                      • Get slow ms.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#slow

                                                                                                      • Set slow ms or short-hand such as "2s".

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#slow

                                                                                                      method timeout

                                                                                                      timeout: { (): number; (ms: string | number): this };
                                                                                                      • Get timeout ms.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#timeout

                                                                                                      • Set timeout ms or short-hand such as "2s".

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#timeout

                                                                                                      method titlePath

                                                                                                      titlePath: () => string[];
                                                                                                      • Return the title path generated by recursively concatenating the parent's title path.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#.Suite#titlePath

                                                                                                      method total

                                                                                                      total: () => number;
                                                                                                      • Return the total number of tests.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Mocha.Suite.html#.Suite#total

                                                                                                      class Test

                                                                                                      class Test extends Runnable {}
                                                                                                      • Initialize a new Test with the given title and callback fn.

                                                                                                        See Also

                                                                                                        • https://mochajs.org/api/Test.html

                                                                                                      property err

                                                                                                      err?: Error;

                                                                                                        property speed

                                                                                                        speed?: 'slow' | 'medium' | 'fast';

                                                                                                          property type

                                                                                                          type: string;

                                                                                                            method clone

                                                                                                            clone: () => Test;

                                                                                                              interface ExclusiveSuiteFunction

                                                                                                              interface ExclusiveSuiteFunction {}

                                                                                                                call signature

                                                                                                                (title: string, fn: (this: Suite) => void): Suite;
                                                                                                                • [bdd, tdd] Describe a "suite" with the given title and callback fn containing nested suites. Indicates this suite should be executed exclusively.

                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                call signature

                                                                                                                (title: string): Suite;
                                                                                                                • [qunit] Describe a "suite" with the given title. Indicates this suite should be executed exclusively.

                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                interface ExclusiveTestFunction

                                                                                                                interface ExclusiveTestFunction {}

                                                                                                                  call signature

                                                                                                                  (fn: Func): Test;
                                                                                                                  • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should be executed exclusively.

                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                  call signature

                                                                                                                  (fn: AsyncFunc): Test;
                                                                                                                  • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should be executed exclusively.

                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                  call signature

                                                                                                                  (title: string, fn?: Func): Test;
                                                                                                                  • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should be executed exclusively.

                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                  call signature

                                                                                                                  (title: string, fn?: AsyncFunc): Test;
                                                                                                                  • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should be executed exclusively.

                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                  interface HookFunction

                                                                                                                  interface HookFunction {}

                                                                                                                    call signature

                                                                                                                    (fn: Func): void;
                                                                                                                    • [bdd, qunit, tdd] Describe a "hook" to execute the given callback fn. The name of the function is used as the name of the hook.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    call signature

                                                                                                                    (fn: AsyncFunc): void;
                                                                                                                    • [bdd, qunit, tdd] Describe a "hook" to execute the given callback fn. The name of the function is used as the name of the hook.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    call signature

                                                                                                                    (name: string, fn?: Func): void;
                                                                                                                    • [bdd, qunit, tdd] Describe a "hook" to execute the given title and callback fn.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    call signature

                                                                                                                    (name: string, fn?: AsyncFunc): void;
                                                                                                                    • [bdd, qunit, tdd] Describe a "hook" to execute the given title and callback fn.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    interface InterfaceContributions

                                                                                                                    interface InterfaceContributions {}
                                                                                                                    • Third-party declarations that want to add new entries to the Interface union can contribute names here.

                                                                                                                    property bdd

                                                                                                                    bdd: never;

                                                                                                                      property exports

                                                                                                                      exports: never;

                                                                                                                        property qunit

                                                                                                                        qunit: never;

                                                                                                                          property tdd

                                                                                                                          tdd: never;

                                                                                                                            interface MochaGlobals

                                                                                                                            interface MochaGlobals {}
                                                                                                                            • Variables added to the global scope by Mocha when run in the CLI.

                                                                                                                            property after

                                                                                                                            after: HookFunction;
                                                                                                                            • Execute after running tests.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                              See Also

                                                                                                                              • https://mochajs.org/api/global.html#after

                                                                                                                            property afterEach

                                                                                                                            afterEach: HookFunction;
                                                                                                                            • Execute after each test case.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                              See Also

                                                                                                                              • https://mochajs.org/api/global.html#afterEach

                                                                                                                            property before

                                                                                                                            before: HookFunction;
                                                                                                                            • Execute before running tests.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                              See Also

                                                                                                                              • https://mochajs.org/api/global.html#before

                                                                                                                            property beforeEach

                                                                                                                            beforeEach: HookFunction;
                                                                                                                            • Execute before each test case.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                              See Also

                                                                                                                              • https://mochajs.org/api/global.html#beforeEach

                                                                                                                            property context

                                                                                                                            context: SuiteFunction;
                                                                                                                            • Describe a "suite" containing nested suites and tests.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                            property describe

                                                                                                                            describe: SuiteFunction;
                                                                                                                            • Describe a "suite" containing nested suites and tests.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                            property it

                                                                                                                            it: TestFunction;
                                                                                                                            • Describes a test case.

                                                                                                                              - _Only available when invoked via the mocha CLI._

                                                                                                                            property run

                                                                                                                            run: typeof run;

                                                                                                                              property setup

                                                                                                                              setup: HookFunction;
                                                                                                                              • Execute before each test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#beforeEach

                                                                                                                              property specify

                                                                                                                              specify: TestFunction;
                                                                                                                              • Describes a test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property suite

                                                                                                                              suite: SuiteFunction;
                                                                                                                              • Describe a "suite" containing nested suites and tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property suiteSetup

                                                                                                                              suiteSetup: HookFunction;
                                                                                                                              • Execute before running tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#before

                                                                                                                              property suiteTeardown

                                                                                                                              suiteTeardown: HookFunction;
                                                                                                                              • Execute after running tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#after

                                                                                                                              property teardown

                                                                                                                              teardown: HookFunction;
                                                                                                                              • Execute after each test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#afterEach

                                                                                                                              property test

                                                                                                                              test: TestFunction;
                                                                                                                              • Describes a test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property xcontext

                                                                                                                              xcontext: PendingSuiteFunction;
                                                                                                                              • Pending suite.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property xdescribe

                                                                                                                              xdescribe: PendingSuiteFunction;
                                                                                                                              • Pending suite.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property xit

                                                                                                                              xit: PendingTestFunction;
                                                                                                                              • Describes a pending test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property xspecify

                                                                                                                              xspecify: PendingTestFunction;
                                                                                                                              • Describes a pending test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              interface MochaInstanceOptions

                                                                                                                              interface MochaInstanceOptions extends MochaOptions {}

                                                                                                                                property files

                                                                                                                                files?: string[] | undefined;

                                                                                                                                  interface MochaOptions

                                                                                                                                  interface MochaOptions {}
                                                                                                                                  • Options to pass to Mocha.

                                                                                                                                  property allowUncaught

                                                                                                                                  allowUncaught?: boolean | undefined;
                                                                                                                                  • Propagate uncaught errors?

                                                                                                                                  property asyncOnly

                                                                                                                                  asyncOnly?: boolean | undefined;
                                                                                                                                  • Force done callback or promise?

                                                                                                                                  property bail

                                                                                                                                  bail?: boolean | undefined;
                                                                                                                                  • bail on the first test failure.

                                                                                                                                  property checkLeaks

                                                                                                                                  checkLeaks?: boolean | undefined;
                                                                                                                                  • Check for global variable leaks?

                                                                                                                                  property color

                                                                                                                                  color?: boolean | undefined;
                                                                                                                                  • Color TTY output from reporter

                                                                                                                                  property delay

                                                                                                                                  delay?: boolean | undefined;
                                                                                                                                  • Delay root suite execution?

                                                                                                                                  property diff

                                                                                                                                  diff?: boolean | undefined;
                                                                                                                                  • Show diff on failure?

                                                                                                                                  property dryRun

                                                                                                                                  dryRun?: boolean | undefined;
                                                                                                                                  • Report tests without running them?

                                                                                                                                  property fgrep

                                                                                                                                  fgrep?: string | undefined;
                                                                                                                                  • Test filter given string.

                                                                                                                                  property forbidOnly

                                                                                                                                  forbidOnly?: boolean | undefined;
                                                                                                                                  • Tests marked only fail the suite?

                                                                                                                                  property forbidPending

                                                                                                                                  forbidPending?: boolean | undefined;
                                                                                                                                  • Pending tests fail the suite?

                                                                                                                                  property fullTrace

                                                                                                                                  fullTrace?: boolean | undefined;
                                                                                                                                  • Full stacktrace upon failure?

                                                                                                                                  property globals

                                                                                                                                  globals?: string[] | undefined;
                                                                                                                                  • Variables expected in global scope.

                                                                                                                                  property grep

                                                                                                                                  grep?: string | RegExp | undefined;
                                                                                                                                  • Test filter given regular expression.

                                                                                                                                  property growl

                                                                                                                                  growl?: boolean | undefined;
                                                                                                                                  • Enable desktop notifications?

                                                                                                                                  property inlineDiffs

                                                                                                                                  inlineDiffs?: boolean | undefined;
                                                                                                                                  • Display inline diffs?

                                                                                                                                  property invert

                                                                                                                                  invert?: boolean | undefined;
                                                                                                                                  • Invert test filter matches?

                                                                                                                                  property isWorker

                                                                                                                                  isWorker?: boolean | undefined;
                                                                                                                                  • Should be true if Mocha process is running in a worker process.

                                                                                                                                  property jobs

                                                                                                                                  jobs?: number | undefined;
                                                                                                                                  • Max number of worker processes for parallel runs.

                                                                                                                                  property noHighlighting

                                                                                                                                  noHighlighting?: boolean | undefined;
                                                                                                                                  • Disable syntax highlighting?

                                                                                                                                  property parallel

                                                                                                                                  parallel?: boolean | undefined;
                                                                                                                                  • Run jobs in parallel

                                                                                                                                  property reporter

                                                                                                                                  reporter?: string | ReporterConstructor | undefined;
                                                                                                                                  • Reporter name or constructor.

                                                                                                                                  property reporterOptions

                                                                                                                                  reporterOptions?: any;
                                                                                                                                  • Reporter settings object.

                                                                                                                                  property require

                                                                                                                                  require?: string[] | undefined;
                                                                                                                                  • Pathname of rootHooks plugin for parallel runs.

                                                                                                                                  property retries

                                                                                                                                  retries?: number | undefined;
                                                                                                                                  • Number of times to retry failed tests.

                                                                                                                                  property rootHooks

                                                                                                                                  rootHooks?: RootHookObject | undefined;
                                                                                                                                  • Hooks to bootstrap the root suite with.

                                                                                                                                  property slow

                                                                                                                                  slow?: number | undefined;
                                                                                                                                  • Slow threshold value.

                                                                                                                                  property timeout

                                                                                                                                  timeout?: number | string | undefined;
                                                                                                                                  • Timeout threshold value.

                                                                                                                                  property ui

                                                                                                                                  ui?: Interface | undefined;
                                                                                                                                  • Interface name.

                                                                                                                                  interface PendingSuiteFunction

                                                                                                                                  interface PendingSuiteFunction {}
                                                                                                                                  • [bdd, tdd] Describe a "suite" with the given title and callback fn containing nested suites. Indicates this suite should not be executed.

                                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                                    Returns

                                                                                                                                    [tdd] void

                                                                                                                                  call signature

                                                                                                                                  (title: string, fn: (this: Suite) => void): Suite | void;

                                                                                                                                    interface PendingTestFunction

                                                                                                                                    interface PendingTestFunction {}

                                                                                                                                      call signature

                                                                                                                                      (fn: Func): Test;
                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should not be executed.

                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                      call signature

                                                                                                                                      (fn: AsyncFunc): Test;
                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should not be executed.

                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                      call signature

                                                                                                                                      (title: string, fn?: Func): Test;
                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should not be executed.

                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                      call signature

                                                                                                                                      (title: string, fn?: AsyncFunc): Test;
                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should not be executed.

                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                      interface ReporterConstructor

                                                                                                                                      interface ReporterConstructor {}

                                                                                                                                        construct signature

                                                                                                                                        new (runner: Runner, options: MochaOptions): reporters.Base;

                                                                                                                                          interface ReporterContributions

                                                                                                                                          interface ReporterContributions {}
                                                                                                                                          • Third-party declarations that want to add new entries to the Reporter union can contribute names here.

                                                                                                                                          property "json-stream"

                                                                                                                                          'json-stream': never;

                                                                                                                                            property base

                                                                                                                                            base: never;

                                                                                                                                              property Base

                                                                                                                                              Base: never;

                                                                                                                                                property dot

                                                                                                                                                dot: never;

                                                                                                                                                  property Dot

                                                                                                                                                  Dot: never;

                                                                                                                                                    property html

                                                                                                                                                    html: never;

                                                                                                                                                      property HTML

                                                                                                                                                      HTML: never;

                                                                                                                                                        property json

                                                                                                                                                        json: never;

                                                                                                                                                          property JSON

                                                                                                                                                          JSON: never;

                                                                                                                                                            property JSONStream

                                                                                                                                                            JSONStream: never;

                                                                                                                                                              property landing

                                                                                                                                                              landing: never;

                                                                                                                                                                property Landing

                                                                                                                                                                Landing: never;

                                                                                                                                                                  property list

                                                                                                                                                                  list: never;

                                                                                                                                                                    property List

                                                                                                                                                                    List: never;

                                                                                                                                                                      property markdown

                                                                                                                                                                      markdown: never;

                                                                                                                                                                        property Markdown

                                                                                                                                                                        Markdown: never;

                                                                                                                                                                          property min

                                                                                                                                                                          min: never;

                                                                                                                                                                            property Min

                                                                                                                                                                            Min: never;

                                                                                                                                                                              property nyan

                                                                                                                                                                              nyan: never;

                                                                                                                                                                                property Nyan

                                                                                                                                                                                Nyan: never;

                                                                                                                                                                                  property progress

                                                                                                                                                                                  progress: never;

                                                                                                                                                                                    property Progress

                                                                                                                                                                                    Progress: never;

                                                                                                                                                                                      property spec

                                                                                                                                                                                      spec: never;

                                                                                                                                                                                        property Spec

                                                                                                                                                                                        Spec: never;

                                                                                                                                                                                          property tap

                                                                                                                                                                                          tap: never;

                                                                                                                                                                                            property TAP

                                                                                                                                                                                            TAP: never;

                                                                                                                                                                                              property xunit

                                                                                                                                                                                              xunit: never;

                                                                                                                                                                                                property XUnit

                                                                                                                                                                                                XUnit: never;

                                                                                                                                                                                                  interface RootHookObject

                                                                                                                                                                                                  interface RootHookObject {}
                                                                                                                                                                                                  • An alternative way to define root hooks that works with parallel runs.

                                                                                                                                                                                                    Root hooks work with any interface, but the property names do not change. In other words, if you are using the tdd interface, suiteSetup maps to beforeAll, and setup maps to beforeEach.

                                                                                                                                                                                                    As with other hooks, this refers to to the current context object.

                                                                                                                                                                                                    See Also

                                                                                                                                                                                                    • https://mochajs.org/#root-hook-plugins

                                                                                                                                                                                                  property afterAll

                                                                                                                                                                                                  afterAll?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
                                                                                                                                                                                                  • In serial mode, run after all tests end, once only. In parallel mode, run after all tests end, for each file.

                                                                                                                                                                                                  property afterEach

                                                                                                                                                                                                  afterEach?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
                                                                                                                                                                                                  • In both modes, run after every test.

                                                                                                                                                                                                  property beforeAll

                                                                                                                                                                                                  beforeAll?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
                                                                                                                                                                                                  • In serial mode (Mocha's default), before all tests begin, once only. In parallel mode, run before all tests begin, for each file.

                                                                                                                                                                                                  property beforeEach

                                                                                                                                                                                                  beforeEach?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
                                                                                                                                                                                                  • In both modes, run before each test.

                                                                                                                                                                                                  interface Runnable

                                                                                                                                                                                                  interface Runnable extends NodeJS.EventEmitter {}

                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                    (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                    };

                                                                                                                                                                                                      method emit

                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                      (name: 'error', error: any): boolean;
                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                      };

                                                                                                                                                                                                        method on

                                                                                                                                                                                                        on: {
                                                                                                                                                                                                        (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          method once

                                                                                                                                                                                                          once: {
                                                                                                                                                                                                          (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                            (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                              (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  interface Runnable

                                                                                                                                                                                                                  interface Runnable extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                    (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                      (name: 'error', error: any): boolean;
                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                      };

                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                        (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                          (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                            (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                              (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                  interface Runner {}

                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;