assert

Vitest, değişmezleri doğrulamak için chai içindeki assert yöntemini kullanıma sunar.

assert

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

Verilen expression'ın doğru (truthy) bir değer olduğunu doğrular, aksi takdirde doğrulama başarısızlıkla sonuçlanır.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo bar ile eşit olmamalıdır');
});

fail

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

Bir doğrulama hatasını tetikler.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('başarısızlıkta hata mesajı');
  assert.fail('foo', 'bar', 'foo bar değil', '===');
});

isOk

• Tip: <T>(value: T, message?: string) => void
• Takma Ad ok

Verilen value'nun doğru (truthy) bir değer olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'her doğru değer geçerlidir');
  assert.isOk(false, 'false doğru değer olmadığı için bu başarısız olacaktır');
});

isNotOk

• Tip: <T>(value: T, message?: string) => void
• Takma Ad notOk

Verilen value'nun yanlış (falsy) bir değer olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'bu başarısız olacaktır, çünkü "foo" doğru bir değerdir');
  assert.isNotOk(false, 'false yanlış değer olduğu için bu geçecektir');
});

equal

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

actual ve expected'ın gevşek eşitliğini (==) doğrular.

import { assert, test } from 'vitest';

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

notEqual

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

actual ve expected'ın gevşek eşitsizliğini (!=) doğrular.

import { assert, test } from 'vitest';

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

strictEqual

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

actual ve expected'ın katı eşitliğini (===) doğrular.

import { assert, test } from 'vitest';

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

deepEqual

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

actual'ın expected'a derinlemesine eşit olduğunu doğrular.

import { assert, test } from 'vitest';

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

notDeepEqual

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

actual'ın expected'a derinlemesine eşit olmadığını doğrular.

import { assert, test } from 'vitest';

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

isAbove

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

valueToCheck'in valueToBeAbove'dan kesinlikle büyük (>) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5, 2\'den kesinlikle büyüktür');
});

isAtLeast

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

valueToCheck'in valueToBeAtLeast'ten büyük veya eşit (>=) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5, 2\'den büyük veya eşittir');
  assert.isAtLeast(3, 3, '3, 3\'ten büyük veya eşittir');
});

isBelow

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

valueToCheck'in valueToBeBelow'dan kesinlikle küçük (<) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3, 6\'dan kesinlikle küçüktür');
});

isAtMost

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

valueToCheck'in valueToBeAtMost'tan küçük veya eşit (<=) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3, 6\'dan küçük veya eşittir');
  assert.isAtMost(4, 4, '4, 4\'ten küçük veya eşittir');
});

isTrue

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

value'nun true olduğunu doğrular.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

value'nun true olmadığını doğrular.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

value'nun false olduğunu doğrular.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

value'nun false olmadığını doğrular.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

value'nun null olduğunu doğrular.

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

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

value'nun null olmadığını doğrular.

import { assert, test } from 'vitest';

const error = { message: 'hata oluştu' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'hata null değildir, bir nesnedir');
});

isNaN

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

value'nun NaN (Not-a-Number) olduğunu doğrular.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

value'nun NaN olmadığını doğrular.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 NaN değil, 2\'dir');
});

exists

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

value'nun null veya undefined olmadığını doğrular.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo ne null ne de undefined');
});

notExists

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

value'nun null veya undefined olduğunu doğrular.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo null olduğu için mevcut değil');
  assert.notExists(bar, 'bar undefined olduğu için mevcut değil');
});

isUndefined

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

value'nun undefined olduğunu doğrular.

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

value'nun undefined olmadığını doğrular.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'isim undefined değil');
});

isFunction

• Tip: <T>(value: T, message?: string) => void
• Takma Ad: isCallablevalue'nun bir fonksiyon olduğunu doğrular.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'isim bir fonksiyondur');
});

isNotFunction

• Tip: <T>(value: T, message?: string) => void
• Takma Ad: isNotCallable

value'nun bir fonksiyon olmadığını doğrular.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'isim bir fonksiyon değil, string');
});

isObject

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

value'nun Object tipinde bir nesne olduğunu doğrular (Object.prototype.toString tarafından gösterildiği gibi). Doğrulama, alt sınıflara ayrılmış nesnelerle eşleşmez.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing bir nesnedir');
});

isNotObject

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

value'nun Object tipinde bir nesne olmadığını doğrular (Object.prototype.toString tarafından gösterildiği gibi). Doğrulama, alt sınıflara ayrılmış nesnelerle eşleşmez.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing bir nesne değildir, stringdir');
});

isArray

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

value'nun bir dizi olduğunu doğrular.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'renk bir dizidir');
});

isNotArray

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

value'nun bir dizi olmadığını doğrular.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'renk bir dizi değildir, stringdir');
});

isString

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

value'nun bir string olduğunu doğrular.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'renk bir stringdir');
});

isNotString

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

value'nun bir string olmadığını doğrular.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'renk bir string değil, dizi');
});

isNumber

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

value'nun bir sayı olduğunu doğrular.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'renkler bir sayıdır');
});

isNotNumber

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

value'nun bir sayı olmadığını doğrular.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'renkler bir sayı değil, string');
});

isFinite

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

value'nun sonlu bir sayı olduğunu doğrular (NaN veya Infinity değil).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'renkler bir sayı, NaN veya Infinity değil');
});

isBoolean

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

value'nun bir boolean olduğunu doğrular.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady bir boolean');
});

isNotBoolean

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

value'nun bir boolean olmadığını doğrular.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady bir boolean değil, string');
});

typeOf

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

value'nun tipinin name olduğunu doğrular, Object.prototype.toString tarafından belirlendiği gibi.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'bir nesne mevcut');
  assert.typeOf(['red', 'green'], 'array', 'bir dizi mevcut');
  assert.typeOf('red', 'string', 'bir string mevcut');
  assert.typeOf(/red/, 'regexp', 'bir düzenli ifade mevcut');
  assert.typeOf(null, 'null', 'bir null değer mevcut');
  assert.typeOf(undefined, 'undefined', 'bir undefined değer mevcut');
});

notTypeOf

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

value'nun tipinin name olmadığını doğrular, Object.prototype.toString tarafından belirlendiği gibi.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" bir sayı değil');
});

instanceOf

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

value'nun constructor'ın bir örneği olduğunu doğrular.

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\'ın bir örneğidir');
  assert.instanceOf(coffee, Tea, 'coffee, Tea\'nin bir örneğidir');
});

notInstanceOf

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

value'nun constructor'ın bir örneği olmadığını doğrular.

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.notInstanceOf', () => {
  assert.notInstanceOf(foo, Tea, 'foo, Tea\'nin bir örneği değildir');
});

include

• Tip:
  • (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'in needle'ı içerdiğini doğrular. Bir dizide bir değerin, bir stringde bir alt stringin veya bir nesnede bir özellik alt kümesinin dahil edilmesini doğrulamak için kullanılabilir.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'dizi değeri içeriyor');
  assert.include('foobar', 'foo', 'string alt string içeriyor');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'nesne özelliği içeriyor'
  );
});

notInclude

• Tip:
  • (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'in needle'ı içermediğini doğrular. Bir dizide bir değerin, bir stringde bir alt stringin veya bir nesnede bir özellik alt kümesinin yokluğunu doğrulamak için kullanılabilir.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, "dizi 4'ü içermiyor");
  assert.notInclude('foobar', 'baz', "foobar baz'ı içermiyor");
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    "nesne özelliği içermiyor"
  );
});

deepInclude

• Tip:
  • (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'in needle'ı içerdiğini doğrular. Bir dizide bir değerin veya bir nesnede bir özellik alt kümesinin dahil edilmesini doğrulamak için kullanılabilir. Derin eşitlik kullanılır.

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

• Tip:
  • (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'in needle'ı içermediğini doğrular. Bir dizide bir değerin veya bir nesnede bir özellik alt kümesinin yokluğunu doğrulamak için kullanılabilir. Derin eşitlik kullanılır.

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

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

haystack'in needle'ı içerdiğini doğrular. Bir nesnede bir özellik alt kümesinin dahil edilmesini doğrulamak için kullanılabilir. İç içe geçmiş özelliklere başvurmak için nokta ve köşeli parantez gösteriminin kullanımını sağlar. Özellik adlarındaki '[]' ve '.' çift ters eğik çizgi kullanılarak kaçılabilir.

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

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

haystack'in needle'ı içermediğini doğrular. Bir nesnede bir özellik alt kümesinin dahil edilmesini doğrulamak için kullanılabilir. İç içe geçmiş özelliklere başvurmak için nokta ve köşeli parantez gösteriminin kullanımını sağlar. Özellik adlarındaki '[]' ve '.' çift ters eğik çizgi kullanılarak kaçılabilir.

import { assert, test } from 'vitest';

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

deepNestedInclude

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

haystack'in needle'ı içerdiğini doğrular. Bir nesnede bir özellik alt kümesinin dahil edilmesini derin eşitlik kontrolü yaparak doğrulamak için kullanılabilir. İç içe geçmiş özelliklere başvurmak için nokta ve köşeli parantez gösteriminin kullanımını sağlar. Özellik adlarındaki '[]' ve '.' çift ters eğik çizgi kullanılarak kaçılabilir.

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

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

haystack'in needle'ı içermediğini doğrular. Bir nesnede bir özellik alt kümesinin yokluğunu derin eşitlik kontrolü yaparak doğrulamak için kullanılabilir. İç içe geçmiş özelliklere başvurmak için nokta ve köşeli parantez gösteriminin kullanımını sağlar. Özellik adlarındaki '[]' ve '.' çift ters eğik çizgi kullanılarak kaçılabilir.

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

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

haystack'in needle'ı içerdiğini doğrular. Miras alınan özellikleri dikkate almayarak bir nesnede bir özellik alt kümesinin dahil edilmesini doğrulamak için kullanılabilir.

import { assert, test } from 'vitest';

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

notOwnInclude

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

haystack'in needle'ı içermediğini doğrular. Miras alınan özellikleri dikkate almayarak bir nesnede bir özellik alt kümesinin yokluğunu doğrulamak için kullanılabilir.

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

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

haystack'in needle'ı içerdiğini doğrular. Miras alınan özellikleri dikkate almayarak ve derin eşitlik kontrolü yaparak bir nesnede bir özellik alt kümesinin dahil edilmesini doğrulamak için kullanılabilir.

import { assert, test } from 'vitest';

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

notDeepOwnInclude

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

haystack'in needle'ı içermediğini doğrular. Miras alınan özellikleri dikkate almayarak ve derin eşitlik kontrolü yaparak bir nesnede bir özellik alt kümesinin yokluğunu doğrulamak için kullanılabilir.

import { assert, test } from 'vitest';

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

match

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

value'nun regexp düzenli ifadesiyle eşleştiğini doğrular.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'düzenli ifade eşleşiyor');
});

notMatch

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

value'nun regexp düzenli ifadesiyle eşleşmediğini doğrular.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'düzenli ifade eşleşmiyor');
});

property

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

object'in property adında doğrudan veya miras alınan bir özelliğe sahip olduğunu doğrular.

import { assert, test } from 'vitest';

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

notProperty

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

object'in property adında doğrudan veya miras alınan bir özelliğe sahip olmadığını doğrular.

import { assert, test } from 'vitest';

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

propertyVal

• Tip: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip doğrudan veya miras alınan bir özelliğe sahip olduğunu doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

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

notPropertyVal

• Tip: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip doğrudan veya miras alınan bir özelliğe sahip olmadığını doğrular. Katı eşitlik kontrolü (===) kullanır.

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

• Tip: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip doğrudan veya miras alınan bir özelliğe sahip olduğunu doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

• Tip: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip doğrudan veya miras alınan bir özelliğe sahip olmadığını doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.notDeepPropertyVal', () => {
  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

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

object'in property adında doğrudan veya miras alınan bir özelliğe sahip olduğunu doğrular; property iç içe geçmiş referans için nokta ve köşeli parantez gösterimi kullanan bir string olabilir.

import { assert, test } from 'vitest';

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

notNestedProperty

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

object'in property adında doğrudan veya miras alınan bir özelliğe sahip olmadığını doğrular; property iç içe geçmiş referans için nokta ve köşeli parantez gösterimi kullanan bir string olabilir.

import { assert, test } from 'vitest';

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

nestedPropertyVal

• Tip: <T>(object: T, property: string, value: any, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip bir özelliğe sahip olduğunu doğrular. property iç içe geçmiş referans için nokta ve köşeli parantez gösterimi kullanabilir. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

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

notNestedPropertyVal

• Tip: <T>(object: T, property: string, value: any, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip bir özelliğe sahip olmadığını doğrular. property iç içe geçmiş referans için nokta ve köşeli parantez gösterimi kullanabilir. Katı eşitlik kontrolü (===) kullanır.

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

• Tip: <T>(object: T, property: string, value: any, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip bir özelliğe sahip olduğunu doğrular. property iç içe geçmiş referans için nokta ve köşeli parantez gösterimi kullanabilir. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

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

notDeepNestedPropertyVal

• Tip: <T>(object: T, property: string, value: any, message?: string) => void

object'in property adında, value tarafından verilen bir değere sahip bir özelliğe sahip olmadığını doğrular. property iç içe geçmiş referans için nokta ve köşeli parantez gösterimi kullanabilir. Derin eşitlik kontrolü kullanır.

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

• Tip: <T extends { readonly length?: number | undefined } | { readonly size?: number | undefined }>(object: T, length: number, message?: string) => void

object'in beklenen değere sahip bir length veya size özelliğine sahip olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'dizi 3 uzunluğundadır');
  assert.lengthOf('foobar', 6, 'string 6 uzunluğundadır');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'set 3 boyutundadır');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'map 3 boyutundadır'
  );
});

hasAnyKeys

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerden en az birine sahip olduğunu doğrular. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerin tümüne ve yalnızca tümüne sahip olduğunu doğrular. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerin tümüne sahip olduğunu, ancak listede olmayan daha fazla anahtara sahip olabileceğini doğrular. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerin hiçbirine sahip olmadığını doğrular. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerden en az birine sahip olmadığını doğrular. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerden en az birine sahip olduğunu doğrular. Set'ler ve Map'ler anahtar olarak nesnelere sahip olabileceğinden, bu doğrulamayı derin bir karşılaştırma yapmak için kullanabilirsiniz. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerin tümüne ve yalnızca tümüne sahip olduğunu doğrular. Set'ler ve Map'ler anahtar olarak nesnelere sahip olabileceğinden, bu doğrulamayı derin bir karşılaştırma yapmak için kullanabilirsiniz. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

import { assert, test } from 'vitest';

test('assert.hasAllDeepKeys', () => {
  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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerin tümünü içerdiğini doğrular. Set'ler ve Map'ler anahtar olarak nesnelere sahip olabileceğinden, bu doğrulamayı derin bir karşılaştırma yapmak için kullanabilirsiniz. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerin hiçbirine sahip olmadığını doğrular. Set'ler ve Map'ler anahtar olarak nesnelere sahip olabileceğinden, bu doğrulamayı derin bir karşılaştırma yapmak için kullanabilirsiniz. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys'lerden en az birine sahip olmadığını doğrular. Set'ler ve Map'ler anahtar olarak nesnelere sahip olabileceğinden, bu doğrulamayı derin bir karşılaştırma yapmak için kullanabilirsiniz. Anahtarlar dizisi yerine tek bir nesne de sağlayabilirsiniz ve anahtarları beklenen anahtar kümesi olarak kullanılacaktır.

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

• Tip:
  • (fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void
  • (fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void
• Takma Ad:
  • throw
  • Throw

Eğer errorLike bir Error constructor ise, fn'nin errorLike'ın bir örneği olan bir hata fırlatacağını doğrular. Eğer errorLike bir Error örneği ise, fırlatılan hatanın errorLike ile aynı örnek olduğunu doğrular. Eğer errMsgMatcher sağlanırsa, fırlatılan hatanın errMsgMatcher ile eşleşen bir mesajı olduğunu da doğrular.

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

• Tip: (fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void
• Tip: (fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void

Eğer errorLike bir Error constructor ise, fn'nin errorLike'ın bir örneği olan bir hata fırlatmayacağını doğrular. Eğer errorLike bir Error örneği ise, fırlatılan hatanın errorLike ile aynı örnek olmadığını doğrular. Eğer errMsgMatcher sağlanırsa, fırlatılan hatanın errMsgMatcher ile eşleşen bir mesajı olmadığını da doğrular.

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

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

val1 ve val2'yi operator kullanarak karşılaştırır.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'test başarılı');
});

closeTo

• Tip: (actual: number, expected: number, delta: number, message?: string) => void
• Takma Ad: approximately

actual'ın expected'a +/- delta aralığında eşit olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'sayılar yakın');
});

sameMembers

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

set1 ve set2'nin herhangi bir sırada aynı üyelere sahip olduğunu doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'aynı üyeler');
});

notSameMembers

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

set1 ve set2'nin herhangi bir sırada aynı üyelere sahip olmadığını doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'aynı üyeler değil');
});

sameDeepMembers

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

set1 ve set2'nin herhangi bir sırada aynı üyelere sahip olduğunu doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'aynı derin üyeler'
  );
});

notSameDeepMembers

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

set1 ve set2'nin herhangi bir sırada aynı üyelere sahip olmadığını doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'aynı derin üyeler değil'
  );
});

sameOrderedMembers

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

set1 ve set2'nin aynı sırada aynı üyelere sahip olduğunu doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'aynı sıralı üyeler');
});

notSameOrderedMembers

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

set1 ve set2'nin aynı sırada aynı üyelere sahip olmadığını doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'aynı sıralı üyeler değil'
  );
});

sameDeepOrderedMembers

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

set1 ve set2'nin aynı sırada aynı üyelere sahip olduğunu doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'aynı derin sıralı üyeler'
  );
});

notSameDeepOrderedMembers

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

set1 ve set2'nin aynı sırada aynı üyelere sahip olmadığını doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'aynı derin sıralı üyeler değil'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'aynı derin sıralı üyeler değil'
  );
});

includeMembers

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

subset'in superset içinde herhangi bir sırada bulunduğunu doğrular. Katı eşitlik kontrolü (===) kullanır. Kopyalar göz ardı edilir.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'üyeleri içeriyor');
});

notIncludeMembers

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

subset'in superset içinde herhangi bir sırada bulunmadığını doğrular. Katı eşitlik kontrolü (===) kullanır. Kopyalar göz ardı edilir.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'üyeleri içermiyor');
});

includeDeepMembers

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

subset'in superset içinde herhangi bir sırada bulunduğunu doğrular. Derin eşitlik kontrolü kullanır. Kopyalar göz ardı edilir.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'derin üyeleri içeriyor'
  );
});

notIncludeDeepMembers

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

subset'in superset içinde herhangi bir sırada bulunmadığını doğrular. Derin eşitlik kontrolü kullanır. Kopyalar göz ardı edilir.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'derin üyeleri içermiyor'
  );
});

includeOrderedMembers

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

subset'in superset içinde, superset'in ilk öğesinden başlayarak aynı sırada bulunduğunu doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'sıralı üyeleri içeriyor');
});

notIncludeOrderedMembers

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

subset'in superset içinde, superset'in ilk öğesinden başlayarak aynı sırada bulunmadığını doğrular. Katı eşitlik kontrolü (===) kullanır.

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'sıralı üyeleri içermiyor'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'sıralı üyeleri içermiyor'
  );
});

includeDeepOrderedMembers

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

subset'in superset içinde, superset'in ilk öğesinden başlayarak aynı sırada bulunduğunu doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'derin sıralı üyeleri içeriyor'
  );
});

notIncludeDeepOrderedMembers

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

subset'in superset içinde, superset'in ilk öğesinden başlayarak aynı sırada bulunmadığını doğrular. Derin eşitlik kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'derin sıralı üyeleri içermiyor'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'derin sıralı üyeleri içermiyor'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'derin sıralı üyeleri içermiyor'
  );
});

oneOf

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

Nesne olmayan, dizi olmayan inList değerinin düz list dizisinde göründüğünü doğrular.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Listede bulunamadı');
});

changes

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

Bir modifier'ın bir object'in property'sini değiştirdiğini doğrular.

import { assert, test } from 'vitest';

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

changesBy

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

Bir modifier'ın bir object'in property'sini belirli bir change miktarı kadar değiştirdiğini doğrular.

import { assert, test } from 'vitest';

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

doesNotChange

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

Bir modifier'ın bir object'in property'sini değiştirmediğini doğrular.

import { assert, test } from 'vitest';

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

changesButNotBy

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

Bir modifier'ın bir object'in property'sini veya bir modifier dönüş değerini belirli bir change kadar değiştirmediğini, ancak yine de değiştirdiğini doğrular.

import { assert, test } from 'vitest';

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

increases

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

Bir modifier'ın sayısal bir object'in property'sini artırdığını doğrular.

import { assert, test } from 'vitest';

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

increasesBy

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

Bir modifier'ın sayısal bir object'in property'sini veya bir modifier dönüş değerini bir change kadar artırdığını doğrular.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Bir modifier'ın sayısal bir object'in property'sini artırmadığını doğrular.

import { assert, test } from 'vitest';

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

increasesButNotBy

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

Bir modifier'ın sayısal bir object'in property'sini veya bir modifier dönüş değerini belirli bir change kadar artırmadığını, ancak yine de artırdığını doğrular.

import { assert, test } from 'vitest';

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

decreases

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

Bir modifier'ın sayısal bir object'in property'sini azalttığını doğrular.

import { assert, test } from 'vitest';

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

decreasesBy

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

Bir modifier'ın sayısal bir object'in property'sini veya bir modifier dönüş değerini bir change kadar azalttığını doğrular.

import { assert, test } from 'vitest';

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

doesNotDecrease

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

Bir modifier'ın sayısal bir object'in property'sini azaltmadığını doğrular.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

Bir modifier'ın sayısal bir object'in property'sini veya bir modifier dönüş değerini belirli bir change kadar azaltmadığını doğrular.

import { assert, test } from 'vitest';

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

decreasesButNotBy

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

Bir modifier'ın sayısal bir object'in property'sini veya bir modifier dönüş değerini belirli bir change kadar azaltmadığını, ancak yine de azalttığını doğrular.

import { assert, test } from 'vitest';

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

ifError

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

object'in yanlış (falsy) bir değer olmadığını doğrular ve doğru (truthy) bir değerse hata fırlatır. Bu, Chai'nin Node'un assert sınıfı için bir doğrudan değiştirme olmasına izin vermek için eklenmiştir.

import { assert, test } from 'vitest';

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

isExtensible

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: extensible

object'in genişletilebilir olduğunu (yeni özellikler eklenebileceğini) doğrular.

import { assert, test } from 'vitest';

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

isNotExtensible

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: notExtensible

object'in genişletilebilir olmadığını (yeni özellikler eklenemeyeceğini) doğrular.

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

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: sealed

object'in mühürlü olduğunu (yeni özellikler eklenemeyeceğini ve mevcut özelliklerinin kaldırılamayacağını) doğrular.

import { assert, test } from 'vitest';

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

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

isNotSealed

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: notSealed

object'in mühürlü olmadığını (yeni özellikler eklenebileceğini veya mevcut özelliklerinin kaldırılabileceğini) doğrular.

import { assert, test } from 'vitest';

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

isFrozen

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: frozen

object'in dondurulmuş olduğunu (yeni özellikler eklenemeyeceğini ve mevcut özelliklerinin değiştirilemeyeceğini) doğrular.

import { assert, test } from 'vitest';

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

isNotFrozen

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: notFrozen

object'in dondurulmuş olmadığını (yeni özellikler eklenebileceğini veya mevcut özelliklerinin değiştirilebileceğini) doğrular.

import { assert, test } from 'vitest';

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

isEmpty

• Tip: <T>(target: T, message?: string) => void
• Takma Ad: empty

target'ın herhangi bir değer içermediğini doğrular. Diziler ve stringler için length özelliğini kontrol eder. Map ve Set örnekleri için size özelliğini kontrol eder. Fonksiyon olmayan nesneler için kendi numaralandırılabilir string anahtarlarının sayısını alır.

import { assert, test } from 'vitest';

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

isNotEmpty

• Tip: <T>(object: T, message?: string) => void
• Takma Ad: notEmpty

target'ın değerler içerdiğini doğrular. Diziler ve stringler için length özelliğini kontrol eder. Map ve Set örnekleri için size özelliğini kontrol eder. Fonksiyon olmayan nesneler için kendi numaralandırılabilir string anahtarlarının sayısını alır.

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