def "jobs can query if they are running on the background executor"() {
        given:
        buildFile << """
            import ${CompletableFuture.name}

            def executors = $executors
            CompletableFuture.runAsync({
                println "backgroundJobExecutor.isInBackground = \${executors.isInBackground()}"
            }, executors.userJobExecutor).exceptionally { e ->

            CompositeStoppable.stoppable(executors).stop();
        } finally {
            executors.clear();
        }
    }

    @Override
    public ManagedExecutor create(String displayName) {
        ManagedExecutor executor = new TrackedManagedExecutor(createExecutor(displayName), new ExecutorPolicy.CatchAndRecordFailures());
        executors.add(executor);
        return executor;
    }

        Thread                            | Thread           | "Thread.currentThread()"
        DefaultThreadFactory              | ThreadFactory    | "java.util.concurrent.Executors.defaultThreadFactory()"
        executorServiceTypeOnCurrentJvm() | Executor         | "java.util.concurrent.Executors.newSingleThreadExecutor().tap { shutdown() }"
        ByteArrayInputStream              | InputStream      | "new java.io.ByteArrayInputStream([] as byte[])"

  internal val resolver = DnsResolver.getInstance()
  private val executor = Executors.newSingleThreadExecutor()

  override fun query(
    hostname: String,
    callback: AsyncDns.Callback,
  ) {
    try {
      resolver.query(
        network,
        hostname,
        dnsClass.type,
        DnsResolver.FLAG_EMPTY,
        executor,
        null,
        object : DnsResolver.Callback<List<InetAddress>> {

 * limitations under the License.
 */
package okhttp3.recipes.kt

import java.io.IOException
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import okhttp3.OkHttpClient
import okhttp3.Request

class CancelCall {
  private val executor = Executors.newScheduledThreadPool(1)
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request.Builder()

        }));
    }

    @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.
     *

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.

        }

        // 時間取得
        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: