@rogolev/value 0.0.3 → 0.0.5

package/tests/classes/Expect/toBeInfinity.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeInfinity класса Expect', () => {
+    test('Должен возвращать true, если значение является бесконечностью (Infinity)', () => {
+        const expectInstance = new Expect(Infinity);
+        expect(expectInstance.toBeInfinity()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является отрицательной бесконечностью (-Infinity)', () => {
+        const expectInstance = new Expect(-Infinity);
+        expect(expectInstance.toBeInfinity()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является бесконечностью (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeInfinity()).toThrow(TypeError);
+        expect(() => expectInstance.toBeInfinity()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является бесконечностью', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeInfinity('Значение должно быть бесконечностью')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeInfinity('Значение должно быть бесконечностью')).toThrow(
+            'Значение должно быть бесконечностью',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(Infinity);
+        expect(() => expectInstance.toBeInfinity(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeInfinity(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не бесконечностью', () => {
+        const expectInstance = new Expect('Infinity');
+        expect(() => expectInstance.toBeInfinity()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не бесконечностью', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeInfinity()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeInt.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeInt класса Expect', () => {
+    test('Должен возвращать true, если значение является целым числом', () => {
+        const expectInstance = new Expect(123);
+        expect(expectInstance.toBeInt()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является целым числом (число с плавающей запятой)', () => {
+        const expectInstance = new Expect(123.45);
+        expect(() => expectInstance.toBeInt()).toThrow(TypeError);
+        expect(() => expectInstance.toBeInt()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является целым числом', () => {
+        const expectInstance = new Expect(123.45);
+        expect(() => expectInstance.toBeInt('Значение должно быть целым числом')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeInt('Значение должно быть целым числом')).toThrow(
+            'Значение должно быть целым числом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeInt(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeInt(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не целым числом', () => {
+        const expectInstance = new Expect('123');
+        expect(() => expectInstance.toBeInt()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не целым числом', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeInt()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является отрицательным целым числом', () => {
+        const expectInstance = new Expect(-123);
+        expect(expectInstance.toBeInt()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeInteger.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeInteger класса Expect', () => {
+    test('Должен возвращать true, если значение является целым числом', () => {
+        const expectInstance = new Expect(123);
+        expect(expectInstance.toBeInteger()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является целым числом (число с плавающей запятой)', () => {
+        const expectInstance = new Expect(123.45);
+        expect(() => expectInstance.toBeInteger()).toThrow(TypeError);
+        expect(() => expectInstance.toBeInteger()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является целым числом', () => {
+        const expectInstance = new Expect(123.45);
+        expect(() => expectInstance.toBeInteger('Значение должно быть целым числом')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeInteger('Значение должно быть целым числом')).toThrow(
+            'Значение должно быть целым числом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeInteger(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeInteger(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не целым числом', () => {
+        const expectInstance = new Expect('123');
+        expect(() => expectInstance.toBeInteger()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не целым числом', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeInteger()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является отрицательным целым числом', () => {
+        const expectInstance = new Expect(-123);
+        expect(expectInstance.toBeInteger()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeList.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeList класса Expect', () => {
+    test('Должен возвращать true, если значение является списком (массив)', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(expectInstance.toBeList()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является списком (строка)', () => {
+        const expectInstance = new Expect('not a list');
+        expect(() => expectInstance.toBeList()).toThrow(TypeError);
+        expect(() => expectInstance.toBeList()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является списком', () => {
+        const expectInstance = new Expect('not a list');
+        expect(() => expectInstance.toBeList('Значение должно быть списком')).toThrow(TypeError);
+        expect(() => expectInstance.toBeList('Значение должно быть списком')).toThrow(
+            'Значение должно быть списком',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeList(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeList(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен возвращать true, если значение является пустым списком', () => {
+        const expectInstance = new Expect([]);
+        expect(expectInstance.toBeList()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не списком', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(() => expectInstance.toBeList()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является списком объектов', () => {
+        const expectInstance = new Expect([{ a: 1 }, { b: 2 }]);
+        expect(expectInstance.toBeList()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeNaN.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeNaN класса Expect', () => {
+    test('Должен возвращать true, если значение является NaN', () => {
+        const expectInstance = new Expect(NaN);
+        expect(expectInstance.toBeNaN()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является NaN (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeNaN()).toThrow(TypeError);
+        expect(() => expectInstance.toBeNaN()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является NaN', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeNaN('Значение должно быть NaN')).toThrow(TypeError);
+        expect(() => expectInstance.toBeNaN('Значение должно быть NaN')).toThrow(
+            'Значение должно быть NaN',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(NaN);
+        expect(() => expectInstance.toBeNaN(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeNaN(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не NaN', () => {
+        const expectInstance = new Expect('NaN');
+        expect(() => expectInstance.toBeNaN()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не NaN', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeNaN()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является undefined, а не NaN', () => {
+        const expectInstance = new Expect(undefined);
+        expect(() => expectInstance.toBeNaN()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeNull.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeNull класса Expect', () => {
+    test('Должен возвращать true, если значение является null', () => {
+        const expectInstance = new Expect(null);
+        expect(expectInstance.toBeNull()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является null (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeNull()).toThrow(TypeError);
+        expect(() => expectInstance.toBeNull()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является null', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeNull('Значение должно быть null')).toThrow(TypeError);
+        expect(() => expectInstance.toBeNull('Значение должно быть null')).toThrow(
+            'Значение должно быть null',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(null);
+        expect(() => expectInstance.toBeNull(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeNull(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не null', () => {
+        const expectInstance = new Expect('null');
+        expect(() => expectInstance.toBeNull()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не null', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeNull()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является undefined, а не null', () => {
+        const expectInstance = new Expect(undefined);
+        expect(() => expectInstance.toBeNull()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeNumber.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeNumber класса Expect', () => {
+    test('Должен возвращать true, если значение является числом', () => {
+        const expectInstance = new Expect(123);
+        expect(expectInstance.toBeNumber()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является числом (строка)', () => {
+        const expectInstance = new Expect('123');
+        expect(() => expectInstance.toBeNumber()).toThrow(TypeError);
+        expect(() => expectInstance.toBeNumber()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является числом', () => {
+        const expectInstance = new Expect('123');
+        expect(() => expectInstance.toBeNumber('Значение должно быть числом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeNumber('Значение должно быть числом')).toThrow(
+            'Значение должно быть числом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeNumber(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeNumber(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не числом', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeNumber()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не числом', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeNumber()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является числом с плавающей запятой', () => {
+        const expectInstance = new Expect(123.45);
+        expect(expectInstance.toBeNumber()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeNumeric.test.mjs

@@ -0,0 +1,53 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeNumeric класса Expect', () => {
+    test('Должен возвращать true, если значение является числовым (строка)', () => {
+        const expectInstance = new Expect('123');
+        expect(expectInstance.toBeNumeric()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является числовым (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(expectInstance.toBeNumeric()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является числовым (строка)', () => {
+        const expectInstance = new Expect('abc');
+        expect(() => expectInstance.toBeNumeric()).toThrow(TypeError);
+        expect(() => expectInstance.toBeNumeric()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является числовым', () => {
+        const expectInstance = new Expect('abc');
+        expect(() => expectInstance.toBeNumeric('Значение должно быть числовым')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeNumeric('Значение должно быть числовым')).toThrow(
+            'Значение должно быть числовым',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect('123');
+        expect(() => expectInstance.toBeNumeric(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeNumeric(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не числовым', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeNumeric()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не числовым', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeNumeric()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является числовым (число с плавающей запятой)', () => {
+        const expectInstance = new Expect(123.45);
+        expect(expectInstance.toBeNumeric()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeObject.test.mjs

@@ -0,0 +1,47 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeObject класса Expect', () => {
+    test('Должен возвращать true, если значение является объектом', () => {
+        class stdClass {}
+        const expectInstance = new Expect(new stdClass());
+        expect(expectInstance.toBeObject()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является объектом (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeObject()).toThrow(TypeError);
+        expect(() => expectInstance.toBeObject()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является объектом', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeObject('Значение должно быть объектом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeObject('Значение должно быть объектом')).toThrow(
+            'Значение должно быть объектом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(() => expectInstance.toBeObject(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeObject(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не объектом', () => {
+        const expectInstance = new Expect('object');
+        expect(() => expectInstance.toBeObject()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не объектом', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeObject()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать выбрасывать ошибку, если значение является ассоциативным массивом', () => {
+        const expectInstance = new Expect({});
+        expect(() => expectInstance.toBeObject()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeScalar.test.mjs

@@ -0,0 +1,63 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeScalar класса Expect', () => {
+    test('Должен возвращать true, если значение является скалярным (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является скалярным (строка)', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является скалярным (boolean)', () => {
+        const expectInstance = new Expect(true);
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является скалярным (symbol)', () => {
+        const expectInstance = new Expect(Symbol('symbol'));
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является скалярным (объект)', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+        expect(() => expectInstance.toBeScalar()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является скалярным', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeScalar('Значение должно быть скалярным')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeScalar('Значение должно быть скалярным')).toThrow(
+            'Значение должно быть скалярным',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeScalar(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeScalar(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не скалярным', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является null, а не скалярным', () => {
+        const expectInstance = new Expect(null);
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является undefined, а не скалярным', () => {
+        const expectInstance = new Expect(undefined);
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeString.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeString класса Expect', () => {
+    test('Должен возвращать true, если значение является строкой', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toBeString()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является строкой (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeString()).toThrow(TypeError);
+        expect(() => expectInstance.toBeString()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeString('Значение должно быть строкой')).toThrow(TypeError);
+        expect(() => expectInstance.toBeString('Значение должно быть строкой')).toThrow(
+            'Значение должно быть строкой',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect('hello');
+        expect(() => expectInstance.toBeString(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeString(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не строкой', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeString()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не строкой', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeString()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является пустой строкой', () => {
+        const expectInstance = new Expect('');
+        expect(expectInstance.toBeString()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeSymbol.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeSymbol класса Expect', () => {
+    test('Должен возвращать true, если значение является символом', () => {
+        const expectInstance = new Expect(Symbol('example'));
+        expect(expectInstance.toBeSymbol()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является символом (строка)', () => {
+        const expectInstance = new Expect('example');
+        expect(() => expectInstance.toBeSymbol()).toThrow(TypeError);
+        expect(() => expectInstance.toBeSymbol()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является символом', () => {
+        const expectInstance = new Expect('example');
+        expect(() => expectInstance.toBeSymbol('Значение должно быть символом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeSymbol('Значение должно быть символом')).toThrow(
+            'Значение должно быть символом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(Symbol('example'));
+        expect(() => expectInstance.toBeSymbol(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeSymbol(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом, а не символом', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeSymbol()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не символом', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeSymbol()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является символом (уникальный символ)', () => {
+        const expectInstance = new Expect(Symbol.for('unique'));
+        expect(expectInstance.toBeSymbol()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeUndefined.test.mjs

@@ -0,0 +1,50 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeUndefined класса Expect', () => {
+    test('Должен возвращать true, если значение является undefined', () => {
+        let value;
+        const expectInstance = new Expect(value);
+        expect(expectInstance.toBeUndefined()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является undefined (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+        expect(() => expectInstance.toBeUndefined()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является undefined', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeUndefined('Значение должно быть undefined')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeUndefined('Значение должно быть undefined')).toThrow(
+            'Значение должно быть undefined',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        let value;
+        const expectInstance = new Expect(value);
+        expect(() => expectInstance.toBeUndefined(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeUndefined(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не undefined', () => {
+        const expectInstance = new Expect('undefined');
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не undefined', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является null, а не undefined', () => {
+        const expectInstance = new Expect(null);
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+    });
+});