@rogolev/value 0.0.3 → 0.0.5

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

@@ -0,0 +1,49 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_chunk } from '../../../index.mjs';
+
+describe('Функция array_chunk', () => {
+    test('Должна разбивать массив на части указанной длины', () => {
+        const array = [1, 2, 3, 4, 5];
+        const result = array_chunk(array, 2);
+        expect(result).toEqual([[1, 2], [3, 4], [5]]);
+    });
+
+    test('Должна возвращать пустой массив, если передан пустой массив', () => {
+        const array = [];
+        const result = array_chunk(array, 2);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна разбивать ассоциативный массив на части указанной длины', () => {
+        const assoc = {
+            key1: 'value1',
+            key2: 'value2',
+            key3: 'value3',
+            key4: 'value4',
+            key5: 'value5',
+        };
+        const result = array_chunk(assoc, 2);
+        expect(result).toEqual([['value1', 'value2'], ['value3', 'value4'], ['value5']]);
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение не является массивом', () => {
+        expect(() => array_chunk('not an array', 2)).toThrow(TypeError);
+        expect(() => array_chunk('not an array', 2)).toThrow(
+            'Параметр "value" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если длина не является целым числом', () => {
+        const array = [1, 2, 3];
+        expect(() => array_chunk(array, 'not an integer')).toThrow(TypeError);
+        expect(() => array_chunk(array, 'not an integer')).toThrow(
+            'Параметр "length" должен быть целым числом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если длина меньше 1', () => {
+        const array = [1, 2, 3];
+        expect(() => array_chunk(array, 0)).toThrow(Error);
+        expect(() => array_chunk(array, 0)).toThrow('Параметр "length" должен быть больше нуля.');
+    });
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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