throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    public Settings read(Reader reader) throws IOException, XmlPullParserException {
        try {
            return new Settings(delegate.read(reader));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

                problems.add(Problem.Severity.WARNING, e.getMessage(), e.getLineNumber(), e.getColumnNumber(), e);
            }
        } catch (ToolchainsParseException e) {
            problems.add(
                    Problem.Severity.FATAL,
                    "Non-parseable toolchains " + toolchainsSource.getLocation() + ": " + e.getMessage(),
                    e.getLineNumber(),

        }
    }

    @Test
    public void test_writeThreadDump_withNullPath() {
        try {
            ThreadDumpUtil.writeThreadDump(null);
            // Should not throw exception but log warning
        } catch (Exception e) {
            fail("writeThreadDump should handle null path gracefully: " + e.getMessage());
        }
    }

    @Test

    @Test
    void testNoArgsConstructor() {
        // Test the constructor with no arguments
        RequestTimeoutException exception = new RequestTimeoutException();
        assertNull(exception.getMessage(), "Message should be null for no-arg constructor");
        assertNull(exception.getCause(), "Cause should be null for no-arg constructor");
    }

    @Test
    void testMessageConstructor() {

        // Arrange & Act
        SmbUnsupportedOperationException ex = new SmbUnsupportedOperationException();

        // Assert
        assertEquals("Operation is not supported with the negotiated capabilities", ex.getMessage(),
                "Default message should match the class contract");
        assertNull(ex.getCause(), "No cause expected from default constructor");
        assertTrue(ex instanceof SmbException, "Should be an SmbException");

    void testNoProblems() {
        ToolchainsBuildingException e = new ToolchainsBuildingException(Collections.emptyList());
        assertEquals("0 problems were encountered while building the effective toolchains" + LS, e.getMessage());
    }

    @Test
    void testOneProblem() {
        ProblemCollector problemCollector = ProblemCollectorFactory.newInstance(null);

        // Act + Assert: exception is propagated with message
        CIFSException ex = assertThrows(CIFSException.class, () -> handle.ensureDFSResolved());
        assertEquals("DFS resolution failed", ex.getMessage());
        verify(handle, times(1)).ensureDFSResolved();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MIN_VALUE, Integer.MAX_VALUE })

                        SettingsProblem.Severity.WARNING, e.getMessage(), e.getLineNumber(), e.getColumnNumber(), e);
            }
        } catch (SettingsParseException e) {
            problems.add(
                    SettingsProblem.Severity.FATAL,
                    "Non-parseable settings " + settingsSource.getLocation() + ": " + e.getMessage(),
                    e.getLineNumber(),

            logger.error("Failed to purge user info.", e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        // update job logs
        try {
            jobLogService.updateStatus();
        } catch (final Exception e) {
            logger.error("Failed to purge job logs.", e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        return resultBuf.toString();
    }

                        result.getMessage().getContent() != null ? result.getMessage().getContent().length() : 0);
            }

            writeJsonResponse(response, HttpServletResponse.SC_OK,
                    createSuccessResponse(result.getSessionId(), result.getMessage().getContent(), result.getMessage().getSources()));

        } catch (final Exception e) {