*/
@HasInternalProtocol
public interface TaskState {
    /**
     * <p>Returns true if this task has been executed.</p>
     *
     * @return true if this task has been executed.
     */
    boolean getExecuted();

    /**
     * Returns the exception describing the task failure, if any.
     *
     * @return The exception, or null if the task did not fail.
     */
    @Nullable
    Throwable getFailure();

     * doesn't really make sense, it's more like a traverse permission; for example, a user
     * must have 'execute' access to the 'bin' directory in order to execute the 'ls' or 'cd' commands.
     */
    void setExecute(boolean execute);

import static org.junit.Assert.fail

class TaskStateInternalTest {
    private final TaskStateInternal state = new TaskStateInternal()

    @Test
    public void defaultValues() {
        assertFalse(state.getExecuted())
        assertFalse(state.getExecuting())
        assertTrue(state.configurable)
        assertThat(state.getFailure(), nullValue())
        assertFalse(state.getDidWork())
        assertFalse(state.getSkipped())

    }

    protected void beforeRead(@SuppressWarnings("unused") EvaluationContext.ScopeContext context) {
        provider.getProducer().visitContentProducerTasks(producer -> {
            if (!producer.getState().getExecuted()) {
                throw new InvalidUserCodeException(
                    String.format("Querying the filtered value of %s before %s has completed is not supported", provider, producer)
                );
            }

    }

    protected void beforeRead(EvaluationContext.ScopeContext context) {
        provider.getProducer().visitContentProducerTasks(producer -> {
            if (!producer.getState().getExecuted()) {
                throw new InvalidUserCodeException(
                    String.format("Querying the mapped value of %s before %s has completed is not supported", provider, producer)
                );
            }

                // running tasks at the same time
                if (identifier.getTask().getState().getExecuted()) {
                    continue;
                }
                locateTask(identifier).queueForExecution();
            }
        }

        private BuildController buildControllerOf(BuildState target) {

import javax.inject.Inject

@SelfType(AbstractIntegrationSpec)
trait ToolingApiSpec {
    ToolingApiBackedGradleExecuter getToolingApiExecutor() {
        return (ToolingApiBackedGradleExecuter) getExecuter()
    }

    TestFile getProjectDir() {
        temporaryFolder.testDirectory
    }

    BuildTestFile singleProjectBuildInRootDir(String projectName, @DelegatesTo(BuildTestFile) Closure cl = {}) {

    private GradleExecuter executor
    private boolean ignoreCleanupAssertions

    private boolean enableProblemsApiCheck = false
    private BuildOperationsFixture buildOperationsFixture = null

    GradleExecuter getExecuter() {
        if (executor == null) {
            executor = createExecuter()
            if (ignoreCleanupAssertions) {
                executor.ignoreCleanupAssertions()
            }
        }