} catch (SecDispatcherException | IOException e) {
                    problems.add(new DefaultSettingsProblem(
                            "Failed to decrypt password for server " + server.getId() + ": " + e.getMessage(),
                            Severity.ERROR,
                            "server: " + server.getId(),
                            -1,
                            -1,
                            e));
                }

        byte[] empty = new byte[0];

        // Act + Assert
        PACDecodingException ex = assertThrows(PACDecodingException.class, () -> new KerberosApRequest(empty, new KerberosKey[0]));
        assertTrue(ex.getMessage().contains("Empty kerberos ApReq"));
    }

    @Test
    @DisplayName("byte[] ctor: malformed DER is wrapped as PACDecodingException (IOException path)")
    void byteArrayConstructor_malformedDER_throwsWrapped() {

        doThrow(new CIFSException("session key failure")).when(session).getSessionKey();

        CIFSException ex = assertThrows(CIFSException.class, () -> session.getSessionKey());
        assertTrue(ex.getMessage().contains("failure"));
        verify(session).getSessionKey();
    }

    // Happy path: transport is returned and verified
    @Test
    @DisplayName("getTransport returns mocked transport")

            assertEquals("Invalid time format: 12. Expected format: HH:MM", e.getMessage());
        }

        try {
            IntervalControlHelper.parseTime("12:30:45");
            fail("Should throw FessSystemException");
        } catch (FessSystemException e) {
            assertEquals("Invalid time format: 12:30:45. Expected format: HH:MM", e.getMessage());
        }

        try {

    @Override
    public Exception getException() {
        return exception;
    }

    @Override
    public String getMessage() {
        String msg;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else {
            msg = exception.getMessage();

            if (msg == null) {
                msg = "";
            }
        }

        return msg;

            fail("Should not throw exception: " + e.getMessage());
        }
    }

    @Test
    public void test_sendMail_withEmptyInfoMap() {
        Map<String, String> infoMap = new HashMap<>();

        try {
            crawler.sendMail(infoMap);
        } catch (Exception e) {
            fail("Should not throw exception with empty map: " + e.getMessage());
        }
    }

            assertEquals("Malformed kerberos ticket", exception.getMessage(), "PAC exception should indicate malformed ticket.");
        } else if (exception instanceof NullPointerException) {
            // Empty input causes null ASN1 object, which is expected behavior
            assertTrue(exception.getMessage() == null || exception.getMessage().contains("Cannot invoke \"Object.getClass()\""),

        CurlResponse response = new CurlResponse();

        try {
            response.getContentAsString();
            fail("Expected CurlException");
        } catch (CurlException e) {
            assertTrue(e.getMessage().contains("Failed to access the content"));
        }
    }

    @Test
    public void testGetContentAsStringWithContentException() {
        CurlResponse response = new CurlResponse();

        final ConverterRuntimeException e = new ConverterRuntimeException("hoge", "xxx", new RuntimeException("cause"));
        System.out.println(e.getMessage());
        assertThat(e.getPropertyName(), is("hoge"));
        assertThat(e.getValue(), is((Object) "xxx"));
        assertThat(e.getCause().getMessage(), is("cause"));
    }

            return CompletableFuture.failedFuture(new IOException("No durable handle available for reconnection: " + path));
        }

        log.debug("Starting reconnection for handle: {} (cause: {})", path, cause.getMessage());
        return attemptReconnect(info, 0, cause);
    }

    /**
     * Attempt to reconnect a specific handle
     * @param handleInfo the handle information