}
                }
            }
            return result;
        }

        @Override
        public TaskDependency getBuildDependencies() {
            return importPathConfig.getBuildDependencies();
        }
    }

            taskDependency.getDependencies(task);
    }

    public static Set<? extends Task> getDependenciesForInternalUse(Buildable buildable) {
        return getDependenciesForInternalUse(buildable.getBuildDependencies(), null);
    }

        EclipseModelBuilder.ClasspathElements elements = EclipseModelBuilder.gatherClasspathElements(projectOpenStatus, eclipseClasspath, false);
        List<TaskDependency> buildDependencies = new ArrayList<>(elements.getBuildDependencies());

        for (Project childProject : getChildProjectsForInternalUse(project)) {
            buildDependencies.addAll(populate(childProject));
        }
        return buildDependencies;
    }

     */
    IvyArtifactName getName();

    /**
     * Collects the build dependencies of this artifact, which are required to build this artifact
     */
    TaskDependency getBuildDependencies();

    /**
     * Allows metadata with non-standard packaging to add a "fallback" artifact, to be resolved only when resolution fails.
     *
     * Typical use-cases are:
     * <ol>

     * Returns the location of the generated solution file.
     */
    @Override
    @Internal
    Provider<RegularFile> getLocation();

    @Override
    @Internal
    @Incubating
    TaskDependency getBuildDependencies();

    @Override
    @Internal
    String getName();

    @Override
    @Internal
    String getDisplayName();

        return file;
    }

    @Override
    public void builtBy(Object... tasks) {
        throw new IllegalStateException();
    }

    @Nonnull
    @Override
    public TaskDependency getBuildDependencies() {
        throw new IllegalStateException();
    }

    @Override
    public boolean shouldBePublished() {
        return shouldBePublished.get();
    }

    @Override

        println "resolve-not-transitive: " + dep.resolve(false).collect { it.name }
        println "resolve-transitive: " + dep.resolve(true).collect { it.name }
        dep.getBuildDependencies()
    }
}
"""

        when:

    }

    @Override
    public TaskDependency getBuildDependencies() {
        return taskDependencyFactory.visitingDependencies(context -> context.add(provider));
    }

    @Override
    public boolean shouldBePublished() {
        return getDelegate().shouldBePublished();

        1 * visitor.visitCollection(FileCollectionInternal.OTHER, filtered)
        0 * _
    }

    void hasNoDependencies() {
        expect:
        assertThat(new TestFileCollection().getBuildDependencies().getDependencies(null), isEmpty())
    }

    void fileTreeHasSameDependenciesAsThis() {
        TestFileCollectionWithDependency collection = new TestFileCollectionWithDependency(dependency)

        throw new UnsupportedOperationException();
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        context.add(dependencyMetadata.getFiles().getBuildDependencies());
    }

    private static class SingletonFileResolvedVariant implements ResolvedVariant, ResolvedArtifactSet, Artifacts, ResolvedVariantSet {
        private final ComponentArtifactIdentifier artifactIdentifier;