@rogolev/value 0.0.3 → 0.0.5

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

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

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

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

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

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

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