// When
        CIFSException exception = new CIFSException(message);

        // Then
        assertNotNull(exception);
        assertEquals(message, exception.getMessage());
        assertTrue(exception instanceof IOException);
    }

    @Test
    @DisplayName("Should create CIFSException with message and cause")
    void testCIFSExceptionWithCause() {
        // Given

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

        }
    }

    @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

            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(),

        assertEquals(3, events.size());
        assertEquals("error 1", events.get(0).getMessage());
        assertEquals("error 2", events.get(1).getMessage());
        assertEquals("error 3", events.get(2).getMessage());
    }

    @Test
    public void test_append_warnAppender_errorEvent() {

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

        // 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(),

        try {
            return new Metadata(delegate.read(reader, strict));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    /**
     * Method read.
     *
     * @param reader a reader object.
     * @return Metadata
     * @throws IOException            IOException if any.