return DefaultResourceHandler.Factory.from(
            fileResolver,
            taskDependencyFactory,
            fileSystem,
            temporaryFileProvider,

    def file2 = new File("2")
    def file3 = new File("3")

    private UnionFileCollection newUnionFileCollection(FileCollectionInternal... source) {
        new UnionFileCollection(TestFiles.taskDependencyFactory(), source)
    }

    def containsUnionOfAllSourceCollections() {
        def source1 = new TestFileCollection(file1, file2)
        def source2 = new TestFileCollection(file2, file3)

        expect:

            }
        };
        GeneratedSingletonFileTree tree = tree("file.txt", fileAction);

        FileTreeAdapter fileTreeAdapter = new FileTreeAdapter(tree, TestFiles.taskDependencyFactory(), TestFiles.getPatternSetFactory());
        File file = rootDir.file("file.txt");

        assertTrue(fileTreeAdapter.contains(file));
        assertTrue(fileTreeAdapter.contains(file));

            FileResolver fileResolver,
            TaskDependencyFactory taskDependencyFactory
        ) {
            return new PublishArtifactNotationParserFactory(
                instantiator,
                metaDataProvider,
                fileResolver,
                taskDependencyFactory
            );
        }

        @Provides

        buildOperationRunner,
        new PublishArtifactNotationParserFactory(
                instantiator,
                metaDataProvider,
                TestFiles.resolver(),
                TestFiles.taskDependencyFactory(),
        ),
        immutableAttributesFactory,
        Stub(ResolveExceptionMapper),
        new AttributeDesugaring(AttributeTestUtil.attributesFactory()),
        userCodeApplicationContext,

import org.gradle.api.internal.resources.ApiTextResourceAdapter
import org.gradle.api.internal.tasks.DefaultTaskDependencyFactory
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.model.ObjectFactory
import org.gradle.api.plugins.PluginContainer
import org.gradle.api.provider.ProviderFactory

        thisBuild,
        graphListeners,
        taskExecutionListeners,
        listenerRegistrationListener,
        Stub(ServiceRegistry) {
            get(TaskDependencyFactory) >> TestFiles.taskDependencyFactory()
        }
    )
    WorkerLeaseRegistry.WorkerLeaseCompletion parentWorkerLease
    def executedTasks = []
    def failures = []

    def setup() {

        ["flavors", new DefaultFlavorContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)],
        ["source sets", new DefaultSourceSetContainer(TestFiles.resolver(), TestFiles.taskDependencyFactory(), null, TestUtil.instantiatorFactory().decorateLenient(), TestUtil.objectFactory(), CollectionCallbackActionDecorator.NOOP)]
    ]

    def cleanup() {
        IncubationLogger.reset()
    }

        userCodeApplicationContext,
        projectStateRegistry,
        Mock(WorkerThreadRegistry),
        TestUtil.domainObjectCollectionFactory(),
        calculatedValueContainerFactory,
        TestFiles.taskDependencyFactory()
    )
    private DefaultConfigurationContainer configurationContainer = new DefaultConfigurationContainer(
        instantiator,
        domainObjectCollectionCallbackActionDecorator,

    }

    static def assertSetContainsForAllTypes(MinimalFileTree set, Iterable<String> filenames) {
        assertSetContainsForAllTypes(new FileTreeAdapter(set, TestFiles.taskDependencyFactory(), TestFiles.patternSetFactory), filenames)
    }

    static def assertSetContainsForFileSet(FileCollection set, String... filenames) {