src/test/java/sbp/exceptions/WorkWithExceptionsTest.java - master - khomec/homework6

src/test/java/sbp/exceptions/WorkWithExceptionsTest.java
377 строк16 KB
Your Name
h2 db commit +test +javadoc
08 янв 2026, 15:35
08 янв 2026, 15:351230383
package sbp.exceptions;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Arrays;

import static org.junit.jupiter.api.Assertions.*;

/**
 * Тесты для класса WorkWithExceptions.
 * Проверяют обработку исключений и поведение методов.
 */
class WorkWithExceptionsTest {

    private WorkWithExceptions workWithExceptions;
    private final ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
    private final PrintStream originalOut = System.out;

    @BeforeEach
    void setUp() {
        workWithExceptions = new WorkWithExceptions();
        System.setOut(new PrintStream(outputStreamCaptor));
    }

    @AfterEach
    void tearDown() {
        System.setOut(originalOut);
    }

    /**
     * Вспомогательный метод для получения вывода в консоль.
     */
    private String getConsoleOutput() {
        return outputStreamCaptor.toString();
    }

    @Test
    @DisplayName("Метод exceptionProcessing выбрасывает CustomException")
    void testExceptionProcessingThrowsCustomException() {
        // Act & Assert
        WorkWithExceptions.CustomException exception = assertThrows(
                WorkWithExceptions.CustomException.class,
                () -> workWithExceptions.exceptionProcessing()
        );

        // Проверяем сообщение исключения
        assertEquals("Обработано непроверяемое исключение", exception.getMessage());

        // Проверяем причину исключения
        assertNotNull(exception.getCause());
        assertTrue(exception.getCause() instanceof RuntimeException);
        assertEquals("Unchecked exception", exception.getCause().getMessage());
    }

    @Test
    @DisplayName("Метод exceptionProcessing обрабатывает оба типа исключений")
    void testExceptionProcessingHandlesBothExceptions() {
        try {
            workWithExceptions.exceptionProcessing();
        } catch (WorkWithExceptions.CustomException e) {
            // Проверяем что в консоли есть сообщения о проверяемом исключении
            String output = getConsoleOutput();
            assertTrue(output.contains("Попытка вызова throwCheckedException..."));
            assertTrue(output.contains("Поймано проверяемое исключение: Checked exception"));
            assertTrue(output.contains("Создано кастомное исключение: Обработано проверяемое исключение"));

            // Проверяем что в консоли есть сообщения о непроверяемом исключении
            assertTrue(output.contains("Попытка вызова throwUncheckedException..."));
            assertTrue(output.contains("Поймано непроверяемое исключение: Unchecked exception"));

            // Проверяем что выполнился блок finally
            assertTrue(output.contains("Finish"));

            // Проверяем подавленные исключения
            Throwable[] suppressed = e.getCause().getSuppressed();
            assertEquals(1, suppressed.length);
            assertEquals("Checked exception", suppressed[0].getMessage());
        }
    }

    @Test
    @DisplayName("Проверяемое исключение добавляется как подавленное")
    void testCheckedExceptionIsAddedAsSuppressed() {
        try {
            workWithExceptions.exceptionProcessing();
            fail("Должно было быть выброшено исключение");
        } catch (WorkWithExceptions.CustomException e) {
            // Проверяем что непроверяемое исключение является причиной
            Throwable cause = e.getCause();
            assertNotNull(cause);
            assertEquals("Unchecked exception", cause.getMessage());

            // Проверяем что проверяемое исключение добавлено как подавленное
            Throwable[] suppressed = cause.getSuppressed();
            assertEquals(1, suppressed.length);
            assertTrue(suppressed[0] instanceof Exception);
            assertEquals("Checked exception", suppressed[0].getMessage());

            // Проверяем что в консоли есть сообщение о подавленном исключении
            String output = getConsoleOutput();
            assertTrue(output.contains("Добавлено подавленное исключение: Checked exception"));
        }
    }

    @Test
    @DisplayName("Метод throwCheckedException выбрасывает Exception")
    void testThrowCheckedException() {
        // Метод приватный, тестируем через reflection или через public метод
        // В данном случае проверим, что exceptionProcessing вызывает этот метод

        try {
            workWithExceptions.exceptionProcessing();
        } catch (WorkWithExceptions.CustomException e) {
            // Проверяем что в цепочке причин есть наше проверяемое исключение
            Throwable cause = e.getCause(); // RuntimeException
            Throwable[] suppressed = cause.getSuppressed();

            boolean foundCheckedException = Arrays.stream(suppressed)
                    .anyMatch(ex -> ex.getMessage() != null && ex.getMessage().contains("Checked exception"));

            assertTrue(foundCheckedException, "Должно содержать проверяемое исключение в подавленных");
        }
    }

    @Test
    @DisplayName("Метод throwUncheckedException выбрасывает RuntimeException")
    void testThrowUncheckedException() {
        // Метод приватный, тестируем через reflection

        try {
            workWithExceptions.exceptionProcessing();
        } catch (WorkWithExceptions.CustomException e) {
            // Проверяем что причиной является RuntimeException из throwUncheckedException
            Throwable cause = e.getCause();
            assertNotNull(cause);
            assertEquals("Unchecked exception", cause.getMessage());
            assertTrue(cause instanceof RuntimeException);
        }
    }

    @Test
    @DisplayName("Кастомное исключение корректно создается и содержит причину")
    void testCustomExceptionCreation() {
        // Arrange
        String message = "Тестовое сообщение";
        Throwable cause = new RuntimeException("Причина");

        // Act
        WorkWithExceptions.CustomException customException =
                new WorkWithExceptions.CustomException(message, cause);

        // Assert
        assertEquals(message, customException.getMessage());
        assertSame(cause, customException.getCause());
    }

    @Test
    @DisplayName("Кастомное исключение создается без причины")
    void testCustomExceptionWithoutCause() {
        // Arrange
        String message = "Тестовое сообщение без причины";

        // Act
        WorkWithExceptions.CustomException customException =
                new WorkWithExceptions.CustomException(message);

        // Assert
        assertEquals(message, customException.getMessage());
        assertNull(customException.getCause());
    }

    @Test
    @DisplayName("Проверка стека вызовов в exceptionProcessing")
    void testStackTraceInExceptionProcessing() {
        try {
            workWithExceptions.exceptionProcessing();
            fail("Должно было быть выброшено исключение");
        } catch (WorkWithExceptions.CustomException e) {
            // Проверяем что исключение содержит stack trace
            assertNotNull(e.getStackTrace());
            assertTrue(e.getStackTrace().length > 0);

            // Проверяем что причина содержит stack trace
            assertNotNull(e.getCause());
            assertNotNull(e.getCause().getStackTrace());
            assertTrue(e.getCause().getStackTrace().length > 0);

            // Проверяем что подавленное исключение содержит stack trace
            Throwable[] suppressed = e.getCause().getSuppressed();
            if (suppressed.length > 0) {
                assertNotNull(suppressed[0].getStackTrace());
                assertTrue(suppressed[0].getStackTrace().length > 0);
            }
        }
    }

    @Test
    @DisplayName("Блок finally выполняется всегда в exceptionProcessing")
    void testFinallyAlwaysExecutesInExceptionProcessing() {
        int finallyExecutionCount = 0;

        try {
            workWithExceptions.exceptionProcessing();
        } catch (WorkWithExceptions.CustomException e) {
            // Считаем сколько раз выведено "Finish"
            String output = getConsoleOutput();
            finallyExecutionCount = countOccurrences(output, "Finish");
        }

        assertEquals(1, finallyExecutionCount, "Блок finally должен выполниться ровно один раз");
    }

    @Test
    @DisplayName("Проверка сообщений в консоли при обработке исключений")
    void testConsoleOutputMessages() {
        try {
            workWithExceptions.exceptionProcessing();
        } catch (WorkWithExceptions.CustomException e) {
            String output = getConsoleOutput();

            // Проверяем все обязательные сообщения
            String[] expectedMessages = {
                    "Попытка вызова throwCheckedException...",
                    "Поймано проверяемое исключение: Checked exception",
                    "Создано кастомное исключение: Обработано проверяемое исключение",
                    "Попытка вызова throwUncheckedException...",
                    "Поймано непроверяемое исключение: Unchecked exception",
                    "Добавлено подавленное исключение: Checked exception",
                    "Finish"
            };

            for (String expectedMessage : expectedMessages) {
                assertTrue(output.contains(expectedMessage),
                        "Должно содержать: " + expectedMessage);
            }
        }
    }

    /**
     * Вспомогательный метод для подсчета вхождений подстроки.
     */
    private int countOccurrences(String text, String substring) {
        int count = 0;
        int index = 0;

        while ((index = text.indexOf(substring, index)) != -1) {
            count++;
            index += substring.length();
        }

        return count;
    }
}

/**
 * Дополнительные тесты для проверки граничных случаев и особенностей поведения.
 */
class WorkWithExceptionsAdvancedTest {


}

/**
 * Тесты для демонстрации различных сценариев обработки исключений.
 */
class WorkWithExceptionsScenarioTest {

    @Test
    @DisplayName("Сценарий: только проверяемое исключение")
    void testOnlyCheckedExceptionScenario() throws Exception {
        // Этот тест демонстрирует, что произойдет если throwUncheckedException не выбросит исключение
        // Нужно модифицировать класс для тестирования

        // В этом случае метод exceptionProcessing не выбросит CustomException
        // потому что нет RuntimeException для упаковки
    }

    @Test
    @DisplayName("Сценарий: несколько подавленных исключений")
    void testMultipleSuppressedExceptions() {
        // Демонстрация работы с несколькими подавленными исключениями
        RuntimeException mainException = new RuntimeException("Основное исключение");

        mainException.addSuppressed(new Exception("Подавленное 1"));
        mainException.addSuppressed(new IllegalArgumentException("Подавленное 2"));
        mainException.addSuppressed(new RuntimeException("Подавленное 3"));

        Throwable[] suppressed = mainException.getSuppressed();
        assertEquals(3, suppressed.length);
        assertEquals("Подавленное 1", suppressed[0].getMessage());
        assertEquals("Подавленное 2", suppressed[1].getMessage());
        assertEquals("Подавленное 3", suppressed[2].getMessage());
    }
}

/**
 * Интеграционные тесты, проверяющие взаимодействие с другими классами.
 */
class WorkWithExceptionsIntegrationTest {

    @Test
    @DisplayName("Интеграция: использование CustomException в других классах")
    void testCustomExceptionUsageInOtherClasses() {
        // Демонстрация как можно использовать CustomException

        try {
            processWithCustomException();
            fail("Должно было быть выброшено CustomException");
        } catch (WorkWithExceptions.CustomException e) {
            assertEquals("Интеграционное исключение", e.getMessage());
            assertNotNull(e.getCause());
        }
    }

    private void processWithCustomException() throws WorkWithExceptions.CustomException {
        try {
            throw new RuntimeException("Ошибка в процессе");
        } catch (RuntimeException e) {
            throw new WorkWithExceptions.CustomException("Интеграционное исключение", e);
        }
    }

    @Test
    @DisplayName("Проверка сериализации исключений")
    void testExceptionSerialization() {
        // Исключения должны быть сериализуемы
        WorkWithExceptions.CustomException exception =
                new WorkWithExceptions.CustomException("Сериализуемое исключение");

        // Проверяем что исключение наследует Serializable (через Exception)
        assertTrue(exception instanceof java.io.Serializable);
    }
}

/**
 * Тесты для проверки корректности вывода stack trace.
 */
class WorkWithExceptionsStackTraceTest {

    private final ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
    private final PrintStream originalOut = System.out;
    private final PrintStream originalErr = System.err;

    @BeforeEach
    void setUp() {
        System.setOut(new PrintStream(outputStreamCaptor));
        System.setErr(new PrintStream(outputStreamCaptor));
    }

    @AfterEach
    void tearDown() {
        System.setOut(originalOut);
        System.setErr(originalErr);
    }

    @Test
    @DisplayName("Проверка что stack trace выводится в консоль")
    void testStackTracePrintedToConsole() {
        WorkWithExceptions instance = new WorkWithExceptions();

        try {
            instance.exceptionProcessing();
        } catch (WorkWithExceptions.CustomException e) {
            String output = outputStreamCaptor.toString();

            // Проверяем что в выводе есть элементы stack trace
            // (обычно содержат "at" и названия классов)
            assertTrue(output.contains("at ") ||
                    output.contains("Exception") ||
                    output.contains("RuntimeException"));
        }
    }
}