*/
  public static String toString(URL url, Charset charset) throws IOException {
    return asCharSource(url, charset).read();
  }

  /**
   * Streams lines from a URL, stopping when our callback returns false, or we have read all of the
   * lines.
   *
   * @param url the URL to read from
   * @param charset the charset used to decode the input stream; see {@link StandardCharsets} for

            fail("Should have caught as FessSystemException, but caught: " + e.getClass());
        }
    }

    public void test_rethrowWithWrapping() {
        // Test rethrowing with wrapping
        String originalMessage = "Original theme error";
        String wrapperMessage = "Failed to process theme";

        try {
            try {
                throw new ThemeException(originalMessage);

    assertThrows(IOException.class, () -> reader.mark(10));

    assertThrows(IOException.class, () -> reader.reset());
  }

  /**
   * Creates a CharSequenceReader wrapping the given CharSequence and tests that the reader produces
   * the same sequence when read using each type of read method it provides.
   */

        // Create a tree and simulate concurrent connection attempt
        SmbTree tree = new SmbTree(session, "testShare", "testService");

        // Mock transport.connect() to throw RuntimeException wrapping InterruptedException
        doThrow(new RuntimeException(new InterruptedException("Interrupted"))).when(transport).connect();

        // Should throw exception due to interrupted wait

    private ASN1ObjectIdentifier[] remoteMechs;

    private final boolean disableMic;
    private boolean requireMic;

    /**
     * Instance a <code>SpnegoContext</code> object by wrapping a {@link SSPContext}
     * with the same mechanism this {@link SSPContext} used.
     *
     * @param source
     *            the {@link SSPContext} to be wrapped
     */

      }

      // don't try to remove the set if it's empty; that can't be done safely without a lock
      // anyway, if the set is empty it'll just be wrapping an array of length 0
    }
  }

  @VisibleForTesting
  Set<Subscriber> getSubscribersForTesting(Class<?> eventType) {
    return MoreObjects.firstNonNull(subscribers.get(eventType), ImmutableSet.<Subscriber>of());

     * Specified failure types will not be logged or counted as errors.
     */
    @Size(max = 1000)
    public String ignoreFailureType;

    /**
     * Threshold for failure count before stopping crawling of a URL.
     * Set to -1 to disable the threshold check.
     */
    @Required
    @Min(-1)
    @Max(10000)
    @ValidateTypeFailure
    public Integer failureCountThreshold;

    /**

    if [ -n "$pid" ]; then
        echo $pid > "$pidfile"
    fi
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    # stop it here, often "killproc $prog"
    killproc -p $pidfile -d 20 $prog
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {

		do
			sleep 1
			i=$(($i + 1))
			if [ $i -gt $timeout ]; then
				log_end_msg 1
				exit 1
			fi
		done
	fi
	log_end_msg $return
	exit $return
	;;		
  stop)
	log_daemon_msg "Stopping $DESC"

	if [ -f "$PID_FILE" ]; then 
		start-stop-daemon --stop --pidfile "$PID_FILE" \
			--user "$FESS_USER" \
			--quiet \
			--retry forever/TERM/20 > /dev/null
		if [ $? -eq 1 ]; then

        } catch (final MalformedURLException e) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    /**
     * Wraps a new context, allowing subclasses to provide custom wrapping behavior.
     *
     * @param newContext the context to wrap
     * @return the wrapped context
     */
    protected CIFSContext wrap(final CIFSContext newContext) {
        return newContext;
    }