return new Future<O>() {

      @Override
      public boolean cancel(boolean mayInterruptIfRunning) {
        return input.cancel(mayInterruptIfRunning);
      }

      @Override
      public boolean isCancelled() {
        return input.isCancelled();
      }

      @Override
      public boolean isDone() {
        return input.isDone();
      }

      @Override

public class ReloadableStopFilterFactory extends AbstractTokenFilterFactory {

    private final Path stopwordPath;

    private final long reloadInterval;

    private final boolean ignoreCase;

    public ReloadableStopFilterFactory(final IndexSettings indexSettings, final Environment environment, final String name,
            final Settings settings) {
        super(indexSettings, name, settings);

                lifeCycleDependencyResolver,
                eventCatapult,
                mojosExecutionStrategy,
                messageBuilderFactory);
    }

    @Override
    protected boolean useProjectLock(MavenSession session) {
        return false;
    }

  override fun contentLength(): Long = delegate.contentLength()

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    delegate.writeTo(sink)
  }

  override fun isDuplex(): Boolean = delegate.isDuplex()

  override fun toString(): String = javaClass.simpleName + "(" + delegate.toString() + ")"

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

    }

    /**
     * Returns true if the request has a condition query, otherwise false.
     *
     * @return True if the request has a condition query, otherwise false.
     */
    public boolean hasConditionQuery() {
        final Map<String, String[]> conditions = getConditions();
        return !isEmptyArray(conditions.get(AS_Q))//
                || !isEmptyArray(conditions.get(AS_EPQ))//

     *
     * @param node the DOM node to check against this pruned tag configuration
     * @return true if the node matches this pruned tag configuration, false otherwise
     */
    public boolean matches(final Node node) {
        if (tag.equalsIgnoreCase(node.getNodeName())) {
            if (attrName != null) {
                final Node attr = node.getAttributes().getNamedItem(attrName);

        if (aliases.containsKey(lifecyclePhase)) {
            lifecyclePhase = PhaseId.of(aliases.get(lifecyclePhase)).phase();
        }

        boolean passed = false;
        for (String phase : lifecycle.getPhases()) {
            boolean include = true;
            if (phase.equals(lifecyclePhase)) {
                passed = true;
            } else if (passed) {

    GcFinalization.awaitDone(() -> reference.finalizeReferentCalled);
  }

  static class MockReference extends FinalizableWeakReference<Object> {

    volatile boolean finalizeReferentCalled;

    MockReference(FinalizableReferenceQueue frq) {
      super(new Object(), frq);
    }

    @Override
    public void finalizeReferent() {
      finalizeReferentCalled = true;
    }

        .testAllPublicInstanceMethods(manager);
  }

  private static final class RecordingListener extends ServiceManager.Listener {
    volatile boolean healthyCalled;
    volatile boolean stoppedCalled;
    final Set<Service> failedServices = Sets.newConcurrentHashSet();

    @Override
    public void healthy() {
      healthyCalled = true;
    }

    @Override

     * @param outputFile The file where the thumbnail will be saved.
     * @return True if thumbnail generation was successful, false otherwise.
     */
    @Override
    public boolean generate(final String thumbnailId, final File outputFile) {
        if (logger.isDebugEnabled()) {
            logger.debug("Generate Thumbnail: {}", thumbnailId);
        }

        if (outputFile.exists()) {