@rogolev/value 0.0.3 → 0.0.5

package/tests/helpers/array/array_uintersect_uassoc.test.mjs

@@ -0,0 +1,122 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_uintersect_uassoc } from '../../../index.mjs';
+
+describe('Функция array_uintersect_uassoc', () => {
+    const value_compare_func = (a, b) => a === b;
+    const key_compare_func = (a, b) => a === b;
+
+    test('Должна возвращать элементы из первого массива, которые присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { b: 2, c: 3 };
+        const result = array_uintersect_uassoc(
+            value_compare_func,
+            key_compare_func,
+            original_array,
+            array1,
+            array2,
+        );
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { c: 3, d: 4 };
+        const result = array_uintersect_uassoc(
+            value_compare_func,
+            key_compare_func,
+            original_array,
+            array1,
+        );
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_uintersect_uassoc(
+            value_compare_func,
+            key_compare_func,
+            original_array,
+            array1,
+        );
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для value_compare_func не является функцией', () => {
+        expect(() => array_uintersect_uassoc('not a function', key_compare_func, {})).toThrow(
+            TypeError,
+        );
+        expect(() => array_uintersect_uassoc('not a function', key_compare_func, {})).toThrow(
+            'Параметр "value_compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для key_compare_func не является функцией', () => {
+        expect(() => array_uintersect_uassoc(value_compare_func, 'not a function', {})).toThrow(
+            TypeError,
+        );
+        expect(() => array_uintersect_uassoc(value_compare_func, 'not a function', {})).toThrow(
+            'Параметр "key_compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() =>
+            array_uintersect_uassoc(value_compare_func, key_compare_func, 'not an array'),
+        ).toThrow(TypeError);
+        expect(() =>
+            array_uintersect_uassoc(value_compare_func, key_compare_func, 'not an array'),
+        ).toThrow('Параметр "original_array" должен быть массивом.');
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() =>
+            array_uintersect_uassoc(value_compare_func, key_compare_func, {}, 'not an array'),
+        ).toThrow(TypeError);
+        expect(() =>
+            array_uintersect_uassoc(value_compare_func, key_compare_func, {}, 'not an array'),
+        ).toThrow('Параметр "arrays" должен быть массивом.');
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_uintersect_uassoc(
+            value_compare_func,
+            key_compare_func,
+            original_array,
+            array1,
+        );
+        expect(result).toEqual({ a: 1 });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_uintersect_uassoc(
+            value_compare_func,
+            key_compare_func,
+            original_array,
+            array1,
+            array2,
+        );
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_uintersect_uassoc(
+            (a, b) => JSON.stringify(a) === JSON.stringify(b),
+            key_compare_func,
+            original_array,
+            array1,
+        );
+        expect(result).toEqual({ a: { id: 1, data: [1, 2] } });
+    });
+});

package/tests/helpers/array/array_unique.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_unique } from '../../../index.mjs';
+
+describe('Функция array_unique', () => {
+    test('Должна удалять дублирующиеся значения из обычного массива', () => {
+        const array = [1, 2, 2, 3, 4, 4, 5];
+        const result = array_unique(array);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна удалять дублирующиеся значения из ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 2, d: 3, e: 4, f: 4, g: 5 };
+        const result = array_unique(array);
+        expect(result).toEqual({ a: 1, b: 2, d: 3, e: 4, g: 5 });
+    });
+
+    test('Должна возвращать пустой массив, если исходный массив пустой', () => {
+        const array = [];
+        const result = array_unique(array);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => array_unique('not an array')).toThrow(TypeError);
+        expect(() => array_unique('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+});

package/tests/helpers/array/array_unshift.test.mjs

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

package/tests/helpers/array/array_values.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_values } from '../../../index.mjs';
+
+describe('Функция array_values', () => {
+    test('Должна возвращать значения из обычного массива', () => {
+        const array = [1, 2, 3];
+        const result = array_values(array);
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('Должна возвращать значения из ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = array_values(array);
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('Должна возвращать пустой массив, если исходный массив пустой', () => {
+        const array = [];
+        const result = array_values(array);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => array_values('not an array')).toThrow(TypeError);
+        expect(() => array_values('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+});

package/tests/helpers/array/array_walk.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { array_walk } from '../../../index.mjs';
+
+describe('Функция array_walk', () => {
+    test('Должна применять функцию к каждому элементу обычного массива', () => {
+        const array = [1, 2, 3];
+        const callback = jest.fn();
+        array_walk(array, callback);
+        expect(callback).toHaveBeenCalledTimes(3);
+        expect(callback).toHaveBeenCalledWith(1, '0', null);
+        expect(callback).toHaveBeenCalledWith(2, '1', null);
+        expect(callback).toHaveBeenCalledWith(3, '2', null);
+    });
+
+    test('Должна применять функцию к каждому элементу ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const callback = jest.fn();
+        array_walk(array, callback);
+        expect(callback).toHaveBeenCalledTimes(3);
+        expect(callback).toHaveBeenCalledWith(1, 'a', null);
+        expect(callback).toHaveBeenCalledWith(2, 'b', null);
+        expect(callback).toHaveBeenCalledWith(3, 'c', null);
+    });
+
+    test('Должна передавать дополнительный аргумент в функцию обратного вызова', () => {
+        const array = [1, 2, 3];
+        const callback = jest.fn();
+        array_walk(array, callback, 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledTimes(3);
+        expect(callback).toHaveBeenCalledWith(1, '0', 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledWith(2, '1', 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledWith(3, '2', 'дополнительный аргумент');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => array_walk('not an array', () => {})).toThrow(TypeError);
+        expect(() => array_walk('not an array', () => {})).toThrow(
+            'Параметр "arr" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр callback не является функцией', () => {
+        expect(() => array_walk([], 'not a function')).toThrow(TypeError);
+        expect(() => array_walk([], 'not a function')).toThrow(
+            'Параметр "callback" должен быть функцией.',
+        );
+    });
+});

package/tests/helpers/array/array_walk_recursive.test.mjs

@@ -0,0 +1,53 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { array_walk_recursive } from '../../../index.mjs';
+
+describe('Функция array_walk_recursive', () => {
+    test('Должна применять функцию к каждому элементу обычного массива рекурсивно', () => {
+        const array = [1, 2, [3, 4], 5];
+        const callback = jest.fn();
+        array_walk_recursive(array, callback);
+        expect(callback).toHaveBeenCalledTimes(5);
+        expect(callback).toHaveBeenCalledWith(1, '0', null);
+        expect(callback).toHaveBeenCalledWith(2, '1', null);
+        expect(callback).toHaveBeenCalledWith(3, '0', null);
+        expect(callback).toHaveBeenCalledWith(4, '1', null);
+        expect(callback).toHaveBeenCalledWith(5, '3', null);
+    });
+
+    test('Должна применять функцию к каждому элементу ассоциативного массива рекурсивно', () => {
+        const array = { a: 1, b: { c: 2, d: 3 }, e: 4 };
+        const callback = jest.fn();
+        array_walk_recursive(array, callback);
+        expect(callback).toHaveBeenCalledTimes(4);
+        expect(callback).toHaveBeenCalledWith(1, 'a', null);
+        expect(callback).toHaveBeenCalledWith(2, 'c', null);
+        expect(callback).toHaveBeenCalledWith(3, 'd', null);
+        expect(callback).toHaveBeenCalledWith(4, 'e', null);
+    });
+
+    test('Должна передавать дополнительный аргумент в функцию обратного вызова', () => {
+        const array = [1, 2, [3, 4], 5];
+        const callback = jest.fn();
+        array_walk_recursive(array, callback, 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledTimes(5);
+        expect(callback).toHaveBeenCalledWith(1, '0', 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledWith(2, '1', 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledWith(3, '0', 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledWith(4, '1', 'дополнительный аргумент');
+        expect(callback).toHaveBeenCalledWith(5, '3', 'дополнительный аргумент');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => array_walk_recursive('not an array', () => {})).toThrow(TypeError);
+        expect(() => array_walk_recursive('not an array', () => {})).toThrow(
+            'Параметр "arr" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр callback не является функцией', () => {
+        expect(() => array_walk_recursive([], 'not a function')).toThrow(TypeError);
+        expect(() => array_walk_recursive([], 'not a function')).toThrow(
+            'Параметр "callback" должен быть функцией.',
+        );
+    });
+});

package/tests/helpers/array/count.test.mjs

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

package/tests/helpers/array/in_array.test.mjs

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

package/tests/helpers/array/natsort.test.mjs

@@ -0,0 +1,71 @@
+import { expect, test, describe } from '@jest/globals';
+import { natsort } from '../../../index.mjs';
+
+describe('Функция natsort', () => {
+    test('Должна корректно сортировать обычный массив', () => {
+        const array = [10, 2, 30, 4];
+        const result = natsort(array);
+        expect(result).toEqual([2, 4, 10, 30]);
+    });
+
+    test('Должна корректно сортировать ассоциативный массив', () => {
+        const array = { a: 10, b: 2, c: 30, d: 4 };
+        const result = natsort(array);
+        expect(result).toEqual([
+            ['b', 2],
+            ['d', 4],
+            ['a', 10],
+            ['c', 30],
+        ]);
+    });
+
+    test('Должна корректно сортировать массив с использованием функции getter', () => {
+        const array = [{ value: 10 }, { value: 2 }, { value: 30 }, { value: 4 }];
+        const result = natsort(array, (entry) => entry[1].value);
+        expect(result).toEqual([{ value: 2 }, { value: 4 }, { value: 10 }, { value: 30 }]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр getter не является функцией', () => {
+        const array = [10, 2, 30, 4];
+        expect(() => natsort(array, 'not a function')).toThrow(TypeError);
+        expect(() => natsort(array, 'not a function')).toThrow(
+            'Параметр "getter" должен быть функцией.',
+        );
+    });
+
+    test('Должна корректно сортировать массив строк', () => {
+        const array = ['apple', 'banana', 'cherry', 'date'];
+        const result = natsort(array);
+        expect(result).toEqual(['apple', 'banana', 'cherry', 'date']);
+    });
+
+    test('Должна корректно сортировать массив строк с числовыми значениями', () => {
+        const array = ['10', '2', '30', '4'];
+        const result = natsort(array);
+        expect(result).toEqual(['2', '4', '10', '30']);
+    });
+
+    test('Должна корректно сортировать массив строк с ведущими нулями', () => {
+        const array = ['0010', '010', '10', '001'];
+        const result = natsort(array);
+        expect(result).toEqual(['001', '0010', '010', '10']);
+    });
+
+    test('Должна корректно сортировать массив строк с пробелами', () => {
+        const array = [' 10', '10', ' 2', '2'];
+        const result = natsort(array);
+        expect(result).toEqual([' 2', '2', ' 10', '10']);
+    });
+
+    test('Должна корректно сортировать массив строк с буквами и числами', () => {
+        const array = ['a10', 'a2', 'b10', 'b2'];
+        const result = natsort(array);
+        expect(result).toEqual(['a2', 'a10', 'b2', 'b10']);
+    });
+
+    test('Должна корректно сортировать массив строк с разными символами', () => {
+        const array = ['10-', '10+', '10*', '10/'];
+        const result = natsort(array);
+        expect(result).toEqual(['10*', '10+', '10-', '10/']);
+    });
+});

package/tests/helpers/array/range.test.mjs

@@ -0,0 +1,51 @@
+import { expect, test, describe } from '@jest/globals';
+import { range } from '../../../index.mjs';
+
+describe('Функция range', () => {
+    test('Должна генерировать числовой диапазон', () => {
+        const result = range(1, 5);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна генерировать числовой диапазон с отрицательным шагом', () => {
+        const result = range(5, 1, -1);
+        expect(result).toEqual([5, 4, 3, 2, 1]);
+    });
+
+    test('Должна генерировать диапазон строк', () => {
+        const result = range('a', 'e');
+        expect(result).toEqual(['a', 'b', 'c', 'd', 'e']);
+    });
+
+    test('Должна обрабатывать значения с преобразованием типов', () => {
+        const result = range('1', 5);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "start" имеет неверный тип', () => {
+        expect(() => range({}, 5)).toThrow(TypeError);
+        expect(() => range({}, 5)).toThrow('Параметр "start" должен быть строкой или числом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "end" имеет неверный тип', () => {
+        expect(() => range(1, {})).toThrow(TypeError);
+        expect(() => range(1, {})).toThrow('Параметр "end" должен быть строкой или числом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "step" имеет неверный тип', () => {
+        expect(() => range(1, 5, 'a')).toThrow(TypeError);
+        expect(() => range(1, 5, 'a')).toThrow('Параметр "step" должен быть числом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "step" равен нулю', () => {
+        expect(() => range(1, 5, 0)).toThrow(TypeError);
+        expect(() => range(1, 5, 0)).toThrow('Параметр "step" не может быть равен нулю.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "step" отрицательный при start < end', () => {
+        expect(() => range(1, 5, -1)).toThrow(TypeError);
+        expect(() => range(1, 5, -1)).toThrow(
+            'Параметр "step" должен быть больше нуля при start <= end.',
+        );
+    });
+});

package/tests/helpers/array/shuffle.test.mjs

@@ -0,0 +1,42 @@
+import { expect, test, describe } from '@jest/globals';
+import { shuffle } from '../../../index.mjs';
+
+describe('Функция shuffle', () => {
+    test('Должна перемешивать элементы обычного массива', () => {
+        const array = [1, 2, 3, 4, 5];
+        const result = shuffle(array);
+        expect(result).toHaveLength(array.length);
+        expect(result).toEqual(expect.arrayContaining(array));
+        expect(result).not.toEqual(array); // Маловероятно, что массив останется в том же порядке
+    });
+
+    test('Должна перемешивать элементы ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = shuffle(array);
+        expect(result).toHaveLength(Object.keys(array).length);
+        expect(result).toEqual(
+            expect.arrayContaining([
+                ['a', 1],
+                ['b', 2],
+                ['c', 3],
+            ]),
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => shuffle('not an array')).toThrow(TypeError);
+        expect(() => shuffle('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+
+    test('Должна возвращать пустой массив, если исходный массив пуст', () => {
+        const array = [];
+        const result = shuffle(array);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна корректно перемешивать массив с одним элементом', () => {
+        const array = [1];
+        const result = shuffle(array);
+        expect(result).toEqual([1]);
+    });
+});

package/tests/helpers/array/sort.test.mjs

@@ -0,0 +1,60 @@
+import { expect, test, describe } from '@jest/globals';
+import { sort } from '../../../index.mjs';
+
+describe('Функция sort', () => {
+    test('Должна сортировать элементы обычного массива по умолчанию', () => {
+        const array = [5, 3, 1, 4, 2];
+        const result = sort(array);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна сортировать элементы ассоциативного массива по умолчанию', () => {
+        const array = { a: 3, b: 1, c: 2 };
+        const result = sort(array);
+        expect(result).toEqual([
+            ['b', 1],
+            ['c', 2],
+            ['a', 3],
+        ]);
+    });
+
+    test('Должна сортировать элементы обычного массива с использованием пользовательской функции сравнения', () => {
+        const array = [5, 3, 1, 4, 2];
+        const result = sort(array, (a, b) => b[1] - a[1]);
+        expect(result).toEqual([5, 4, 3, 2, 1]);
+    });
+
+    test('Должна сортировать элементы ассоциативного массива с использованием пользовательской функции сравнения', () => {
+        const array = { a: 3, b: 1, c: 2 };
+        const result = sort(array, (a, b) => b[1] - a[1]);
+        expect(result).toEqual([
+            ['a', 3],
+            ['c', 2],
+            ['b', 1],
+        ]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => sort('not an array')).toThrow(TypeError);
+        expect(() => sort('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр compare_func не является функцией', () => {
+        expect(() => sort([1, 2, 3], 'not a function')).toThrow(TypeError);
+        expect(() => sort([1, 2, 3], 'not a function')).toThrow(
+            'Параметр "compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна корректно сортировать пустой массив', () => {
+        const array = [];
+        const result = sort(array);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна корректно сортировать массив с одним элементом', () => {
+        const array = [1];
+        const result = sort(array);
+        expect(result).toEqual([1]);
+    });
+});