@rogolev/value 0.0.3 → 0.0.5

package/src/helpers/string/natcompare_numeric.mjs

@@ -0,0 +1,131 @@
+import is_string from '../is_string.mjs';
+import is_digit_char from './is_digit_char.mjs';
+
+/**
+ * Сравнивает две строки, содержащие числовые значения, в естественном порядке.
+ *
+ * ### Описание
+ *
+ * Функция `natcompare_numeric` используется для сравнения двух строк, содержащих числовые значения, в естественном порядке.
+ * Она поддерживает строки с ведущими нулями и игнорирует их при сравнении.
+ *
+ * ### Параметры
+ *
+ * - `a` (string): Первая строка для сравнения.
+ * - `b` (string): Вторая строка для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает отрицательное значение, если `a` меньше `b`, ноль, если `a` равно `b`, и положительное значение, если `a` больше `b`.
+ *
+ * ### Примеры использования
+ *
+ * 1. Сравнение строк с числовыми значениями:
+ *
+ *    ```js
+ *    const result = natcompare_numeric('10', '2');
+ *    console.log(result); // 1
+ *    ```
+ *
+ * 2. Сравнение строк с ведущими нулями:
+ *
+ *    ```js
+ *    const result = natcompare_numeric('0010', '10');
+ *    console.log(result); // 0
+ *    ```
+ *
+ * 3. Сравнение строк с пробелами:
+ *
+ *    ```js
+ *    const result = natcompare_numeric(' 10', '10');
+ *    console.log(result); // 0
+ *    ```
+ *
+ * 4. Сравнение строк с буквами и числами:
+ *
+ *    ```js
+ *    const result = natcompare_numeric('a10', 'a2');
+ *    console.log(result); // 1
+ *    ```
+ *
+ * 5. Сравнение строк с разными символами:
+ *
+ *    ```js
+ *    const result = natcompare_numeric('10-', '10+');
+ *    console.log(result); // 0
+ *    ```
+ *
+ * @param {string} a Первая строка для сравнения.
+ * @param {string} b Вторая строка для сравнения.
+ * @returns {number} Возвращает отрицательное значение, если `a` меньше `b`, ноль, если `a` равно `b`, и положительное значение, если `a` больше `b`.
+ * @throws {TypeError} Если параметры не являются строками.
+ */
+export default function natcompare_numeric(a, b) {
+    if (!is_string(a)) {
+        throw new TypeError('Параметр "a" должен быть строкой.');
+    }
+
+    if (!is_string(b)) {
+        throw new TypeError('Параметр "b" должен быть строкой.');
+    }
+
+    a = a.trim();
+    b = b.trim();
+
+    let result = 0;
+
+    let ia = 0;
+    let ib = 0;
+
+    // Пропускаем ведущие нули
+    while (ia < a.length && a[ia] === '0') {
+        ia++;
+    }
+    while (ib < b.length && b[ib] === '0') {
+        ib++;
+    }
+
+    // Сравниваем оставшиеся части строк
+    while (ia < a.length && ib < b.length) {
+        const ca = a[ia];
+        const cb = b[ib];
+
+        if (!is_digit_char(ca) && !is_digit_char(cb)) {
+            ia++;
+            ib++;
+            continue;
+        }
+
+        if (!is_digit_char(ca)) {
+            ia++;
+            continue;
+        }
+
+        if (!is_digit_char(cb)) {
+            ib++;
+            continue;
+        }
+
+        if (ca < cb) {
+            if (result === 0) {
+                result = -1;
+            }
+        } else if (ca > cb) {
+            if (result === 0) {
+                result = 1;
+            }
+        }
+
+        ia++;
+        ib++;
+    }
+
+    // Если одна строка длиннее другой, она считается больше
+    if (ia < a.length) {
+        return 1;
+    } else if (ib < b.length) {
+        return -1;
+    }
+
+    return result;
+}

package/tests/classes/Expect/toBe.test.mjs

@@ -0,0 +1,60 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBe класса Expect', () => {
+    test('Должен возвращать true, если значения строго равны (числа)', () => {
+        const expectInstance = new Expect(5);
+        expect(expectInstance.toBe(5)).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения строго равны (строки)', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toBe('hello')).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не равны (числа)', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toBe(10)).toThrow(TypeError);
+        expect(() => expectInstance.toBe(10)).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значения не равны', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toBe(10, 'Значения не равны')).toThrow(TypeError);
+        expect(() => expectInstance.toBe(10, 'Значения не равны')).toThrow('Значения не равны');
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toBe(5, 123)).toThrow(TypeError);
+        expect(() => expectInstance.toBe(5, 123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен возвращать true, если значения строго равны (объекты)', () => {
+        const obj = { a: 1, b: 2 };
+        const expectInstance = new Expect(obj);
+        expect(expectInstance.toBe(obj)).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не равны (объекты)', () => {
+        const obj1 = { a: 1, b: 2 };
+        const obj2 = { a: 1, b: 3 };
+        const expectInstance = new Expect(obj1);
+        expect(() => expectInstance.toBe(obj2)).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значения строго равны (массивы)', () => {
+        const arr = [1, 2, 3];
+        const expectInstance = new Expect(arr);
+        expect(expectInstance.toBe(arr)).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не равны (массивы)', () => {
+        const arr1 = [1, 2, 3];
+        const arr2 = [1, 2, 4];
+        const expectInstance = new Expect(arr1);
+        expect(() => expectInstance.toBe(arr2)).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeArray.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeArray класса Expect', () => {
+    test('Должен возвращать true, если значение является массивом', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(expectInstance.toBeArray()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является массивом', () => {
+        const expectInstance = new Expect('not an array');
+        expect(() => expectInstance.toBeArray()).toThrow(TypeError);
+        expect(() => expectInstance.toBeArray()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является массивом', () => {
+        const expectInstance = new Expect('not an array');
+        expect(() => expectInstance.toBeArray('Значение должно быть массивом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeArray('Значение должно быть массивом')).toThrow(
+            'Значение должно быть массивом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeArray(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeArray(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен возвращать true, если значение является пустым массивом', () => {
+        const expectInstance = new Expect([]);
+        expect(expectInstance.toBeArray()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является массивом объектов', () => {
+        const expectInstance = new Expect([{ a: 1 }, { b: 2 }]);
+        expect(expectInstance.toBeArray()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является ассоциативным массивом', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(expectInstance.toBeArray()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeAssoc.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeAssoc класса Expect', () => {
+    test('Должен возвращать true, если значение является ассоциативным массивом', () => {
+        const expectInstance = new Expect({ a: 1, b: 2, c: 3 });
+        expect(expectInstance.toBeAssoc()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является ассоциативным массивом', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeAssoc()).toThrow(TypeError);
+        expect(() => expectInstance.toBeAssoc()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является ассоциативным массивом', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() =>
+            expectInstance.toBeAssoc('Значение должно быть ассоциативным массивом'),
+        ).toThrow(TypeError);
+        expect(() =>
+            expectInstance.toBeAssoc('Значение должно быть ассоциативным массивом'),
+        ).toThrow('Значение должно быть ассоциативным массивом');
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect({ a: 1, b: 2, c: 3 });
+        expect(() => expectInstance.toBeAssoc(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeAssoc(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен возвращать true, если значение является пустым объектом', () => {
+        const expectInstance = new Expect({});
+        expect(expectInstance.toBeAssoc()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является объектом с вложенными объектами', () => {
+        const expectInstance = new Expect({ a: { b: 2 }, c: 3 });
+        expect(expectInstance.toBeAssoc()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не ассоциативным массивом', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeAssoc()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeBigInt.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeBigInt класса Expect', () => {
+    test('Должен возвращать true, если значение является BigInt', () => {
+        const expectInstance = new Expect(123n);
+        expect(expectInstance.toBeBigInt()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является BigInt', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeBigInt()).toThrow(TypeError);
+        expect(() => expectInstance.toBeBigInt()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является BigInt', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeBigInt('Значение должно быть BigInt')).toThrow(TypeError);
+        expect(() => expectInstance.toBeBigInt('Значение должно быть BigInt')).toThrow(
+            'Значение должно быть BigInt',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(123n);
+        expect(() => expectInstance.toBeBigInt(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeBigInt(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен возвращать true, если значение является отрицательным BigInt', () => {
+        const expectInstance = new Expect(-123n);
+        expect(expectInstance.toBeBigInt()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не BigInt', () => {
+        const expectInstance = new Expect('123');
+        expect(() => expectInstance.toBeBigInt()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом с плавающей запятой, а не BigInt', () => {
+        const expectInstance = new Expect(123.45);
+        expect(() => expectInstance.toBeBigInt()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeBool.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeBool класса Expect', () => {
+    test('Должен возвращать true, если значение является логическим типом (true)', () => {
+        const expectInstance = new Expect(true);
+        expect(expectInstance.toBeBool()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является логическим типом (false)', () => {
+        const expectInstance = new Expect(false);
+        expect(expectInstance.toBeBool()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является логическим типом', () => {
+        const expectInstance = new Expect(1);
+        expect(() => expectInstance.toBeBool()).toThrow(TypeError);
+        expect(() => expectInstance.toBeBool()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является логическим типом', () => {
+        const expectInstance = new Expect(1);
+        expect(() => expectInstance.toBeBool('Значение должно быть логическим типом')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeBool('Значение должно быть логическим типом')).toThrow(
+            'Значение должно быть логическим типом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(true);
+        expect(() => expectInstance.toBeBool(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeBool(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не логическим типом', () => {
+        const expectInstance = new Expect('true');
+        expect(() => expectInstance.toBeBool()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом, а не логическим типом', () => {
+        const expectInstance = new Expect(0);
+        expect(() => expectInstance.toBeBool()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeBoolean.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeBoolean класса Expect', () => {
+    test('Должен возвращать true, если значение является логическим типом (true)', () => {
+        const expectInstance = new Expect(true);
+        expect(expectInstance.toBeBoolean()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является логическим типом (false)', () => {
+        const expectInstance = new Expect(false);
+        expect(expectInstance.toBeBoolean()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является логическим типом', () => {
+        const expectInstance = new Expect(1);
+        expect(() => expectInstance.toBeBoolean()).toThrow(TypeError);
+        expect(() => expectInstance.toBeBoolean()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является логическим типом', () => {
+        const expectInstance = new Expect(1);
+        expect(() => expectInstance.toBeBoolean('Значение должно быть логическим типом')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeBoolean('Значение должно быть логическим типом')).toThrow(
+            'Значение должно быть логическим типом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(true);
+        expect(() => expectInstance.toBeBoolean(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeBoolean(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не логическим типом', () => {
+        const expectInstance = new Expect('true');
+        expect(() => expectInstance.toBeBoolean()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом, а не логическим типом', () => {
+        const expectInstance = new Expect(0);
+        expect(() => expectInstance.toBeBoolean()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeChar.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeChar класса Expect', () => {
+    test('Должен возвращать true, если значение является символом (один символ)', () => {
+        const expectInstance = new Expect('a');
+        expect(expectInstance.toBeChar()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является символом (строка из нескольких символов)', () => {
+        const expectInstance = new Expect('abc');
+        expect(() => expectInstance.toBeChar()).toThrow(TypeError);
+        expect(() => expectInstance.toBeChar()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является символом', () => {
+        const expectInstance = new Expect('abc');
+        expect(() => expectInstance.toBeChar('Значение должно быть символом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeChar('Значение должно быть символом')).toThrow(
+            'Значение должно быть символом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect('a');
+        expect(() => expectInstance.toBeChar(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeChar(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом, а не символом', () => {
+        const expectInstance = new Expect(1);
+        expect(() => expectInstance.toBeChar()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является пустой строкой', () => {
+        const expectInstance = new Expect('');
+        expect(() => expectInstance.toBeChar()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является символом (специальный символ)', () => {
+        const expectInstance = new Expect('@');
+        expect(expectInstance.toBeChar()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeClass.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeClass класса Expect', () => {
+    test('Должен возвращать true, если значение является классом', () => {
+        class MyClass {}
+        const expectInstance = new Expect(MyClass);
+        expect(expectInstance.toBeClass()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является классом (функция)', () => {
+        const expectInstance = new Expect(() => {});
+        expect(() => expectInstance.toBeClass()).toThrow(TypeError);
+        expect(() => expectInstance.toBeClass()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является классом', () => {
+        const expectInstance = new Expect(() => {});
+        expect(() => expectInstance.toBeClass('Значение должно быть классом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeClass('Значение должно быть классом')).toThrow(
+            'Значение должно быть классом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        class MyClass {}
+        const expectInstance = new Expect(MyClass);
+        expect(() => expectInstance.toBeClass(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeClass(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не классом', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeClass()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не классом', () => {
+        const expectInstance = new Expect('MyClass');
+        expect(() => expectInstance.toBeClass()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом, а не классом', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeClass()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeFloat.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeFloat класса Expect', () => {
+    test('Должен возвращать true, если значение является числом с плавающей запятой', () => {
+        const expectInstance = new Expect(3.14);
+        expect(expectInstance.toBeFloat()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является числом с плавающей запятой', () => {
+        const expectInstance = new Expect(3);
+        expect(() => expectInstance.toBeFloat()).toThrow(TypeError);
+        expect(() => expectInstance.toBeFloat()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является числом с плавающей запятой', () => {
+        const expectInstance = new Expect(3);
+        expect(() =>
+            expectInstance.toBeFloat('Значение должно быть числом с плавающей запятой'),
+        ).toThrow(TypeError);
+        expect(() =>
+            expectInstance.toBeFloat('Значение должно быть числом с плавающей запятой'),
+        ).toThrow('Значение должно быть числом с плавающей запятой');
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(3.14);
+        expect(() => expectInstance.toBeFloat(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeFloat(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не числом с плавающей запятой', () => {
+        const expectInstance = new Expect('3.14');
+        expect(() => expectInstance.toBeFloat()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является целым числом, а не числом с плавающей запятой', () => {
+        const expectInstance = new Expect(3);
+        expect(() => expectInstance.toBeFloat()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является отрицательным числом с плавающей запятой', () => {
+        const expectInstance = new Expect(-3.14);
+        expect(expectInstance.toBeFloat()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeFunction.test.mjs

@@ -0,0 +1,51 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeFunction класса Expect', () => {
+    test('Должен возвращать true, если значение является функцией', () => {
+        function myFunction() {}
+        const expectInstance = new Expect(myFunction);
+        expect(expectInstance.toBeFunction()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является функцией (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeFunction()).toThrow(TypeError);
+        expect(() => expectInstance.toBeFunction()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является функцией', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeFunction('Значение должно быть функцией')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeFunction('Значение должно быть функцией')).toThrow(
+            'Значение должно быть функцией',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        function myFunction() {}
+        const expectInstance = new Expect(myFunction);
+        expect(() => expectInstance.toBeFunction(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeFunction(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не функцией', () => {
+        const expectInstance = new Expect('function');
+        expect(() => expectInstance.toBeFunction()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не функцией', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeFunction()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является функцией (стрелочная функция)', () => {
+        const myFunction = () => {};
+        const expectInstance = new Expect(myFunction);
+        expect(expectInstance.toBeFunction()).toBe(true);
+    });
+});