"the plugin is already on the classpath with an unknown version, so compatibility cannot be checked."
            );
        } else if (!existingVersion.equals(version)) {
            throw new InvalidPluginRequestException(
                pluginRequest,
                "The request for this plugin could not be satisfied because " +

    def "registers javaToolchains extension"() {
        expect:
        project.extensions.getByType(JavaToolchainService) == project.extensions.getByName("javaToolchains")
    }

    def "toolchain service dependencies are satisfied"() {
        expect:
        project.extensions.getByType(JavaToolchainService).launcherFor(Actions.doNothing()).get().executablePath.asFile.isFile()
    }

            this.preconditions = preconditions
        }

        @Override
        void evaluate() {
            Assume.assumeTrue("Not all Requirements ${preconditions*.simpleName} are satisfied", false)
        }
    }

     *
     * @param action The action to delegate filtered items to
     * @param filter The spec to use to filter items by
     * @param <T> The type of item the action expects
     * @return A new action that only forwards arguments on to the given filter is they are satisfied by the given spec.
     */

  // excluded from the requirement check. Possible values are:
  //
  // - In: the requirement is satisfied if at least one container exit code
  //   (might be multiple if there are multiple containers not restricted
  //   by the 'containerName' field) is in the set of specified values.
  // - NotIn: the requirement is satisfied if at least one container exit code
  //   (might be multiple if there are multiple containers not restricted

	if exactHandler, ok := h.pathToHandler[r.URL.Path]; ok {
		klog.V(5).Infof("%v: %q satisfied by exact match", h.muxName, r.URL.Path)
		exactHandler.ServeHTTP(w, r)
		return
	}

	for _, prefixHandler := range h.prefixHandlers {
		if strings.HasPrefix(r.URL.Path, prefixHandler.prefix) {
			klog.V(5).Infof("%v: %q satisfied by prefix %v", h.muxName, r.URL.Path, prefixHandler.prefix)
			prefixHandler.handler.ServeHTTP(w, r)

            challenge.charset,
          )
        return request.newBuilder()
          .header(credentialHeader, credential)
          .build()
      }
    }

    return null // No challenges were satisfied!
  }

  @Throws(IOException::class)
  private fun Proxy.connectToInetAddress(
    url: HttpUrl,
    dns: Dns,
  ): InetAddress {
    return when (type()) {

package constraint

import (
	"strconv"
	"strings"
)

// GoVersion returns the minimum Go version implied by a given build expression.
// If the expression can be satisfied without any Go version tags, GoVersion returns an empty string.
//
// For example:
//
//	GoVersion(linux && go1.22) = "go1.22"
//	GoVersion((linux && go1.22) || (windows && go1.20)) = "go1.20" => go1.20

     *
     * @since 7.4
     */
    void notCompatibleWithConfigurationCache(String reason);

    /**
     * <p>Execute the task only if the given spec is satisfied. The spec will be evaluated at task execution time, not
     * during configuration. If the Spec is not satisfied, the task will be skipped.</p>
     *
     * <p>You may add multiple such predicates. The task is skipped if any of the predicates return false.</p>
     *

        "MappingProvider"         | { p, m -> new MappingProvider(Integer, p, m) }
    }

    def "runs the side effect when changing provider is filtered with #description and spec is satisfied"() {
        given:
        def sideEffect = Mock(ValueSupplier.SideEffect)
        def counter = new AtomicInteger(23)
        def parent = Providers.changing { counter.getAndIncrement() }