@types/jasminewd2

  • Version 2.0.10
  • Published
  • 7.06 kB
  • 1 dependency
  • MIT license

Install

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

Overview

TypeScript definitions for jasminewd2

Index

Functions

function afterAll

afterAll: (action: (done: any) => Promise<void>, timeout?: number) => void;

    function afterEach

    afterEach: (action: (done: any) => Promise<void>, timeout?: number) => void;

      function beforeAll

      beforeAll: (action: (done: any) => Promise<void>, timeout?: number) => void;

        function beforeEach

        beforeEach: (action: (done: any) => Promise<void>, timeout?: number) => void;

          function fit

          fit: (
          expectation: string,
          assertion?: (done: any) => Promise<void>,
          timeout?: number
          ) => void;

            function it

            it: (
            expectation: string,
            assertion?: (done: any) => Promise<void>,
            timeout?: number
            ) => void;

              function xit

              xit: (
              expectation: string,
              assertion?: (done: any) => Promise<void>,
              timeout?: number
              ) => void;

                Namespaces

                namespace jasmine

                namespace jasmine {}

                  function addMatchers

                  addMatchers: (matchers: AsyncCustomMatcherFactories) => void;

                    interface ArrayLikeMatchers

                    interface ArrayLikeMatchers<T> extends Matchers<ArrayLike<T>> {}

                      property not

                      not: ArrayLikeMatchers<T>;

                        method toBe

                        toBe: (expected: any, expectationFailOutput?: any) => Promise<void>;

                          method toContain

                          toContain: (expected: T, expectationFailOutput?: any) => Promise<void>;

                            method toEqual

                            toEqual: (expected: any, expectationFailOutput?: any) => Promise<void>;

                              interface AsyncCustomMatcher

                              interface AsyncCustomMatcher {}

                                method compare

                                compare: {
                                <T>(actual: T, expected: T): AsyncCustomMatcherResult;
                                (actual: any, expected: any): AsyncCustomMatcherResult;
                                };

                                  interface AsyncCustomMatcherFactories

                                  interface AsyncCustomMatcherFactories {}

                                    index signature

                                    [index: string]: AsyncCustomMatcherFactory;

                                      interface AsyncCustomMatcherFactory

                                      interface AsyncCustomMatcherFactory {}

                                        call signature

                                        (
                                        util: MatchersUtil,
                                        customEqualityTesters: CustomEqualityTester[]
                                        ): AsyncCustomMatcher;

                                          interface AsyncCustomMatcherResult

                                          interface AsyncCustomMatcherResult {}

                                            property message

                                            message?: string | undefined;

                                              property pass

                                              pass: boolean | Promise<boolean>;

                                                interface FunctionMatchers

                                                interface FunctionMatchers<Fn extends (...args: any[]) => any>
                                                extends Matchers<any> {}

                                                  method toHaveBeenCalledWith

                                                  toHaveBeenCalledWith: {
                                                  (...params: any[]): boolean;
                                                  (...params: any[]): Promise<void>;
                                                  };

                                                    interface Matchers

                                                    interface Matchers<T> {}

                                                      method toBe

                                                      toBe: (expected: any, expectationFailOutput?: any) => Promise<void>;

                                                        method toBeCloseTo

                                                        toBeCloseTo: (
                                                        expected: number | Promise<number>,
                                                        precision?: any,
                                                        expectationFailOutput?: any
                                                        ) => Promise<void>;

                                                          method toBeDefined

                                                          toBeDefined: (expectationFailOutput?: any) => Promise<void>;

                                                            method toBeFalsy

                                                            toBeFalsy: (expectationFailOutput?: any) => Promise<void>;

                                                              method toBeGreaterThan

                                                              toBeGreaterThan: (
                                                              expected: number | Promise<number>,
                                                              expectationFailOutput?: any
                                                              ) => Promise<void>;

                                                                method toBeGreaterThanOrEqual

                                                                toBeGreaterThanOrEqual: (
                                                                expected: number | Promise<number>,
                                                                expectationFailOutput?: any
                                                                ) => Promise<void>;

                                                                  method toBeLessThan

                                                                  toBeLessThan: (
                                                                  expected: number | Promise<number>,
                                                                  expectationFailOutput?: any
                                                                  ) => Promise<void>;

                                                                    method toBeLessThanOrEqual

                                                                    toBeLessThanOrEqual: (
                                                                    expected: number | Promise<number>,
                                                                    expectationFailOutput?: any
                                                                    ) => Promise<void>;

                                                                      method toBeNaN

                                                                      toBeNaN: () => Promise<void>;

                                                                        method toBeNull

                                                                        toBeNull: (expectationFailOutput?: any) => Promise<void>;

                                                                          method toBeTruthy

                                                                          toBeTruthy: (expectationFailOutput?: any) => Promise<void>;

                                                                            method toBeUndefined

                                                                            toBeUndefined: (expectationFailOutput?: any) => Promise<void>;

                                                                              method toContain

                                                                              toContain: (expected: any, expectationFailOutput?: any) => Promise<void>;

                                                                                method toEqual

                                                                                toEqual: (expected: any, expectationFailOutput?: any) => Promise<void>;

                                                                                  method toHaveBeenCalled

                                                                                  toHaveBeenCalled: () => Promise<void>;

                                                                                    method toHaveBeenCalledTimes

                                                                                    toHaveBeenCalledTimes: (expected: number | Promise<number>) => Promise<void>;

                                                                                      method toHaveBeenCalledWith

                                                                                      toHaveBeenCalledWith: (...params: any[]) => Promise<void>;

                                                                                        method toMatch

                                                                                        toMatch: (
                                                                                        expected: string | RegExp | Promise<string | RegExp>,
                                                                                        expectationFailOutput?: any
                                                                                        ) => Promise<void>;

                                                                                          method toThrow

                                                                                          toThrow: (expected?: any) => Promise<void>;

                                                                                            method toThrowError

                                                                                            toThrowError: {
                                                                                            (message?: string | RegExp | Promise<string | RegExp>): Promise<void>;
                                                                                            (
                                                                                            expected?: new (...args: any[]) =>
                                                                                            | Error
                                                                                            | Promise<new (...args: any[]) => Error>,
                                                                                            message?: string | RegExp | Promise<string | RegExp>
                                                                                            ): Promise<void>;
                                                                                            };

                                                                                              interface Spec

                                                                                              interface Spec {}

                                                                                                method addMatchers

                                                                                                addMatchers: (matchers: AsyncCustomMatcherFactories) => void;

                                                                                                  Package Files (1)

                                                                                                  Dependencies (1)

                                                                                                  Dev Dependencies (0)

                                                                                                  No dev dependencies.

                                                                                                  Peer Dependencies (0)

                                                                                                  No peer dependencies.

                                                                                                  Badge

                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/jasminewd2.

                                                                                                  • Markdown
                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/jasminewd2)
                                                                                                  • HTML
                                                                                                    <a href="https://www.jsdocs.io/package/@types/jasminewd2"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>