assertFalse(future.isCancelled());

    ExecutorService executor = Executors.newSingleThreadExecutor();

    try {
      Future<Boolean> getResult = executor.submit(() -> future.get());

      // Release the future value.
      latch.countDown();

      assertTrue(getResult.get(10, SECONDS));
    } finally {
      executor.shutdownNow();
    }

    assertTrue(future.isDone());

        }));
    }

    @Override
    public boolean isInBackground() {
        return Thread.currentThread() instanceof BackgroundThread;
    }

    /**
     * Shuts the executors down.
     * All executors immediately stops accepting new jobs. The method blocks until already submitted jobs complete.
     *

 */

package org.gradle.tooling.internal.consumer;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DefaultExecutorServiceFactory implements ExecutorServiceFactory {
    @Override
    public ExecutorService create() {
        return Executors.newSingleThreadExecutor();
    }

import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;

/**
 * Provides executors to run jobs in the background workers. The implementation is provided by Gradle.
 */
@ServiceScope(Scope.BuildTree.class)
public interface GradleEnterprisePluginBackgroundJobExecutors {
    /**
     * Returns the executor to run user-provided background jobs in the background workers.

   */
  public static <V extends @Nullable Object> ListenableFuture<V> listenInPoolThread(
      Future<V> future, Executor executor) {
    checkNotNull(executor);
    if (future instanceof ListenableFuture) {
      return (ListenableFuture<V>) future;
    }
    return new ListenableFutureAdapter<>(future, executor);
  }

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.vfs.impl


import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

class DefaultFileSystemAccessConcurrencyTest extends AbstractFileSystemAccessTest {

    def "parallel invalidation yields correct results"() {

        }

        // 時間取得
        final long time = System.nanoTime();

        // Callableタスク(複数)を実行する
        final ExecutorService executor = Executors.newFixedThreadPool(numTasks);
        try {
            final List<Future<Integer>> futures = executor.invokeAll(tasks);
            for (final Future<Integer> future : futures) {
                future.get();
            }

import org.gradle.process.internal.DefaultExecHandleBuilder
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

import java.util.concurrent.Executors

class DefaultJvmMetadataDetectorIntegrationTest extends AbstractIntegrationSpec {

    @Requires(IntegTestPreconditions.JavaHomeWithDifferentVersionAvailable)
    def "works on real installation"() {
        when:

            }
        }
        def executor = Mock(Executor)
        def delegateExecutor = Executors.newFixedThreadPool(threads)
        operationQueue = new DefaultBuildOperationQueue(false, workerRegistry, executor, new SimpleWorker())

        println "expecting ${expectedWorkerCount} concurrent work processors to be started..."

        when:

   *
   * @param executor The executor to decorate
   * @param nameSupplier The source of names for each task
   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  static Executor renamingDecorator(final Executor executor, final Supplier<String> nameSupplier) {
    checkNotNull(executor);
    checkNotNull(nameSupplier);
    return new Executor() {
      @Override