import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;

/**
 * Tests for {@link ClosingFuture} that exercise {@link
 * ClosingFuture#finishToValueAndCloser(ValueAndCloserConsumer, Executor)}.
 */
public class ClosingFutureFinishToValueAndCloserTest extends AbstractClosingFutureTest {

package org.gradle.internal.hash

import spock.lang.Specification

import static java.lang.Thread.currentThread
import static java.util.concurrent.CompletableFuture.supplyAsync
import static java.util.concurrent.Executors.newFixedThreadPool

class HashingTest extends Specification {
    def 'cannot call hash multiple times'() {
        given:
        def hasher = Hashing.newHasher()
        hasher.putInt(1)
        hasher.hash()

    ScheduledExecutorService executor = newScheduledThreadPool(1);
    try {
      FluentFuture<?> f =
          FluentFuture.from(SettableFuture.create()).withTimeout(0, SECONDS, executor);
      ExecutionException e = assertThrows(ExecutionException.class, () -> f.get());
      assertThat(e).hasCauseThat().isInstanceOf(TimeoutException.class);
    } finally {
      executor.shutdown();
    }
  }

    ScheduledExecutorService executor = newScheduledThreadPool(1);
    try {
      FluentFuture<?> f =
          FluentFuture.from(SettableFuture.create()).withTimeout(0, SECONDS, executor);
      ExecutionException e = assertThrows(ExecutionException.class, () -> f.get());
      assertThat(e).hasCauseThat().isInstanceOf(TimeoutException.class);
    } finally {
      executor.shutdown();
    }
  }

    public static boolean isConfigCache() {
        Executer executer = getSystemPropertyExecuter();
        return executer == Executer.configCache || executer == Executer.isolatedProjects;
    }

    public static boolean isNotIsolatedProjects() {
        return !isIsolatedProjects();
    }

    public static boolean isIsolatedProjects() {
        return getSystemPropertyExecuter() == Executer.isolatedProjects;
    }

                  + runnable
                  + " with executor "
                  + executor,
              e);
    }
  }

  private static final class RunnableExecutorPair {
    final Runnable runnable;
    final Executor executor;
    @CheckForNull RunnableExecutorPair next;

    RunnableExecutorPair(
        Runnable runnable, Executor executor, @CheckForNull RunnableExecutorPair next) {

    }

    // public void test_doGet_mt() throws Exception {
    // ExecutorService executorService = Executors.newFixedThreadPool(1);
    //
    // // HttpClient Parameters
    // Map<String, Object> paramMap = new HashMap<String, Object>();
    // httpClient.setInitParameterMap(paramMap);
    //

                  + runnable
                  + " with executor "
                  + executor,
              e);
    }
  }

  private static final class RunnableExecutorPair {
    final Runnable runnable;
    final Executor executor;
    @CheckForNull RunnableExecutorPair next;

    RunnableExecutorPair(
        Runnable runnable, Executor executor, @CheckForNull RunnableExecutorPair next) {

## Multi-Tenant environments

It is possible to run multiple TensorFlow models in parallel. For example,
`ModelServer` collates all computation graphs exposed to it (from multiple
`SavedModel`) and executes them in parallel on available executors. Running
TensorFlow in a multitenant design mixes the risks described above with the
inherent ones from multitenant configurations. The primary areas of concern are

        this.workerLimits = workerLimits;
        this.workerLeaseService = workerLeaseService;
        this.executor = executorFactory.create(displayName);

        executor.setKeepAlive(KEEP_ALIVE_TIME_MS, TimeUnit.MILLISECONDS);
    }

    @Override
    public void submit(ConditionalExecution<T> execution) {
        if (queueState == QueueState.Stopped) {