}

    /**
     * Calls the given callable converting any thrown exception to an unchecked exception via {@link UncheckedException#throwAsUncheckedException(Throwable)}
     *
     * @param callable The callable to call
     * @param <T> Callable's return type
     * @return The value returned by {@link Callable#call()}
     */
    @Nullable
    public static <T> T uncheckedCall(Callable<T> callable) {
        try {

    private final Callable<V> callable;

    CallableInterruptibleTask(Callable<V> callable, Executor listenerExecutor) {
      super(listenerExecutor);
      this.callable = checkNotNull(callable);
    }

    @Override
    @ParametricNullness
    V runInterruptibly() throws Exception {
      return callable.call();
    }

    @Override
    void setValue(@ParametricNullness V value) {

    private final Callable<V> callable;

    CallableInterruptibleTask(Callable<V> callable, Executor listenerExecutor) {
      super(listenerExecutor);
      this.callable = checkNotNull(callable);
    }

    @Override
    @ParametricNullness
    V runInterruptibly() throws Exception {
      return callable.call();
    }

    @Override
    void setValue(@ParametricNullness V value) {

    this.delegate = checkNotNull(delegate);
  }

  /**
   * Wraps a {@code Callable} for submission to the underlying executor. This method is also applied
   * to any {@code Runnable} passed to the default implementation of {@link #wrapTask(Runnable)}.
   */
  protected abstract <T extends @Nullable Object> Callable<T> wrapTask(Callable<T> callable);

  /**

    this.delegate = checkNotNull(delegate);
  }

  /**
   * Wraps a {@code Callable} for submission to the underlying executor. This method is also applied
   * to any {@code Runnable} passed to the default implementation of {@link #wrapTask(Runnable)}.
   */
  protected abstract <T extends @Nullable Object> Callable<T> wrapTask(Callable<T> callable);

  /**

        then:
        def t = thrown(RuntimeException)
        t == failure
    }

    def "infers value type from callable implementation"() {
        def provider = new DefaultProvider(callable)

        expect:
        provider.type == valueType

        where:
        callable                    | valueType
        new RawCallable()           | null
        new StringCallable()        | String

 *
 * <h3>Configuration Cache Behavior</h3>
 * <b>Lazy</b>. The given {@link Callable} is stored to the cache so the value can be recomputed on each run.
 */
class ChangingProvider<T> extends DefaultProvider<T> {

    public <CALLABLE extends Callable<T> & Serializable> ChangingProvider(CALLABLE value) {
        super(value);
    }

    @Override
    protected String toStringNoReentrance() {
        return "changing(?)";

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


class CallableCodecTest : AbstractFunctionalTypeTest() {

    @Test
    fun `defers evaluation of Callable objects`() {
        assertDeferredEvaluationOf(callable()) {
            call()
        }
    }

    @Test
    fun `defers evaluation of dynamic Callable fields`() {
        assertDeferredEvaluationOf(BeanOf(callable())) {
            value.call()
        }

        val callables = typeScope.getCallableSignatures().toList()
        return prettyPrint {
            callables.forEach {
                appendLine(stringRepresentation(it))
            }
        }
    }

    private fun KaSession.prettyPrintForTests(typeScope: KaTypeScope): String {
        val callables = typeScope.getCallableSignatures().toList()
        return prettyPrint {

  @ParametricNullness
  private <T extends @Nullable Object> T callWithTimeout(
      Callable<T> callable, long timeoutDuration, TimeUnit timeoutUnit, boolean amInterruptible)
      throws Exception {
    checkNotNull(callable);
    checkNotNull(timeoutUnit);
    checkPositiveTimeout(timeoutDuration);

    Future<T> future = executor.submit(callable);

    try {
      return amInterruptible