*/
    public enum SortPolicy {
        /**
         * By name, in default Java sort order.
         */
        BY_NAME,

        /**
         * Group contents will not be sorted, and will remain in the
         * order they were added.
         */
        UNSORTED;
    }

    def executor = new DefaultPlanExecutor(new DefaultWorkerLimits(1), executorFactory, workerLeaseService, cancellationHandler, coordinationService, new DefaultInternalOptions([:]))

    def "executes tasks until no further tasks remain"() {
        def gradle = Mock(Gradle)
        def project = Mock(Project)
        def node = Mock(LocalTaskNode)
        def task = Mock(TaskInternal)
        def state = Mock(TaskStateInternal)

     * about Java classpath or anything alike. How artifact is being consumed depends heavily on the consumer project.
     * Resolver is and will remain agnostic of consumer project use cases.
     */
    public static final String CONSTITUTES_BUILD_PATH = "constitutesBuildPath";

    /**

   * waiting for the running calls to complete.
   *
   * If more than [maxRequests] requests are in flight when this is invoked, those requests will
   * remain in flight.
   */
  var maxRequests = 64
    get() = this.withLock { field }
    set(maxRequests) {
      require(maxRequests >= 1) { "max < 1: $maxRequests" }
      this.withLock {
        field = maxRequests

			break
		}
		if im[0] == ',' {
			im = im[1:]
			continue
		}
		if im[0] == '*' {
			return condTrue
		}
		etag, remain := scanETag(im)
		if etag == "" {
			break
		}
		if etagStrongMatch(etag, w.Header().get("Etag")) {
			return condTrue
		}
		im = remain
	}

	return condFalse
}

func checkIfUnmodifiedSince(r *Request, modtime time.Time) condResult {

        // This code path will always be a no-op following the changes in DefaultImmutableAttributesFactory
        // However this code will have to remain forever while the other one should be removed at some point (Gradle 7.0?)
        for (MutableComponentVariant variant : metaDataFromResource.getMutableVariants()) {
            ImmutableAttributes attributes = variant.getAttributes();

        expect: "unrealized elements remain as such"
        container.index.asMap().size() == 2
        container.index.pendingAsMap.size() == 2

        when: "filter the list via the `named` method"
        def filtered = container.named { it.contains("2") }

        then: "unrealized elements remain as such"
        container.index.asMap().size() == 2

	case cfg.Interval > 0 && cfg.Count > 0:
		// TCP_KEEPALIVE_ABORT_THRESHOLD will be recalculated only when both TCP_KEEPINTVL
		// and TCP_KEEPCNT are set, otherwise it will remain the default value.
		tcpKeepAliveAbortThreshold = cfg.Interval * time.Duration(cfg.Count)
	}

	tcpKeepAlive, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
	if err != nil {
		t.Fatal(err)

// phielimValue tries to convert the phi v to a copy.
func phielimValue(v *Value) bool {
	if v.Op != OpPhi {
		return false
	}

	// If there are two distinct args of v which
	// are not v itself, then the phi must remain.
	// Otherwise, we can replace it with a copy.
	var w *Value
	for _, x := range v.Args {
		if x == v {
			continue
		}
		if x == w {
			continue
		}
		if w != nil {
			return false
		}

		t.Errorf("Duplicate instances in cycle: %s (%p) -> %s (%p) -> %s (%p)", Inst, Inst, Node, Node, Tree, Tree)
	}
}

// TestMethodOrdering is a simple test verifying that the indices of methods of
// a named type remain the same as long as the same source and AddMethod calls
// are presented to the type checker in the same order (go.dev/issue/61298).
func TestMethodOrdering(t *testing.T) {
	const src = `
package p

type T struct{}