@rogolev/value 0.0.4 → 0.0.5

package/src/helpers/expect_scalar.mjs

@@ -0,0 +1,66 @@
+import is_scalar from './is_scalar.mjs';
+import is_string from './is_string.mjs';
+
+/**
+ * Проверяет, является ли значение скалярным, и выбрасывает ошибку с указанным сообщением, если это не так.
+ *
+ * ### Описание
+ *
+ * Функция `expect_scalar` используется для проверки, является ли переданное значение скалярным.
+ * Если значение не является скалярным, функция выбрасывает ошибку типа `TypeError` с указанным сообщением.
+ *
+ * ### Параметры
+ *
+ * - `value` (any): Значение для проверки.
+ * - `message` (string): Сообщение об ошибке, если значение не является скалярным. По умолчанию пустая строка.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает `true`, если значение является скалярным.
+ *
+ * ### Примеры использования
+ *
+ * 1. Проверка значения, являющегося скалярным:
+ *
+ *    ```js
+ *    const value = 123;
+ *    const result = expect_scalar(value);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 2. Проверка значения, не являющегося скалярным:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_scalar([1, 2, 3], 'Значение должно быть скалярным.');
+ *    } catch (e) {
+ *        console.error(e.message); // Значение должно быть скалярным.
+ *    }
+ *    ```
+ *
+ * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_scalar({}, 'Ожидалось скалярное значение.');
+ *    } catch (e) {
+ *        console.error(e.message); // Ожидалось скалярное значение.
+ *    }
+ *    ```
+ *
+ * @param {any} value Значение для проверки.
+ * @param {string} [message=''] Сообщение об ошибке, если значение не является скалярным.
+ * @returns {boolean} Возвращает `true`, если значение является скалярным.
+ * @throws {TypeError} Если значение не является скалярным или если параметр `message` не является строкой.
+ */
+export default function expect_scalar(value, message = '') {
+    if (!is_string(message)) {
+        throw new TypeError('Параметр "message" должен быть строкой.');
+    }
+
+    if (!is_scalar(value)) {
+        throw new TypeError(message);
+    }
+
+    return true;
+}

package/src/helpers/expect_string.mjs

@@ -0,0 +1,65 @@
+import is_string from './is_string.mjs';
+
+/**
+ * Проверяет, является ли значение строкой, и выбрасывает ошибку с указанным сообщением, если это не так.
+ *
+ * ### Описание
+ *
+ * Функция `expect_string` используется для проверки, является ли переданное значение строкой.
+ * Если значение не является строкой, функция выбрасывает ошибку типа `TypeError` с указанным сообщением.
+ *
+ * ### Параметры
+ *
+ * - `value` (any): Значение для проверки.
+ * - `message` (string): Сообщение об ошибке, если значение не является строкой. По умолчанию пустая строка.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает `true`, если значение является строкой.
+ *
+ * ### Примеры использования
+ *
+ * 1. Проверка значения, являющегося строкой:
+ *
+ *    ```js
+ *    const value = 'Hello, world!';
+ *    const result = expect_string(value);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 2. Проверка значения, не являющегося строкой:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_string(123, 'Значение должно быть строкой.');
+ *    } catch (e) {
+ *        console.error(e.message); // Значение должно быть строкой.
+ *    }
+ *    ```
+ *
+ * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_string({}, 'Ожидалась строка.');
+ *    } catch (e) {
+ *        console.error(e.message); // Ожидалась строка.
+ *    }
+ *    ```
+ *
+ * @param {any} value Значение для проверки.
+ * @param {string} [message=''] Сообщение об ошибке, если значение не является строкой.
+ * @returns {boolean} Возвращает `true`, если значение является строкой.
+ * @throws {TypeError} Если значение не является строкой или если параметр `message` не является строкой.
+ */
+export default function expect_string(value, message = '') {
+    if (!is_string(message)) {
+        throw new TypeError('Параметр "message" должен быть строкой.');
+    }
+
+    if (!is_string(value)) {
+        throw new TypeError(message);
+    }
+
+    return true;
+}

package/src/helpers/expect_symbol.mjs

@@ -0,0 +1,66 @@
+import is_string from './is_string.mjs';
+import is_symbol from './is_symbol.mjs';
+
+/**
+ * Проверяет, является ли значение символом, и выбрасывает ошибку с указанным сообщением, если это не так.
+ *
+ * ### Описание
+ *
+ * Функция `expect_symbol` используется для проверки, является ли переданное значение символом.
+ * Если значение не является символом, функция выбрасывает ошибку типа `TypeError` с указанным сообщением.
+ *
+ * ### Параметры
+ *
+ * - `value` (any): Значение для проверки.
+ * - `message` (string): Сообщение об ошибке, если значение не является символом. По умолчанию пустая строка.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает `true`, если значение является символом.
+ *
+ * ### Примеры использования
+ *
+ * 1. Проверка значения, являющегося символом:
+ *
+ *    ```js
+ *    const value = Symbol('example');
+ *    const result = expect_symbol(value);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 2. Проверка значения, не являющегося символом:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_symbol('not a symbol', 'Значение должно быть символом.');
+ *    } catch (e) {
+ *        console.error(e.message); // Значение должно быть символом.
+ *    }
+ *    ```
+ *
+ * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_symbol(123, 'Ожидался символ.');
+ *    } catch (e) {
+ *        console.error(e.message); // Ожидался символ.
+ *    }
+ *    ```
+ *
+ * @param {any} value Значение для проверки.
+ * @param {string} [message=''] Сообщение об ошибке, если значение не является символом.
+ * @returns {boolean} Возвращает `true`, если значение является символом.
+ * @throws {TypeError} Если значение не является символом или если параметр `message` не является строкой.
+ */
+export default function expect_symbol(value, message = '') {
+    if (!is_string(message)) {
+        throw new TypeError('Параметр "message" должен быть строкой.');
+    }
+
+    if (!is_symbol(value)) {
+        throw new TypeError(message);
+    }
+
+    return true;
+}

package/src/helpers/expect_undefined.mjs

@@ -0,0 +1,66 @@
+import is_string from './is_string.mjs';
+import is_undefined from './is_undefined.mjs';
+
+/**
+ * Проверяет, является ли значение undefined, и выбрасывает ошибку с указанным сообщением, если это не так.
+ *
+ * ### Описание
+ *
+ * Функция `expect_undefined` используется для проверки, является ли переданное значение undefined.
+ * Если значение не является undefined, функция выбрасывает ошибку типа `TypeError` с указанным сообщением.
+ *
+ * ### Параметры
+ *
+ * - `value` (any): Значение для проверки.
+ * - `message` (string): Сообщение об ошибке, если значение не является undefined. По умолчанию пустая строка.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает `true`, если значение является undefined.
+ *
+ * ### Примеры использования
+ *
+ * 1. Проверка значения, являющегося undefined:
+ *
+ *    ```js
+ *    let value;
+ *    const result = expect_undefined(value);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 2. Проверка значения, не являющегося undefined:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_undefined(123, 'Значение должно быть undefined.');
+ *    } catch (e) {
+ *        console.error(e.message); // Значение должно быть undefined.
+ *    }
+ *    ```
+ *
+ * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+ *
+ *    ```js
+ *    try {
+ *        const result = expect_undefined('not undefined', 'Ожидалось значение undefined.');
+ *    } catch (e) {
+ *        console.error(e.message); // Ожидалось значение undefined.
+ *    }
+ *    ```
+ *
+ * @param {any} value Значение для проверки.
+ * @param {string} [message=''] Сообщение об ошибке, если значение не является undefined.
+ * @returns {boolean} Возвращает `true`, если значение является undefined.
+ * @throws {TypeError} Если значение не является undefined или если параметр `message` не является строкой.
+ */
+export default function expect_undefined(value, message = '') {
+    if (!is_string(message)) {
+        throw new TypeError('Параметр "message" должен быть строкой.');
+    }
+
+    if (!is_undefined(value)) {
+        throw new TypeError(message);
+    }
+
+    return true;
+}

package/src/helpers/is_equal.mjs

@@ -0,0 +1,94 @@
+/**
+ * Проверяет, являются ли два значения равными.
+ *
+ * ### Описание
+ *
+ * Функция `is_equal` используется для проверки равенства двух значений. Она поддерживает сравнение
+ * примитивных типов данных, а также объектов и массивов. Для объектов и массивов функция рекурсивно
+ * сравнивает их ключи и значения. Функция также поддерживает строгий режим сравнения, который учитывает типы значений.
+ *
+ * ### Параметры
+ *
+ * - `actual` (any): Первое значение для сравнения.
+ * - `expected` (any): Второе значение для сравнения.
+ * - `strict` (boolean): Флаг строгого сравнения. По умолчанию `false`.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает `true`, если значения равны, иначе `false`.
+ *
+ * ### Примеры использования
+ *
+ * 1. Проверка равенства чисел:
+ *
+ *    ```js
+ *    const result = is_equal(1, 1);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 2. Проверка равенства строк:
+ *
+ *    ```js
+ *    const result = is_equal('hello', 'hello');
+ *    console.log(result); // true
+ *    ```
+ *
+ * 3. Проверка равенства объектов:
+ *
+ *    ```js
+ *    const obj1 = { a: 1, b: 2 };
+ *    const obj2 = { a: 1, b: 2 };
+ *    const result = is_equal(obj1, obj2);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 4. Проверка равенства массивов:
+ *
+ *    ```js
+ *    const arr1 = [1, 2, 3];
+ *    const arr2 = [1, 2, 3];
+ *    const result = is_equal(arr1, arr2);
+ *    console.log(result); // true
+ *    ```
+ *
+ * 5. Проверка равенства с использованием строгого сравнения:
+ *
+ *    ```js
+ *    const result = is_equal(1, '1', true);
+ *    console.log(result); // false
+ *    ```
+ *
+ * @param {any} actual Первое значение для сравнения.
+ * @param {any} expected Второе значение для сравнения.
+ * @param {boolean} [strict=false] Флаг строгого сравнения.
+ * @returns {boolean} Возвращает `true`, если значения равны, иначе `false`.
+ */
+export default function is_equal(actual, expected, strict = false) {
+    if (
+        typeof actual === 'object' &&
+        typeof expected === 'object' &&
+        actual !== null &&
+        expected !== null
+    ) {
+        const entriesA = Object.entries(actual);
+        const entriesB = Object.entries(expected);
+
+        if (entriesA.length !== entriesB.length) {
+            return false;
+        }
+
+        for (let i = 0; i < entriesA.length; i++) {
+            if (entriesA[i][0] !== entriesB[i][0] || !is_equal(entriesA[i][1], entriesB[i][1])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    if (strict) {
+        return Object.is(actual, expected);
+    }
+
+    return actual == expected;
+}

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