@rogolev/value 0.0.3 → 0.0.5

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

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

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

@@ -0,0 +1,23 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_key_to_lower_case } from '../../../index.mjs';
+
+describe('Функция array_key_to_lower_case', () => {
+    test('Должна преобразовывать ключи ассоциативного массива в нижний регистр', () => {
+        const assoc = { Key1: 'value1', Key2: 'value2' };
+        const result = array_key_to_lower_case(assoc);
+        expect(result).toEqual({ key1: 'value1', key2: 'value2' });
+    });
+
+    test('Должна возвращать список (обычный массив) без изменений', () => {
+        const list = [1, 2, 3];
+        const result = array_key_to_lower_case(list);
+        expect(result).toEqual(list);
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение не является массивом', () => {
+        expect(() => array_key_to_lower_case('not an array')).toThrow(TypeError);
+        expect(() => array_key_to_lower_case('not an array')).toThrow(
+            'Параметр "array" должен быть массивом.',
+        );
+    });
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,59 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_rand } from '../../../index.mjs';
+
+describe('Функция array_rand', () => {
+    test('Должна возвращать случайный ключ из обычного массива', () => {
+        const array = [1, 2, 3, 4, 5];
+        const result = array_rand(array);
+        expect(array).toContain(array[result]);
+    });
+
+    test('Должна возвращать случайный ключ из ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = array_rand(array);
+        expect(Object.keys(array)).toContain(result[0]);
+    });
+
+    test('Должна возвращать несколько случайных ключей из обычного массива', () => {
+        const array = [1, 2, 3, 4, 5];
+        const result = array_rand(array, 3);
+        expect(result.length).toBe(3);
+        result.forEach((key) => {
+            expect(array).toContain(array[key]);
+        });
+    });
+
+    test('Должна возвращать несколько случайных ключей из ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 3, d: 4, e: 5 };
+        const result = array_rand(array, 3);
+        expect(result.length).toBe(3);
+        result.forEach((key) => {
+            expect(Object.keys(array)).toContain(key[0]);
+        });
+    });
+
+    test('Должна возвращать null для пустого массива', () => {
+        const array = [];
+        const result = array_rand(array);
+        expect(result).toBeNull();
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => array_rand('not an array')).toThrow(TypeError);
+        expect(() => array_rand('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр count не является целым числом', () => {
+        expect(() => array_rand([1, 2, 3], 'not a number')).toThrow(TypeError);
+        expect(() => array_rand([1, 2, 3], 'not a number')).toThrow(
+            'Параметр "count" должен быть целым числом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр count выходит за пределы длины массива', () => {
+        expect(() => array_rand([1, 2, 3], 5)).toThrow(Error);
+        expect(() => array_rand([1, 2, 3], 5)).toThrow(
+            'Значение параметра "count" выходит за пределы длины массива.',
+        );
+    });
+});

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

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

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

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

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

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

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

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