@rogolev/value 0.0.3 → 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_char.test.mjs

@@ -0,0 +1,40 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_char } from '../../index.mjs';
+
+describe('Функция is_char', () => {
+    test('Должна возвращать true для одиночного символа', () => {
+        expect(is_char('a')).toBe(true);
+    });
+
+    test('Должна возвращать false для строки из нескольких символов', () => {
+        expect(is_char('abc')).toBe(false);
+    });
+
+    test('Должна возвращать false для пустой строки', () => {
+        expect(is_char('')).toBe(false);
+    });
+
+    test('Должна возвращать false для значения, не являющегося строкой', () => {
+        expect(is_char(1)).toBe(false);
+        expect(is_char(null)).toBe(false);
+        expect(is_char(undefined)).toBe(false);
+        expect(is_char({})).toBe(false);
+        expect(is_char([])).toBe(false);
+    });
+
+    test('Должна возвращать true для пробельного символа', () => {
+        expect(is_char(' ')).toBe(true);
+    });
+
+    test('Должна возвращать false для строки с пробелами', () => {
+        expect(is_char(' a ')).toBe(false);
+    });
+
+    test('Должна возвращать false для строки с числовыми значениями', () => {
+        expect(is_char('123')).toBe(false);
+    });
+
+    test('Должна возвращать true для одиночного числового символа', () => {
+        expect(is_char('1')).toBe(true);
+    });
+});

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

package/tests/helpers/string/is_digit_char.test.mjs

@@ -0,0 +1,32 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_digit_char } from '../../../index.mjs';
+
+describe('Функция is_digit_char', () => {
+    test('Должна возвращать true для цифрового символа', () => {
+        expect(is_digit_char('0')).toBe(true);
+        expect(is_digit_char('5')).toBe(true);
+        expect(is_digit_char('9')).toBe(true);
+    });
+
+    test('Должна возвращать false для непробельного символа', () => {
+        expect(is_digit_char('a')).toBe(false);
+        expect(is_digit_char(' ')).toBe(false);
+        expect(is_digit_char('!')).toBe(false);
+    });
+
+    test('Должна возвращать false для строки из нескольких символов', () => {
+        expect(is_digit_char('123')).toBe(false);
+    });
+
+    test('Должна возвращать false для пустой строки', () => {
+        expect(is_digit_char('')).toBe(false);
+    });
+
+    test('Должна возвращать false для значения, не являющегося строкой', () => {
+        expect(is_digit_char(1)).toBe(false);
+        expect(is_digit_char(null)).toBe(false);
+        expect(is_digit_char(undefined)).toBe(false);
+        expect(is_digit_char({})).toBe(false);
+        expect(is_digit_char([])).toBe(false);
+    });
+});

package/tests/helpers/string/is_whitespace_char.test.mjs

@@ -0,0 +1,32 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_whitespace_char } from '../../../index.mjs';
+
+describe('Функция is_whitespace_char', () => {
+    test('Должна возвращать true для пробельного символа', () => {
+        expect(is_whitespace_char(' ')).toBe(true);
+        expect(is_whitespace_char('\t')).toBe(true);
+        expect(is_whitespace_char('\n')).toBe(true);
+    });
+
+    test('Должна возвращать false для непробельного символа', () => {
+        expect(is_whitespace_char('a')).toBe(false);
+        expect(is_whitespace_char('1')).toBe(false);
+        expect(is_whitespace_char('!')).toBe(false);
+    });
+
+    test('Должна возвращать false для строки из нескольких символов', () => {
+        expect(is_whitespace_char('abc')).toBe(false);
+    });
+
+    test('Должна возвращать false для пустой строки', () => {
+        expect(is_whitespace_char('')).toBe(false);
+    });
+
+    test('Должна возвращать false для значения, не являющегося строкой', () => {
+        expect(is_whitespace_char(1)).toBe(false);
+        expect(is_whitespace_char(null)).toBe(false);
+        expect(is_whitespace_char(undefined)).toBe(false);
+        expect(is_whitespace_char({})).toBe(false);
+        expect(is_whitespace_char([])).toBe(false);
+    });
+});

package/tests/helpers/string/natcompare.test.mjs

@@ -0,0 +1,100 @@
+import { expect, test, describe } from '@jest/globals';
+import { natcompare } from '../../../index.mjs';
+
+describe('Функция natcompare', () => {
+    test('Должна корректно сравнивать строки с числовыми значениями', () => {
+        expect(natcompare('10', '2')).toBeGreaterThan(0);
+        expect(natcompare('2', '10')).toBeLessThan(0);
+        expect(natcompare('10', '10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с ведущими нулями', () => {
+        expect(natcompare('0010', '10')).toBe(0);
+        expect(natcompare('010', '10')).toBe(0);
+        expect(natcompare('10', '0010')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с пробелами', () => {
+        expect(natcompare(' 10', '10')).toBe(0);
+        expect(natcompare('10', ' 10')).toBe(0);
+        expect(natcompare(' 10', ' 10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с буквами и числами', () => {
+        expect(natcompare('a10', 'a2')).toBeGreaterThan(0);
+        expect(natcompare('a2', 'a10')).toBeLessThan(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с разными символами', () => {
+        expect(natcompare('10-', '10+')).toBeGreaterThan(0);
+        expect(natcompare('10+', '10-')).toBeLessThan(0);
+        expect(natcompare('10-', '10-')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными буквами', () => {
+        expect(natcompare('10a', '10b')).toBeLessThan(0);
+        expect(natcompare('10b', '10a')).toBeGreaterThan(0);
+        expect(natcompare('10a', '10a')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными регистрами', () => {
+        expect(natcompare('10A', '10a')).toBeLessThan(0);
+        expect(natcompare('10a', '10A')).toBeGreaterThan(0);
+        expect(natcompare('10A', '10A')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными пробелами', () => {
+        expect(natcompare('10 ', '10')).toBe(0);
+        expect(natcompare('10', '10 ')).toBe(0);
+        expect(natcompare('10 ', '10 ')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми буквами и разными числовыми значениями', () => {
+        expect(natcompare('a10', 'a2')).toBeGreaterThan(0);
+        expect(natcompare('a2', 'a10')).toBeLessThan(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми буквами и одинаковыми числовыми значениями', () => {
+        expect(natcompare('a10', 'a10')).toBe(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с разными длинами', () => {
+        expect(natcompare('a', 'aa')).toBeLessThan(0);
+        expect(natcompare('aa', 'a')).toBeGreaterThan(0);
+        expect(natcompare('a', 'a')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми длинами и разными символами', () => {
+        expect(natcompare('a1', 'a2')).toBeLessThan(0);
+        expect(natcompare('a2', 'a1')).toBeGreaterThan(0);
+        expect(natcompare('a1', 'a1')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми длинами и одинаковыми символами', () => {
+        expect(natcompare('a1', 'a1')).toBe(0);
+        expect(natcompare('a1', 'a1')).toBe(0);
+        expect(natcompare('a1', 'a1')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях', () => {
+        expect(natcompare('a1b2', 'a1b10')).toBeLessThan(0);
+        expect(natcompare('a1b10', 'a1b2')).toBeGreaterThan(0);
+        expect(natcompare('a1b2', 'a1b2')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях и разными регистрами', () => {
+        expect(natcompare('a1B2', 'a1b10')).toBeLessThan(0);
+        expect(natcompare('a1b10', 'a1B2')).toBeGreaterThan(0);
+        expect(natcompare('a1B2', 'a1B2')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях и разными символами', () => {
+        expect(natcompare('a1-b2', 'a1+b10')).toBeLessThan(0);
+        expect(natcompare('a1+b10', 'a1-b2')).toBeGreaterThan(0);
+        expect(natcompare('a1-b2', 'a1-b2')).toBe(0);
+    });
+});