@Override
  @ParametricNullness
  public <T extends @Nullable Object> T callWithTimeout(
      Callable<T> callable, long timeoutDuration, TimeUnit timeoutUnit) throws ExecutionException {
    checkNotNull(callable);
    checkNotNull(timeoutUnit);
    try {
      return callable.call();
    } catch (RuntimeException e) {
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {

   * @throws ExecutionError if {@code callable} throws an {@code Error}
   * @since 28.0
   */
  @CanIgnoreReturnValue
  @ParametricNullness
  default <T extends @Nullable Object> T callWithTimeout(Callable<T> callable, Duration timeout)
      throws TimeoutException, InterruptedException, ExecutionException {
    return callWithTimeout(callable, toNanosSaturated(timeout), TimeUnit.NANOSECONDS);

  }

  @WeakOuter
  private final class TrustedFutureInterruptibleTask extends InterruptibleTask<V> {
    private final Callable<V> callable;

    TrustedFutureInterruptibleTask(Callable<V> callable) {
      this.callable = checkNotNull(callable);
    }

    @Override
    final boolean isDone() {
      return TrustedListenableFutureTask.this.isDone();
    }

    @Override

    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
        singleScheduledActions.add(command);
        return null;
    }

    @Override
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {

        """

        file("src/main/groovy/Caller.groovy") << """
            class Caller {
                private MockIt callable

                Caller(MockIt callable) {
                    this.callable = callable
                }

                void call() {
                   callable.call()
                }
            }
        """
        file("src/test/groovy/TestSpec.groovy") << """

    def "recursively resolves return value of a Callable"() {
        def fileCollection = Mock(FileCollectionInternal)
        def callable = Mock(Callable)

        when:
        visitor.add(callable)

        then:
        1 * callable.call() >> fileCollection
        1 * context.accept(fileCollection)
        0 * context._
    }

    def "resolves a Callable which returns null"() {

    override fun getCallableSymbol(callable: PsiMember): KaCallableSymbol? {
        if (callable !is PsiMethod && callable !is PsiField) return null
        val name = callable.name?.let(Name::identifier) ?: return null
        val containingClass = callable.containingClass ?: return null
        val classSymbol = getNamedClassSymbol(containingClass) ?: return null

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code
   * Callable}.
   *
   * @param callable the callable task
   * @since 10.0
   */
  public static <V extends @Nullable Object> ListenableFutureTask<V> create(Callable<V> callable) {
    return new ListenableFutureTask<>(callable);
  }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code

}  // namespace

// Add numbers in a loop by calling a callable.
void CallFunctions(::testing::benchmark::State& state) {
  Integer sum(0);
  Callable callable((impl::TaggedValue(impl::Func(AddTagged))));
  *callable.Call<Integer>(sum, Integer(30));
  size_t i = 0;
  for (auto dummy : state) {
    sum = *callable.Call<Integer>(sum, Integer(i));
    i++;
  }
}

   */
  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  protected final <T extends @Nullable Object> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return TrustedListenableFutureTask.create(callable);
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  public ListenableFuture<?> submit(Runnable task) {