@Override
    public File getFile() {
        return project.getProjectFile().getLocation();
    }

    @Override
    public Set<? extends Task> getGeneratorTasks() {
        return TaskDependencyUtil.getDependenciesForInternalUse(project);
    }

    public List<VisualStudioProjectConfigurationMetadata> getConfigurations() {
        return CollectionUtils.collect(
            project.getConfigurations(),

            if (node instanceof TaskDependency) {
                TaskDependency taskDependency = (TaskDependency) node;
                Set<? extends Task> dependenciesForInternalUse = TaskDependencyUtil.getDependenciesForInternalUse(taskDependency, originalTask);

                for (Task dependencyTask : dependenciesForInternalUse) {
                    resolveAction.execute(dependencyTask);
                }
                return true;

        public AntTargetsTaskDependency(List<String> taskDependencyNames) {
            this.taskDependencyNames = taskDependencyNames;
        }

        @Override
        public Set<? extends Task> getDependenciesForInternalUse(@Nullable Task task) {
            Set<Task> tasks = Sets.newHashSetWithExpectedSize(taskDependencyNames.size());
            for (String dependedOnTaskName : taskDependencyNames) {

    @Override
    public void builtBy(Object... tasks) {
        buildTaskDependencies.add(tasks);
    }

    @Override
    public boolean hasBuildDependencies() {
        return buildTaskDependencies.getDependenciesForInternalUse(buildTask).size() > 0;
    }

    @Nullable
    @Override
    public Task getCheckTask() {
        return checkTask;
    }

    @Override
    public void setCheckTask(@Nullable Task checkTask) {

        def tracker = Mock(TaskDependencyUsageTracker)
        def dependency = DefaultTaskDependencyFactory.forProject(resolver, tracker).configurableDependency()

        when:
        dependency.getDependenciesForInternalUse(null)
        then:
        0 * tracker.onTaskDependencyUsage(_)

        when:
        dependency.getDependencies(null)
        then:
        1 * tracker.onTaskDependencyUsage(_)
    }

                this.notBuildable = notBuildable;
            }

            @Override
            public void execute(Task task) {
                Set<? extends Task> taskDependencies = TaskDependencyUtil.getDependenciesForInternalUse(task.getTaskDependencies(), task);

                if (taskDependencies.isEmpty()) {
                    TreeFormatter formatter = new TreeFormatter();

        then:
        0 * builtBy._

        when:
        def tasks = collection.buildDependencies.getDependencies(null)

        then:
        tasks == [task] as Set
        1 * builtBy.getDependenciesForInternalUse(_) >> [task]
        0 * _
    }

    def "constructs a configurable collection"() {
        expect:
        def collection = factory.configurableFiles("some collection")
        collection.files.empty

            eclipseProject.setAutoBuildTasks(!TaskDependencyUtil.getDependenciesForInternalUse(eclipseModel.getAutoBuildTasks(), null).isEmpty());

            org.gradle.plugins.ide.eclipse.model.Project xmlProject = new org.gradle.plugins.ide.eclipse.model.Project(new XmlTransformer());