value.call() == null
        value.taskDependencies == TaskDependencyContainer.EMPTY
        value.attachProducer(Stub(Task))
        value.maybeFinalizeValue()
    }

    def "creates value for other value"() {
        expect:
        def value = StaticValue.of("abc")
        value.call() == "abc"
        value.taskDependencies == TaskDependencyContainer.EMPTY
        value.attachProducer(Stub(Task))

) : TaskDependencyUsageTracker {
    override fun onTaskDependencyUsage(taskDependencies: Set<Task>) {
        checkForCoupledProjects(taskDependencies)
        reportProjectIsolationProblemOnApiUsage()
    }

    private
    fun checkForCoupledProjects(taskDependencies: Set<Task>) {
        taskDependencies.forEach { task ->
            val otherProject = task.project as ProjectInternal

        def main = project.tasks.generateGrammarSource
        main instanceof AntlrTask
        project.tasks.compileJava.taskDependencies.getDependencies(null).contains(main)

        def test = project.tasks.generateTestGrammarSource
        test instanceof AntlrTask
        project.tasks.compileTestJava.taskDependencies.getDependencies(null).contains(test)

        when:
        project.sourceSets.create('custom')

        then:

        assert project.tasks.eclipse.taskDependencies.getDependencies(project.tasks.eclipse).contains(eclipseJdt)
        assert eclipseJdt.outputFile == project.file('.settings/org.eclipse.jdt.core.prefs')
    }

    void assertThatCleanEclipseDependsOn(Project project, Task dependsOnTask) {
        assert dependsOnTask instanceof Delete

    def "fails when task action uses Task.taskDependencies and feature preview is enabled"() {
        settingsFile """
            enableFeaturePreview 'STABLE_CONFIGURATION_CACHE'
        """
        buildFile """
            task broken {
                doLast {
                    taskDependencies
                }
            }
        """

        when:

                }

                override fun visitInputProperty(propertyName: String, value: PropertyValue, optional: Boolean) {

                    val taskDependencies = value.taskDependencies
                    taskDependencies.visitDependencies(
                        object : AbstractTaskDependencyResolveContext() {
                            override fun add(dependency: Any) {

        return compileModules;
    }

    public void addTaskDependency(TaskDependency taskDependency) {
        taskDependencies.add(taskDependency);
    }

    public List<TaskDependency> getTaskDependencies() {
        return taskDependencies;
    }

    public List<XcodeBinary> getBinaries() {
        return binaries;
    }

        def parentIdeaModule = project.tasks.ideaModule
        def childIdeaModule = childProject.tasks.ideaModule

        childIdeaModule.taskDependencies.getDependencies(childIdeaModule).contains(parentIdeaProject)
        !parentIdeaModule.taskDependencies.getDependencies(parentIdeaModule).contains(parentIdeaProject)
    }

    def "project language level set to highest module sourceCompatibility"() {
        when:

        }

        @SuppressWarnings("unchecked")
        List<TaskIdentity> taskDependencies = (List<TaskIdentity>) nodeDependencies;
        return taskDependencies;
    }

    @Override
    public List<TaskIdentity> getMustRunAfter() {
        return mustRunAfter;
    }

    @Override

        then:
        def buildTask = project.tasks.getByName("eclipseClosedDependencies")
        buildTask != null
        buildTask.taskDependencies.getDependencies(buildTask).collect { it.path }.sort() == ([':child1:jar', ':child1:testJar'])
        project.getGradle().getStartParameter().getTaskNames() == ['eclipseClosedDependencies']
    }