@rogolev/value 0.0.3 → 0.0.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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