private final FileCollectionInternal collection;
    private final Spec<? super File> filterSpec;

    public FilteredFileCollection(AbstractFileCollection collection, Spec<? super File> filterSpec) {
        super(collection.taskDependencyFactory, collection.patternSetFactory);
        this.collection = collection;
        this.filterSpec = filterSpec;
    }

    @Override

    @Rule TestNameTestDirectoryProvider dir = new TestNameTestDirectoryProvider(getClass())

    def processor = Mock(TestResultProcessor)
    def filterSpec = Spy(new TestFilterSpec([] as Set, [] as Set, [] as Set))
    def spec = Spy(new TestNGSpec(
        filterSpec,
        "Gradle suite", "Gradle test", null, -1, 1, false, null,
        [] as Set, [] as Set, [] as Set,

        ClassLoader parent = getClass().getClassLoader();
        FilteringClassLoader.Spec filterSpec = new FilteringClassLoader.Spec();
        filterSpec.allowPackage("org.gradle.tooling.internal.protocol");
        filterSpec.allowClass(TaskExecutionRequest.class);
        rootClassLoader = new FilteringClassLoader(parent, filterSpec);
    }

    @Override

        FilteringClassLoader.Spec filterSpec = new FilteringClassLoader.Spec();
        filterSpec.allowPackage("com.sun.tools");
        filterSpec.allowPackage("com.sun.source");
        return classLoaderFactory.createFilteringClassLoader(
            this.getClass().getClassLoader(),
            filterSpec
        );
    }

    public ContextAwareJavaCompiler getSystemJavaCompiler() {

public interface FileCollectionInternal extends FileCollection, TaskDependencyContainer {
    String DEFAULT_COLLECTION_DISPLAY_NAME = "file collection";

    @Override
    FileCollectionInternal filter(Spec<? super File> filterSpec);

    @Override
    FileTreeInternal getAsFileTree();

    /**
     * Returns a copy of this collection, with the given collection replaced with the value returned by the given supplier.
     *

/**
 * See [Configuration.filter].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().filter(filterSpec"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.filter(filterSpec: Spec<File>) =
    get().filter(filterSpec)


/**
 * See [Configuration.isEmpty].
 */

        return filter(Specs.convertClosureToSpec(filterClosure));
    }

    @Override
    public FileCollectionInternal filter(final Spec<? super File> filterSpec) {
        return new FilteredFileCollection(this, filterSpec);
    }

    /**
     * This is final - override {@link #visitContents(FileCollectionStructureVisitor)} instead to provide the contents.
     */
    @Override

	case *MapType:
		b1 := filterType(t.Key, f, export)
		b2 := filterType(t.Value, f, export)
		return b1 || b2
	case *ChanType:
		return filterType(t.Value, f, export)
	}
	return false
}

func filterSpec(spec Spec, f Filter, export bool) bool {
	switch s := spec.(type) {
	case *ValueSpec:
		s.Names = filterIdentList(s.Names, f)
		s.Values = filterExprList(s.Values, f, export)
		if len(s.Names) > 0 {
			if export {

                // TODO - when the collection is static then we should serialize the current contents of the collection
                elements.add(FilteredFileCollectionSpec(fileCollection.collection, fileCollection.filterSpec))
                false
            }

            is ProviderBackedFileCollection -> {
                // Guard against file collection created from a task provider such as `layout.files(compileJava)`

    }

    def "replace transformation result is evaluated lazily"() {
        given:
        Spec<File> filterSpec = Mock()
        collection.from(containing(new File("a.txt")))

        when:
        collection.replace { it.filter(filterSpec) }

        then:
        0 * filterSpec._
    }

    def "can set paths as convention to the collection"() {
        when: