@rogolev/value 0.0.3 → 0.0.4

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

@@ -0,0 +1,76 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_intersect_uassoc } from '../../../index.mjs';
+
+describe('Функция array_intersect_uassoc', () => {
+    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_intersect_uassoc(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_intersect_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_intersect_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для key_compare_func не является функцией', () => {
+        expect(() => array_intersect_uassoc('not a function', {})).toThrow(TypeError);
+        expect(() => array_intersect_uassoc('not a function', {})).toThrow(
+            'Параметр "key_compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_intersect_uassoc(key_compare_func, 'not an array')).toThrow(TypeError);
+        expect(() => array_intersect_uassoc(key_compare_func, 'not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_intersect_uassoc(key_compare_func, {}, 'not an array')).toThrow(
+            TypeError,
+        );
+        expect(() => array_intersect_uassoc(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_intersect_uassoc(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_intersect_uassoc(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_intersect_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({ a: { id: 1, data: [1, 2] } });
+    });
+});

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

@@ -0,0 +1,74 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_intersect_ukey } from '../../../index.mjs';
+
+describe('Функция array_intersect_ukey', () => {
+    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_intersect_ukey(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_intersect_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_intersect_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для key_compare_func не является функцией', () => {
+        expect(() => array_intersect_ukey('not a function', {})).toThrow(TypeError);
+        expect(() => array_intersect_ukey('not a function', {})).toThrow(
+            'Параметр "key_compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_intersect_ukey(key_compare_func, 'not an array')).toThrow(TypeError);
+        expect(() => array_intersect_ukey(key_compare_func, 'not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_intersect_ukey(key_compare_func, {}, 'not an array')).toThrow(TypeError);
+        expect(() => array_intersect_ukey(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_intersect_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({ a: 1, b: '2' });
+    });
+
+    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_intersect_ukey(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_intersect_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({ a: { id: 1, data: [1, 2] } });
+    });
+});

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

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

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

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

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" должен быть массивом.',
+        );
+    });
+});