assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofSeconds(12));
  }

  public void testScheduleCallable() throws Exception {
    Callable<String> callable = () -> "hello";

    ListenableScheduledFuture<String> future =
        executorService.schedule(callable, Duration.ofMinutes(12));

    assertThat(future.get()).isEqualTo("hello");
    assertThat(recordedTimeUnit).isEqualTo(TimeUnit.NANOSECONDS);

            conventionMapping.map("jdkName", new Callable<String>() {
                @Override
                public String call() {
                    return JavaVersion.current().toString();
                }
            });
            conventionMapping.map("languageLevel", new Callable<IdeaLanguageLevel>() {
                @Override
                public IdeaLanguageLevel call() {

     * - A [org.gradle.api.provider.Provider] of any supported type.
     *   The provider's value is resolved recursively.
     * - A [java.util.concurrent.Callable] that returns any supported type.
     *   The callable's return value is resolved recursively.
     *
     * @param path The object to resolve as a `File`.
     * @return The resolved file.
     */
    @Suppress("unused")

                || notation instanceof Number
                || notation instanceof Boolean) {
            result.converted(notation.toString());
        } else if (notation instanceof Callable) {
            final Callable<?> callableNotation = (Callable<?>) notation;
            final Object called = uncheckedCall(callableNotation);
            convert(called, result);
        } else if (notation instanceof Provider) {

      Callable<V> callable, long delay, TimeUnit unit);

  /**
   * Duration-based overload of {@link #schedule(Callable, long, TimeUnit)}.
   *
   * @since 29.0
   */
  default <V extends @Nullable Object> ListenableScheduledFuture<V> schedule(
      Callable<V> callable, Duration delay) {
    return schedule(callable, toNanosSaturated(delay), TimeUnit.NANOSECONDS);
  }

                    .orElseThrow(() -> new IllegalStateException("Interception type name is not set for " + request.getInterceptedCallable().getOwner().getType()));
                CallableInfo callable = request.getInterceptedCallable();
                CallableKindInfo kind = callable.getKind();
                if (kind == CallableKindInfo.AFTER_CONSTRUCTOR) {
                    Type constructedType = request.getInterceptedCallable().getOwner().getType();

import spock.lang.Specification

import java.util.concurrent.Callable

class NetworkOperationBackOffAndRetryTest extends Specification {

    def 'retries operation on transient network issue and fails after max attempts - #ex'() {
        when:
        int attempts = 0
        Callable operation = {
            attempts++
            throw ex
        }

  TF_ASSERT_OK(child.Get(String("test3")).status());
}

TEST(ObjectTest, CallFunctionOnObject) {
  Object module;
  module.Set(String("add"), Callable(TaggedValue(AddIntegers)));
  TF_ASSERT_OK_AND_ASSIGN(Callable method, module.Get<Callable>(String("add")));

  TF_ASSERT_OK_AND_ASSIGN(Integer val, method.Call<Integer>(1, 2));
  EXPECT_EQ(val.get(), 3);
}

TEST(ObjectTest, Capsule) {
  Object obj;

  private static final Callable<String> GOOD_CALLABLE =
      new Callable<String>() {
        @Override
        public String call() throws InterruptedException {
          MILLISECONDS.sleep(DELAY_MS);
          return GOOD_CALLABLE_RESULT;
        }
      };
  private static final Callable<String> BAD_CALLABLE =
      new Callable<String>() {
        @Override

 */

package org.gradle.kotlin.dsl

import org.junit.Assert.assertEquals
import org.junit.Test
import java.util.concurrent.Callable


class CallableExtensionsTest {

    @Test
    fun `Callable#call can be called using invoke`() {
        val answer = "42"
        val answerCallable = Callable { answer }

        assertEquals(answer, answerCallable())
    }