this.source = source;
            this.filter = filter;
        }

        @Override
        public FileCollectionInternal toFileCollection(FileCollectionFactory fileCollectionFactory) {
            return source.toFileCollection(fileCollectionFactory).filter(filter);
        }
    }

 */
public interface FileCollectionExecutionTimeValue {

    FileCollectionInternal toFileCollection(FileCollectionFactory fileCollectionFactory);

                                                  ClassPathRegistry classPathRegistry,
                                                  FileCollectionFactory fileCollectionFactory,
                                                  RuntimeShadedJarFactory runtimeShadedJarFactory,
                                                  Interner<String> stringInterner) {

    def resolver = TestFiles.resolver(tmpDir.testDirectory)
    def fileCollectionFactory = TestFiles.fileCollectionFactory(tmpDir.testDirectory)
    def instantiator = TestUtil.instantiatorFactory()
    def factory =
        DefaultExecActionFactory
            .of(resolver, fileCollectionFactory, executorFactory, TestFiles.tmpDirTemporaryFileProvider(tmpDir.createDir("tmp")))
            .forContext()

    def fileCollectionFactory = TestFiles.fileCollectionFactory()
    def attributesFactory = AttributeTestUtil.attributesFactory()
    def displayName = Describables.of("<config>")
    def publications = new DefaultConfigurationPublications(displayName, artifacts, {
        allArtifacts
    }, parentAttributes, TestUtil.instantiatorFactory().decorateLenient(), artifactNotationParser, capabilityNotationParser, fileCollectionFactory, attributesFactory,

        BuildOperationRunner buildOperationRunner,
        ClassLoaderHierarchyHasher classLoaderHierarchyHasher,
        ExecutionHistoryStore executionHistoryStore,
        FileCollectionFactory fileCollectionFactory,
        TaskDependencyFactory taskDependencyFactory,
        FileOperations fileOperations,
        ListenerManager listenerManager,

 * limitations under the License.
 */

package org.gradle.api.internal.file

import spock.lang.Specification

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

class EmptyFileCollectionExecutionTimeValueTest extends Specification {

    def "EmptyFileCollection supports execution time value"() {
        given:
        def collection = new EmptyFileCollection("foo")

    private List<CommandLineArgumentProvider> jvmArgumentProviders;

    @Inject
    public DefaultJavaForkOptions(PathToFileResolver resolver, FileCollectionFactory fileCollectionFactory, JavaDebugOptions debugOptions) {
        super(resolver);
        options = new JvmOptions(fileCollectionFactory, debugOptions);
    }

    @Override
    public List<String> getAllJvmArgs() {
        if (hasJvmArgumentProviders(this)) {

        }
        manifestInternal.setContentCharset(manifestContentCharset);
        return manifestInternal;
    }

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

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

    /**

    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")