for (String task : tasks) {
            if (isBeforeOrAfterPhase(task)) {
                String prevTask = task;
                task = PhaseId.of(task).phase();
                logger.warn("Illegal call to phase '{}'. The main phase '{}' will be used instead.", prevTask, task);
            }
            if (isGoalSpecification(task)) {

  /**
   * @return a {@code ListenableFuture} representing pending completion of the task
   * @throws RejectedExecutionException {@inheritDoc}
   */
  @Override
  <T extends @Nullable Object> ListenableFuture<T> submit(Callable<T> task);

  /**
   * @return a {@code ListenableFuture} representing pending completion of the task
   * @throws RejectedExecutionException {@inheritDoc}
   */
  @Override

                }
                r.run();
              }
            });
    Runnable task = numCalls::incrementAndGet;
    assertThrows(RejectedExecutionException.class, () -> executor.execute(task));
    assertEquals(0, numCalls.get());
    reject.set(false);
    executor.execute(task);
    assertEquals(1, numCalls.get());
  }

  /*
   * Under Android, MyError propagates up and fails the test?

  public <T> ListenableFuture<T> submit(Callable<T> task) {
    Preconditions.checkNotNull(task, "task must not be null!");
    return delegate.submit(task);
  }

  @Override
  public <T> ListenableFuture<T> submit(Runnable task, T result) {
    Preconditions.checkNotNull(task, "task must not be null!");
    Preconditions.checkNotNull(result, "result must not be null!");
    return delegate.submit(task, result);
  }

  @Override

  public <T> ListenableFuture<T> submit(Callable<T> task) {
    Preconditions.checkNotNull(task, "task must not be null!");
    return delegate.submit(task);
  }

  @Override
  public <T> ListenableFuture<T> submit(Runnable task, T result) {
    Preconditions.checkNotNull(task, "task must not be null!");
    Preconditions.checkNotNull(result, "result must not be null!");
    return delegate.submit(task, result);
  }

  @Override

        String api = "foo.json"
        setupRestResources([api])

        when:
        def result = gradleRunner("copyRestApiSpecsTask").build()

        then:
        result.task(':copyRestApiSpecsTask').outcome == TaskOutcome.NO_SOURCE
        result.task(':copyYamlTestsTask').outcome == TaskOutcome.NO_SOURCE
    }

    def "restResources copies API by default for projects with tests"() {
        given:
        internalBuild()

    private static RerunTestExecuter createRetryTestExecuter(Task task, TestRerunTaskExtension extension) {
        TestExecuter<JvmTestExecutionSpec> delegate = getTestExecuter(task);
        return new RerunTestExecuter(extension, delegate);
    }

    private static TestExecuter<JvmTestExecutionSpec> getTestExecuter(Task task) {
        return invoke(declaredMethod(Test.class, "createTestExecuter"), task);
    }

                .build()
        then:
        result.task(":distribution:bwc:${bwcProject}:buildBwcDarwinTar").outcome == TaskOutcome.SUCCESS
        result.task(":distribution:bwc:${bwcProject}:buildBwcOssDarwinTar").outcome == TaskOutcome.SUCCESS

        and: "assemble task triggered"
        assertOutputContains(result.output, "[$bwcDistVersion] > Task :distribution:archives:darwin-tar:${expectedAssembleTaskName}")

            );
            task.getDocsDirectory().convention(extension.getDocumentationRenderedRoot());
            task.getPort().convention(webserverPort);

            task.dependsOn(extension.getRenderedDocumentation());
        });

        tasks.register("docs", task -> {
            task.setDescription("Generates all documentation");
            task.setGroup("documentation");

        tasks.withType(AsciidoctorTask.class).configureEach(task -> {
            if (task.getName().equals("asciidoctor")) {
                // ignore this task
                task.setEnabled(false);
                return;
            }

            task.setExecutionMode(ExecutionMode.OUT_OF_PROCESS);
            task.outputOptions(options -> {
                options.setSeparateOutputDirs(false);