def toolchain = queryService.findMatchingToolchain(filter)

        then:
        toolchain.vendor.knownVendor == JvmVendor.KnownJvmVendor.BELLSOFT
    }

    def "ignores invalid toolchains when finding a matching one"() {
        given:
        def queryService = createQueryServiceWithInstallations(["8.0", "8.0.242.hs-adpt", "8.0.broken"])

        when:
        def filter = createSpec(JavaLanguageVersion.of(8))

	// at least "minFeasibleNodesToFind" feasible nodes no matter what the value of this flag is.
	// Example: if the cluster size is 500 nodes and the value of this flag is 30,
	// then scheduler stops finding further feasible nodes once it finds 150 feasible ones.
	// When the value is 0, default percentage (5%--50% based on the size of the cluster) of the
	// nodes will be scored. It is overridden by profile level PercentageOfNodesToScore.

        1 * connection.markSuspect()
        1 * connection.dispatch({ it instanceof CloseInput })
        1 * connection.stop()
        0 * connection._
    }

    def "does not loop forever finding usable daemons"() {
        given:
        connector.connect(compatibilitySpec) >> connection
        connector.startDaemon(compatibilitySpec) >> connection
        connection.daemon >> Stub(DaemonConnectDetails)

		//
		// Notably, this works even if we can't run 'go env GOROOT' as a
		// subprocess.

		cwd, err := os.Getwd()
		if err != nil {
			gorootErr = fmt.Errorf("finding GOROOT: %w", err)
			return
		}

		dir := cwd
		for {
			parent := filepath.Dir(dir)
			if parent == dir {
				// dir is either "." or only a volume name.

[[sec:abm_algorithm]]
=== Variant attribute matching algorithm

Finding the best variant can get complicated when there are many different variants available for a component and many different attributes. Gradle's dependency resolution engine performs the following algorithm when finding the best result (or failing):

			}
		}
	}

	for _, ifi := range []*Interface{loopbackInterface(), nil} {
		// Note that multicast interface assignment by system
		// is not recommended because it usually relies on
		// routing stuff for finding out an appropriate
		// nexthop containing both network and link layer
		// adjacencies.
		if ifi == nil || !*testIPv4 {
			continue
		}
		for _, tt := range ipv4MulticastListenerTests {
			var err error

         * unresolvable dependencies defined in the configuration.
         *
         * We can probably do better by inspecting the runtime classpath and finding out which
         * Configurations are part of it and only traversing any extra file collections manually.
         */
        private Collection<File> collectClasspathFiles(SourceSet sourceSet) {

// Bisect prints tracing logs to standard error and the minimal change sets
// to standard output.
//
// # Command Line Flags
//
// Bisect supports the following command-line flags:
//
//	-max=M
//
// Stop after finding M minimal change sets. The default is no maximum, meaning to run until
// all changes that provoke a failure have been identified.
//
//	-maxset=S
//
// Disallow change sets larger than S elements. The default is no maximum.

This chapter is about finding out why a cache miss happened.
If you have a cache hit which you didn't expect we suggest to declare whatever change you expected to trigger the cache miss as an input to the task.

[[finding_problems]]
== Finding problems with task output caching

// ReadSlice reads until the first occurrence of delim in the input,
// returning a slice pointing at the bytes in the buffer.
// The bytes stop being valid at the next read.
// If ReadSlice encounters an error before finding a delimiter,
// it returns all the data in the buffer and the error itself (often io.EOF).
// ReadSlice fails with error [ErrBufferFull] if the buffer fills without a delim.