def selector = newSelector(UTIL, "1.0")
        def matching = newId(UTIL, "1.0")

        def differentGroup = newId("xorg", "util", "1.0")
        def differentName = newId("org", "xutil", "1.0")
        def differentVersion = newId("org", "xutil", "x1.0")

        expect:
        selector.matchesStrictly(matching)

        !selector.matchesStrictly(differentGroup)

public enum CachingDisabledReasonCategory {
    /**
     * Reason for disabled caching is not known.
     */
    UNKNOWN,

    /**
     * Caching has not been enabled for the build.
     */
    BUILD_CACHE_DISABLED,

    /**
     * Caching has not been enabled for the task.
     */
    NOT_ENABLED_FOR_TASK,

    /**
     * Caching has not been enabled for the work.
     *
     * @since 8.3
     */

import org.gradle.caching.internal.controller.service.BuildCacheServicesConfiguration;
import org.gradle.caching.internal.origin.OriginMetadataFactory;
import org.gradle.caching.internal.packaging.BuildCacheEntryPacker;
import org.gradle.caching.local.DirectoryBuildCache;
import org.gradle.caching.local.internal.DirectoryBuildCacheService;

go list -m -e -f $FMT --versions example.com/retract/self/pseudo
stdout '^example.com/retract/self/pseudo ""$'

go list -m -e -f $FMT --versions example.com/retract/self/pseudo@latest
stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: no matching versions for query \\"latest\\"" "latest"$'

-- go.mod --

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

        expect:

func (b *bufferedBackend) processIncomingEvents(stopCh <-chan struct{}) {
	defer close(b.buffer)

	var (
		maxWaitChan  <-chan time.Time
		maxWaitTimer *time.Timer
	)
	// Only use max wait batching if batching is enabled.
	if b.maxBatchSize > 1 {
		maxWaitTimer = time.NewTimer(b.maxBatchWait)
		maxWaitChan = maxWaitTimer.C
		defer maxWaitTimer.Stop()
	}

	for {
		func() {

        graph.nodeDiscovered(a)

        then:
        1 * listener.onDiscovered(a)
        0 * listener.onDiscovered(_)
    }

    def "notifies listener of new node with matching path"() {
        def listener = allAcceptingListener()

        def a = node("a")
        def b = node("b")
        def c = node("c")

        given:
        listener.getPath() >> b.path

                List<String> matching = listedVersions.stream()
                    .filter(version -> regexPattern.matcher(currentVersionListPattern.getPath().replace(REVISION_TOKEN, version)).matches())
                    .collect(Collectors.toList());
                if (!matching.isEmpty()) {
                    LOGGER.debug("Filtered out {} from results for overlapping match with {}", matching, otherVersionListPattern);

    dependsOn tasks.withType(PublishToIvyRepository).matching {
        it.repository == publishing.repositories.external
    }
}
tasks.register('publishToInternalRepository') {
    group "publishing"
    description "Publishes all Ivy publications to Ivy repository 'internal'."
    dependsOn tasks.withType(PublishToIvyRepository).matching {
        it.repository == publishing.repositories.internal
    }
}

# we should add that one particular module but not resolve import ambiguities.
#
# In particular, if the module that previously provided the package has a
# matching version, but does not itself match the pattern and contains no
# matching packages, we should not change its version. (We should *not* downgrade
# module example.net/split to v0.1.0, despite the fact that