@rogolev/value 0.0.3 → 0.0.5

package/tests/helpers/array.test.mjs

@@ -1,58 +1,58 @@
-import { expect, test, describe } from '@jest/globals';
-import { array } from '../../index.mjs';
-
-describe('Функция array', () => {
-    test('Должна возвращать массив с единственным элементом, если передан один массив', () => {
-        const input = [1, 2, 3];
-        const result = array(input);
-        expect(result).toEqual([1, 2, 3]);
-    });
-
-    test('Должна добавлять элементы в массив, если передано несколько значений', () => {
-        const result = array(1, [2, 3], { a: 10, b: 20 });
-        expect(result).toEqual([1, [2, 3], { a: 10, b: 20 }]);
-    });
-
-    test('Должна обрабатывать ассоциативные массивы (объекты с ключами и значениями)', () => {
-        const assoc = { key1: 'value1', key2: 'value2' };
-        const result = array(assoc);
-        expect(result).toEqual(assoc); // Элемент должен быть объектом
-        expect(Object.getPrototypeOf(result)).toBeNull(); // Прототип должен быть null
-    });
-
-    test('Должна создавать итератор для ассоциативного массива', () => {
-        const assoc = { key: 'value', anotherKey: 'anotherValue' };
-        const result = array(assoc);
-
-        const iteratorOutput = [];
-        for (const [key, value] of result) {
-            iteratorOutput.push([key, value]);
-        }
-
-        expect(iteratorOutput).toEqual([
-            ['key', 'value'],
-            ['anotherKey', 'anotherValue'],
-        ]);
-    });
-
-    test('Должна возвращать исходный массив, если он передан как единственный аргумент', () => {
-        const nestedArray = [1, 2, 3];
-        const result = array(nestedArray);
-        expect(result).toBe(nestedArray); // Массив должен быть возвращен напрямую
-    });
-
-    test('Должна работать с примитивными значениями', () => {
-        const result = array(42, 'test', true, null);
-        expect(result).toEqual([42, 'test', true, null]);
-    });
-
-    test('Должна возвращать массив, если передано несколько различных типов', () => {
-        const result = array(1, 'text', [2, 3], { foo: 'bar' });
-        expect(result).toEqual([1, 'text', [2, 3], { foo: 'bar' }]);
-    });
-
-    test('Должна возвращать массив с объектами и ассоциативными массивами', () => {
-        const result = array({ key1: 'value1' }, [1, 2], { key2: 'value2' });
-        expect(result).toEqual([{ key1: 'value1' }, [1, 2], { key2: 'value2' }]);
-    });
-});
+import { expect, test, describe } from '@jest/globals';
+import { array } from '../../index.mjs';
+
+describe('Функция array', () => {
+    test('Должна возвращать массив с единственным элементом, если передан один массив', () => {
+        const input = [1, 2, 3];
+        const result = array(input);
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('Должна добавлять элементы в массив, если передано несколько значений', () => {
+        const result = array(1, [2, 3], { a: 10, b: 20 });
+        expect(result).toEqual([1, [2, 3], { a: 10, b: 20 }]);
+    });
+
+    test('Должна обрабатывать ассоциативные массивы (объекты с ключами и значениями)', () => {
+        const assoc = { key1: 'value1', key2: 'value2' };
+        const result = array(assoc);
+        expect(result).toEqual(assoc); // Элемент должен быть объектом
+        expect(Object.getPrototypeOf(result)).toBeNull(); // Прототип должен быть null
+    });
+
+    test('Должна создавать итератор для ассоциативного массива', () => {
+        const assoc = { key: 'value', anotherKey: 'anotherValue' };
+        const result = array(assoc);
+
+        const iteratorOutput = [];
+        for (const [key, value] of result) {
+            iteratorOutput.push([key, value]);
+        }
+
+        expect(iteratorOutput).toEqual([
+            ['key', 'value'],
+            ['anotherKey', 'anotherValue'],
+        ]);
+    });
+
+    test('Должна возвращать исходный массив, если он передан как единственный аргумент', () => {
+        const nestedArray = [1, 2, 3];
+        const result = array(nestedArray);
+        expect(result).toBe(nestedArray); // Массив должен быть возвращен напрямую
+    });
+
+    test('Должна работать с примитивными значениями', () => {
+        const result = array(42, 'test', true, null);
+        expect(result).toEqual([42, 'test', true, null]);
+    });
+
+    test('Должна возвращать массив, если передано несколько различных типов', () => {
+        const result = array(1, 'text', [2, 3], { foo: 'bar' });
+        expect(result).toEqual([1, 'text', [2, 3], { foo: 'bar' }]);
+    });
+
+    test('Должна возвращать массив с объектами и ассоциативными массивами', () => {
+        const result = array({ key1: 'value1' }, [1, 2], { key2: 'value2' });
+        expect(result).toEqual([{ key1: 'value1' }, [1, 2], { key2: 'value2' }]);
+    });
+});

package/tests/helpers/expect.test.mjs

@@ -0,0 +1,95 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect, expect as exp } from '../../index.mjs';
+
+describe('Функция expect', () => {
+    test('Должна возвращать экземпляр класса Expect', () => {
+        expect(exp(5)).toBeInstanceOf(Expect);
+    });
+
+    test('Должна корректно передавать значение в экземпляр класса Expect', () => {
+        expect(exp(5).toBe(5)).toBe(true);
+    });
+
+    test('Должна корректно работать с массивами', () => {
+        expect(exp([1, 2, 3]).toBeArray()).toBe(true);
+    });
+
+    test('Должна корректно работать с объектами', () => {
+        class stdClass {}
+        expect(exp(new stdClass()).toBeObject()).toBe(true);
+    });
+
+    test('Должна корректно работать с BigInt', () => {
+        expect(exp(123n).toBeBigInt()).toBe(true);
+    });
+
+    test('Должна корректно работать с логическими значениями', () => {
+        expect(exp(true).toBeBool()).toBe(true);
+    });
+
+    test('Должна корректно работать с символами', () => {
+        expect(exp('a').toBeChar()).toBe(true);
+    });
+
+    test('Должна корректно работать с классами', () => {
+        class MyClass {}
+        expect(exp(MyClass).toBeClass()).toBe(true);
+    });
+
+    test('Должна корректно работать с числами с плавающей запятой', () => {
+        expect(exp(3.14).toBeFloat()).toBe(true);
+    });
+
+    test('Должна корректно работать с функциями', () => {
+        function myFunction() {}
+        expect(exp(myFunction).toBeFunction()).toBe(true);
+    });
+
+    test('Должна корректно работать с бесконечностью', () => {
+        expect(exp(Infinity).toBeInfinity()).toBe(true);
+    });
+
+    test('Должна корректно работать с целыми числами', () => {
+        expect(exp(123).toBeInt()).toBe(true);
+    });
+
+    test('Должна корректно работать с NaN', () => {
+        expect(exp(NaN).toBeNaN()).toBe(true);
+    });
+
+    test('Должна корректно работать с null', () => {
+        expect(exp(null).toBeNull()).toBe(true);
+    });
+
+    test('Должна корректно работать с числами', () => {
+        expect(exp(123).toBeNumber()).toBe(true);
+    });
+
+    test('Должна корректно работать с числовыми значениями', () => {
+        expect(exp('123').toBeNumeric()).toBe(true);
+    });
+
+    test('Должна корректно работать со скалярными значениями', () => {
+        expect(exp(123).toBeScalar()).toBe(true);
+    });
+
+    test('Должна корректно работать со строками', () => {
+        expect(exp('hello').toBeString()).toBe(true);
+    });
+
+    test('Должна корректно работать с символами (Symbol)', () => {
+        expect(exp(Symbol('example')).toBeSymbol()).toBe(true);
+    });
+
+    test('Должна корректно работать с undefined', () => {
+        expect(exp(undefined).toBeUndefined()).toBe(true);
+    });
+
+    test('Должна корректно проверять эквивалентность значений', () => {
+        expect(exp({ a: 1, b: '2' }).toEqual({ a: 1, b: 2 })).toBe(true);
+    });
+
+    test('Должна корректно проверять строгую эквивалентность значений', () => {
+        expect(exp({ a: 1, b: 2 }).toStrictEqual({ a: 1, b: 2 })).toBe(true);
+    });
+});

package/tests/helpers/expect_array.test.mjs

@@ -0,0 +1,71 @@
+import { expect, test, describe } from '@jest/globals';
+import { expect_array } from '../../index.mjs';
+
+describe('Функция expect_array', () => {
+    test('Должна возвращать true, если значение является массивом', () => {
+        const array = [1, 2, 3];
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+
+    test('Должна выбрасывать ошибку, если значение не является массивом', () => {
+        expect(() => expect_array('not an array')).toThrow(TypeError);
+        expect(() => expect_array('not an array')).toThrow('');
+    });
+
+    test('Должна выбрасывать ошибку с пользовательским сообщением, если значение не является массивом', () => {
+        expect(() => expect_array('not an array', 'Значение должно быть массивом.')).toThrow(
+            TypeError,
+        );
+        expect(() => expect_array('not an array', 'Значение должно быть массивом.')).toThrow(
+            'Значение должно быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр message не является строкой', () => {
+        expect(() => expect_array([1, 2, 3], 123)).toThrow(TypeError);
+        expect(() => expect_array([1, 2, 3], 123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должна корректно обрабатывать пустой массив', () => {
+        const array = [];
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать массив с одним элементом', () => {
+        const array = [1];
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать массив с несколькими элементами', () => {
+        const array = [1, 2, 3, 4, 5];
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать ассоциативный массив', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать массив с вложенными массивами', () => {
+        const array = [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+        ];
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать массив с различными типами данных', () => {
+        const array = [1, '2', true, null, undefined, { a: 1 }, [1, 2]];
+        const result = expect_array(array);
+        expect(result).toBe(true);
+    });
+});

package/tests/helpers/expect_assoc.test.mjs

@@ -0,0 +1,61 @@
+import { expect, test, describe } from '@jest/globals';
+import { expect_assoc } from '../../index.mjs';
+
+describe('Функция expect_assoc', () => {
+    test('Должна возвращать true, если значение является ассоциативным массивом', () => {
+        const assoc = { a: 1, b: 2, c: 3 };
+        const result = expect_assoc(assoc);
+        expect(result).toBe(true);
+    });
+
+    test('Должна выбрасывать ошибку, если значение не является ассоциативным массивом', () => {
+        expect(() => expect_assoc([1, 2, 3])).toThrow(TypeError);
+        expect(() => expect_assoc([1, 2, 3])).toThrow('');
+    });
+
+    test('Должна выбрасывать ошибку с пользовательским сообщением, если значение не является ассоциативным массивом', () => {
+        expect(() =>
+            expect_assoc([1, 2, 3], 'Значение должно быть ассоциативным массивом.'),
+        ).toThrow(TypeError);
+        expect(() =>
+            expect_assoc([1, 2, 3], 'Значение должно быть ассоциативным массивом.'),
+        ).toThrow('Значение должно быть ассоциативным массивом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр message не является строкой', () => {
+        expect(() => expect_assoc({ a: 1, b: 2, c: 3 }, 123)).toThrow(TypeError);
+        expect(() => expect_assoc({ a: 1, b: 2, c: 3 }, 123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должна корректно обрабатывать пустой ассоциативный массив', () => {
+        const assoc = {};
+        const result = expect_assoc(assoc);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать ассоциативный массив с одним элементом', () => {
+        const assoc = { a: 1 };
+        const result = expect_assoc(assoc);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать ассоциативный массив с несколькими элементами', () => {
+        const assoc = { a: 1, b: 2, c: 3, d: 4, e: 5 };
+        const result = expect_assoc(assoc);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать ассоциативный массив с вложенными массивами', () => {
+        const assoc = { a: [1, 2], b: [3, 4], c: [5, 6] };
+        const result = expect_assoc(assoc);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать ассоциативный массив с различными типами данных', () => {
+        const assoc = { a: 1, b: '2', c: true, d: null, e: undefined, f: { a: 1 }, g: [1, 2] };
+        const result = expect_assoc(assoc);
+        expect(result).toBe(true);
+    });
+});

package/tests/helpers/expect_bigint.test.mjs

@@ -0,0 +1,63 @@
+import { expect, test, describe } from '@jest/globals';
+import { expect_bigint } from '../../index.mjs';
+
+describe('Функция expect_bigint', () => {
+    test('Должна возвращать true, если значение является BigInt', () => {
+        const value = 123n;
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна выбрасывать ошибку, если значение не является BigInt', () => {
+        expect(() => expect_bigint(123)).toThrow(TypeError);
+        expect(() => expect_bigint(123)).toThrow('');
+    });
+
+    test('Должна выбрасывать ошибку с пользовательским сообщением, если значение не является BigInt', () => {
+        expect(() => expect_bigint(123, 'Значение должно быть BigInt.')).toThrow(TypeError);
+        expect(() => expect_bigint(123, 'Значение должно быть BigInt.')).toThrow(
+            'Значение должно быть BigInt.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр message не является строкой', () => {
+        expect(() => expect_bigint(123n, 123)).toThrow(TypeError);
+        expect(() => expect_bigint(123n, 123)).toThrow('Параметр "message" должен быть строкой.');
+    });
+
+    test('Должна корректно обрабатывать значение BigInt с нулевым значением', () => {
+        const value = 0n;
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение BigInt с отрицательным значением', () => {
+        const value = -123n;
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение BigInt с большим значением', () => {
+        const value = 123456789012345678901234567890n;
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение BigInt с маленьким значением', () => {
+        const value = 1n;
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение BigInt с максимальным значением', () => {
+        const value = BigInt(Number.MAX_SAFE_INTEGER);
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение BigInt с минимальным значением', () => {
+        const value = BigInt(Number.MIN_SAFE_INTEGER);
+        const result = expect_bigint(value);
+        expect(result).toBe(true);
+    });
+});

package/tests/helpers/expect_bool.test.mjs

@@ -0,0 +1,59 @@
+import { expect, test, describe } from '@jest/globals';
+import { expect_bool } from '../../index.mjs';
+
+describe('Функция expect_bool', () => {
+    test('Должна возвращать true, если значение является логическим типом', () => {
+        const value = true;
+        const result = expect_bool(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна выбрасывать ошибку, если значение не является логическим типом', () => {
+        expect(() => expect_bool(123)).toThrow(TypeError);
+        expect(() => expect_bool(123)).toThrow('');
+    });
+
+    test('Должна выбрасывать ошибку с пользовательским сообщением, если значение не является логическим типом', () => {
+        expect(() => expect_bool(123, 'Значение должно быть логическим типом.')).toThrow(TypeError);
+        expect(() => expect_bool(123, 'Значение должно быть логическим типом.')).toThrow(
+            'Значение должно быть логическим типом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр message не является строкой', () => {
+        expect(() => expect_bool(true, 123)).toThrow(TypeError);
+        expect(() => expect_bool(true, 123)).toThrow('Параметр "message" должен быть строкой.');
+    });
+
+    test('Должна корректно обрабатывать значение true', () => {
+        const value = true;
+        const result = expect_bool(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение false', () => {
+        const value = false;
+        const result = expect_bool(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение, не являющееся логическим типом', () => {
+        expect(() => expect_bool('true')).toThrow(TypeError);
+        expect(() => expect_bool('true')).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение null', () => {
+        expect(() => expect_bool(null)).toThrow(TypeError);
+        expect(() => expect_bool(null)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение undefined', () => {
+        expect(() => expect_bool(undefined)).toThrow(TypeError);
+        expect(() => expect_bool(undefined)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение объекта', () => {
+        expect(() => expect_bool({})).toThrow(TypeError);
+        expect(() => expect_bool({})).toThrow('');
+    });
+});

package/tests/helpers/expect_boolean.test.mjs

@@ -0,0 +1,61 @@
+import { expect, test, describe } from '@jest/globals';
+import { expect_boolean } from '../../index.mjs';
+
+describe('Функция expect_boolean', () => {
+    test('Должна возвращать true, если значение является логическим типом', () => {
+        const value = true;
+        const result = expect_boolean(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна выбрасывать ошибку, если значение не является логическим типом', () => {
+        expect(() => expect_boolean(123)).toThrow(TypeError);
+        expect(() => expect_boolean(123)).toThrow('');
+    });
+
+    test('Должна выбрасывать ошибку с пользовательским сообщением, если значение не является логическим типом', () => {
+        expect(() => expect_boolean(123, 'Значение должно быть логическим типом.')).toThrow(
+            TypeError,
+        );
+        expect(() => expect_boolean(123, 'Значение должно быть логическим типом.')).toThrow(
+            'Значение должно быть логическим типом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр message не является строкой', () => {
+        expect(() => expect_boolean(true, 123)).toThrow(TypeError);
+        expect(() => expect_boolean(true, 123)).toThrow('Параметр "message" должен быть строкой.');
+    });
+
+    test('Должна корректно обрабатывать значение true', () => {
+        const value = true;
+        const result = expect_boolean(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение false', () => {
+        const value = false;
+        const result = expect_boolean(value);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение, не являющееся логическим типом', () => {
+        expect(() => expect_boolean('true')).toThrow(TypeError);
+        expect(() => expect_boolean('true')).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение null', () => {
+        expect(() => expect_boolean(null)).toThrow(TypeError);
+        expect(() => expect_boolean(null)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение undefined', () => {
+        expect(() => expect_boolean(undefined)).toThrow(TypeError);
+        expect(() => expect_boolean(undefined)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение объекта', () => {
+        expect(() => expect_boolean({})).toThrow(TypeError);
+        expect(() => expect_boolean({})).toThrow('');
+    });
+});

package/tests/helpers/expect_char.test.mjs

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

package/tests/helpers/expect_class.test.mjs

@@ -0,0 +1,64 @@
+import { expect, test, describe } from '@jest/globals';
+import { expect_class } from '../../index.mjs';
+
+describe('Функция expect_class', () => {
+    test('Должна возвращать true, если значение является классом', () => {
+        class MyClass {}
+        const result = expect_class(MyClass);
+        expect(result).toBe(true);
+    });
+
+    test('Должна выбрасывать ошибку, если значение не является классом', () => {
+        expect(() => expect_class('not a class')).toThrow(TypeError);
+        expect(() => expect_class('not a class')).toThrow('');
+    });
+
+    test('Должна выбрасывать ошибку с пользовательским сообщением, если значение не является классом', () => {
+        expect(() => expect_class('not a class', 'Значение должно быть классом.')).toThrow(
+            TypeError,
+        );
+        expect(() => expect_class('not a class', 'Значение должно быть классом.')).toThrow(
+            'Значение должно быть классом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр message не является строкой', () => {
+        expect(() => expect_class(class {}, 123)).toThrow(TypeError);
+        expect(() => expect_class(class {}, 123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должна корректно обрабатывать значение класса', () => {
+        class AnotherClass {}
+        const result = expect_class(AnotherClass);
+        expect(result).toBe(true);
+    });
+
+    test('Должна корректно обрабатывать значение функции', () => {
+        function notAClass() {}
+        expect(() => expect_class(notAClass)).toThrow(TypeError);
+        expect(() => expect_class(notAClass)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение объекта', () => {
+        const obj = {};
+        expect(() => expect_class(obj)).toThrow(TypeError);
+        expect(() => expect_class(obj)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение null', () => {
+        expect(() => expect_class(null)).toThrow(TypeError);
+        expect(() => expect_class(null)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение undefined', () => {
+        expect(() => expect_class(undefined)).toThrow(TypeError);
+        expect(() => expect_class(undefined)).toThrow('');
+    });
+
+    test('Должна корректно обрабатывать значение строки', () => {
+        expect(() => expect_class('class')).toThrow(TypeError);
+        expect(() => expect_class('class')).toThrow('');
+    });
+});