[
            'filter { it.path.endsWith "ok" }',
            'matching(patternSet)',
            'matching(patternSet).filter { it.file }',
            'matching(patternSet).asFileTree.filter { it.file }',
            'filter { it.path.endsWith "ok" }.asFileTree',
            'filter { it.file }.asFileTree.matching(patternSet)',
        ]
    }

    HISTORICAL_PERFORMANCE("Historical Performance", "Once a week: Run performance tests for multiple Gradle versions", "HistoricalPerformance"),
    EXPERIMENTAL_VFS_RETENTION("Experimental FS Watching", "On demand checks to run tests with file system watching enabled", "ExperimentalVfsRetention"),
    EXPERIMENTAL_PERFORMANCE("Experimental Performance", "Try out new performance test running", "ExperimentalPerformance");

    val id: String

	// badCharSkip[b] is len(pattern).
	//
	// Whenever a mismatch is found with byte b in the text, we can safely
	// shift the matching frame at least badCharSkip[b] until the next time
	// the matching char could be in alignment.
	badCharSkip [256]int

	// goodSuffixSkip[i] defines how far we can shift the matching frame given
	// that the suffix pattern[i+1:] matches, but the byte pattern[i] does
	// not. There are two cases to consider:
	//

               .assertHasCause("Cannot find a Java installation on your machine matching this tasks requirements: {languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific} for ")
               .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +

Enables project isolation, which enables configuration caching.
+
_Default is `false`._

`org.gradle.vfs.verbose=(true,false)`::
Configures verbose logging when <<file_system_watching.adoc#sec:daemon_watch_fs,watching the file system>>.
+
_Default is `false`._

`org.gradle.vfs.watch=(true,false)`::
Toggles <<file_system_watching.adoc#sec:daemon_watch_fs,watching the file system>>.

    /**
     * Returns a {@link BinaryProvider} that contains the single binary matching the specified type and specification. The binary will be in the finalized state. The provider can be used to apply configuration to the element before it is finalized.
     *
     * <p>Querying the return value will fail when there is not exactly one matching binary.
     *
     * @param type type to match

        unchanged
    }

    def "matching etags are enough to be considered equal"() {
        given:
        configureMetadata(local, "abc", null, -1)
        configureMetadataForEtagMatch(remote, "abc")

        when:
        compare(local, remote)

        then:
        unchanged
    }

    def "non matching etags, no mod date, but matching content length does not match"() {
        given:

                "matcher_tree": {
                  "input": {
                    "name": "ip",
                    "typed_config": {
                      "@type": "type.googleapis.com/envoy.extensions.matching.common_inputs.network.v3.DestinationIPInput"
                    }
                  },
                  "custom_match": {
                    "name": "ip",
                    "typed_config": {

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apiserver/pkg/admission"
	"k8s.io/apiserver/pkg/admission/plugin/policy/matching"
)

// Matcher is used for matching ValidatingAdmissionPolicy and ValidatingAdmissionPolicyBinding to attributes
type PolicyMatcher interface {
	admission.InitializationValidator

                }
            }
        """

        expect:
        succeeds "verify"
    }

    def "chained lookup of testContainer.withType.matching"() {
        buildFile << """
            testContainer.withType(testContainer.type).matching({ it.name.endsWith("foo") }).all { element ->
                assert element.name in ['foo', 'barfoo']
            }

            testContainer.register("foo")