|| resp.getStatus() == TransPeekNamedPipeResponse.STATUS_SERVER_END_CLOSED) {
                fd.markClosed();
                return 0;
            }
            return resp.getAvailable();
        } catch (final SmbException se) {
            throw seToIoe(se);
        }
    }

    @Override
    public void close() {
        // ignore, the shared file descriptor is closed by the pipe handle
    }

        XmlNode dom;
        try {
            XMLStreamReader reader = XMLInputFactory.newFactory().createXMLStreamReader(is);
            dom = XmlService.read(reader);
        } catch (XMLStreamException e) {
            throw new IOException(e.getMessage(), e);
        }

        if (!"extension".equals(dom.name())) {

            logger.debug("loading {}", componentName);
        }
        try (CrawlerClient client = crawlerContainer.getComponent(componentName)) {
            crawlerClientFactory.addClient(regex, client);
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create {}.", componentName, e);
            } else {
                logger.info("{} is not available.", componentName);

                            .getPluginDescriptor()
                            .getLifecycleMappings()
                            .values()));
                } catch (Exception e) {
                    throw new RuntimeException("Unable to load plugin lifecycles", e);
                }
            }

            @Override
            public ClassLoader getClassLoader() {

            outputBufferField.setAccessible(true);
            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

            result.setUsername(DfTypeUtil.toString(source.get("username")));
            result.setWebConfigId(DfTypeUtil.toString(source.get("webConfigId")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

                        // Release buffer
                        BufferCache.releaseBuffer(buffer);
                        successCount.incrementAndGet();
                    }
                } catch (Exception e) {
                    synchronized (exceptions) {
                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }

                 * to return a proper ListenableFuture instead of using listenInPoolThread.
                 */
                getUninterruptibly(delegate);
              } catch (Throwable t) {
                // (including CancellationException and sneaky checked exception)
                // The task is presumably done, run the listeners.

  @CollectionSize.Require(absent = ZERO)
  public void testPut_unsupportedPresentExistingValue() {
    try {
      assertEquals("put(present, existingValue) should return present or throw", v0(), put(e0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

        PreauthIntegrityNegotiateContext ctx = new PreauthIntegrityNegotiateContext();
        try {
            setPrivateField(ctx, "hashAlgos", new int[] { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 });
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return ctx;
    }

    private NegotiateContextRequest createMockEncryptionContext() {