@rogolev/value 0.0.3 → 0.0.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] } });
+    });
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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