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
        }

     * - 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")

      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);
  }

  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())
    }

    def tasks = Mock(TaskContainerInternal)
    def project = Stub(ProjectInternal) {
        getObjects() >> TestUtil.objectFactory()
        getProviders() >> TestUtil.providerFactory()
        provider(_ as Callable<Object>) >> {
            Callable producer -> TestUtil.providerFactory().provider(
                {
                    producer.call()
                }
            )
        }
        getLayout() >> Stub(ProjectLayout) {

    runConcurrentTest(
        numberOfThreads,
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            long unused = ticker.read();
            return null;
          }
        });

    assertEquals(incrementByNanos * numberOfThreads, ticker.read());
  }

  /** Runs {@code callable} concurrently {@code numberOfThreads} times. */

import java.util.concurrent.Callable;

/**
 * A provider whose value is computed by a {@link Callable}.
 *
 * <h3>Configuration Cache Behavior</h3>
 * <b>Eager</b>. The value is computed at store time and loaded from the cache.
 */
public class DefaultProvider<T> extends AbstractMinimalProvider<T> {
    private final Callable<? extends T> value;

    public DefaultProvider(Callable<? extends T> value) {

  /** @since 15.0 (previously returned ScheduledFuture) */
  @Override
  <V extends @Nullable Object> ListenableScheduledFuture<V> schedule(
      Callable<V> callable, long delay, TimeUnit unit);

  /** @since 15.0 (previously returned ScheduledFuture) */
  @Override
  ListenableScheduledFuture<?> scheduleAtFixedRate(

        given:
        def failure1 = new RuntimeException()
        def action1 = new Callable<Void>() {
            Void call() {
                instant.broken1
                throw failure1
            }
        }
        def failure2 = new RuntimeException()
        def action2 = new Callable<Void>() {
            Void call() {
                instant.broken2
                throw failure2