import ${PropertyWalker.name}
            import ${FileCollectionFactory.name}

            class CustomTask extends DefaultTask {
                @Optional @$annotation.simpleName input
                @TaskAction void doSomething() {
                    def fileCollectionFactory = services.get(FileCollectionFactory)

                );
            }

            return null;
        }));

        appDir = getObjectFactory().directoryProperty();
    }

    private FileCollectionFactory fileCollectionFactory() {
        return getServices().get(FileCollectionFactory.class);
    }

    private OutputChangeListener outputChangeListener() {
        return getServices().get(OutputChangeListener.class);
    }

        val dependencyManagementServices = gradle.serviceOf<DependencyManagementServices>()
        val fileCollectionFactory = gradle.serviceOf<FileCollectionFactory>()
        val dependencyResolutionServices = dependencyManagementServices.create(
            gradle.serviceOf<FileResolver>(),
            fileCollectionFactory,
            gradle.serviceOf<DependencyMetaDataProvider>(),

    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def resolver = TestFiles.resolver(tmpDir.testDirectory)
    def fileCollectionFactory = TestFiles.fileCollectionFactory(tmpDir.testDirectory)
    def factory = new DefaultFilePropertyFactory(host, resolver, fileCollectionFactory)
    // Make sure that `baseDir` isn't the same as the base for the resolver.
    def baseDir = tmpDir.testDirectory.createDir("base")

    private final DefaultProjectDependencyFactory projectDependencyFactory;
    private final FeatureFlags featureFlags;
    private final ExecutionEngine engine;
    private final FileCollectionFactory fileCollectionFactory;
    private final InputFingerprinter inputFingerprinter;
    private final ImmutableAttributesFactory attributesFactory;
    private final CapabilityNotationParser capabilityNotationParser;

        return execFactory.forContext()
            .withFileResolver(fileResolver)
            .withFileCollectionFactory(fileCollectionFactory)
            .withInstantiator(instantiator)

        ft.files.isEmpty()
    }

    def "contains all files"() {
        given:
        def a1 = file("a/1.txt") << "a/1"
        def b1 = file("b/1.txt") << "b/1"
        def fileResolver = TestFiles.fileCollectionFactory(testDirectory)

        when:
        def a = fileResolver.resolving(["a"]).asFileTree
        def b = fileResolver.resolving(["b"]).asFileTree
        def composite = newCompositeFileTree([a, b])

 * limitations under the License.
 */

package org.gradle.nativeplatform.internal;

import org.gradle.api.file.FileCollection;
import org.gradle.api.internal.file.FileCollectionFactory;
import org.gradle.nativeplatform.StaticLibraryBinary;
import org.gradle.nativeplatform.StaticLibraryBinarySpec;
import org.gradle.nativeplatform.tasks.CreateStaticLibrary;

    private final BuildActionExecutor<BuildActionParameters, BuildRequestContext> embeddedExecutor;
    private final ServiceRegistry sharedServices;
    private final FileCollectionFactory fileCollectionFactory;
    private final GlobalUserInputReceiver userInputReceiver;
    private final UserInputReader userInputReader;

    private final JvmVersionDetector jvmVersionDetector;

import spock.lang.Specification

import static org.gradle.api.internal.file.TestFiles.fileCollectionFactory

class DefaultPublishArtifactSetTest extends Specification {
    final store = new DefaultDomainObjectSet<PublishArtifact>(PublishArtifact, CollectionCallbackActionDecorator.NOOP)
    final set = new DefaultPublishArtifactSet('artifacts', store, fileCollectionFactory(), TestFiles.taskDependencyFactory())