assert

Vitestは、不変条件を確認するために、chaiからのassertメソッドを再エクスポートします。

assert

• 型: (expression: any, message?: string) => asserts expression

与えられたexpressionが真であることをアサートします。そうでない場合、アサーションは失敗します。

import { assert, test } from 'vitest'

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

fail

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

アサーションの失敗を強制します。

import { assert, test } from 'vitest'

test('assert.fail', () => {
  assert.fail('error message on failure')
  assert.fail('foo', 'bar', 'foo is not bar', '===')
})

isOk

• 型: <T>(value: T, message?: string) => void
• エイリアス ok

与えられたvalueが真であることをアサートします。

import { assert, test } from 'vitest'

test('assert.isOk', () => {
  assert.isOk('foo', 'every truthy is ok')
  assert.isOk(false, 'this will fail since false is not truthy')
})

isNotOk

• 型: <T>(value: T, message?: string) => void
• エイリアス notOk

与えられたvalueが偽であることをアサートします。

import { assert, test } from 'vitest'

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'this will fail, every truthy is not ok')
  assert.isNotOk(false, 'this will pass since false is falsy')
})

equal

• 型: <T>(actual: T, expected: T, message?: string) => void

actualとexpectedが非厳密等価（==）であることをアサートします。

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が非厳密不等価（!=）であることをアサートします。

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が厳密等価（===）であることをアサートします。

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と深く等しいことをアサートします。

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と深く等しくないことをアサートします。

import { assert, test } from 'vitest'

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

isAbove

• 型: (valueToCheck: number, valueToBeAbove: number, message?: string) => void

valueToCheckがvalueToBeAboveより厳密に大きい（>）ことをアサートします。

import { assert, test } from 'vitest'

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 is strictly greater than 2')
})

isAtLeast

• 型: (valueToCheck: number, valueToBeAtLeast: number, message?: string) => void

valueToCheckがvalueToBeAtLeast以上（>=）であることをアサートします。

import { assert, test } from 'vitest'

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 is greater or equal to 2')
  assert.isAtLeast(3, 3, '3 is greater or equal to 3')
})

isBelow

• 型: (valueToCheck: number, valueToBeBelow: number, message?: string) => void

valueToCheckがvalueToBeBelowより厳密に小さい（<）ことをアサートします。

import { assert, test } from 'vitest'

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 is strictly less than 6')
})

isAtMost

• 型: (valueToCheck: number, valueToBeAtMost: number, message?: string) => void

valueToCheckがvalueToBeAtMost以下（<=）であることをアサートします。

import { assert, test } from 'vitest'

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 is less than or equal to 6')
  assert.isAtMost(4, 4, '4 is less than or equal to 4')
})

isTrue

• 型: <T>(value: T, message?: string) => void

valueがtrueであることをアサートします。

import { assert, test } from 'vitest'

const testPassed = true

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

isNotTrue

• 型: <T>(value: T, message?: string) => void

valueがtrueでないことをアサートします。

import { assert, test } from 'vitest'

const testPassed = 'ok'

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

isFalse

• 型: <T>(value: T, message?: string) => void

valueがfalseであることをアサートします。

import { assert, test } from 'vitest'

const testPassed = false

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

isNotFalse

• 型: <T>(value: T, message?: string) => void

valueがfalseでないことをアサートします。

import { assert, test } from 'vitest'

const testPassed = 'no'

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

isNull

• 型: <T>(value: T, message?: string) => void

valueがnullであることをアサートします。

import { assert, test } from 'vitest'

const error = null

test('assert.isNull', () => {
  assert.isNull(error, 'error is null')
})

isNotNull

• 型: <T>(value: T, message?: string) => void

valueがnullでないことをアサートします。

import { assert, test } from 'vitest'

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

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error is not null but object')
})

isNaN

• 型: <T>(value: T, message?: string) => void

valueがNaNであることをアサートします。

import { assert, test } from 'vitest'

const calculation = 1 * 'viitest'

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

isNotNaN

• 型: <T>(value: T, message?: string) => void

valueがNaNでないことをアサートします。

import { assert, test } from 'vitest'

const calculation = 1 * 2

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 is Not NaN but 2')
})

exists

• 型: <T>(value: T, message?: string) => void

valueがnullでもundefinedでもないことをアサートします。

import { assert, test } from 'vitest'

const name = 'foo'

test('assert.exists', () => {
  assert.exists(name, 'foo is neither null nor undefined')
})

notExists

• 型: <T>(value: T, message?: string) => void

valueがnullまたはundefinedであることをアサートします。

import { assert, test } from 'vitest'

const foo = null
const bar = undefined

test('assert.notExists', () => {
  assert.notExists(foo, 'foo is null so not exist')
  assert.notExists(bar, 'bar is undefined so not exist')
})

isUndefined

• 型: <T>(value: T, message?: string) => void

valueがundefinedであることをアサートします。

import { assert, test } from 'vitest'

const name = undefined

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

isDefined

• 型: <T>(value: T, message?: string) => void

valueがundefinedでないことをアサートします。

import { assert, test } from 'vitest'

const name = 'foo'

test('assert.isDefined', () => {
  assert.isDefined(name, 'name is not undefined')
})

isFunction

• 型: <T>(value: T, message?: string) => void
• エイリアス: isCallable valueが関数であることをアサートします。

import { assert, test } from 'vitest'

function name() { return 'foo' };

test('assert.isFunction', () => {
  assert.isFunction(name, 'name is function')
})

isNotFunction

• 型: <T>(value: T, message?: string) => void
• エイリアス: isNotCallable

valueが関数でないことをアサートします。

import { assert, test } from 'vitest'

const name = 'foo'

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name is not function but string')
})

isObject

• 型: <T>(value: T, message?: string) => void

valueがObject型のオブジェクトであることをアサートします（Object.prototype.toStringによって明らかになります）。このアサーションは、サブクラス化されたオブジェクトには一致しません。

import { assert, test } from 'vitest'

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing is object')
})

isNotObject

• 型: <T>(value: T, message?: string) => void

valueがObject型のオブジェクトでないことをアサートします（Object.prototype.toStringによって明らかになります）。このアサーションは、サブクラス化されたオブジェクトには一致しません。

import { assert, test } from 'vitest'

const someThing = 'redCircle'

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing is not object but string')
})

isArray

• 型: <T>(value: T, message?: string) => void

valueが配列であることをアサートします。

import { assert, test } from 'vitest'

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

test('assert.isArray', () => {
  assert.isArray(color, 'color is array')
})

isNotArray

• 型: <T>(value: T, message?: string) => void

valueが配列でないことをアサートします。

import { assert, test } from 'vitest'

const color = 'red'

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color is not array but string')
})

isString

• 型: <T>(value: T, message?: string) => void

valueが文字列であることをアサートします。

import { assert, test } from 'vitest'

const color = 'red'

test('assert.isString', () => {
  assert.isString(color, 'color is string')
})

isNotString

• 型: <T>(value: T, message?: string) => void

valueが文字列でないことをアサートします。

import { assert, test } from 'vitest'

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color is not string but array')
})

isNumber

• 型: <T>(value: T, message?: string) => void

valueが数値であることをアサートします。

import { assert, test } from 'vitest'

const colors = 3

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors is number')
})

isNotNumber

• 型: <T>(value: T, message?: string) => void

valueが数値でないことをアサートします。

import { assert, test } from 'vitest'

const colors = '3 colors'

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors is not number but strings')
})

isFinite

• 型: <T>(value: T, message?: string) => void

valueが有限の数値（NaN、Infinityではない）であることをアサートします。

import { assert, test } from 'vitest'

const colors = 3

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors is number not NaN or Infinity')
})

isBoolean

• 型: <T>(value: T, message?: string) => void

valueがブール値であることをアサートします。

import { assert, test } from 'vitest'

const isReady = true

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady is a boolean')
})

isNotBoolean

• 型: <T>(value: T, message?: string) => void

valueがブール値でないことをアサートします。

import { assert, test } from 'vitest'

const isReady = 'sure'

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady is not a boolean but string')
})

typeOf

• 型: <T>(value: T, name: string, message?: string) => void

valueの型がObject.prototype.toStringによって決定されたnameであることをアサートします。

import { assert, test } from 'vitest'

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'we have an object')
  assert.typeOf(['red', 'green'], 'array', 'we have an array')
  assert.typeOf('red', 'string', 'we have a string')
  assert.typeOf(/red/, 'regexp', 'we have a regular expression')
  assert.typeOf(null, 'null', 'we have a null')
  assert.typeOf(undefined, 'undefined', 'we have an undefined')
})

notTypeOf

• 型: <T>(value: T, name: string, message?: string) => void

valueの型がObject.prototype.toStringによって決定されたnameでないことをアサートします。

import { assert, test } from 'vitest'

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" is not a number')
})

instanceOf

• 型: <T>(value: T, constructor: Function, message?: string) => void

valueがconstructorのインスタンスであることをアサートします。

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 is an instance of Person')
  assert.instanceOf(coffee, Tea, 'coffee is an instance of Tea')
})

notInstanceOf

• 型: <T>(value: T, constructor: Function, message?: string) => void

valueがconstructorのインスタンスでないことをアサートします。

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 is not an instance of 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を含むことをアサートします。配列内の値、文字列内の部分文字列、またはオブジェクト内のプロパティのサブセットの包含をアサートするために使用できます。

import { assert, test } from 'vitest'

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'array contains value')
  assert.include('foobar', 'foo', 'string contains substring')
  assert.include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, 'object contains property')
})

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を含まないことをアサートします。配列内の値、文字列内の部分文字列、またはオブジェクト内のプロパティのサブセットの不在をアサートするために使用できます。

import { assert, test } from 'vitest'

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, 'array doesn\'t contain 4')
  assert.notInclude('foobar', 'baz', 'foobar doesn\'t contain baz')
  assert.notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, 'object doesn\'t contain property')
})

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を含むことをアサートします。配列内の値またはオブジェクト内のプロパティのサブセットの包含をアサートするために使用できます。深い等価性が使用されます。

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を含まないことをアサートします。配列内の値またはオブジェクト内のプロパティのサブセットの不在をアサートするために使用できます。深い等価性が使用されます。

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を含むことをアサートします。オブジェクト内のプロパティのサブセットの包含をアサートするために使用できます。入れ子のプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュを使用してエスケープできます。

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を含まないことをアサートします。オブジェクト内のプロパティのサブセットの包含をアサートするために使用できます。入れ子のプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュを使用してエスケープできます。

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を含むことをアサートします。深い等価性をチェックしながら、オブジェクト内のプロパティのサブセットの包含をアサートするために使用できます。入れ子のプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュを使用してエスケープできます。

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を含まないことをアサートします。オブジェクトのプロパティのサブセットが存在しないことを、深い等価性をチェックしながらアサートするために使用できます。ネストされたプロパティを参照するために、ドット記法とブラケット記法を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュを使用してエスケープできます。

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を含むことをアサートします。継承されたプロパティを無視しながら、オブジェクトのプロパティのサブセットが含まれていることをアサートするために使用できます。

import { assert, test } from 'vitest'

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

notOwnInclude

• 型: (haystack: any, needle: any, message?: string) => void

haystackがneedleを含まないことをアサートします。継承されたプロパティを無視しながら、オブジェクトのプロパティのサブセットが存在しないことをアサートするために使用できます。

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を含むことをアサートします。継承されたプロパティを無視し、深い等価性をチェックしながら、オブジェクトのプロパティのサブセットが含まれていることをアサートするために使用できます。

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を含まないことをアサートします。継承されたプロパティを無視し、深い等価性をチェックしながら、オブジェクトのプロパティのサブセットが存在しないことをアサートするために使用できます。

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に一致することをアサートします。

import { assert, test } from 'vitest'

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'regexp matches')
})

notMatch

• 型: (value: string, regexp: RegExp, message?: string) => void

valueが正規表現regexpに一致しないことをアサートします。

import { assert, test } from 'vitest'

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'regexp does not match')
})

property

• 型: <T>(object: T, property: string, message?: string) => void

objectが、propertyで指定された直接または継承されたプロパティを持つことをアサートします。

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で指定された直接または継承されたプロパティを持たないことをアサートします。

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で指定された値を持つ直接または継承されたプロパティを持つことをアサートします。厳密な等価性チェック（===）を使用します。

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で指定された値を持つ直接または継承されたプロパティを持たないことをアサートします。厳密な等価性チェック（===）を使用します。

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で指定された値を持つ直接または継承されたプロパティを持つことをアサートします。深い等価性チェックを使用します。

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で指定された値を持つ直接または継承されたプロパティを持たないことをアサートします。深い等価性チェックを使用します。

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で指定された名前を持つ直接または継承されたプロパティを持つことをアサートします。propertyは、ネストされた参照のためにドット記法とブラケット記法を使用する文字列にすることができます。

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で指定された名前を持つ直接または継承されたプロパティを持たないことをアサートします。propertyは、ネストされた参照のためにドット記法とブラケット記法を使用する文字列にすることができます。

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は、ネストされた参照のためにドット記法とブラケット記法を使用できます。厳密な等価性チェック（===）を使用します。

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は、ネストされた参照のためにドット記法とブラケット記法を使用できます。厳密な等価性チェック（===）を使用します。

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は、ネストされた参照のためにドット記法とブラケット記法を使用できます。深い等価性チェック（===）を使用します。

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は、ネストされた参照のためにドット記法とブラケット記法を使用できます。深い等価性チェックを使用します。

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を持つことをアサートします。

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のうち少なくとも1つを持つことをアサートします。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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のすべて、かつそれのみを持つことをアサートします。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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のすべてを持つが、リストされていないキーをさらに持つ可能性があることをアサートします。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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のいずれも持たないことをアサートします。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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のうち少なくとも1つを持たないことをアサートします。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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のうち少なくとも1つを持つことをアサートします。SetとMapはオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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はオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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のうち少なくとも1つを持たないことをアサートします。SetとMapはオブジェクトをキーとして持つことができるため、このアサーションを使用して深い比較を実行できます。キーの配列ではなく単一のオブジェクトを提供することもでき、そのキーが期待されるキーのセットとして使用されます。

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に一致することをアサートします。

import { assert, test } from 'vitest'

test('assert.throws', () => {
  assert.throws(fn, 'Error thrown must have this msg')
  assert.throws(fn, /Error thrown must have a msg that matches this/)
  assert.throws(fn, ReferenceError)
  assert.throws(fn, errorInstance)
  assert.throws(fn, ReferenceError, 'Error thrown must be a ReferenceError and have this msg')
  assert.throws(fn, errorInstance, 'Error thrown must be the same errorInstance and have this msg')
  assert.throws(fn, ReferenceError, /Error thrown must be a ReferenceError and match this/)
  assert.throws(fn, errorInstance, /Error thrown must be the same errorInstance and match this/)
})

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に一致しないことをアサートします。

import { assert, test } from 'vitest'

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Any Error thrown must not have this message')
  assert.doesNotThrow(fn, /Any Error thrown must not match this/)
  assert.doesNotThrow(fn, Error)
  assert.doesNotThrow(fn, errorInstance)
  assert.doesNotThrow(fn, Error, 'Error must not have this message')
  assert.doesNotThrow(fn, errorInstance, 'Error must not have this message')
  assert.doesNotThrow(fn, Error, /Error must not match this/)
  assert.doesNotThrow(fn, errorInstance, /Error must not match this/)
})

operator

• 型: (val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void

operatorを使用してval1とval2を比較します。

import { assert, test } from 'vitest'

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'everything is ok')
})

closeTo

• 型: (actual: number, expected: number, delta: number, message?: string) => void
• エイリアス: approximately

actualが、+/- deltaの範囲内でexpectedと等しいことをアサートします。

import { assert, test } from 'vitest'

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'numbers are close')
})

sameMembers

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

set1とset2が、順序に関係なく同じ要素を持つことをアサートします。厳密等価比較（===）を使用します。

import { assert, test } from 'vitest'

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'same members')
})

notSameMembers

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

set1とset2が、順序に関係なく同じ要素を持たないことをアサートします。厳密等価比較（===）を使用します。

import { assert, test } from 'vitest'

test('assert.sameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'not same members')
})

sameDeepMembers

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

set1とset2が、順序に関係なく同じ要素を持つことをアサートします。深層等価比較を使用します。

import { assert, test } from 'vitest'

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members')
})

notSameDeepMembers

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

set1とset2が、順序に関係なく同じ要素を持たないことをアサートします。深層等価比較を使用します。

import { assert, test } from 'vitest'

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members')
})

sameOrderedMembers

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

set1とset2が、同じ順序で同じ要素を持つことをアサートします。厳密等価比較（===）を使用します。

import { assert, test } from 'vitest'

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'same ordered members')
})

notSameOrderedMembers

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

set1とset2が、同じ順序で同じ要素を持つことをアサートします。厳密等価比較（===）を使用します。

import { assert, test } from 'vitest'

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers([1, 2, 3], [2, 1, 3], 'not same ordered members')
})

sameDeepOrderedMembers

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

set1とset2が、同じ順序で同じ要素を持つことをアサートします。深層等価比較を使用します。

import { assert, test } from 'vitest'

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { b: 2 }, { c: 3 }], 'same deep ordered members')
})

notSameDeepOrderedMembers

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

set1とset2が、同じ順序で同じ要素を持たないことをアサートします。深層等価比較を使用します。

import { assert, test } from 'vitest'

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { b: 2 }, { z: 5 }], 'not same deep ordered members')
  assert.notSameDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { c: 3 }], 'not same deep ordered members')
})

includeMembers

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

subsetが、順序に関係なくsupersetに含まれることをアサートします。厳密等価比較（===）を使用します。重複は無視されます。

import { assert, test } from 'vitest'

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'include members')
})

notIncludeMembers

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

subsetが、順序に関係なくsupersetに含まれないことをアサートします。厳密等価比較（===）を使用します。重複は無視されます。

import { assert, test } from 'vitest'

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'not include members')
})

includeDeepMembers

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

subsetが、順序に関係なくsupersetに含まれることをアサートします。深層等価比較を使用します。重複は無視されます。

import { assert, test } from 'vitest'

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }, { b: 2 }], 'include deep members')
})

notIncludeDeepMembers

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

subsetが、順序に関係なくsupersetに含まれないことをアサートします。深層等価比較を使用します。重複は無視されます。

import { assert, test } from 'vitest'

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { f: 5 }], 'not include deep members')
})

includeOrderedMembers

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

subsetが、supersetの最初の要素から始まる同じ順序でsupersetに含まれることをアサートします。厳密等価比較（===）を使用します。

import { assert, test } from 'vitest'

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'include ordered members')
})

notIncludeOrderedMembers

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

subsetが、supersetの最初の要素から始まる同じ順序でsupersetに含まれないことをアサートします。厳密等価比較（===）を使用します。

import { assert, test } from 'vitest'

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers([1, 2, 3], [2, 1], 'not include ordered members')
  assert.notIncludeOrderedMembers([1, 2, 3], [2, 3], 'not include ordered members')
})

includeDeepOrderedMembers

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

subsetが、supersetの最初の要素から始まる同じ順序でsupersetに含まれることをアサートします。深層等価比較を使用します。

import { assert, test } from 'vitest'

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { b: 2 }], 'include deep ordered members')
})

notIncludeDeepOrderedMembers

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

subsetが、supersetの最初の要素から始まる同じ順序でsupersetに含まれないことをアサートします。深層等価比較を使用します。

import { assert, test } from 'vitest'

test('assert.includeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ a: 1 }, { f: 5 }], 'not include deep ordered members')
  assert.notIncludeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { a: 1 }], 'not include deep ordered members')
  assert.notIncludeDeepOrderedMembers([{ a: 1 }, { b: 2 }, { c: 3 }], [{ b: 2 }, { c: 3 }], 'not include deep ordered members')
})

oneOf

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

オブジェクトでも配列でもない値inListが、フラットな配列listに含まれることをアサートします。

import { assert, test } from 'vitest'

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Not found in list')
})

changes

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

modifierがobjectのpropertyを変更することをアサートします。

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だけ変更することをアサートします。

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を変更しないことをアサートします。

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だけ変更しないことをアサートします。

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を増やすことをアサートします。

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だけ増やすことをアサートします。

import { assert, test } from 'vitest'

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

doesNotIncrease

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

modifierが数値型のobjectのpropertyを増やさないことをアサートします。

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だけ増やさないことをアサートします。

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を減らすことをアサートします。

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だけ減らすことをアサートします。

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を減らさないことをアサートします。

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だけ減らさないことをアサートします。

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だけ減らさないことをアサートします。

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クラスの代替として使用できるようにするためです。

import { assert, test } from 'vitest'

test('assert.ifError', () => {
  const err = new Error('I am a custom error')
  assert.ifError(err) // Rethrows err!
})

isExtensible

• 型: <T>(object: T, message?: string) => void
• 別名: extensible

objectが拡張可能である（新しいプロパティを追加できる）ことをアサートします。

import { assert, test } from 'vitest'

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

isNotExtensible

• 型: <T>(object: T, message?: string) => void
• 別名: notExtensible

objectが拡張不可能である（新しいプロパティを追加できない）ことをアサートします。

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がシール済みである（新しいプロパティを追加できず、既存のプロパティを削除できない）ことをアサートします。

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がシール済みでない（新しいプロパティを追加でき、既存のプロパティを削除できる）ことをアサートします。

import { assert, test } from 'vitest'

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

isFrozen

• 型: <T>(object: T, message?: string) => void
• 別名: frozen

objectがフリーズ済みである（新しいプロパティを追加できず、既存のプロパティを変更できない）ことをアサートします。

import { assert, test } from 'vitest'

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

isNotFrozen

• 型: <T>(object: T, message?: string) => void
• 別名: notFrozen

objectがフリーズ済みでない（新しいプロパティを追加でき、既存のプロパティを変更できる）ことをアサートします。

import { assert, test } from 'vitest'

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

isEmpty

• 型: <T>(target: T, message?: string) => void
• 別名: empty

targetが値を含まないことをアサートします。配列と文字列の場合は、lengthプロパティをチェックします。MapとSetインスタンスの場合は、sizeプロパティをチェックします。関数以外のオブジェクトの場合は、自身の列挙可能な文字列キーの数を取得します。

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プロパティをチェックします。関数以外のオブジェクトの場合は、自身の列挙可能な文字列キーの数を取得します。

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 })
})