1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.// This module is browser compatible.import { AssertionError } from "./assertion_error.ts";import { assertIsError } from "./assert_is_error.ts";
/** * Executes a function which returns a promise, expecting it to reject. * * To assert that a synchronous function throws, use {@linkcode assertThrows}. * * @example * ```ts * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts"; * * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw * await assertRejects(async () => console.log("Hello world")); // Throws * ``` */export function assertRejects(  fn: () => PromiseLike<unknown>,  msg?: string,): Promise<unknown>;/** * Executes a function which returns a promise, expecting it to reject. * If it does not, then it throws. An error class and a string that should be * included in the error message can also be asserted. * * To assert that a synchronous function throws, use {@linkcode assertThrows}. * * @example * ```ts * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts"; * * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws * ``` */export function assertRejects<E extends Error = Error>(  fn: () => PromiseLike<unknown>,  // deno-lint-ignore no-explicit-any  ErrorClass: new (...args: any[]) => E,  msgIncludes?: string,  msg?: string,): Promise<E>;export async function assertRejects<E extends Error = Error>(  fn: () => PromiseLike<unknown>,  errorClassOrMsg?:    // deno-lint-ignore no-explicit-any    | (new (...args: any[]) => E)    | string,  msgIncludesOrMsg?: string,  msg?: string,): Promise<E | Error | unknown> {  // deno-lint-ignore no-explicit-any  let ErrorClass: (new (...args: any[]) => E) | undefined = undefined;  let msgIncludes: string | undefined = undefined;  let err;
  if (typeof errorClassOrMsg !== "string") {    if (      errorClassOrMsg === undefined ||      errorClassOrMsg.prototype instanceof Error ||      errorClassOrMsg.prototype === Error.prototype    ) {      // deno-lint-ignore no-explicit-any      ErrorClass = errorClassOrMsg as new (...args: any[]) => E;      msgIncludes = msgIncludesOrMsg;    }  } else {    msg = errorClassOrMsg;  }  let doesThrow = false;  let isPromiseReturned = false;  const msgSuffix = msg ? `: ${msg}` : ".";  try {    const possiblePromise = fn();    if (      possiblePromise &&      typeof possiblePromise === "object" &&      typeof possiblePromise.then === "function"    ) {      isPromiseReturned = true;      await possiblePromise;    }  } catch (error) {    if (!isPromiseReturned) {      throw new AssertionError(        `Function throws when expected to reject${msgSuffix}`,      );    }    if (ErrorClass) {      if (error instanceof Error === false) {        throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);      }      assertIsError(        error,        ErrorClass,        msgIncludes,        msg,      );    }    err = error;    doesThrow = true;  }  if (!doesThrow) {    throw new AssertionError(      `Expected function to reject${msgSuffix}`,    );  }  return err;}