* method execute in the same order they were passed.</p>
     *
     * <p>If the project has already been evaluated, the action never executes.</p>
     * <p>If you call this method within a <code>beforeEvaluate</code> action, the passed action never executes.</p>
     *
     * @param action the action to execute.
     */
    void beforeEvaluate(Action<? super Project> action);

    executor.execute(task);
    return task;
  }

  /**
   * Executes {@code runnable} on the specified {@code executor}, returning a {@code Future} that
   * will complete after execution.
   *
   * @throws RejectedExecutionException if the task cannot be scheduled for execution
   * @since 28.2
   */
  public static ListenableFuture<@Nullable Void> submit(Runnable runnable, Executor executor) {

    executor.execute(task);
    return task;
  }

  /**
   * Executes {@code runnable} on the specified {@code executor}, returning a {@code Future} that
   * will complete after execution.
   *
   * @throws RejectedExecutionException if the task cannot be scheduled for execution
   * @since 28.2
   */
  public static ListenableFuture<@Nullable Void> submit(Runnable runnable, Executor executor) {

        when:
        container.withType(type, action)

        then:
        1 * action.execute(c) >> {
            container.add(d)
            container.add(a)
        }
        1 * action.execute(a)
        0 * action._
    }

    def "provider for element is queried and action executed for filtered collection with matching type"() {
        containerAllowsExternalProviders()

    server.enqueue(MockResponse(body = "A"))
    server.enqueue(MockResponse(body = "A"))
    val executor = Executors.newCachedThreadPool(threadFactory("HttpOverHttp2Test"))
    val countDownLatch = CountDownLatch(2)
    executor.execute(AsyncRequest("/r1", countDownLatch))
    executor.execute(AsyncRequest("/r2", countDownLatch))
    countDownLatch.await()
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    @CheckForNull // null only for TOMBSTONE
    final Executor executor;

    // writes to next are made visible by subsequent CAS's on the listeners field
    @CheckForNull Listener next;

    Listener(Runnable task, Executor executor) {
      this.task = task;
      this.executor = executor;
    }

    Listener() {
      this.task = null;
      this.executor = null;
    }
  }

    @CheckForNull // null only for TOMBSTONE
    final Executor executor;

    // writes to next are made visible by subsequent CAS's on the listeners field
    @CheckForNull Listener next;

    Listener(Runnable task, Executor executor) {
      this.task = task;
      this.executor = executor;
    }

    Listener() {
      this.task = null;
      this.executor = null;
    }
  }

```
# Executes all tests in SomeTestClass
gradle test --tests SomeTestClass

# Executes a single specified test in SomeTestClass
gradle test --tests SomeTestClass.someSpecificMethod

gradle test --tests SomeTestClass.*someMethod*
```

        assertTaskReady(broken)
        assertAllWorkComplete(continueOnFailure)

        where:
        continueOnFailure << [false, true]
    }

    def "finalizer tasks are executed on task failure but dependents of failed task are not"() {
        Task finalizerDepDep = task("finalizerDepDep")
        Task finalizerDep = task("finalizerDep", dependsOn: [finalizerDepDep])

    }
    try {
      closingFuture.finishToValueAndCloser(new NoOpValueAndCloserConsumer<>(), executor);
      fail();
    } catch (IllegalStateException expected) {
    }
  }

  // Avoid infinite recursion if a closeable's close() method throws RejectedExecutionException and
  // is closed using the direct executor.
  public void testCloseThrowsRejectedExecutionException() throws Exception {