@rogolev/value 0.0.4 → 0.0.5

package/tests/helpers/expect_object.test.mjs

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

package/tests/helpers/expect_scalar.test.mjs

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

package/tests/helpers/expect_string.test.mjs

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

package/tests/helpers/expect_symbol.test.mjs

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

package/tests/helpers/expect_undefined.test.mjs

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

package/tests/helpers/is_equal.test.mjs

@@ -0,0 +1,110 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_equal } from '../../index.mjs';
+
+describe('Функция is_equal', () => {
+    test('Должна возвращать true для одинаковых чисел', () => {
+        expect(is_equal(1, 1)).toBe(true);
+    });
+
+    test('Должна возвращать false для разных чисел', () => {
+        expect(is_equal(1, 2)).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых строк', () => {
+        expect(is_equal('hello', 'hello')).toBe(true);
+    });
+
+    test('Должна возвращать false для разных строк', () => {
+        expect(is_equal('hello', 'world')).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых объектов', () => {
+        const obj1 = { a: 1, b: 2 };
+        const obj2 = { a: 1, b: 2 };
+        expect(is_equal(obj1, obj2)).toBe(true);
+    });
+
+    test('Должна возвращать false для объектов с разными значениями', () => {
+        const obj1 = { a: 1, b: 2 };
+        const obj2 = { a: 1, b: 3 };
+        expect(is_equal(obj1, obj2)).toBe(false);
+    });
+
+    test('Должна возвращать false для объектов с разными ключами', () => {
+        const obj1 = { a: 1, b: 2 };
+        const obj2 = { a: 1, c: 2 };
+        expect(is_equal(obj1, obj2)).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых массивов', () => {
+        const arr1 = [1, 2, 3];
+        const arr2 = [1, 2, 3];
+        expect(is_equal(arr1, arr2)).toBe(true);
+    });
+
+    test('Должна возвращать false для массивов с разными значениями', () => {
+        const arr1 = [1, 2, 3];
+        const arr2 = [1, 2, 4];
+        expect(is_equal(arr1, arr2)).toBe(false);
+    });
+
+    test('Должна возвращать true для вложенных объектов с одинаковыми значениями', () => {
+        const obj1 = { a: { b: 2 } };
+        const obj2 = { a: { b: 2 } };
+        expect(is_equal(obj1, obj2)).toBe(true);
+    });
+
+    test('Должна возвращать false для вложенных объектов с разными значениями', () => {
+        const obj1 = { a: { b: 2 } };
+        const obj2 = { a: { b: 3 } };
+        expect(is_equal(obj1, obj2)).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых символов', () => {
+        const sym1 = Symbol('test');
+        const sym2 = sym1;
+        expect(is_equal(sym1, sym2)).toBe(true);
+    });
+
+    test('Должна возвращать false для разных символов', () => {
+        const sym1 = Symbol('test');
+        const sym2 = Symbol('test');
+        expect(is_equal(sym1, sym2)).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых значений null', () => {
+        expect(is_equal(null, null)).toBe(true);
+    });
+
+    test('Должна возвращать true для null и undefined', () => {
+        expect(is_equal(null, undefined)).toBe(true);
+    });
+
+    test('Должна возвращать true для одинаковых значений undefined', () => {
+        expect(is_equal(undefined, undefined)).toBe(true);
+    });
+
+    test('Должна возвращать false для одинаковых значений NaN', () => {
+        expect(is_equal(NaN, NaN)).toBe(false);
+    });
+
+    test('Должна возвращать false для NaN и числа', () => {
+        expect(is_equal(NaN, 1)).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых чисел в строгом режиме', () => {
+        expect(is_equal(1, 1, true)).toBe(true);
+    });
+
+    test('Должна возвращать false для чисел и строк в строгом режиме', () => {
+        expect(is_equal(1, '1', true)).toBe(false);
+    });
+
+    test('Должна возвращать true для одинаковых строк в строгом режиме', () => {
+        expect(is_equal('hello', 'hello', true)).toBe(true);
+    });
+
+    test('Должна возвращать false для строк и чисел в строгом режиме', () => {
+        expect(is_equal('1', 1, true)).toBe(false);
+    });
+});