def file = tempDir.file('testFile')
        file.text = "content"

        when:
        def tree = new FileTreeAdapter(TestFiles.directoryFileTreeFactory().create(file), TestFiles.taskDependencyFactory(), TestFiles.patternSetFactory)

        then:
        assertSingleFileTree(tree)

        assertSingleFileTree(tree.matching(new Action<PatternFilterable>() {
            @Override

            TestUtil.objectFactory(),
            TestFiles.fileSystem(),
            TestFiles.patternSetFactory,
            TestFiles.deleter(),
            TestFiles.documentationRegistry(),
            TestFiles.taskDependencyFactory(),
            TestUtil.providerFactory(),
            TestDecompressionCoordinators.decompressionCoordinator(temporaryFileProvider.newTemporaryDirectory("cache")),
            null
        )
    }

import spock.lang.Subject

class EclipseModelTest extends Specification {

    @Subject
    EclipseModel model
    def project = Mock(ProjectInternal) {
        getTaskDependencyFactory() >> TestFiles.taskDependencyFactory()
    }

    def setup() {
        project.getObjects() >> TestUtil.objectFactory()
        model = TestUtil.newInstance(EclipseModel, project)

    def context = Mock(Consumer)
    def resolver = Mock(PathToFileResolver)
    def patternSetFactory = Mock(Factory)
    def visitor = new UnpackingVisitor(context, resolver, TestFiles.taskDependencyFactory(), patternSetFactory)

    def "resolves null"() {
        when:
        visitor.add(null)

        then:
        0 * context._
    }

    def "resolves String"() {

    def host = Mock(PropertyHost)
    def patternSetFactory = TestFiles.patternSetFactory
    def taskDependencyFactory = DefaultTaskDependencyFactory.forProject(taskResolver, (tasks) -> { })
    def collection = new DefaultConfigurableFileCollection("<display>", fileResolver, taskDependencyFactory, patternSetFactory, host)

    @Override
    AbstractFileCollection containing(File... files) {

    final PublishArtifactNotationParserFactory publishArtifactNotationParserFactory = new PublishArtifactNotationParserFactory(instantiator, provider, TestFiles.resolver(tmpDir.getTestDirectory()), TestFiles.taskDependencyFactory())
    final NotationParser<Object, PublishArtifact> publishArtifactNotationParser = publishArtifactNotationParserFactory.create();

    def setup() {
        Module module = Mock()

    @Shared
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def factory = new DefaultFileCollectionFactory(TestFiles.pathToFileResolver(tmpDir.testDirectory), TestFiles.taskDependencyFactory(), TestFiles.directoryFileTreeFactory(), Stub(Factory), Stub(PropertyHost), TestFiles.fileSystem())

    def "lazily queries contents of collection created from MinimalFileSet"() {
        def contents = Mock(MinimalFileSet)

        given:
        def projectIdentity = this.projectIdentity(coordinates.group, coordinates.name, coordinates.version)
        def artifact = new FileBasedIvyArtifact(new File("foo.txt"), projectIdentity, TestFiles.taskDependencyFactory())
        artifact.setConf("unknown")
        def descriptor = ivyDescriptor()
        descriptor.artifacts.set([artifact])
        def ivyFile = ivyFile(descriptor)

        and:

import org.gradle.api.internal.project.ProjectState
import org.gradle.api.internal.project.ProjectStateInternal
import org.gradle.api.internal.tasks.TaskContainerInternal
import org.gradle.api.internal.tasks.TaskDependencyFactory
import org.gradle.api.internal.tasks.TaskDependencyUsageTracker
import org.gradle.api.logging.Logger
import org.gradle.api.logging.LoggingManager
import org.gradle.api.model.ObjectFactory

        classloaderHierarchyHasher,
        executionEngine,
        inputFingerprinter,
        listenerManager,
        reservedFileSystemLocationRegistry,
        fileCollectionFactory,
        TestFiles.taskDependencyFactory(),
        Stub(PathToFileResolver)
    )

    def setup() {
        ProjectInternal project = Mock(ProjectInternal)
        task.getProject() >> project
        task.getState() >> state