TypeScript jest-matcher-utils.ensureNoExpected函数代码示例

const createToReturnMatcher = (matcherName: string) => (
  received: any,
  expected: unknown,
): SyncExpectationResult => {
  ensureNoExpected(expected, matcherName);
  ensureMock(received, matcherName);

  const receivedName = received.getMockName();
  const identifier =
    receivedName === 'jest.fn()'
      ? 'mock function'
      : `mock function "${receivedName}"`;

  // List of return values that correspond only to calls that returned
  const returnValues = received.mock.results
    .filter((result: any) => result.type === 'return')
    .map((result: any) => result.value);

  const count = returnValues.length;
  const pass = count > 0;

  const message = pass
    ? () =>
        matcherHint('.not' + matcherName, receivedName, '') +
        '\n\n' +
        `Expected ${identifier} not to have returned, but it returned:\n` +
        `  ${getPrintedReturnValues(returnValues, RETURN_PRINT_LIMIT)}`
    : () =>
        matcherHint(matcherName, receivedName, '') +
        '\n\n' +
        `Expected ${identifier} to have returned.`;

  return {message, pass};
};

function hasAssertions(...args: Array<any>) {
  const error = new Error();
  if (Error.captureStackTrace) {
    Error.captureStackTrace(error, hasAssertions);
  }

  matcherUtils.ensureNoExpected(args[0], '.hasAssertions');
  getState().isExpectingAssertions = true;
  getState().isExpectingAssertionsError = error;
}

utils.SUGGEST_TO_EQUAL; // $ExpectType string

utils.stringify({}); // $ExpectType string
utils.stringify({}, 44);
utils.stringify({}, '44'); // $ExpectError
utils.stringify({}, false); // $ExpectError

utils.highlightTrailingWhitespace('', chalk.red); // $ExpectType string
utils.highlightTrailingWhitespace(44, chalk.blue); // $ExpectError
utils.highlightTrailingWhitespace(false, chalk.green); // $ExpectError

utils.printReceived({}); // $ExpectType string
utils.printExpected({}); // $ExpectType string
utils.printWithType('obj', {}, () => ''); // $ExpectType string

utils.ensureNoExpected(null, ''); // $ExpectType void
utils.ensureNoExpected('', '');

utils.ensureActualIsNumber(66); // $ExpectType void
utils.ensureActualIsNumber(66, 'highwayRouteMatcher');
utils.ensureActualIsNumber('66', 'highwayRouteMatcher');

utils.ensureExpectedIsNumber(66); // $ExpectType void
utils.ensureExpectedIsNumber(66, 'highwayRouteMatcher');
utils.ensureExpectedIsNumber('66', 'highwayRouteMatcher');

utils.ensureNumbers(66, 66); // $ExpectType void
utils.ensureNumbers(66, 66, 'highwayRouteMatcher');
utils.ensureNumbers('66', 'highwayRouteMatcher');
utils.ensureNumbers(66); // $ExpectError

          `Received: ${printReceived(received)}\n` +
          '\n' +
          `Expected precision:    ${printExpected(precision)}\n` +
          `Expected difference: < ${printExpected(expectedDiff)}\n` +
          `Received difference:   ${printReceived(receivedDiff)}`;

    return {message, pass};
  },

  toBeDefined(this: MatcherState, received: unknown, expected: void) {
    const matcherName = 'toBeDefined';
    const options: MatcherHintOptions = {
      isNot: this.isNot,
      promise: this.promise,
    };
    ensureNoExpected(expected, matcherName, options);

    const pass = received !== void 0;

    const message = () =>
      matcherHint(matcherName, undefined, '', options) +
      '\n\n' +
      `Received: ${printReceived(received)}`;

    return {message, pass};
  },

  toBeFalsy(this: MatcherState, received: unknown, expected: void) {
    const matcherName = 'toBeFalsy';
    const options: MatcherHintOptions = {
      isNot: this.isNot,

          `Expected: ${printExpected(expected)}\n` +
          `Received: ${printReceived(received)}\n` +
          '\n' +
          `Expected precision:    ${printExpected(precision)}\n` +
          `Expected difference: < ${printExpected(expectedDiff)}\n` +
          `Received difference:   ${printReceived(receivedDiff)}`;

    return {message, pass};
  },

  toBeDefined(this: MatcherState, received: unknown, expected: void) {
    const options: MatcherHintOptions = {
      isNot: this.isNot,
      promise: this.promise,
    };
    ensureNoExpected(expected, 'toBeDefined', options);

    const pass = received !== void 0;

    const message = () =>
      matcherHint('toBeDefined', undefined, '', options) +
      '\n\n' +
      `Received: ${printReceived(received)}`;

    return {message, pass};
  },

  toBeFalsy(this: MatcherState, received: unknown, expected: void) {
    const options: MatcherHintOptions = {
      isNot: this.isNot,
      promise: this.promise,