return target.getClass().getSimpleName() + "[" + target.getMessage() + "]";
        }
        final StringBuilder sb = new StringBuilder();
        while (target != null) {
            sb.append(target.getClass().getSimpleName());
            if (target.getMessage() != null) {
                sb.append("[");
                sb.append(target.getMessage());
                sb.append("]");
            }

                buf.append(line);
            }
        } catch (final Exception e) {
            throwValidationError(messages -> messages.addErrorsFailedToReadRequestFile(GLOBAL, e.getMessage()),
                    () -> asListHtml(this::saveToken));
        }

        final CurlRequest curlRequest = getCurlRequest(header);
        if (curlRequest == null) {
            final String msg = header;

        PACDecodingException e =
                assertThrows(PACDecodingException.class, () -> PacMac.calculateMac(PacSignature.KERB_CHECKSUM_HMAC_MD5, keys, TEST_DATA));
        assertEquals("Missing key", e.getMessage());
    }

    /**
     * Test calculateMac with an invalid algorithm type.
     */
    @Test
    void testCalculateMacInvalidAlgorithm() {
        Map<Integer, KerberosKey> keys = new HashMap<>();

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            new LsaPolicyHandle(mockDcerpcHandle, server, access);
        });

        assertEquals("Network error", thrown.getMessage());
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
    }

    @Test
    void close_shouldClosePolicySuccessfully() throws IOException {
        // Arrange

     *
     * @param cause
     *            the cause
     */
    public UnsupportedEncodingRuntimeException(final UnsupportedEncodingException cause) {
        super("ECL0105", new Object[] { cause.getMessage() }, cause);
    }

            byte[] actualBuffer = (byte[]) outputBufferField.get(response);
            assertSame(outputBuffer, actualBuffer);
        } catch (Exception e) {
            fail("Failed to access outputBuffer field: " + e.getMessage());
        }
    }

    @Test
    void testWriteSetupWireFormat() {
        // Test that writeSetupWireFormat returns 0
        byte[] dst = new byte[100];

        String malformedUrl = "invalid-url";
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            cifsContextWrapper.get(malformedUrl);
        });
        assertTrue(thrown.getMessage().contains("Invalid URL"));
        assertTrue(thrown.getCause() instanceof MalformedURLException);
    }

    @Test
    void testGetPipe() throws CIFSException, MalformedURLException {

    void testConstructorWithMessage() {
        String testMessage = "This is a test message for NdrException.";
        NdrException exception = new NdrException(testMessage);
        assertEquals(testMessage, exception.getMessage(), "The exception message should match the input message.");
    }

    /**
     * Test the NO_NULL_REF static field.
     * Ensures that the static field holds the expected string value.
     */
    @Test

            } catch (final ChildUrlsException e) {
                connected = true;
                break;
            } catch (final Exception e) {
                logger.info("[{}] {}", i + 1, e.getMessage());
            }
            ThreadUtil.sleep(200L);
        }
        if (!connected) {
            throw new IllegalStateException("Could not connect to the Samba server");
        }
    }

    @Test
    public void testSIndexOutOfBoundsExceptionString() {
        final ClIndexOutOfBoundsException clIndexOutOfBoundsException = new ClIndexOutOfBoundsException("hoge");
        assertThat(clIndexOutOfBoundsException.getMessage(), is("hoge"));
    }