}

    @Override
    public FileTree matching(final Closure filterConfigClosure) {
        return newFilteredFileTree(() -> {
            // For backwards compatibility, run the closure each time the file tree contents are queried
            return configure(filterConfigClosure, patternSetFactory.create());
        });
    }

    @Override
    public FileTree matching(final Action<? super PatternFilterable> filterConfigAction) {

import javax.annotation.Nullable;
import java.util.List;

public interface GraphSelectionCandidates {

    /**
     * Returns the set of variants to select from during attribute matching, or an empty list of this
     * component does not support attribute matching.
     */
    List<? extends VariantGraphResolveState> getVariantsForAttributeMatching();

    /**

     * @return the project.
     * @throws InvalidUserDataException When project cannot be selected due to some user input mismatch, or when there are no matching projects
     * or multiple matching projects.
     */
    <T extends ProjectIdentifier> T selectProject(String settingsDescription, ProjectRegistry<? extends T> registry) throws InvalidUserDataException;

    /**
     * Ignore attributes in {@code META-INF/MANIFEST.MF} within archives matching {@code name}. {@code name} is matched case-insensitively with the manifest attribute name.
     *
     * @since 6.6
     */
    void ignoreAttribute(String name);

    /**
     * Ignore keys in properties files stored in {@code META-INF} within archives matching {@code name}. {@code name} is matched case-sensitively with the property key.
     *

        expect:
        succeeds "help"

        where:
        queryMethod << getQueryMethods()
    }

    def "can execute query method #queryMethod.key from matching.configureEach"() {
        buildFile << """
            testContainer.matching({ it in testContainer.type }).configureEach {
                ${queryMethod.value}
            }
            toBeRealized.get()
        """

        expect:

        return filtered(createFilter(type));
    }

    @Override
    public PluginCollection<T> matching(Spec<? super T> spec) {
        return filtered(createFilter(spec));
    }

    @Override
    public PluginCollection<T> matching(Closure spec) {
        return matching(Specs.<T>convertClosureToSpec(spec));
    }

    @Override
    public Action<? super T> whenPluginAdded(Action<? super T> action) {

	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNewHorizontalPodAutoscaler("foo"),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{
			{"foo": "bar"},
		},
		// matching fields
		[]fields.Set{},
		// not matching fields
		[]fields.Set{
			{"metadata.name": "bar"},
			{"name": "foo"},
		},
	)
}

	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNetworkPolicy(),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{
			{"foo": "bar"},
		},
		// matching fields
		[]fields.Set{
			{"metadata.name": "foo"},
		},
		// not matching fields
		[]fields.Set{
			{"metadata.name": "bar"},
			{"name": "foo"},
		},
	)
}

import org.gradle.caching.internal.controller.operations.PackOperationDetails;
import org.gradle.caching.internal.controller.operations.PackOperationResult;
import org.gradle.caching.internal.controller.operations.UnpackOperationDetails;
import org.gradle.caching.internal.controller.operations.UnpackOperationResult;
import org.gradle.caching.internal.controller.service.BuildCacheLoadResult;

 * {@code GwtIncompatible}. This is more accurate for {@link Futures#catching}, which is available
 * under GWT but with a slightly different signature.
 *
 * <p>We can't use {@code PartiallyGwtIncompatible} because then the GWT compiler wouldn't recognize
 * it as a {@code GwtIncompatible} annotation. And for {@code Futures.catching}, we need the GWT