return lengthIfKnown.get();
    }

    Closer closer = Closer.create();
    try {
      Reader reader = closer.register(openStream());
      return countBySkipping(reader);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  private static long countBySkipping(Reader reader) throws IOException {
    long count = 0;
    long read;

     *
     * @param message the detail message describing the exception
     * @param cause the cause of this exception
     */
    public FessSystemException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new FessSystemException with the specified detail message.
     *
     * @param message the detail message describing the exception

                artifact.getDependencyTrail());
    }

    protected ArtifactNotFoundException(
            String message, Artifact artifact, List<ArtifactRepository> remoteRepositories, Throwable cause) {
        this(
                message,
                artifact.getGroupId(),
                artifact.getArtifactId(),
                artifact.getVersion(),
                artifact.getType(),

        // to currentFuture doesn't race with itself so that currentFuture is assigned in the
        // correct order.
        Throwable scheduleFailure = null;
        Cancellable toReturn;
        lock.lock();
        try {
          toReturn = initializeOrUpdateCancellationDelegate(schedule);
        } catch (Throwable e) {
          // Any Exception is either a RuntimeException or sneaky checked exception.
          //

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#renewCredentials(java.lang.String, java.lang.Throwable)
     */
    @Override
    public boolean renewCredentials(final String locationHint, final Throwable error) {
        return false;
    }

    /**
     * {@inheritDoc}
     *
     *
     * @see jcifs.CIFSContext#close()
     */

import static com.google.common.base.Throwables.throwIfUnchecked;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.fail;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Function;
import com.google.common.base.Throwables;
import com.google.common.reflect.AbstractInvocationHandler;

    address: InetSocketAddress,
    connectTimeout: Int,
  ) {
    socket.connect(address, connectTimeout)
  }

  open fun log(
    message: String,
    level: Int = INFO,
    t: Throwable? = null,
  ) {
    val logLevel = if (level == WARN) Level.WARNING else Level.INFO
    logger.log(logLevel, message, t)
  }

  open fun isCleartextTrafficPermitted(hostname: String): Boolean = true

  /**

     *
     * @param msg
     *            the error message
     * @param rootCause
     *            the underlying cause of this exception
     */
    public DcerpcException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

    /**
     * Returns the DCE/RPC error code associated with this exception
     *
     * @return the error code
     */
    public int getErrorCode() {

      this.runtime = runtime;
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception

        try {
            client.execute(RequestDataBuilder.newRequestData().get().url(url).build());
            fail();
        } catch (final MultipleCrawlingAccessException e) {
            // ok
            final Throwable[] causes = e.getCauses();
            assertEquals(5, causes.length);
        }
        assertEquals(1, testListener.startCount);
        assertEquals(5, testListener.requestCount);