@SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
    Future<?> possiblyIgnoredError1 = testExecutor.scheduleAtFixedRate(() -> {}, 3, 7, SECONDS);
    mock.assertLastMethodCalled("scheduleAtFixedRate", 3, 7, SECONDS);
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

   * execute/submit/schedule}, as in {@link CallerRunsPolicy}. This applies both to individually
   * submitted tasks and to collections of tasks submitted via {@code invokeAll}, {@code invokeAny},
   * {@code schedule}, {@code scheduleAtFixedRate}, and {@code scheduleWithFixedDelay}. In the case
   * of tasks submitted by {@code invokeAll} or {@code invokeAny}, tasks will run serially on the

    @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
    Future<?> possiblyIgnoredError1 = testExecutor.scheduleAtFixedRate(() -> {}, 3, 7, SECONDS);
    mock.assertLastMethodCalled("scheduleAtFixedRate", 3, 7, SECONDS);
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    return delegate.schedule(wrapTask(task), delay, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleAtFixedRate(
      Runnable command, long initialDelay, long period, TimeUnit unit) {
    return delegate.scheduleAtFixedRate(wrapTask(command), initialDelay, period, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleWithFixedDelay(

        }
      };
    }

    /**
     * Returns a {@link Scheduler} that schedules the task using the {@link
     * ScheduledExecutorService#scheduleAtFixedRate} method.
     *
     * @param initialDelay the time to delay first execution
     * @param period the period between successive executions of the task
     * @since 33.4.0 (but since 28.0 in the JRE flavor)
     */

    Cancellable unused =
        schedule.schedule(
            null,
            new ScheduledThreadPoolExecutor(1) {
              @Override
              public ScheduledFuture<?> scheduleAtFixedRate(
                  Runnable command, long initialDelay, long period, TimeUnit unit) {
                assertSingleCallWithCorrectParameters(command, initialDelay, period, unit);

    Cancellable unused =
        schedule.schedule(
            null,
            new ScheduledThreadPoolExecutor(1) {
              @Override
              public ScheduledFuture<?> scheduleAtFixedRate(
                  Runnable command, long initialDelay, long period, TimeUnit unit) {
                assertSingleCallWithCorrectParameters(command, initialDelay, period, unit);

    }

    @Override
    public ListenableScheduledFuture<?> scheduleAtFixedRate(
        Runnable command, long initialDelay, long period, TimeUnit unit) {
      NeverSuccessfulListenableFutureTask task = new NeverSuccessfulListenableFutureTask(command);
      ScheduledFuture<?> scheduled = delegate.scheduleAtFixedRate(task, initialDelay, period, unit);

        this.multiChannelEnabled = false;

        // Schedule periodic health checks
        scheduler.scheduleAtFixedRate(this::performHealthCheck, 10, 10, TimeUnit.SECONDS);

        // Schedule interface discovery
        scheduler.scheduleAtFixedRate(this::discoverInterfaces, 0, 30, TimeUnit.SECONDS);
    }

    /**
     * Initialize multi-channel support
     *

        this.scheduler = Executors.newScheduledThreadPool(1);
        this.changeNotifier = new DirectoryChangeNotifier(this);

        // Schedule periodic cache cleanup
        scheduler.scheduleAtFixedRate(this::cleanupExpiredEntries, 60, 60, TimeUnit.SECONDS);
    }

    /**
     * Request a directory lease
     *
     * @param directoryPath directory path
     * @param requestedState requested lease state