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

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

        results.add(result2);

        ProjectBuildingException exception = new ProjectBuildingException(results);
        String message = exception.getMessage();

        assertTrue(
                message.contains("3 problems were encountered while processing the POMs (2 errors)"),
                "Message should contain problem count and error count");

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

     * @return true if TCP fallback is recommended
     */
    public boolean shouldFallbackToTcp(Exception error) {
        // Hardware errors suggest RDMA is not working
        if (error.getMessage() != null) {
            String message = error.getMessage().toLowerCase();
            if (message.contains("hardware") || message.contains("device not found") || message.contains("driver")

        } catch (final ExtractException e) {
            assertTrue("Error message should mention ZIP archive", e.getMessage().contains("ZIP archive"));
            assertTrue("Error message should indicate failure",
                    e.getMessage().contains("Failed to extract") || e.getMessage().contains("No entries could be processed"));
        }
    }

    /**

        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.

            // Verify error message is clear and helpful
            assertNotNull(exception.getMessage());
            assertTrue(exception.getMessage().contains("Expected structureSize = 4"));
        }

        @Test
        @DisplayName("Should handle zero structure size")
        void testZeroStructureSize() {
            // Given

        assertEquals(SmbException.getStatusByCode(-1), e.getNtStatus());
        assertEquals(SmbException.getMessageByCode(-1), e.getMessage());
    }

    @Test
    void zeroCodeProducesSuccess() {
        SmbAuthException e = new SmbAuthException(0);
        assertEquals("NT_STATUS_SUCCESS", e.getMessage());
        assertEquals(SmbException.getStatusByCode(0), e.getNtStatus());
    }