def "circular dependency detected with complex finalizedBy cycle in the graph"() {
        buildFile """
            task a
            task b
            task c
            task d
            task e
            task f

            a.dependsOn b
            b.dependsOn c
            b.finalizedBy d
            d.dependsOn f
            e.dependsOn d

    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Start the task to put it in the RUNNING state.  Have to use a separate
    // thread because the task will block on the task latch after unblocking
    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

                TestTaskReportContainer(Task task) {
                    super(Report, task, CollectionCallbackActionDecorator.NOOP)
                    add(TaskGeneratedSingleFileReport, "file1", task)
                    add(TaskGeneratedSingleFileReport, "file2", task)
                    add(TaskGeneratedSingleDirectoryReport, "dir1", task, null)

        testTaskContainerVia(
            "api",
            script = """

            val t1: Task = tasks.getByName("foo")
            val t2: Task = tasks.getByName("foo", Task::class)
            val t3: Task = tasks.getByName<Task>("foo")

            val t4: Task = tasks.getByName("bar") {
                description += "A"
            }
            val t5: Copy = tasks.getByName("bar", Copy::class) {

    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    assertEquals(2, getDone(task).intValue());
  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));

        expect:
        task.getOnlyIf().isSatisfiedBy(task)

        when:
        task.onlyIf(spec)

        then:
        !task.getOnlyIf().isSatisfiedBy(task)
    }

    def "can specify onlyIf predicate using description and spec"() {
        given:
        final task = getTask()
        final Spec<Task> spec = Mock(Spec.class)
        spec.isSatisfiedBy(task) >> false

    def "continues build when delegated task fails when run with --continue"() {
        when:
        buildA.buildFile << """
    task delegateWithFailure {
        dependsOn gradle.includedBuild('buildB').task(':fails')
    }
    task delegateWithSuccess {
        dependsOn gradle.includedBuild('buildB').task(':succeeds')
    }
    task delegate {
        dependsOn delegateWithSuccess, delegateWithFailure

            import org.gradle.api.DefaultTask;
            import org.gradle.api.Task;

            public class BrokenTask extends DefaultTask {
                public BrokenTask() {
                    doFirst(new Action<Task>() {
                        public void execute(Task task) {
                            throw new RuntimeException("broken action");
                        }
                    });

    }

    public void beforeExecute(Task task) {
        logger.lifecycle("LOGGER: executing $task.path")
    }

    public void afterExecute(Task task, TaskState state) {
        logger.info("LOGGER: executed task $task.path")
    }

    public void beforeActions(Task task) {
        logger.info("LOGGER: task $task.path starting work")
    }

    public void afterActions(Task task) {

        assertTestExecuted(className: "example.MyTest", methodName: "foo", task: ":secondTest")
        events.tests.size() == (supportsEfficientClassFiltering() ? 8 : 12)

        assertTestNotExecuted(className: "example.MyTest", methodName: "foo2", task: ":secondTest")
        assertTestNotExecuted(className: "example.MyTest", methodName: "foo2", task: ":test")