@rogolev/value 0.0.4 → 0.0.5

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

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

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

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

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

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

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

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

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