} catch (ComponentLookupException e) {
            throw new IllegalStateException(e);
        }
    }

    private static RepositorySystemSession rss(PlexusContainer c) {
        try {
            LegacySupport legacySupport = c.lookup(LegacySupport.class);

            return legacySupport.getRepositorySession();
        } catch (ComponentLookupException e) {

            zipExtractor.getText(in, null);
            fail();
        } catch (MaxLengthExceededException e) {
            // pass
        }
        zipExtractor.setMaxContentSize(-1);
    }

    public void test_getText_null() {
        try {
            zipExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {
            // NOP
        }
    }

     * @return the sequence number
     */
    public long getSequenceNumber() {
        return sequenceNumber;
    }

    /**
     * Gets the response sequence number returned by the server.
     * This should match the request sequence number in a successful response.
     *
     * @return the response sequence number
     */
    public long getResponseSequenceNumber() {
        return responseSequenceNumber;
    }

     *
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override
    public SmbResource get(final String url) throws CIFSException {
        try {
            return new SmbFile(url, this);
        } catch (final MalformedURLException e) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    /**
     *
     * {@inheritDoc}
     *

    try {
      delegate::class.java.getMethod(
        "checkServerTrusted",
        Array<X509Certificate>::class.java,
        String::class.java,
        String::class.java,
      )
    } catch (_: NoSuchMethodException) {
      null
    }

  /** Android method to clean and sort certificates, called via reflection. */
  @Suppress("unused", "UNCHECKED_CAST")
  fun checkServerTrusted(

  }

  @Override public Socket createSocket(String host, int port) throws IOException {
    Socket result = createSocket();

    try {
      result.connect(new InetSocketAddress(host, port));
    } catch (IOException e) {
      result.close();
      throw e;
    }
    return result;
  }

  @Override public Socket createSocket(
      String host, int port, InetAddress localHost, int localPort) throws IOException {

     */
    public static JarInputStream create(final InputStream is) throws IORuntimeException {
        assertArgumentNotNull("is", is);

        try {
            return new JarInputStream(is);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Method that wraps exception handling for {@link JarInputStream#getNextJarEntry()}.
     *

     */
    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);
        } catch (final InterruptedException e) {
            throw new InterruptedRuntimeException(e);
        }
    }

    /**

        when(mockAllocInfo.getFree()).thenReturn(400L);

        assertEquals(1000L, mockAllocInfo.getCapacity(), "capacity should match stubbed value");
        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**

        try (final XContentBuilder builder = func.apply(mediaType.contentBuilder(), ToXContent.EMPTY_PARAMS)) {
            builder.flush();
            return builder.getOutputStream();
        } catch (final IOException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to print the output.", e);
            }
            return new ByteArrayOutputStream();
        }
    }