@rogolev/value 0.0.1 → 0.0.3

package/tests/classes/Type.test.mjs

@@ -0,0 +1,1262 @@
+import { expect, test, describe } from '@jest/globals';
+import { Type } from '../../index.mjs';
+
+describe('Класс Type', () => {
+    describe('Метод Type.isEmpty', () => {
+        test('Должен возвращать true для пустых значений', () => {
+            expect(Type.isEmpty(null)).toBe(true);
+            expect(Type.isEmpty(undefined)).toBe(true);
+            expect(Type.isEmpty('')).toBe(true);
+            expect(Type.isEmpty(0)).toBe(true);
+            expect(Type.isEmpty(false)).toBe(true);
+            expect(Type.isEmpty([])).toBe(true);
+            expect(Type.isEmpty({})).toBe(true);
+        });
+
+        test('Должен возвращать false для непустых значений', () => {
+            expect(Type.isEmpty('example')).toBe(false);
+            expect(Type.isEmpty(123)).toBe(false);
+            expect(Type.isEmpty(true)).toBe(false);
+            expect(Type.isEmpty([1, 2, 3])).toBe(false);
+            expect(Type.isEmpty({ key: 'value' })).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isArray', () => {
+        describe('Примитивные значения и базовые типы', () => {
+            test('false не является массивом', () => {
+                expect(Type.isArray(false)).toBeFalsy();
+            });
+
+            test('true не является массивом', () => {
+                expect(Type.isArray(true)).toBeFalsy();
+            });
+
+            test('Число 3 не является массивом', () => {
+                expect(Type.isArray(3)).toBeFalsy();
+            });
+
+            test('Число 3.14 не является массивом', () => {
+                expect(Type.isArray(3.14)).toBeFalsy();
+            });
+
+            test('Строка "string" не является массивом', () => {
+                expect(Type.isArray('string')).toBeFalsy();
+            });
+
+            test('null не является массивом', () => {
+                expect(Type.isArray(null)).toBeFalsy();
+            });
+
+            test('undefined не является массивом', () => {
+                expect(Type.isArray(undefined)).toBeFalsy();
+            });
+
+            test('NaN не является массивом', () => {
+                expect(Type.isArray(NaN)).toBeFalsy();
+            });
+
+            test('Symbol не является массивом', () => {
+                expect(Type.isArray(Symbol())).toBeFalsy();
+            });
+        });
+
+        describe('Массивы и объекты', () => {
+            test('Обычный массив [1, 2] является массивом', () => {
+                expect(Type.isArray([1, 2])).toBeTruthy();
+            });
+
+            test('Объект с парами ключ-значение {0: 1, 1: 2} является ассоциативным массивом', () => {
+                expect(Type.isArray({ 0: 1, 1: 2 })).toBeTruthy();
+            });
+
+            test('Объект {foo: "bar"} является ассоциативным массивом', () => {
+                expect(Type.isArray({ foo: 'bar' })).toBeTruthy();
+            });
+
+            test('Объект, созданный через Object.create(null), является ассоциативным массивом', () => {
+                const noProtoObject = Object.create(null);
+                noProtoObject.foo = 'bar';
+                expect(Type.isArray(noProtoObject)).toBeTruthy();
+            });
+
+            test('Proxy является массивом', () => {
+                const handler = {};
+                const proxy = new Proxy([1, 2, 3], handler); // Проксируем массив
+                expect(Type.isArray(proxy)).toBeTruthy();
+            });
+        });
+
+        describe('Не массивы', () => {
+            describe('Классы', () => {
+                test('Экземпляр класса stdClass не является массивом', () => {
+                    class stdClass {}
+                    expect(Type.isArray(new stdClass())).toBeFalsy();
+                });
+
+                test('Класс stdClass сам по себе не является массивом', () => {
+                    class stdClass {}
+                    expect(Type.isArray(stdClass)).toBeFalsy();
+                });
+            });
+
+            describe('Глобальные объекты', () => {
+                // Массив глобальных объектов, которые не являются массивами
+                const globalObjects = [Object, Function, Boolean];
+
+                globalObjects.forEach((globalObj) => {
+                    test(`${globalObj.name} не является массивом`, () => {
+                        expect(Type.isArray(globalObj)).toBeFalsy();
+                    });
+                });
+
+                test('Symbol не является массивом', () => {
+                    expect(Type.isArray(Symbol)).toBeFalsy();
+                });
+            });
+
+            describe('Обработка текста', () => {
+                test('String не является массивом', () => {
+                    expect(Type.isArray(String)).toBeFalsy();
+                });
+
+                test('RegExp не является массивом', () => {
+                    expect(Type.isArray(RegExp)).toBeFalsy();
+                    expect(Type.isArray(/abc/)).toBeFalsy();
+                });
+            });
+
+            describe('Числа и даты', () => {
+                test('Number не является массивом', () => {
+                    expect(Type.isArray(Number)).toBeFalsy();
+                });
+
+                test('BigInt не является массивом', () => {
+                    expect(Type.isArray(BigInt)).toBeFalsy();
+                    expect(Type.isArray(123n)).toBeFalsy();
+                });
+
+                test('Math не является массивом', () => {
+                    expect(Type.isArray(Math)).toBeFalsy();
+                });
+
+                test('Date не является массивом', () => {
+                    expect(Type.isArray(Date)).toBeFalsy();
+                    expect(Type.isArray(new Date())).toBeFalsy();
+                });
+            });
+
+            describe('Структурированные данные', () => {
+                test('Array не является массивом', () => {
+                    expect(Type.isArray(Array)).toBeFalsy();
+                });
+
+                test('Экземпляр Map не является массивом', () => {
+                    expect(Type.isArray(Map)).toBeFalsy();
+                    expect(Type.isArray(new Map())).toBeFalsy();
+                });
+
+                test('Экземпляр Set не является массивом', () => {
+                    expect(Type.isArray(Set)).toBeFalsy();
+                    expect(Type.isArray(new Set())).toBeFalsy();
+                });
+
+                test('WeakMap не является массивом', () => {
+                    expect(Type.isArray(WeakMap)).toBeFalsy();
+                    expect(Type.isArray(new WeakMap())).toBeFalsy();
+                });
+
+                test('WeakSet не является массивом', () => {
+                    expect(Type.isArray(WeakSet)).toBeFalsy();
+                    expect(Type.isArray(new WeakSet())).toBeFalsy();
+                });
+
+                test('ArrayBuffer не является массивом', () => {
+                    expect(Type.isArray(ArrayBuffer)).toBeFalsy();
+                    expect(Type.isArray(new ArrayBuffer(8))).toBeFalsy();
+                });
+
+                test('SharedArrayBuffer не является массивом', () => {
+                    expect(Type.isArray(SharedArrayBuffer)).toBeFalsy();
+                    expect(Type.isArray(new SharedArrayBuffer(8))).toBeFalsy();
+                });
+
+                test('DataView не является массивом', () => {
+                    expect(Type.isArray(DataView)).toBeFalsy();
+                    expect(Type.isArray(new DataView(new ArrayBuffer(8)))).toBeFalsy();
+                });
+
+                test('Typed Arrays не являются массивами', () => {
+                    const typedArrays = [
+                        Int8Array,
+                        Uint8Array,
+                        Uint8ClampedArray,
+                        Int16Array,
+                        Uint16Array,
+                        Int32Array,
+                        Uint32Array,
+                        Float32Array,
+                        Float64Array,
+                        BigInt64Array,
+                        BigUint64Array,
+                    ];
+                    typedArrays.forEach((ArrayType) => {
+                        expect(Type.isArray(ArrayType)).toBeFalsy();
+                        expect(Type.isArray(new ArrayType(8))).toBeFalsy();
+                    });
+                });
+            });
+
+            describe('Объекты абстракции управления', () => {
+                test('Promise не является массивом', () => {
+                    expect(Type.isArray(new Promise(() => {}))).toBeFalsy();
+                });
+
+                test('Generator не является массивом', () => {
+                    function* gen() {}
+                    expect(Type.isArray(gen())).toBeFalsy();
+                });
+
+                test('GeneratorFunction не является массивом', () => {
+                    function* gen() {}
+                    expect(Type.isArray(gen.constructor)).toBeFalsy();
+                });
+
+                test('AsyncFunction не является массивом', () => {
+                    async function func() {}
+                    expect(Type.isArray(func)).toBeFalsy();
+                });
+
+                test('AsyncGenerator не является массивом', () => {
+                    async function* gen() {}
+                    expect(Type.isArray(gen())).toBeFalsy();
+                });
+
+                test('AsyncGeneratorFunction не является массивом', () => {
+                    async function* gen() {}
+                    expect(Type.isArray(gen.constructor)).toBeFalsy();
+                });
+            });
+
+            describe('Отражение', () => {
+                test('Reflect не является массивом', () => {
+                    expect(Type.isArray(Reflect)).toBeFalsy();
+                });
+            });
+
+            describe('Интернационализация', () => {
+                test('Intl не является массивом', () => {
+                    expect(Type.isArray(Intl)).toBeFalsy();
+                });
+            });
+
+            describe('Обработка ошибок', () => {
+                const errorTypes = [
+                    Error,
+                    EvalError,
+                    RangeError,
+                    ReferenceError,
+                    SyntaxError,
+                    TypeError,
+                    URIError,
+                ];
+
+                // Тестируем все ошибки из списка
+                errorTypes.forEach((errorType) => {
+                    test(`${errorType.name} не является массивом`, () => {
+                        expect(Type.isArray(errorType)).toBeFalsy();
+                    });
+                });
+            });
+
+            describe('Веб-API (объекты, зависящие от браузера)', () => {
+                test('Window не является массивом', () => {
+                    expect(Type.isArray(Window)).toBeFalsy();
+                });
+
+                test('document не является массивом', () => {
+                    expect(Type.isArray(document)).toBeFalsy();
+                });
+
+                test('navigator не является массивом', () => {
+                    expect(Type.isArray(navigator)).toBeFalsy();
+                });
+
+                test('location не является массивом', () => {
+                    expect(Type.isArray(location)).toBeFalsy();
+                });
+
+                test('Function не является массивом', () => {
+                    expect(Type.isArray(Function)).toBeFalsy();
+                });
+
+                test('screen не является массивом', () => {
+                    expect(Type.isArray(screen)).toBeFalsy();
+                });
+
+                test('history не является массивом', () => {
+                    expect(Type.isArray(history)).toBeFalsy();
+                });
+
+                test('localStorage не является массивом', () => {
+                    expect(Type.isArray(localStorage)).toBeFalsy();
+                });
+
+                test('Function не является массивом', () => {
+                    expect(Type.isArray(Function)).toBeFalsy();
+                });
+
+                test('sessionStorage не является массивом', () => {
+                    expect(Type.isArray(sessionStorage)).toBeFalsy();
+                });
+
+                test('XMLHttpRequest не является массивом', () => {
+                    expect(Type.isArray(XMLHttpRequest)).toBeFalsy();
+                });
+
+                test('WebSocket не является массивом', () => {
+                    expect(Type.isArray(WebSocket)).toBeFalsy();
+                    expect(Type.isArray(new WebSocket('ws://localhost'))).toBeFalsy();
+                });
+
+                test('Event не является массивом', () => {
+                    expect(Type.isArray(Event)).toBeFalsy();
+                    expect(Type.isArray(new Event('click'))).toBeFalsy();
+                });
+
+                test('CustomEvent не является массивом', () => {
+                    expect(Type.isArray(CustomEvent)).toBeFalsy();
+                    expect(Type.isArray(new CustomEvent('test'))).toBeFalsy();
+                });
+
+                test('AbortController не является массивом', () => {
+                    expect(Type.isArray(AbortController)).toBeFalsy();
+                    expect(Type.isArray(new AbortController())).toBeFalsy();
+                });
+
+                test('FormData не является массивом', () => {
+                    expect(Type.isArray(FormData)).toBeFalsy();
+                });
+
+                test('Blob не является массивом', () => {
+                    expect(Type.isArray(Blob)).toBeFalsy();
+                    expect(Type.isArray(new Blob([]))).toBeFalsy();
+                });
+
+                test('File не является массивом', () => {
+                    expect(Type.isArray(File)).toBeFalsy();
+                    expect(Type.isArray(new File([], 'test.txt'))).toBeFalsy();
+                });
+
+                test('FileReader не является массивом', () => {
+                    expect(Type.isArray(FileReader)).toBeFalsy();
+                    expect(Type.isArray(new FileReader())).toBeFalsy();
+                });
+
+                test('Performance не является массивом', () => {
+                    expect(Type.isArray(Performance)).toBeFalsy();
+                });
+            });
+
+            describe('Веб-хранилище и сетевое взаимодействие', () => {
+                test('URL не является массивом', () => {
+                    expect(Type.isArray(URL)).toBeFalsy();
+                });
+
+                test('URLSearchParams не является массивом', () => {
+                    expect(Type.isArray(URLSearchParams)).toBeFalsy();
+                });
+
+                test('Location не является массивом', () => {
+                    expect(Type.isArray(Location)).toBeFalsy();
+                });
+
+                test('Cookies не является массивом', () => {
+                    expect(Type.isArray(document.cookie)).toBeFalsy();
+                });
+
+                test('IndexedDB не является массивом', () => {
+                    expect(Type.isArray(window.indexedDB)).toBeFalsy();
+                });
+            });
+
+            describe('Другие', () => {
+                test('JSON не является массивом', () => {
+                    expect(Type.isArray(JSON)).toBeFalsy();
+                });
+
+                test('Math не является массивом', () => {
+                    expect(Type.isArray(Math)).toBeFalsy();
+                });
+
+                test('console не является массивом', () => {
+                    expect(Type.isArray(console)).toBeFalsy();
+                });
+
+                test('setTimeout не является массивом', () => {
+                    expect(Type.isArray(setTimeout)).toBeFalsy();
+                });
+
+                test('clearTimeout не является массивом', () => {
+                    expect(Type.isArray(clearTimeout)).toBeFalsy();
+                });
+
+                test('setInterval не является массивом', () => {
+                    expect(Type.isArray(setInterval)).toBeFalsy();
+                });
+
+                test('clearInterval не является массивом', () => {
+                    expect(Type.isArray(clearInterval)).toBeFalsy();
+                });
+
+                test('setImmediate не является массивом', () => {
+                    expect(Type.isArray(setImmediate)).toBeFalsy();
+                });
+
+                test('clearImmediate не является массивом', () => {
+                    expect(Type.isArray(clearImmediate)).toBeFalsy();
+                });
+
+                test('process не является массивом', () => {
+                    expect(Type.isArray(process)).toBeFalsy();
+                });
+            });
+        });
+    });
+
+    describe('Метод Type.isAssoc', () => {
+        test('должен возвращать true для ассоциативных массивов', () => {
+            expect(Type.isAssoc({ foo: 'bar' })).toBe(true);
+            expect(Type.isAssoc({})).toBe(true);
+        });
+
+        test('должен возвращать false для обычных массивов', () => {
+            expect(Type.isAssoc([])).toBe(false);
+            expect(Type.isAssoc([1, 2, 3])).toBe(false);
+        });
+
+        test('должен возвращать false для строк', () => {
+            expect(Type.isAssoc('string')).toBe(false);
+        });
+
+        test('должен возвращать false для чисел', () => {
+            expect(Type.isAssoc(42)).toBe(false);
+        });
+
+        test('должен возвращать false для null и undefined', () => {
+            expect(Type.isAssoc(null)).toBe(false);
+            expect(Type.isAssoc(undefined)).toBe(false);
+        });
+
+        test('должен возвращать false для логических значений', () => {
+            expect(Type.isAssoc(true)).toBe(false);
+            expect(Type.isAssoc(false)).toBe(false);
+        });
+
+        test('должен возвращать false для функций', () => {
+            function func() {}
+            expect(Type.isAssoc(func)).toBe(false);
+            expect(Type.isAssoc(() => {})).toBe(false);
+        });
+
+        test('должен возвращать false для символов', () => {
+            expect(Type.isAssoc(Symbol('symbol'))).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isBigInt', () => {
+        test('должен возвращать true для значений типа bigint', () => {
+            expect(Type.isBigInt(BigInt(123456))).toBe(true);
+            expect(Type.isBigInt(BigInt(-123456))).toBe(true);
+        });
+
+        test('должен возвращать false для чисел', () => {
+            expect(Type.isBigInt(42)).toBe(false);
+            expect(Type.isBigInt(-42)).toBe(false);
+            expect(Type.isBigInt(0)).toBe(false);
+            expect(Type.isBigInt(3.14)).toBe(false);
+            expect(Type.isBigInt(-0.99)).toBe(false);
+        });
+
+        test('должен возвращать false для специальных чисел', () => {
+            expect(Type.isBigInt(NaN)).toBe(false);
+            expect(Type.isBigInt(Infinity)).toBe(false);
+            expect(Type.isBigInt(-Infinity)).toBe(false);
+        });
+
+        test('должен возвращать false для строк', () => {
+            expect(Type.isBigInt('42')).toBe(false);
+            expect(Type.isBigInt('3.14')).toBe(false);
+            expect(Type.isBigInt('')).toBe(false);
+        });
+
+        test('должен возвращать false для логических значений', () => {
+            expect(Type.isBigInt(true)).toBe(false);
+            expect(Type.isBigInt(false)).toBe(false);
+        });
+
+        test('должен возвращать false для null и undefined', () => {
+            expect(Type.isBigInt(null)).toBe(false);
+            expect(Type.isBigInt(undefined)).toBe(false);
+        });
+
+        test('должен возвращать false для объектов и массивов', () => {
+            expect(Type.isBigInt({})).toBe(false);
+            expect(Type.isBigInt([])).toBe(false);
+            expect(Type.isBigInt({ foo: 42 })).toBe(false);
+            expect(Type.isBigInt([1, 2, 3])).toBe(false);
+        });
+
+        test('должен возвращать false для функций', () => {
+            expect(Type.isBigInt(() => {})).toBe(false);
+            expect(Type.isBigInt(() => {})).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isBool', () => {
+        test('должен возвращать true для значения true', () => {
+            expect(Type.isBool(true)).toBe(true);
+        });
+
+        test('должен возвращать true для значения false', () => {
+            expect(Type.isBool(false)).toBe(true);
+        });
+
+        test('должен возвращать false для значения числа', () => {
+            expect(Type.isBool(0)).toBe(false);
+            expect(Type.isBool(1)).toBe(false);
+        });
+
+        test('должен возвращать false для строки', () => {
+            expect(Type.isBool('true')).toBe(false);
+            expect(Type.isBool('false')).toBe(false);
+        });
+
+        test('должен возвращать false для объекта', () => {
+            expect(Type.isBool({})).toBe(false);
+            expect(Type.isBool([])).toBe(false);
+        });
+
+        test('должен возвращать false для null', () => {
+            expect(Type.isBool(null)).toBe(false);
+        });
+
+        test('должен возвращать false для undefined', () => {
+            expect(Type.isBool(undefined)).toBe(false);
+        });
+
+        test('должен возвращать false для функции', () => {
+            expect(Type.isBool(() => {})).toBe(false);
+        });
+
+        test('должен возвращать false для объекта Boolean', () => {
+            expect(Type.isBool(new Boolean(true))).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isBoolean', () => {
+        test('должен возвращать true для значения true', () => {
+            expect(Type.isBoolean(true)).toBe(true);
+        });
+
+        test('должен возвращать true для значения false', () => {
+            expect(Type.isBoolean(false)).toBe(true);
+        });
+
+        test('должен возвращать false для значения числа', () => {
+            expect(Type.isBoolean(0)).toBe(false);
+            expect(Type.isBoolean(1)).toBe(false);
+        });
+
+        test('должен возвращать false для строки', () => {
+            expect(Type.isBoolean('true')).toBe(false);
+            expect(Type.isBoolean('false')).toBe(false);
+        });
+
+        test('должен возвращать false для объекта', () => {
+            expect(Type.isBoolean({})).toBe(false);
+            expect(Type.isBoolean([])).toBe(false);
+        });
+
+        test('должен возвращать false для null', () => {
+            expect(Type.isBoolean(null)).toBe(false);
+        });
+
+        test('должен возвращать false для undefined', () => {
+            expect(Type.isBoolean(undefined)).toBe(false);
+        });
+
+        test('должен возвращать false для функции', () => {
+            expect(Type.isBoolean(() => {})).toBe(false);
+        });
+
+        test('должен возвращать false для объекта Boolean', () => {
+            expect(Type.isBoolean(new Boolean(true))).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isClass', () => {
+        test('должен возвращать true для класса', () => {
+            class MyClass {}
+            expect(Type.isClass(MyClass)).toBe(true);
+        });
+
+        test('должен возвращать false для функции-конструктора', () => {
+            function MyFunction() {}
+            expect(Type.isClass(MyFunction)).toBe(false);
+        });
+
+        test('должен возвращать false для объектов', () => {
+            expect(Type.isClass({})).toBe(false);
+        });
+
+        test('должен возвращать false для массивов', () => {
+            expect(Type.isClass([])).toBe(false);
+        });
+
+        test('должен возвращать false для null', () => {
+            expect(Type.isClass(null)).toBe(false);
+        });
+
+        test('должен возвращать false для чисел', () => {
+            expect(Type.isClass(42)).toBe(false);
+        });
+
+        test('должен возвращать false для строк', () => {
+            expect(Type.isClass('hello')).toBe(false);
+        });
+
+        test('должен возвращать false для булевых значений', () => {
+            expect(Type.isClass(true)).toBe(false);
+        });
+
+        test('должен возвращать false для встроенных объектов, таких как Map', () => {
+            expect(Type.isClass(new Map())).toBe(false);
+        });
+
+        test('должен возвращать false для встроенных объектов, таких как Date', () => {
+            expect(Type.isClass(new Date())).toBe(false);
+        });
+
+        test('должен возвращать false для объекта, созданного через Object.create(null)', () => {
+            const noProtoObject = Object.create(null);
+            noProtoObject.foo = 'bar';
+            expect(Type.isClass(noProtoObject)).toBe(false);
+        });
+
+        test('должен возвращать false для стрелочных функций', () => {
+            expect(Type.isClass(() => {})).toBe(false);
+        });
+
+        test('должен возвращать false для async функций', () => {
+            async function asyncFunc() {}
+            expect(Type.isClass(asyncFunc)).toBe(false);
+        });
+
+        test('должен возвращать false для генераторов', () => {
+            function* generatorFunc() {}
+            expect(Type.isClass(generatorFunc)).toBe(false);
+        });
+
+        test('должен возвращать false для async генераторов', () => {
+            async function* asyncGeneratorFunc() {}
+            expect(Type.isClass(asyncGeneratorFunc)).toBe(false);
+        });
+
+        test('должен возвращать false для символов', () => {
+            expect(Type.isClass(Symbol('symbol'))).toBe(false);
+        });
+
+        test('должен возвращать false для объектов с методом toString', () => {
+            const obj = {
+                toString() {
+                    return 'class';
+                },
+            };
+            expect(Type.isClass(obj)).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isFloat', () => {
+        describe('Числа с плавающей точкой', () => {
+            test('должна возвращать true для положительных дробных чисел', () => {
+                expect(Type.isFloat(3.14)).toBe(true);
+            });
+
+            test('должна возвращать true для отрицательных дробных чисел', () => {
+                expect(Type.isFloat(-0.5)).toBe(true);
+            });
+
+            test('должна возвращать true для дробных чисел, полученных в результате вычислений', () => {
+                expect(Type.isFloat(0.1 + 0.2)).toBe(true);
+            });
+        });
+
+        describe('Целые числа', () => {
+            test('должна возвращать false для нуля', () => {
+                expect(Type.isFloat(0)).toBe(false);
+            });
+
+            test('должна возвращать false для положительных целых чисел', () => {
+                expect(Type.isFloat(42)).toBe(false);
+            });
+
+            test('должна возвращать false для отрицательных целых чисел', () => {
+                expect(Type.isFloat(-100)).toBe(false);
+            });
+        });
+
+        describe('Нечисловые значения', () => {
+            test('должна возвращать false для строки', () => {
+                expect(Type.isFloat('3.14')).toBe(false);
+            });
+
+            test('должна возвращать false для NaN', () => {
+                expect(Type.isFloat(NaN)).toBe(false);
+            });
+
+            test('должна возвращать false для null', () => {
+                expect(Type.isFloat(null)).toBe(false);
+            });
+
+            test('должна возвращать false для undefined', () => {
+                expect(Type.isFloat(undefined)).toBe(false);
+            });
+
+            test('должна возвращать false для булевых значений', () => {
+                expect(Type.isFloat(true)).toBe(false);
+                expect(Type.isFloat(false)).toBe(false);
+            });
+
+            test('должна возвращать false для объектов', () => {
+                expect(Type.isFloat({})).toBe(false);
+            });
+
+            test('должна возвращать false для массивов', () => {
+                expect(Type.isFloat([])).toBe(false);
+            });
+        });
+
+        describe('Специальные значения', () => {
+            test('должна возвращать false для Infinity', () => {
+                expect(Type.isFloat(Infinity)).toBe(false);
+            });
+
+            test('должна возвращать false для -Infinity', () => {
+                expect(Type.isFloat(-Infinity)).toBe(false);
+            });
+        });
+
+        describe('Проверка с использованием числовых строк', () => {
+            test('должна возвращать false для числовых строк', () => {
+                expect(Type.isFloat('3.14')).toBe(false);
+                expect(Type.isFloat('-0.5')).toBe(false);
+            });
+        });
+
+        describe('Проверка с использованием объектов Number', () => {
+            test('должна возвращать false для объектов Number', () => {
+                expect(Type.isFloat(new Number(3.14))).toBe(false);
+                expect(Type.isFloat(new Number(-0.5))).toBe(false);
+            });
+        });
+    });
+
+    describe('Метод Type.isFunction', () => {
+        test('должна возвращать true для обычной функции', () => {
+            function example() {}
+            expect(Type.isFunction(example)).toBe(true);
+        });
+
+        test('должна возвращать false для класса', () => {
+            class MyClass {}
+            expect(Type.isFunction(MyClass)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов', () => {
+            class MyClass {}
+            const obj = new MyClass();
+            expect(Type.isFunction(obj)).toBe(false);
+        });
+
+        test('должна возвращать false для массивов', () => {
+            expect(Type.isFunction([])).toBe(false);
+            expect(Type.isFunction({})).toBe(false);
+            expect(Type.isFunction(Object.create(null))).toBe(false);
+        });
+
+        test('должна возвращать false для примитивных типов', () => {
+            expect(Type.isFunction(42)).toBe(false);
+            expect(Type.isFunction('hello')).toBe(false);
+            expect(Type.isFunction(null)).toBe(false);
+            expect(Type.isFunction(undefined)).toBe(false);
+        });
+
+        test('должна возвращать true для стрелочных функций', () => {
+            expect(Type.isFunction(() => {})).toBe(true);
+        });
+
+        test('должна возвращать true для функции без строкового представления', () => {
+            const func = () => {};
+            func.toString = undefined;
+            expect(Type.isFunction(func)).toBe(true);
+        });
+
+        test('должна возвращать true для async функции', () => {
+            async function asyncFunc() {}
+            expect(Type.isFunction(asyncFunc)).toBe(true);
+        });
+
+        test('должна возвращать true для генератора', () => {
+            function* generatorFunc() {}
+            expect(Type.isFunction(generatorFunc)).toBe(true);
+        });
+
+        test('должна возвращать true для async генератора', () => {
+            async function* asyncGeneratorFunc() {}
+            expect(Type.isFunction(asyncGeneratorFunc)).toBe(true);
+        });
+
+        test('должна возвращать false для null', () => {
+            expect(Type.isFunction(null)).toBe(false);
+        });
+
+        test('должна возвращать false для undefined', () => {
+            expect(Type.isFunction(undefined)).toBe(false);
+        });
+
+        test('должна возвращать false для NaN', () => {
+            expect(Type.isFunction(NaN)).toBe(false);
+        });
+
+        test('должна возвращать false для символов', () => {
+            expect(Type.isFunction(Symbol('symbol'))).toBe(false);
+        });
+
+        test('должна возвращать false для объектов с методом toString', () => {
+            const obj = {
+                toString() {
+                    return 'function';
+                },
+            };
+            expect(Type.isFunction(obj)).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isInfinity', () => {
+        test('должна возвращать true для Infinity', () => {
+            expect(Type.isInfinity(Infinity)).toBe(true);
+        });
+
+        test('должна возвращать true для -Infinity', () => {
+            expect(Type.isInfinity(-Infinity)).toBe(true);
+        });
+
+        test('должна возвращать false для чисел', () => {
+            expect(Type.isInfinity(42)).toBe(false);
+            expect(Type.isInfinity(3.14)).toBe(false);
+            expect(Type.isInfinity(NaN)).toBe(false);
+        });
+
+        test('должна возвращать false для строк', () => {
+            expect(Type.isInfinity('Infinity')).toBe(false);
+            expect(Type.isInfinity('42')).toBe(false);
+            expect(Type.isInfinity('')).toBe(false);
+        });
+
+        test('должна возвращать false для логических значений', () => {
+            expect(Type.isInfinity(true)).toBe(false);
+            expect(Type.isInfinity(false)).toBe(false);
+        });
+
+        test('должна возвращать false для null и undefined', () => {
+            expect(Type.isInfinity(null)).toBe(false);
+            expect(Type.isInfinity(undefined)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов и массивов', () => {
+            expect(Type.isInfinity({})).toBe(false);
+            expect(Type.isInfinity([])).toBe(false);
+            expect(Type.isInfinity({ foo: 42 })).toBe(false);
+            expect(Type.isInfinity([1, 2, 3])).toBe(false);
+        });
+
+        test('должна возвращать false для функций', () => {
+            expect(Type.isInfinity(() => {})).toBe(false);
+            expect(Type.isInfinity(() => {})).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isInt', () => {
+        test('Возвращает true для положительных целых чисел', () => {
+            expect(Type.isInt(1)).toBe(true);
+            expect(Type.isInt(100)).toBe(true);
+            expect(Type.isInt(123456)).toBe(true);
+        });
+
+        test('Возвращает true для отрицательных целых чисел', () => {
+            expect(Type.isInt(-1)).toBe(true);
+            expect(Type.isInt(-100)).toBe(true);
+            expect(Type.isInt(-123456)).toBe(true);
+        });
+
+        test('Возвращает true для нуля', () => {
+            expect(Type.isInt(0)).toBe(true);
+        });
+
+        test('Возвращает false для чисел с плавающей точкой', () => {
+            expect(Type.isInt(1.1)).toBe(false);
+            expect(Type.isInt(-0.5)).toBe(false);
+            expect(Type.isInt(3.14159)).toBe(false);
+        });
+
+        test('Возвращает false для значений не типа number', () => {
+            expect(Type.isInt('42')).toBe(false); // строка
+            expect(Type.isInt(true)).toBe(false); // логическое значение
+            expect(Type.isInt(null)).toBe(false); // null
+            expect(Type.isInt(undefined)).toBe(false); // undefined
+            expect(Type.isInt({})).toBe(false); // объект
+            expect(Type.isInt([])).toBe(false); // массив
+        });
+
+        test('Возвращает false для специальных числовых значений', () => {
+            expect(Type.isInt(Infinity)).toBe(false); // бесконечность
+            expect(Type.isInt(-Infinity)).toBe(false); // отрицательная бесконечность
+            expect(Type.isInt(NaN)).toBe(false); // не число
+        });
+
+        test('Возвращает false для типа bigint', () => {
+            expect(Type.isInt(BigInt(123456))).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isInteger', () => {
+        test('должна возвращать true для положительных целых чисел', () => {
+            expect(Type.isInteger(42)).toBe(true);
+            expect(Type.isInteger(100)).toBe(true);
+            expect(Type.isInteger(123456)).toBe(true);
+        });
+
+        test('должна возвращать true для отрицательных целых чисел', () => {
+            expect(Type.isInteger(-42)).toBe(true);
+            expect(Type.isInteger(-100)).toBe(true);
+            expect(Type.isInteger(-123456)).toBe(true);
+        });
+
+        test('должна возвращать true для нуля', () => {
+            expect(Type.isInteger(0)).toBe(true);
+        });
+
+        test('должна возвращать false для чисел с плавающей точкой', () => {
+            expect(Type.isInteger(3.14)).toBe(false);
+            expect(Type.isInteger(-0.99)).toBe(false);
+            expect(Type.isInteger(0.1)).toBe(false);
+        });
+
+        test('должна возвращать false для специальных чисел', () => {
+            expect(Type.isInteger(NaN)).toBe(false);
+            expect(Type.isInteger(Infinity)).toBe(false);
+            expect(Type.isInteger(-Infinity)).toBe(false);
+        });
+
+        test('должна возвращать false для строк', () => {
+            expect(Type.isInteger('42')).toBe(false);
+            expect(Type.isInteger('3.14')).toBe(false);
+            expect(Type.isInteger('')).toBe(false);
+        });
+
+        test('должна возвращать false для логических значений', () => {
+            expect(Type.isInteger(true)).toBe(false);
+            expect(Type.isInteger(false)).toBe(false);
+        });
+
+        test('должна возвращать false для null и undefined', () => {
+            expect(Type.isInteger(null)).toBe(false);
+            expect(Type.isInteger(undefined)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов и массивов', () => {
+            expect(Type.isInteger({})).toBe(false);
+            expect(Type.isInteger([])).toBe(false);
+            expect(Type.isInteger({ foo: 42 })).toBe(false);
+            expect(Type.isInteger([1, 2, 3])).toBe(false);
+        });
+
+        test('должна возвращать false для функций', () => {
+            expect(Type.isInteger(() => {})).toBe(false);
+            expect(Type.isInteger(() => {})).toBe(false);
+        });
+
+        test('должна возвращать false для типа bigint', () => {
+            expect(Type.isInteger(BigInt(123456))).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isList', () => {
+        test('должна возвращать true для массивов', () => {
+            expect(Type.isList([])).toBe(true);
+            expect(Type.isList([1, 2, 3])).toBe(true);
+        });
+
+        test('должна возвращать false для ассоциативных массивов', () => {
+            expect(Type.isList({})).toBe(false);
+            expect(Type.isList({ foo: 'bar' })).toBe(false);
+        });
+
+        test('должна возвращать false для строк', () => {
+            expect(Type.isList('string')).toBe(false);
+        });
+
+        test('должна возвращать false для чисел', () => {
+            expect(Type.isList(42)).toBe(false);
+        });
+
+        test('должна возвращать false для null и undefined', () => {
+            expect(Type.isList(null)).toBe(false);
+            expect(Type.isList(undefined)).toBe(false);
+        });
+
+        test('должна возвращать false для логических значений', () => {
+            expect(Type.isList(true)).toBe(false);
+            expect(Type.isList(false)).toBe(false);
+        });
+
+        test('должна возвращать false для функций', () => {
+            function func() {}
+            expect(Type.isList(func)).toBe(false);
+            expect(Type.isList(() => {})).toBe(false);
+        });
+
+        test('должна возвращать false для символов', () => {
+            expect(Type.isList(Symbol('symbol'))).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isNaN', () => {
+        test('должна возвращать true для NaN', () => {
+            expect(Type.isNaN(NaN)).toBe(true);
+        });
+
+        test('должна возвращать false для чисел', () => {
+            expect(Type.isNaN(42)).toBe(false);
+            expect(Type.isNaN(3.14)).toBe(false);
+            expect(Type.isNaN(Infinity)).toBe(false);
+            expect(Type.isNaN(-Infinity)).toBe(false);
+        });
+
+        test('должна возвращать false для строк', () => {
+            expect(Type.isNaN('42')).toBe(false);
+            expect(Type.isNaN('NaN')).toBe(false);
+            expect(Type.isNaN('')).toBe(false);
+        });
+
+        test('должна возвращать false для логических значений', () => {
+            expect(Type.isNaN(true)).toBe(false);
+            expect(Type.isNaN(false)).toBe(false);
+        });
+
+        test('должна возвращать false для null и undefined', () => {
+            expect(Type.isNaN(null)).toBe(false);
+            expect(Type.isNaN(undefined)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов и массивов', () => {
+            expect(Type.isNaN({})).toBe(false);
+            expect(Type.isNaN([])).toBe(false);
+            expect(Type.isNaN({ foo: 42 })).toBe(false);
+            expect(Type.isNaN([1, 2, 3])).toBe(false);
+        });
+
+        test('должна возвращать false для функций', () => {
+            expect(Type.isNaN(() => {})).toBe(false);
+            expect(Type.isNaN(() => {})).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isNull', () => {
+        test('должен возвращать true для значения null', () => {
+            expect(Type.isNull(null)).toBe(true);
+        });
+
+        test('должен возвращать false для значений не типа null', () => {
+            expect(Type.isNull(undefined)).toBe(false);
+            expect(Type.isNull(0)).toBe(false);
+            expect(Type.isNull('')).toBe(false);
+            expect(Type.isNull(false)).toBe(false);
+            expect(Type.isNull({})).toBe(false);
+            expect(Type.isNull([])).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isNumber', () => {
+        test('Возвращает true для числовых значений', () => {
+            expect(Type.isNumber(42)).toBe(true);
+            expect(Type.isNumber(3.14)).toBe(true);
+            expect(Type.isNumber(-0.99)).toBe(true);
+        });
+
+        test('Возвращает false для специальных числовых значений', () => {
+            expect(Type.isNumber(NaN)).toBe(false);
+            expect(Type.isNumber(Infinity)).toBe(false);
+            expect(Type.isNumber(-Infinity)).toBe(false);
+        });
+
+        test('Возвращает false для значений не типа number', () => {
+            expect(Type.isNumber('42')).toBe(false); // строка
+            expect(Type.isNumber(true)).toBe(false); // логическое значение
+            expect(Type.isNumber(null)).toBe(false); // null
+            expect(Type.isNumber(undefined)).toBe(false); // undefined
+            expect(Type.isNumber({})).toBe(false); // объект
+            expect(Type.isNumber([])).toBe(false); // массив
+        });
+    });
+
+    describe('Метод Type.isNumeric', () => {
+        test('Возвращает true для числовых значений', () => {
+            expect(Type.isNumeric(42)).toBe(true);
+            expect(Type.isNumeric(3.14)).toBe(true);
+            expect(Type.isNumeric(-0.99)).toBe(true);
+        });
+
+        test('Возвращает true для числовых строк', () => {
+            expect(Type.isNumeric('42')).toBe(true);
+            expect(Type.isNumeric('3.14')).toBe(true);
+            expect(Type.isNumeric('-0.99')).toBe(true);
+        });
+
+        test('Возвращает false для специальных числовых значений', () => {
+            expect(Type.isNumeric(NaN)).toBe(false);
+            expect(Type.isNumeric(Infinity)).toBe(false);
+            expect(Type.isNumeric(-Infinity)).toBe(false);
+        });
+
+        test('Возвращает false для значений не типа number или string', () => {
+            expect(Type.isNumeric(true)).toBe(false); // логическое значение
+            expect(Type.isNumeric(null)).toBe(false); // null
+            expect(Type.isNumeric(undefined)).toBe(false); // undefined
+            expect(Type.isNumeric({})).toBe(false); // объект
+            expect(Type.isNumeric([])).toBe(false); // массив
+        });
+    });
+
+    describe('Метод Type.isObject', () => {
+        test('должна возвращать true для объектов, созданных с использованием классов', () => {
+            class MyClass {}
+            const myClassInstance = new MyClass();
+            expect(Type.isObject(myClassInstance)).toBe(true);
+        });
+
+        test('должна возвращать false для классов', () => {
+            class MyClass {}
+            expect(Type.isObject(MyClass)).toBe(false);
+        });
+
+        test('должна возвращать false для ассоциативных массивов', () => {
+            const obj = {};
+            expect(Type.isObject(obj)).toBe(false);
+        });
+
+        test('должна возвращать false для массивов', () => {
+            const arr = [];
+            expect(Type.isObject(arr)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов, таких как Date', () => {
+            const date = new Date();
+            expect(Type.isObject(date)).toBe(false);
+        });
+
+        test('должна возвращать false для null', () => {
+            expect(Type.isObject(null)).toBe(false);
+        });
+
+        test('должна возвращать false для числа', () => {
+            expect(Type.isObject(42)).toBe(false);
+        });
+
+        test('должна возвращать false для строки', () => {
+            expect(Type.isObject('string')).toBe(false);
+        });
+
+        test('должна возвращать false для объектов, таких как Map', () => {
+            const map = new Map();
+            expect(Type.isObject(map)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов, созданных с Object.create(null)', () => {
+            const objNoProto = Object.create(null);
+            expect(Type.isObject(objNoProto)).toBe(false);
+        });
+    });
+
+    describe('Метод Type.isScalar', () => {
+        test('Возвращает true для скалярных значений', () => {
+            expect(Type.isScalar(true)).toBe(true);
+            expect(Type.isScalar(false)).toBe(true);
+            expect(Type.isScalar(42)).toBe(true);
+            expect(Type.isScalar(3.14)).toBe(true);
+            expect(Type.isScalar('hello')).toBe(true);
+            expect(Type.isScalar(Symbol('symbol'))).toBe(true);
+        });
+
+        test('Возвращает false для не скалярных значений', () => {
+            expect(Type.isScalar(null)).toBe(false);
+            expect(Type.isScalar(undefined)).toBe(false);
+            expect(Type.isScalar({})).toBe(false); // объект
+            expect(Type.isScalar([])).toBe(false); // массив
+            expect(Type.isScalar(() => {})).toBe(false); // функция
+        });
+    });
+
+    describe('Метод Type.isString', () => {
+        test('Возвращает true для строковых значений', () => {
+            expect(Type.isString('hello')).toBe(true);
+            expect(Type.isString('')).toBe(true);
+            expect(Type.isString(`template string`)).toBe(true);
+        });
+
+        test('Возвращает false для значений других типов', () => {
+            expect(Type.isString(42)).toBe(false); // число
+            expect(Type.isString(true)).toBe(false); // логическое значение
+            expect(Type.isString(null)).toBe(false);
+            expect(Type.isString(undefined)).toBe(false);
+            expect(Type.isString({})).toBe(false); // объект
+            expect(Type.isString([])).toBe(false); // массив
+            expect(Type.isString(() => {})).toBe(false); // функция
+        });
+    });
+
+    describe('Метод Type.isSymbol', () => {
+        test('Возвращает true для символов', () => {
+            expect(Type.isSymbol(Symbol('symbol'))).toBe(true);
+            expect(Type.isSymbol(Symbol.iterator)).toBe(true);
+        });
+
+        test('Возвращает false для значений других типов', () => {
+            expect(Type.isSymbol('hello')).toBe(false); // строка
+            expect(Type.isSymbol(42)).toBe(false); // число
+            expect(Type.isSymbol(true)).toBe(false); // логическое значение
+            expect(Type.isSymbol(null)).toBe(false);
+            expect(Type.isSymbol(undefined)).toBe(false);
+            expect(Type.isSymbol({})).toBe(false); // объект
+            expect(Type.isSymbol([])).toBe(false); // массив
+            expect(Type.isSymbol(() => {})).toBe(false); // функция
+        });
+    });
+
+    describe('Метод Type.isUndefined', () => {
+        test('Возвращает true для значения undefined', () => {
+            expect(Type.isUndefined(undefined)).toBe(true);
+        });
+
+        test('Возвращает false для значений других типов', () => {
+            expect(Type.isUndefined('hello')).toBe(false); // строка
+            expect(Type.isUndefined(42)).toBe(false); // число
+            expect(Type.isUndefined(true)).toBe(false); // логическое значение
+            expect(Type.isUndefined(null)).toBe(false);
+            expect(Type.isUndefined({})).toBe(false); // объект
+            expect(Type.isUndefined([])).toBe(false); // массив
+            expect(Type.isUndefined(() => {})).toBe(false); // функция
+        });
+    });
+});