e2.message == message
            .replace("tasks that match", "excluded tasks that match")
            .replace("matching tasks", "matching excluded tasks")

        where:
        path        | message
        ""          | "Cannot locate matching tasks for an empty path. The path should include a task name (for example ':help' or 'help')."

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * A {@link ArtifactVariantSelector} that uses attribute matching to select a matching set of artifacts.
 *
 * If no producer variant is compatible with the requested attributes, this selector will attempt to construct a chain of artifact

	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNewResourceClaimParameters("foo"),
		// 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"},
		},
	)

# but without actually fuzzing the target (by using a non-matching pattern)
go test -fuzz=xxx -race -v
! stderr 'race detected during execution of test'

# Test with just race instrumentation enabled
go test -race -v
! stderr 'race detected during execution of test'

# Test with coverage and race instrumentation enabled, and a matching fuzz
# pattern
go test -fuzz=FuzzRace -race -v -fuzztime=200x

import java.util.function.Predicate;

/**
 * A feature of a cache-like storage that provides an ability to invalidate the items matching a predicate.
 * @param <T> the type of the stored items.
 */
public interface ConditionalInvalidation<T> {
    /**
     * Instructs the cache to drop the stored items matching the predicate.
     */
    void invalidateItemsMatching(Predicate<T> predicate);

 * round of attribute matching to select a variant containing artifacts.
 *
 * This class is intentionally named similarly to {@link GraphVariantSelector}, as it has a
 * similar purpose.  An instance of {@link ResolutionFailureHandler} should be provided
 * to allow the caller to handle failures in a consistent way - all matching failures should be reported via
 * calls to that instance.
 */

        NamedDomainObjectSet<T> allWithType = platforms.withType(type);
        T matching = CollectionUtils.findFirst(allWithType, new Spec<T>() {
            @Override
            public boolean isSatisfiedBy(T element) {
                return element.getName().equals(target);
            }
        });

        if (matching == null) {

	// A path-literal query results in only one set: the path itself, which
	// may resolve to either a package path or a module path.
	//
	// A wildcard query results in one set for each matching module path, each
	// module for which the matching version contains at least one matching
	// package, and (if no other modules match) one candidate set for the pattern
	// overall if no existing match is identified in the build list.
	//

	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validNewClass("foo"),
		// 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"},
		},
	)

	test.TestWatch(
		validNewResourceSlice("foo"),
		// 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"},
		},
	)