* will not be released until that submitted task is also complete.
   *
   * <p>If a task is {@linkplain Thread#interrupt interrupted} while a task is running:
   *
   * <ol>
   *   <li>execution will not stop until the task queue is empty.
   *   <li>tasks will begin execution with the thread marked as not interrupted - any interruption
   *       applies only to the task that was running at the point of interruption.

   * will not be released until that submitted task is also complete.
   *
   * <p>If a task is {@linkplain Thread#interrupt interrupted} while a task is running:
   *
   * <ol>
   *   <li>execution will not stop until the task queue is empty.
   *   <li>tasks will begin execution with the thread marked as not interrupted - any interruption
   *       applies only to the task that was running at the point of interruption.

        buildFile << """
            def handler = services.get(${UserInputHandler.name})

            task askYesNo {
                def result = handler.askUser { it.askYesNoQuestion("thing?") }
                doLast {
                    println "result = " + result.getOrElse("<default>")
                }
            }

            task askBoolean {
                def result = handler.askUser { it.askBooleanQuestion("thing?", true) }

            }

            compileCustomJava.doLast {
                logger.lifecycle("task.sourceCompatibility = '\$sourceCompatibility'")
                logger.lifecycle("task.targetCompatibility = '\$targetCompatibility'")
            }
        """

        file("src/custom/java/Test.java") << """public class Test { }"""

        when:

        }
    }

    private def findLaunchables(Collection<GradleProject> gradleProjects, String taskName) {
        collectGradleProjects(gradleProjects).collect { it.tasks }.flatten().findAll { GradleTask task -> task.path.contains(taskName) }
    }

    private def collectGradleProjects(Collection<GradleProject> projects, Collection<GradleProject> acc = []) {
        acc.addAll(projects)

        }
    }

    def "explicit task dependency relationships are honored even if it violates destroys/creates/consumes relationships"() {
        given:
        withParallelThreads(2)

        buildFile << """
            def foo = file("foo")

            aPing.destroyables.register foo
            aPing.dependsOn ":bPing"

            task aIntermediate { dependsOn aPing }

                }
            }
        """
    }

    def "can use ResolvedComponentResult result as task input and changing source in '#changeLoc' doesn't invalidate the cache"() {
        given:
        resolvedComponentResultSetup()

        when: "Task without changes is executed & not skipped"
        succeeds "verify"

        then:
        executedAndNotSkipped ":verify"

            onAccess("task")
            return delegate.task(args, name, configureClosure)
        }

        override fun task(name: String, configureClosure: Closure<*>): Task {
            onAccess("task")
            return delegate.task(name, configureClosure)
        }

        override fun task(name: String, configureAction: Action<in Task>): Task {
            onAccess("task")

  }

  return devices_and_hosts;
}

// Helper struct for keeping track of task and device for an associated TPU
// device coordinate.
struct TaskAndDevice {
  TaskAndDevice() = default;
  TaskAndDevice(int task, int device) : task(task), device(device) {}

  int task = -1;
  int device = -1;
};

// Check if device coordinate is outside of topology mesh shape bounds.

        assertSuccessfulFinishEventHas(progressEvents[5], "RUN_MAIN_TASKS")

        // We will run just 1 task
        assertStartEventHas(progressEvents[3], "RUN_WORK", 1)
        assertFailedFinishEventHas(progressEvents[4], "RUN_WORK")
    }

    def "generates build phase events for task composite build for task #taskName and expects #expectedReportedTasksCount run tasks"() {
        setupCompositeBuildProject()