@rogolev/value 0.0.4 → 0.0.5

package/tests/helpers/expect_float.test.mjs

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

package/tests/helpers/expect_function.test.mjs

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

package/tests/helpers/expect_infinity.test.mjs

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

package/tests/helpers/expect_int.test.mjs

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

package/tests/helpers/expect_integer.test.mjs

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

package/tests/helpers/expect_list.test.mjs

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

package/tests/helpers/expect_nan.test.mjs

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

package/tests/helpers/expect_null.test.mjs

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

package/tests/helpers/expect_number.test.mjs

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

package/tests/helpers/expect_numeric.test.mjs

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