TestByteSink failSink = new TestByteSink(WRITE_THROWS);
    assertThrows(IOException.class, () -> new TestByteSource(new byte[10]).copyTo(failSink));
    assertTrue(failSink.wasStreamClosed());
  }

  public void testClosesOnErrors_writingFromInputStreamThatThrows() throws IOException {
    TestByteSink okSink = new TestByteSink();
    TestInputStream in = new TestInputStream(new ByteArrayInputStream(new byte[10]), READ_THROWS);

    TestByteSink failSink = new TestByteSink(WRITE_THROWS);
    assertThrows(IOException.class, () -> new TestByteSource(new byte[10]).copyTo(failSink));
    assertTrue(failSink.wasStreamClosed());
  }

  public void testClosesOnErrors_writingFromInputStreamThatThrows() throws IOException {
    TestByteSink okSink = new TestByteSink();
    TestInputStream in = new TestInputStream(new ByteArrayInputStream(new byte[10]), READ_THROWS);

          }
        };
    static final PermittedMetaException UOE =
        new PermittedMetaException("UnsupportedOperationException") {
          @Override
          boolean isPermitted(Exception exception) {
            return exception instanceof UnsupportedOperationException;
          }
        };
    static final PermittedMetaException ISE =
        new PermittedMetaException("IllegalStateException") {
          @Override

        TestComponent component = new TestComponent();
        PooledObject<TestComponent> pooledObject = new DefaultPooledObject<>(component);

        AtomicBoolean listenerCalled = new AtomicBoolean(false);
        final PooledObject<TestComponent>[] capturedObject = new PooledObject[1];

        factory.setOnDestroyListener(new OnDestroyListener<TestComponent>() {
            @Override

            int threadCount = 10;
            Thread[] threads = new Thread[threadCount];
            byte[][] dataArrays = new byte[threadCount][128];

            for (int i = 0; i < threadCount; i++) {
                final int index = i;
                dataArrays[i] = new byte[128];
                Arrays.fill(dataArrays[i], (byte) i);

                threads[i] = new Thread(() -> {

        itemList.add(new SynonymItem(2, new String[] { "b1", "b2" }, new String[] { "B1" }));
        itemList.add(new SynonymItem(3, new String[] { "c1" }, new String[] { "C1", "C2" }));
        itemList.add(new SynonymItem(4, new String[] { "x1", "X1" }, new String[] { "x1", "X1" }));

            StringBuilder sb = new StringBuilder("\\\\server");
            for (int i = 0; i < 1000; i++) {
                sb.append("\\segment");
            }
            String path = sb.toString();

            buffer = new DfsReferralRequestBuffer(path, 3);

            byte[] dst = new byte[buffer.size()];
            int bytesEncoded = buffer.encode(dst, 0);

        when(mockFileInfo.encode(any(byte[].class), anyInt())).thenReturn(50);

        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        byte[] setupBuffer = new byte[256];
        byte[] paramBuffer = new byte[256];
        byte[] dataBuffer = new byte[256];

        int setupWritten = trans2SetFileInfo.writeSetupWireFormat(setupBuffer, 0);

        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_FID);
        String[] results = new String[10];
        Thread[] threads = new Thread[10];

        // Act
        for (int i = 0; i < threads.length; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                results[index] = transPeekNamedPipe.toString();

    }

    public void test_nestedExceptions() {
        // Test nested exception handling
        Exception innerCause = new IllegalArgumentException("Invalid LDAP parameter");
        RuntimeException middleCause = new RuntimeException("LDAP configuration error", innerCause);
        LdapOperationException exception = new LdapOperationException("LDAP operation failed", middleCause);