---
url: /api/assert.md
---
# assert

Vitest 从 [`chai`](https://www.chaijs.com/api/assert/) 重新导出 `assert` 方法，用于验证不变量。

::: warning In-Source Testing {#in-source-testing}
当在 [源内测试](/guide/in-source) 中使用来自 `import.meta.vitest` 的 [断言函数](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions)，例如 `assert` 时，TypeScript 会报告错误 `TS2775`，因为它们必须通过显式标注名称来调用。请将变量标注为 `Chai.Assert`，或者直接调用它：

::: code-group

```ts [Annotated variable]
if (import.meta.vitest) {
  const { test, assert } = import.meta.vitest // [!code --]
  const { test } = import.meta.vitest // [!code ++]
  const assert: Chai.Assert = import.meta.vitest.assert // [!code ++]

  test('assert', () => {
    assert('foo' !== 'bar', 'foo should not be equal to bar')
  })
}
```

```ts [Direct call]
if (import.meta.vitest) {
  const { test, assert } = import.meta.vitest // [!code --]
  const { test } = import.meta.vitest // [!code ++]

  test('assert', () => {
    assert('foo' !== 'bar', 'foo should not be equal to bar') // [!code --]
    import.meta.vitest!.assert('foo' !== 'bar', 'foo should not be equal to bar') // [!code ++]
  })
}
```

:::

## assert

* **类型:** `(expression: any, message?: string) => asserts expression`

断言给定的 `expression` 为真值，否则断言失败。

```ts
import { assert, test } from 'vitest'

test('assert', () => {
  assert('foo' !== 'bar', 'foo 不应该等于 bar')
})
```

## fail

* **类型:**
  * `(message?: string) => never`
  * `<T>(actual: T, expected: T, message?: string, operator?: string) => never`

强制断言失败。

```ts
import { assert, test } from 'vitest'

test('assert.fail', () => {
  assert.fail('失败时的错误信息')
  assert.fail('foo', 'bar', 'foo 不是 bar', '===')
})
```

## isOk

* **Type:** `<T>(value: T, message?: string) => asserts value`
* **Alias:** `ok`

断言给定的 `value` 为真值。

```ts
import { assert, test } from 'vitest'

test('assert.isOk', () => {
  assert.isOk('foo', '任何真值都是 ok')
  assert.isOk(false, '这会失败，因为 false 不是真值')
})
```

## isNotOk

* **Type:** `<T>(value: T, message?: string) => void`
* **Alias:** `notOk`

断言给定的 `value` 为假值。

```ts
import { assert, test } from 'vitest'

test('assert.isNotOk', () => {
  assert.isNotOk('foo', '这会失败，任何真值都不是 ok')
  assert.isNotOk(false, '这会通过，因为 false 是假值')
})
```

## equal

* **类型:** `<T>(actual: T, expected: T, message?: string) => void`

断言 `actual` 和 `expected` 非严格相等 (==)。

```ts
import { assert, test } from 'vitest'

test('assert.equal', () => {
  assert.equal(Math.sqrt(4), '2')
})
```

## notEqual

* **类型:** `<T>(actual: T, expected: T, message?: string) => void`

断言 `actual` 和 `expected` 非严格不等 (!=)。

```ts
import { assert, test } from 'vitest'

test('assert.equal', () => {
  assert.notEqual(Math.sqrt(4), 3)
})
```

## strictEqual

* **类型:** `<T>(actual: T, expected: T, message?: string) => void`

断言 `actual` 和 `expected` 严格相等 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.strictEqual', () => {
  assert.strictEqual(Math.sqrt(4), 2)
})
```

## deepEqual

* **类型:** `<T>(actual: T, expected: T, message?: string) => void`

断言 `actual` 与 `expected` 深度相等。

```ts
import { assert, test } from 'vitest'

test('assert.deepEqual', () => {
  assert.deepEqual({ color: 'green' }, { color: 'green' })
})
```

## notDeepEqual

* **类型:** `<T>(actual: T, expected: T, message?: string) => void`

断言 `actual` 与 `expected` 不深度相等。

```ts
import { assert, test } from 'vitest'

test('assert.notDeepEqual', () => {
  assert.notDeepEqual({ color: 'green' }, { color: 'red' })
})
```

## isAbove

* **类型:** `(valueToCheck: number, valueToBeAbove: number, message?: string) => void`

断言 `valueToCheck` 严格大于 (>) `valueToBeAbove`。

```ts
import { assert, test } from 'vitest'

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 严格大于 2')
})
```

## isAtLeast

* **类型:** `(valueToCheck: number, valueToBeAtLeast: number, message?: string) => void`

断言 `valueToCheck` 大于或等于 (>=) `valueToBeAtLeast`。

```ts
import { assert, test } from 'vitest'

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 大于或等于 2')
  assert.isAtLeast(3, 3, '3 大于或等于 3')
})
```

## isBelow

* **类型:** `(valueToCheck: number, valueToBeBelow: number, message?: string) => void`

断言 `valueToCheck` 严格小于 (<) `valueToBeBelow`。

```ts
import { assert, test } from 'vitest'

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 严格小于 6')
})
```

## isAtMost

* **类型:** `(valueToCheck: number, valueToBeAtMost: number, message?: string) => void`

断言 `valueToCheck` 小于或等于 (<=) `valueToBeAtMost`。

```ts
import { assert, test } from 'vitest'

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 小于或等于 6')
  assert.isAtMost(4, 4, '4 小于或等于 4')
})
```

## isTrue

* **类型:** `<T>(value: T, message?: string) => asserts value is true`

断言 `value` 为 true。

```ts
import { assert, test } from 'vitest'

const testPassed = true

test('assert.isTrue', () => {
  assert.isTrue(testPassed)
})
```

## isNotTrue

* **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, true>`

断言 `value` 不为 true。

```ts
import { assert, test } from 'vitest'

const testPassed = 'ok'

test('assert.isNotTrue', () => {
  assert.isNotTrue(testPassed)
})
```

## isFalse

* **类型:** `<T>(value: T, message?: string) => asserts value is false`

断言 `value` 为 false。

```ts
import { assert, test } from 'vitest'

const testPassed = false

test('assert.isFalse', () => {
  assert.isFalse(testPassed)
})
```

## isNotFalse

* **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, false>`

断言 `value` 不为 false。

```ts
import { assert, test } from 'vitest'

const testPassed = 'no'

test('assert.isNotFalse', () => {
  assert.isNotFalse(testPassed)
})
```

## isNull

* **类型:** `<T>(value: T, message?: string) => asserts value is null`

断言 `value` 为 null。

```ts
import { assert, test } from 'vitest'

const error = null

test('assert.isNull', () => {
  assert.isNull(error, 'error 为空')
})
```

## isNotNull

* **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, null>`

断言 `value` 不为 null。

```ts
import { assert, test } from 'vitest'

const error = { message: 'error was occurred' }

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error 不是 null 而是一个对象')
})
```

## isNaN

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 为 NaN。

```ts
import { assert, test } from 'vitest'

const calculation = 1 * 'vitest'

test('assert.isNaN', () => {
  assert.isNaN(calculation, '1 * "vitest" 是 NaN')
})
```

## isNotNaN

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 不为 NaN。

```ts
import { assert, test } from 'vitest'

const calculation = 1 * 2

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 不是 NaN，而是 2')
})
```

## exists

* **类型:** `<T>(value: T, message?: string) => asserts value is NonNullable<T>`

断言 `value` 既不是 null 也不是 undefined。

```ts
import { assert, test } from 'vitest'

const name = 'foo'

test('assert.exists', () => {
  assert.exists(name, 'foo 既不是 null 也不是 undefined')
})
```

## notExists

* **类型:** `<T>(value: T, message?: string) => asserts value is null | undefined`

断言 `value` 是 null 或 undefined。

```ts
import { assert, test } from 'vitest'

const foo = null
const bar = undefined

test('assert.notExists', () => {
  assert.notExists(foo, 'foo 是 null，所以不存在')
  assert.notExists(bar, 'bar 是 undefined，所以不存在')
})
```

## isUndefined

* **类型:** `<T>(value: T, message?: string) => asserts value is undefined`

断言 `value` 为 undefined。

```ts
import { assert, test } from 'vitest'

const name = undefined

test('assert.isUndefined', () => {
  assert.isUndefined(name, 'name 是 undefined')
})
```

## isDefined

* **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, undefined>`

断言 `value` 不为 undefined。

```ts
import { assert, test } from 'vitest'

const name = 'foo'

test('assert.isDefined', () => {
  assert.isDefined(name, 'name 不是 undefined')
})
```

## isFunction

* **类型:** `<T>(value: T, message?: string) => void`
* **别名:** `isCallable`
  断言 `value` 是一个函数。

```ts
import { assert, test } from 'vitest'

function name() { return 'foo' };

test('assert.isFunction', () => {
  assert.isFunction(name, 'name 是函数')
})
```

## isNotFunction

* **类型:** `<T>(value: T, message?: string) => void`
* **别名:** `isNotCallable`

断言 `value` 不是一个函数。

```ts
import { assert, test } from 'vitest'

const name = 'foo'

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name 不是函数而是字符串')
})
```

## isObject

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 是一个 Object 类型的对象（由 Object.prototype.toString 揭示）。该断言不匹配子类对象。

```ts
import { assert, test } from 'vitest'

const someThing = { color: 'red', shape: 'circle' }

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing 是对象')
})
```

## isNotObject

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 不是 Object 类型的对象（由 Object.prototype.toString 揭示）。该断言不匹配子类对象。

```ts
import { assert, test } from 'vitest'

const someThing = 'redCircle'

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing 不是对象而是字符串')
})
```

## isArray

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 是一个数组。

```ts
import { assert, test } from 'vitest'

const color = ['red', 'green', 'yellow']

test('assert.isArray', () => {
  assert.isArray(color, 'color 是数组')
})
```

## isNotArray

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 不是一个数组。

```ts
import { assert, test } from 'vitest'

const color = 'red'

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color 不是数组而是字符串')
})
```

## isString

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 是一个字符串。

```ts
import { assert, test } from 'vitest'

const color = 'red'

test('assert.isString', () => {
  assert.isString(color, 'color 是字符串')
})
```

## isNotString

* **类型:** `<T>(value: T, message?: string) => void`

断言 `value` 不是一个字符串。

```ts
import { assert, test } from 'vitest'

const color = ['red', 'green', 'yellow']

test('assert.isNotString', () => {
  assert.isNotString(color, 'color 不是字符串而是数组')
})
```

## isNumber

* **类型：** `<T>(value: T, message?: string) => void`

断言 `value` 是一个数字。

```ts
import { assert, test } from 'vitest'

const colors = 3

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors 是数字')
})
```

## isNotNumber

* **类型：** `<T>(value: T, message?: string) => void`

断言 `value` 不是一个数字。

```ts
import { assert, test } from 'vitest'

const colors = '3 colors'

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors 不是数字而是字符串')
})
```

## isFinite

* **类型：** `<T>(value: T, message?: string) => void`

断言 `value` 是一个有限数字（不是 NaN 或 Infinity）。

```ts
import { assert, test } from 'vitest'

const colors = 3

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors 是数字，不是 NaN 或 Infinity')
})
```

## isBoolean

* **类型：** `<T>(value: T, message?: string) => void`

断言 `value` 是一个布尔值。

```ts
import { assert, test } from 'vitest'

const isReady = true

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady 是一个布尔值')
})
```

## isNotBoolean

* **类型：** `<T>(value: T, message?: string) => void`

断言 `value` 不是一个布尔值。

```ts
import { assert, test } from 'vitest'

const isReady = 'sure'

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady 不是一个布尔值，而是字符串')
})
```

## typeOf

* **类型：** `<T>(value: T, name: string, message?: string) => void`

断言 `value` 的类型是 `name`，由 Object.prototype.toString 确定。

```ts
import { assert, test } from 'vitest'

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', '我们有一个对象')
  assert.typeOf(['red', 'green'], 'array', '我们有一个数组')
  assert.typeOf('red', 'string', '我们有一个字符串')
  assert.typeOf(/red/, 'regexp', '我们有一个正则表达式')
  assert.typeOf(null, 'null', '我们有一个 null')
  assert.typeOf(undefined, 'undefined', '我们有一个 undefined')
})
```

## notTypeOf

* **类型：** `<T>(value: T, name: string, message?: string) => void`

断言 `value` 的类型不是 `name`，由 Object.prototype.toString 确定。

```ts
import { assert, test } from 'vitest'

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" 不是一个数字')
})
```

## instanceOf

* **类型：** `<T>(value: T, constructor: Function, message?: string) => asserts value is T`

断言 `value` 是 `constructor` 的实例。

```ts
import { assert, test } from 'vitest'

function Person(name) { this.name = name }
const foo = new Person('foo')

class Tea {
  constructor(name) {
    this.name = name
  }
}
const coffee = new Tea('coffee')

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Person, 'foo 是 Person 的实例')
  assert.instanceOf(coffee, Tea, 'coffee 是 Tea 的实例')
})
```

## notInstanceOf

* **类型：** `<T>(value: T, constructor: Function, message?: string) => asserts value is Exclude<T, U>`

断言 `value` 不是 `constructor` 的实例。

```ts
import { assert, test } from 'vitest'

function Person(name) { this.name = name }
const foo = new Person('foo')

class Tea {
  constructor(name) {
    this.name = name
  }
}
const coffee = new Tea('coffee')

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Tea, 'foo 不是 Tea 的实例')
})
```

## include

* **类型：**
  * `(haystack: string, needle: string, message?: string) => void`
  * `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
  * `<T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void`
  * `<T>(haystack: T, needle: Partial<T>, message?: string) => void`

断言 `haystack` 包含 `needle`。可用于断言数组中包含某个值、字符串中包含某个子串，或对象中包含某个属性子集。

```ts
import { assert, test } from 'vitest'

test('assert.include', () => {
  assert.include([1, 2, 3], 2, '数组包含该值')
  assert.include('foobar', 'foo', '字符串包含该子串')
  assert.include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, '对象包含该属性')
})
```

## notInclude

* **类型：**
  * `(haystack: string, needle: string, message?: string) => void`
  * `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
  * `<T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void`
  * `<T>(haystack: T, needle: Partial<T>, message?: string) => void`

断言 `haystack` 不包含 `needle`。可用于断言数组中不存在某个值、字符串中不存在某个子串，或对象中不存在某个属性子集。

```ts
import { assert, test } from 'vitest'

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, '数组不包含 4')
  assert.notInclude('foobar', 'baz', 'foobar 不包含 baz')
  assert.notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, '对象不包含该属性')
})
```

## deepInclude

* **类型：**
* `(haystack: string, needle: string, message?: string) => void`
* `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
* `<T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void`

断言 `haystack` 包含 `needle`。可用于断言数组中包含某个值或对象中包含某个属性子集。使用深度相等性检查。

```ts
import { assert, test } from 'vitest'

const obj1 = { a: 1 }
const obj2 = { b: 2 }

test('assert.deepInclude', () => {
  assert.deepInclude([obj1, obj2], { a: 1 })
  assert.deepInclude({ foo: obj1, bar: obj2 }, { foo: { a: 1 } })
})
```

## notDeepInclude

* **类型：**
  * `(haystack: string, needle: string, message?: string) => void`
  * `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
  * `<T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void`

断言 `haystack` 不包含 `needle`。可用于断言数组中不存在某个值或对象中不存在某个属性子集。使用深度相等性检查。

```ts
import { assert, test } from 'vitest'

const obj1 = { a: 1 }
const obj2 = { b: 2 }

test('assert.notDeepInclude', () => {
  assert.notDeepInclude([obj1, obj2], { a: 10 })
  assert.notDeepInclude({ foo: obj1, bar: obj2 }, { foo: { a: 10 } })
})
```

## nestedInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 包含 `needle`。可用于断言对象中包含某个属性子集。支持使用点号和括号表示法来引用嵌套属性。属性名中的 '\[]' 和 '.' 可以使用双反斜杠进行转义。

```ts
import { assert, test } from 'vitest'

test('assert.nestedInclude', () => {
  assert.nestedInclude({ '.a': { b: 'x' } }, { '\\.a.[b]': 'x' })
  assert.nestedInclude({ a: { '[b]': 'x' } }, { 'a.\\[b\\]': 'x' })
})
```

## notNestedInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 不包含 `needle`。可用于断言对象中包含某个属性子集。支持使用点号和括号表示法来引用嵌套属性。属性名中的 '\[]' 和 '.' 可以使用双反斜杠进行转义。

```ts
import { assert, test } from 'vitest'

test('assert.nestedInclude', () => {
  assert.notNestedInclude({ '.a': { b: 'x' } }, { '\\.a.b': 'y' })
  assert.notNestedInclude({ a: { '[b]': 'x' } }, { 'a.\\[b\\]': 'y' })
})
```

## deepNestedInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 包含 `needle`。可用于断言对象中包含某个属性子集，同时检查深度相等性。支持使用点号和括号表示法来引用嵌套属性。属性名中的 '\[]' 和 '.' 可以使用双反斜杠进行转义。

```ts
import { assert, test } from 'vitest'

test('assert.deepNestedInclude', () => {
  assert.deepNestedInclude({ a: { b: [{ x: 1 }] } }, { 'a.b[0]': { x: 1 } })
  assert.deepNestedInclude({ '.a': { '[b]': { x: 1 } } }, { '\\.a.\\[b\\]': { x: 1 } })
})
```

## notDeepNestedInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 不包含 `needle`。可用于断言对象中不存在某个属性子集，同时检查深度相等性。支持使用点号和括号表示法来引用嵌套属性。属性名中的 '\[]' 和 '.' 可以使用双反斜杠进行转义。

```ts
import { assert, test } from 'vitest'

test('assert.notDeepNestedInclude', () => {
  assert.notDeepNestedInclude({ a: { b: [{ x: 1 }] } }, { 'a.b[0]': { y: 1 } })
  assert.notDeepNestedInclude({ '.a': { '[b]': { x: 1 } } }, { '\\.a.\\[b\\]': { y: 2 } })
})
```

## ownInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 包含 `needle`。可用于断言对象中包含某个属性子集，同时忽略继承的属性。

```ts
import { assert, test } from 'vitest'

test('assert.ownInclude', () => {
  assert.ownInclude({ a: 1 }, { a: 1 })
})
```

## notOwnInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 不包含 `needle`。可用于断言对象中不存在某个属性子集，同时忽略继承的属性。

```ts
import { assert, test } from 'vitest'

const obj1 = {
  b: 2
}

const obj2 = object.create(obj1)
obj2.a = 1

test('assert.notOwnInclude', () => {
  assert.notOwnInclude(obj2, { b: 2 })
})
```

## deepOwnInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 包含 `needle`。可用于断言对象中包含某个属性子集，同时忽略继承的属性并检查深度相等性。

```ts
import { assert, test } from 'vitest'

test('assert.deepOwnInclude', () => {
  assert.deepOwnInclude({ a: { b: 2 } }, { a: { b: 2 } })
})
```

## notDeepOwnInclude

* **类型：** `(haystack: any, needle: any, message?: string) => void`

断言 `haystack` 不包含 `needle`。可用于断言对象中不存在某个子集属性，同时忽略继承的属性并检查深度相等性。

```ts
import { assert, test } from 'vitest'

test('assert.notDeepOwnInclude', () => {
  assert.notDeepOwnInclude({ a: { b: 2 } }, { a: { c: 3 } })
})
```

## match

* **类型：** `(value: string, regexp: RegExp, message?: string) => void`

断言 `value` 匹配正则表达式 `regexp`。

```ts
import { assert, test } from 'vitest'

test('assert.match', () => {
  assert.match('foobar', /^foo/, '正则表达式匹配')
})
```

## notMatch

* **类型：** `(value: string, regexp: RegExp, message?: string) => void`

断言 `value` 不匹配正则表达式 `regexp`。

```ts
import { assert, test } from 'vitest'

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, '正则表达式不匹配')
})
```

## property

* **类型：** `<T>(object: T, property: string, message?: string) => void`

断言 `object` 拥有一个名为 `property` 的直接或继承属性

```ts
import { assert, test } from 'vitest'

test('assert.property', () => {
  assert.property({ tea: { green: 'matcha' } }, 'tea')
  assert.property({ tea: { green: 'matcha' } }, 'toString')
})
```

## notProperty

* **类型：** `<T>(object: T, property: string, message?: string) => void`

断言 `object` 不拥有一个名为 `property` 的直接或继承属性

```ts
import { assert, test } from 'vitest'

test('assert.notProperty', () => {
  assert.notProperty({ tea: { green: 'matcha' } }, 'coffee')
})
```

## propertyVal

* **类型：** `<T, V>(object: T, property: string, value: V, message?: string) => void`

断言 `object` 拥有一个名为 `property` 的直接或继承属性，其值由 `value` 给定。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.notPropertyVal', () => {
  assert.propertyVal({ tea: 'is good' }, 'tea', 'is good')
})
```

## notPropertyVal

* **类型：** `<T, V>(object: T, property: string, value: V, message?: string) => void`

断言 `object` 不拥有一个名为 `property` 的直接或继承属性，其值由 `value` 给定。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.notPropertyVal', () => {
  assert.notPropertyVal({ tea: 'is good' }, 'tea', 'is bad')
  assert.notPropertyVal({ tea: 'is good' }, 'coffee', 'is good')
})
```

## deepPropertyVal

* **类型：** `<T, V>(object: T, property: string, value: V, message?: string) => void`

断言 `object` 拥有一个名为 `property` 的直接或继承属性，其值由 `value` 给定。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.deepPropertyVal', () => {
  assert.deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' })
})
```

## notDeepPropertyVal

* **类型：** `<T, V>(object: T, property: string, value: V, message?: string) => void`

断言 `object` 不拥有一个名为 `property` 的直接或继承属性，其值由 `value` 给定。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.deepPropertyVal', () => {
  assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' })
  assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' })
  assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' })
})
```

## nestedProperty

* **类型：** `<T>(object: T, property: string, message?: string) => void`

断言 `object` 拥有一个名为 `property` 的直接或继承属性，它可以是使用点和括号表示法进行嵌套引用的字符串。

```ts
import { assert, test } from 'vitest'

test('assert.deepPropertyVal', () => {
  assert.nestedProperty({ tea: { green: 'matcha' } }, 'tea.green')
})
```

## notNestedProperty

* **类型：** `<T>(object: T, property: string, message?: string) => void`

断言 `object` 不拥有一个名为 `property` 的直接或继承属性，它可以是使用点和括号表示法进行嵌套引用的字符串。

```ts
import { assert, test } from 'vitest'

test('assert.deepPropertyVal', () => {
  assert.notNestedProperty({ tea: { green: 'matcha' } }, 'tea.oolong')
})
```

## nestedPropertyVal

* **类型：** `<T>(object: T, property: string, value: any, message?: string) => void`

断言 `object` 拥有一个名为 `property` 的属性，其值由 `value` 给定。`property` 可以使用点和括号表示法进行嵌套引用。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.nestedPropertyVal', () => {
  assert.nestedPropertyVal({ tea: { green: 'matcha' } }, 'tea.green', 'matcha')
})
```

## notNestedPropertyVal

* **类型：** `<T>(object: T, property: string, value: any, message?: string) => void`

断言 `object` 不拥有一个名为 `property` 的属性，其值由 `value` 给定。`property` 可以使用点和括号表示法进行嵌套引用。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.notNestedPropertyVal', () => {
  assert.notNestedPropertyVal({ tea: { green: 'matcha' } }, 'tea.green', 'konacha')
  assert.notNestedPropertyVal({ tea: { green: 'matcha' } }, 'coffee.green', 'matcha')
})
```

## deepNestedPropertyVal

* **类型：** `<T>(object: T, property: string, value: any, message?: string) => void`

断言 `object` 拥有一个名为 `property` 的属性，其值由 `value` 给定。`property` 可以使用点和括号表示法进行嵌套引用。使用深度相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.notNestedPropertyVal', () => {
  assert.notNestedPropertyVal({ tea: { green: 'matcha' } }, 'tea.green', 'konacha')
  assert.notNestedPropertyVal({ tea: { green: 'matcha' } }, 'coffee.green', 'matcha')
})
```

## notDeepNestedPropertyVal

* **类型：** `<T>(object: T, property: string, value: any, message?: string) => void`

断言 `object` 不拥有一个名为 `property` 的属性，其值由 `value` 给定。`property` 可以使用点和括号表示法进行嵌套引用。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.notDeepNestedPropertyVal', () => {
  assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { oolong: 'yum' })
  assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yuck' })
  assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.black', { matcha: 'yum' })
})
```

## lengthOf

* **类型：** `<T extends { readonly length?: number | undefined } | { readonly size?: number | undefined }>(object: T, length: number, message?: string) => void`

断言 `object` 具有预期值的 `length` 或 `size`。

```ts
import { assert, test } from 'vitest'

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'array has length of 3')
  assert.lengthOf('foobar', 6, 'string has length of 6')
  assert.lengthOf(new Set([1, 2, 3]), 3, 'set has size of 3')
  assert.lengthOf(new Map([['a', 1], ['b', 2], ['c', 3]]), 3, 'map has size of 3')
})
```

## hasAnyKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 `object` 至少具有提供的 `keys` 中的一个。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.hasAnyKeys', () => {
  assert.hasAnyKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'iDontExist', 'baz'])
  assert.hasAnyKeys({ foo: 1, bar: 2, baz: 3 }, { foo: 30, iDontExist: 99, baz: 1337 })
  assert.hasAnyKeys(new Map([[{ foo: 1 }, 'bar'], ['key', 'value']]), [{ foo: 1 }, 'key'])
  assert.hasAnyKeys(new Set([{ foo: 'bar' }, 'anotherKey']), [{ foo: 'bar' }, 'anotherKey'])
})
```

## hasAllKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 `object` 具有且仅具有提供的所有 `keys`。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.hasAllKeys', () => {
  assert.hasAllKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'bar', 'baz'])
  assert.hasAllKeys({ foo: 1, bar: 2, baz: 3 }, { foo: 30, bar: 99, baz: 1337 })
  assert.hasAllKeys(new Map([[{ foo: 1 }, 'bar'], ['key', 'value']]), [{ foo: 1 }, 'key'])
  assert.hasAllKeys(new Set([{ foo: 'bar' }, 'anotherKey'], [{ foo: 'bar' }, 'anotherKey']))
})
```

## containsAllKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 `object` 具有所有提供的 `keys`，但可能拥有更多未列出的键。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.containsAllKeys', () => {
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'baz'])
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'bar', 'baz'])
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, { foo: 30, baz: 1337 })
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, { foo: 30, bar: 99, baz: 1337 })
  assert.containsAllKeys(new Map([[{ foo: 1 }, 'bar'], ['key', 'value']]), [{ foo: 1 }])
  assert.containsAllKeys(new Map([[{ foo: 1 }, 'bar'], ['key', 'value']]), [{ foo: 1 }, 'key'])
  assert.containsAllKeys(new Set([{ foo: 'bar' }, 'anotherKey'], [{ foo: 'bar' }]))
  assert.containsAllKeys(new Set([{ foo: 'bar' }, 'anotherKey'], [{ foo: 'bar' }, 'anotherKey']))
})
```

## doesNotHaveAnyKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 `object` 不具有提供的任何 `keys`。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotHaveAnyKeys', () => {
  assert.doesNotHaveAnyKeys({ foo: 1, bar: 2, baz: 3 }, ['one', 'two', 'example'])
  assert.doesNotHaveAnyKeys({ foo: 1, bar: 2, baz: 3 }, { one: 1, two: 2, example: 'foo' })
  assert.doesNotHaveAnyKeys(new Map([[{ foo: 1 }, 'bar'], ['key', 'value']]), [{ one: 'two' }, 'example'])
  assert.doesNotHaveAnyKeys(new Set([{ foo: 'bar' }, 'anotherKey'], [{ one: 'two' }, 'example']))
})
```

## doesNotHaveAllKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 object 至少不包含提供的 keys 中的一个。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.hasAnyKeys', () => {
  assert.doesNotHaveAnyKeys({ foo: 1, bar: 2, baz: 3 }, ['one', 'two', 'example'])
  assert.doesNotHaveAnyKeys({ foo: 1, bar: 2, baz: 3 }, { one: 1, two: 2, example: 'foo' })
  assert.doesNotHaveAnyKeys(new Map([[{ foo: 1 }, 'bar'], ['key', 'value']]), [{ one: 'two' }, 'example'])
  assert.doesNotHaveAnyKeys(new Set([{ foo: 'bar' }, 'anotherKey']), [{ one: 'two' }, 'example'])
})
```

## hasAnyDeepKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 object 至少包含提供的 keys 中的一个。由于 Set 和 Map 可以将对象作为键，你可以使用此断言执行深度比较。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.hasAnyDeepKeys', () => {
  assert.hasAnyDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [1, 2]]), { one: 'one' })
  assert.hasAnyDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [1, 2]]), [{ one: 'one' }, { two: 'two' }])
  assert.hasAnyDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [{ two: 'two' }, 'valueTwo']]), [{ one: 'one' }, { two: 'two' }])
  assert.hasAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), { one: 'one' })
  assert.hasAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [{ one: 'one' }, { three: 'three' }])
  assert.hasAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [{ one: 'one' }, { two: 'two' }])
})
```

## hasAllDeepKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 object 拥有提供的 keys 中的所有键，且仅拥有这些键。由于 Set 和 Map 可以将对象作为键，你可以使用此断言执行深度比较。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.hasAnyDeepKeys', () => {
  assert.hasAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne']]), { one: 'one' })
  assert.hasAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [{ two: 'two' }, 'valueTwo']]), [{ one: 'one' }, { two: 'two' }])
  assert.hasAllDeepKeys(new Set([{ one: 'one' }]), { one: 'one' })
  assert.hasAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [{ one: 'one' }, { two: 'two' }])
})
```

## containsAllDeepKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 object 包含提供的 keys 中的所有键。由于 Set 和 Map 可以将对象作为键，你可以使用此断言执行深度比较。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.containsAllDeepKeys', () => {
  assert.containsAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [1, 2]]), { one: 'one' })
  assert.containsAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [{ two: 'two' }, 'valueTwo']]), [{ one: 'one' }, { two: 'two' }])
  assert.containsAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), { one: 'one' })
  assert.containsAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [{ one: 'one' }, { two: 'two' }])
})
```

## doesNotHaveAnyDeepKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 object 不包含提供的 keys 中的任何键。由于 Set 和 Map 可以将对象作为键，你可以使用此断言执行深度比较。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotHaveAnyDeepKeys', () => {
  assert.doesNotHaveAnyDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [1, 2]]), { thisDoesNot: 'exist' })
  assert.doesNotHaveAnyDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [{ two: 'two' }, 'valueTwo']]), [{ twenty: 'twenty' }, { fifty: 'fifty' }])
  assert.doesNotHaveAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), { twenty: 'twenty' })
  assert.doesNotHaveAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [{ twenty: 'twenty' }, { fifty: 'fifty' }])
})
```

## doesNotHaveAllDeepKeys

* **类型：** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`

断言 object 至少不包含提供的 keys 中的一个。由于 Set 和 Map 可以将对象作为键，你可以使用此断言执行深度比较。你也可以提供单个对象而不是 keys 数组，其键将被用作预期的键集。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotHaveAllDeepKeys', () => {
  assert.doesNotHaveAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [1, 2]]), { thisDoesNot: 'exist' })
  assert.doesNotHaveAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne'], [{ two: 'two' }, 'valueTwo']]), [{ twenty: 'twenty' }, { one: 'one' }])
  assert.doesNotHaveAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), { twenty: 'twenty' })
  assert.doesNotHaveAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [{ one: 'one' }, { fifty: 'fifty' }])
})
```

## throws

* **类型：**
  * `(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void`
  * `(fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void`
* **别名：**
  * `throw`
  * `Throw`

如果 errorLike 是 Error 构造函数，断言 fn 将抛出一个属于 errorLike 实例的错误。如果 errorLike 是 Error 实例，断言抛出的错误与 errorLike 是同一个实例。如果提供了 errMsgMatcher，还会断言抛出的错误消息匹配 errMsgMatcher。

```ts
import { assert, test } from 'vitest'

test('assert.throws', () => {
  assert.throws(fn, '抛出的错误必须具有此消息')
  assert.throws(fn, /抛出的错误必须匹配此消息/)
  assert.throws(fn, ReferenceError)
  assert.throws(fn, errorInstance)
  assert.throws(fn, ReferenceError, '抛出的错误必须是 ReferenceError 并具有此消息')
  assert.throws(fn, errorInstance, '抛出的错误必须是同一个 errorInstance 并具有此消息')
  assert.throws(fn, ReferenceError, /抛出的错误必须是 ReferenceError 并匹配此消息/)
  assert.throws(fn, errorInstance, /抛出的错误必须是同一个 errorInstance 并匹配此消息/)
})
```

## doesNotThrow

* **类型：** `(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void`
* **类型：** `(fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void`

如果 errorLike 是 Error 构造函数，断言 fn 不会抛出一个属于 errorLike 实例的错误。如果 errorLike 是 Error 实例，断言抛出的错误与 errorLike 不是同一个实例。如果提供了 errMsgMatcher，还会断言抛出的错误消息不匹配 errMsgMatcher。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, '任何抛出的错误都不能有此消息')
  assert.doesNotThrow(fn, /任何抛出的错误都不能匹配此项/)
  assert.doesNotThrow(fn, Error)
  assert.doesNotThrow(fn, errorInstance)
  assert.doesNotThrow(fn, Error, '错误不能有此消息')
  assert.doesNotThrow(fn, errorInstance, '错误不能有此消息')
  assert.doesNotThrow(fn, Error, /错误不能匹配此项/)
  assert.doesNotThrow(fn, errorInstance, /错误不能匹配此项/)
})
```

## operator

* **类型：** `(val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void`

使用 operator 比较 val1 和 val2。

```ts
import { assert, test } from 'vitest'

test('assert.operator', () => {
  assert.operator(1, '<', 2, '一切正常')
})
```

## closeTo

* **类型：** `(actual: number, expected: number, delta: number, message?: string) => void`
* **别名：** `approximately`

断言 actual 等于 expected，在 +/- delta 范围内。

```ts
import { assert, test } from 'vitest'

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, '数字很接近')
})
```

## sameMembers

* **类型：** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 set1 和 set2 具有相同的成员，顺序任意。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], '相同成员')
})
```

## notSameMembers

* **类型：** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 set1 和 set2 不具有相同的成员，顺序任意。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.sameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], '不相同的成员')
})
```

## sameDeepMembers

* **类型：** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 set1 和 set2 具有相同的成员，顺序任意。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { c: 3 }], '相同的深度成员')
})
```

## notSameDeepMembers

* **类型：** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 set1 和 set2 不具有相同的成员，顺序任意。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { c: 3 }], '相同的深度成员')
})
```

## sameOrderedMembers

* **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 `set1` 和 `set2` 具有相同顺序的相同成员。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], '相同顺序的成员')
})
```

## notSameOrderedMembers

* **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 `set1` 和 `set2` 具有相同顺序的相同成员。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers([1, 2, 3], [2, 1, 3], '不相同顺序的成员')
})
```

## sameDeepOrderedMembers

* **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 `set1` 和 `set2` 具有相同顺序的相同成员。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { b: 2 }, { c: 3 }], '相同深度顺序成员')
})
```

## notSameDeepOrderedMembers

* **类型：** `<T>(set1: T[], set2: T[], message?: string) => void`

断言 `set1` 和 `set2` 不具有相同顺序的相同成员。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { b: 2 }, { z: 5 }], '不相同深度顺序成员')
  assert.notSameDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { c: 3 }], '不相同深度顺序成员')
})
```

## includeMembers

* **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 包含于 `superset` 中，顺序任意。使用严格相等检查 (===)。重复项将被忽略。

```ts
import { assert, test } from 'vitest'

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], '包含成员')
})
```

## notIncludeMembers

* **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 不包含于 `superset` 中，顺序任意。使用严格相等检查 (===)。重复项将被忽略。

```ts
import { assert, test } from 'vitest'

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], '不包含成员')
})
```

## includeDeepMembers

* **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 包含于 `superset` 中，顺序任意。使用深度相等检查。重复项将被忽略。

```ts
import { assert, test } from 'vitest'

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { b: 2 }], '包含深度成员')
})
```

## notIncludeDeepMembers

* **类型：** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 不包含于 `superset` 中，顺序任意。使用深度相等检查。重复项将被忽略。

```ts
import { assert, test } from 'vitest'

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { f: 5 }], '不包含深度成员')
})
```

## includeOrderedMembers

* **类型：** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 包含于 `superset` 中，且顺序相同，从 `superset` 的第一个元素开始。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], '包含顺序成员')
})
```

## notIncludeOrderedMembers

* **类型：** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 不包含于 `superset` 中，且顺序相同，从 `superset` 的第一个元素开始。使用严格相等检查 (===)。

```ts
import { assert, test } from 'vitest'

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers([1, 2, 3], [2, 1], '不包含顺序成员')
  assert.notIncludeOrderedMembers([1, 2, 3], [2, 3], '不包含顺序成员')
})
```

## includeDeepOrderedMembers

* **类型：** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 包含于 `superset` 中，且顺序相同，从 `superset` 的第一个元素开始。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { b: 2 }], '包含深度顺序成员')
})
```

## notIncludeDeepOrderedMembers

* **类型：** `<T>(superset: T[], subset: T[], message?: string) => void`

断言 `subset` 不包含于 `superset` 中，且顺序相同，从 superset 的第一个元素开始。使用深度相等检查。

```ts
import { assert, test } from 'vitest'

test('assert.includeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { f: 5 }], '不包含深度顺序成员')
  assert.notIncludeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }], '不包含深度顺序成员')
  assert.notIncludeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { c: 3 }], '不包含深度顺序成员')
})
```

## oneOf

* **类型:** `<T>(inList: T, list: T[], message?: string) => void`

断言非对象、非数组的值 `inList` 出现在扁平数组 `list` 中。

```ts
import { assert, test } from 'vitest'

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], '未在列表中找到')
})
```

## changes

* **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`

断言一个 `modifier` 改变了 `object` 的 `property`。

```ts
import { assert, test } from 'vitest'

test('assert.changes', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 22 };
  assert.changes(fn, obj, 'val')
})
```

## changesBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`

断言一个 `modifier` 将 `object` 的 `property` 改变了 `change` 量。

```ts
import { assert, test } from 'vitest'

test('assert.changesBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val += 2 };
  assert.changesBy(fn, obj, 'val', 2)
})
```

## doesNotChange

* **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`

断言一个 `modifier` 没有改变 `object` 的 `property`。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotChange', () => {
  const obj = { val: 10 }
  function fn() { obj.val += 2 };
  assert.doesNotChange(fn, obj, 'val', 2)
})
```

## changesButNotBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change:number, message?: string) => void`

断言一个 `modifier` 没有将 `object` 的 `property` 或 `modifier` 的返回值改变 `change` 量。

```ts
import { assert, test } from 'vitest'

test('assert.changesButNotBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val += 10 };
  assert.changesButNotBy(fn, obj, 'val', 5)
})
```

## increases

* **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`

断言一个 `modifier` 增加了数值 `object` 的 `property`。

```ts
import { assert, test } from 'vitest'

test('assert.increases', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 13 };
  assert.increases(fn, obj, 'val')
})
```

## increasesBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`

断言一个 `modifier` 将数值 `object` 的 `property` 或 `modifier` 的返回值增加了 `change` 量。

```ts
import { assert, test } from 'vitest'

test('assert.increasesBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val += 10 };
  assert.increasesBy(fn, obj, 'val', 10)
})
```

## doesNotIncrease

* **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`

断言一个 `modifier` 没有增加数值 `object` 的 `property`。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotIncrease', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 8 }
  assert.doesNotIncrease(fn, obj, 'val')
})
```

## increasesButNotBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`

断言一个 `modifier` 没有将数值 `object` 的 `property` 或 `modifier` 的返回值增加 `change` 量。

```ts
import { assert, test } from 'vitest'

test('assert.increasesButNotBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val += 15 };
  assert.increasesButNotBy(fn, obj, 'val', 10)
})
```

## decreases

* **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`

断言一个 `modifier` 减少了数值 `object` 的 `property`。

```ts
import { assert, test } from 'vitest'

test('assert.decreases', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 5 };
  assert.decreases(fn, obj, 'val')
})
```

## decreasesBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`

断言一个 `modifier` 将数值 `object` 的 `property` 或 `modifier` 的返回值减少了 `change` 量。

```ts
import { assert, test } from 'vitest'

test('assert.decreasesBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val -= 5 };
  assert.decreasesBy(fn, obj, 'val', 5)
})
```

## doesNotDecrease

* **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`

断言一个 `modifier` 没有减少数值 `object` 的 `property`。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotDecrease', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 15 }
  assert.doesNotDecrease(fn, obj, 'val')
})
```

## doesNotDecreaseBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`

断言 `modifier` 不会将数值 `object` 的 `property` 或 `modifier` 的返回值减少 `change`。

```ts
import { assert, test } from 'vitest'

test('assert.doesNotDecreaseBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 5 };
  assert.doesNotDecreaseBy(fn, obj, 'val', 1)
})
```

## decreasesButNotBy

* **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`

断言 `modifier` 不会将数值 `object` 的 `property` 或 `modifier` 的返回值减少 `change`。

```ts
import { assert, test } from 'vitest'

test('assert.decreasesButNotBy', () => {
  const obj = { val: 10 }
  function fn() { obj.val = 5 };
  assert.decreasesButNotBy(fn, obj, 'val', 1)
})
```

## ifError

* **类型:** `<T>(object: T, message?: string) => void`

断言 `object` 不是假值，如果是真值则抛出错误。添加此方法是为了允许 chai 作为 Node 的 assert 类的直接替代品。

```ts
import { assert, test } from 'vitest'

test('assert.ifError', () => {
  const err = new Error('我是一个自定义错误')
  assert.ifError(err) // 重新抛出错误！
})
```

## isExtensible

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `extensible`

断言 `object` 是可扩展的（可以向其添加新属性）。

```ts
import { assert, test } from 'vitest'

test('assert.isExtensible', () => {
  assert.isExtensible({})
})
```

## isNotExtensible

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `notExtensible`

断言 `object` 不可扩展（不能向其添加新属性）。

```ts
import { assert, test } from 'vitest'

test('assert.isNotExtensible', () => {
  const nonExtensibleObject = Object.preventExtensions({})
  const sealedObject = Object.seal({})
  const frozenObject = Object.freeze({})

  assert.isNotExtensible(nonExtensibleObject)
  assert.isNotExtensible(sealedObject)
  assert.isNotExtensible(frozenObject)
})
```

## isSealed

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `sealed`

断言 `object` 是密封的（不能向其添加新属性，且其现有属性不能被移除）。

```ts
import { assert, test } from 'vitest'

test('assert.isSealed', () => {
  const sealedObject = Object.seal({})
  const frozenObject = Object.seal({})

  assert.isSealed(sealedObject)
  assert.isSealed(frozenObject)
})
```

## isNotSealed

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `notSealed`

断言 `object` 未密封（可以向其添加新属性，且其现有属性可以被移除）。

```ts
import { assert, test } from 'vitest'

test('assert.isNotSealed', () => {
  assert.isNotSealed({})
})
```

## isFrozen

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `frozen`

断言对象是冻结的（不能向其添加新属性，且其现有属性不能被修改）。

```ts
import { assert, test } from 'vitest'

test('assert.isFrozen', () => {
  const frozenObject = Object.freeze({})
  assert.frozen(frozenObject)
})
```

## isNotFrozen

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `notFrozen`

断言 `object` 未冻结（可以向其添加新属性，且其现有属性可以被修改）。

```ts
import { assert, test } from 'vitest'

test('assert.isNotFrozen', () => {
  assert.isNotFrozen({})
})
```

## isEmpty

* **类型:** `<T>(target: T, message?: string) => void`
* **别名:** `empty`

断言 `target` 不包含任何值。对于数组和字符串，它检查 length 属性。对于 Map 和 Set 实例，它检查 size 属性。对于非函数对象，它获取其自身可枚举字符串键的数量。

```ts
import { assert, test } from 'vitest'

test('assert.isEmpty', () => {
  assert.isEmpty([])
  assert.isEmpty('')
  assert.isEmpty(new Map())
  assert.isEmpty({})
})
```

## isNotEmpty

* **类型:** `<T>(object: T, message?: string) => void`
* **别名:** `notEmpty`

断言 `target` 包含值。对于数组和字符串，它检查 length 属性。对于 Map 和 Set 实例，它检查 size 属性。对于非函数对象，它获取其自身可枚举字符串键的数量。

```ts
import { assert, test } from 'vitest'

test('assert.isNotEmpty', () => {
  assert.isNotEmpty([1, 2])
  assert.isNotEmpty('34')
  assert.isNotEmpty(new Set([5, 6]))
  assert.isNotEmpty({ key: 7 })
})
```