}

// Prioritize implements the extender Prioritize function.
func (f *FakeExtender) Prioritize(pod *v1.Pod, nodes []*framework.NodeInfo) (*extenderv1.HostPriorityList, int64, error) {
	result := extenderv1.HostPriorityList{}
	combinedScores := map[string]int64{}
	for _, prioritizer := range f.Prioritizers {
		weight := prioritizer.Weight
		if weight == 0 {
			continue
		}

	// Prioritize based on extender-implemented priority functions. The returned scores & weight
	// are used to compute the weighted score for an extender. The weighted scores are added to
	// the scores computed by Kubernetes scheduler. The total scores are used to do the host selection.

    }

    private Iterable<LanguageTransform<?, ?>> prioritize(LanguageTransformContainer languageTransforms) {
        List<LanguageTransform<?, ?>> prioritized = Lists.newArrayList(languageTransforms);
        Collections.sort(prioritized, new Comparator<LanguageTransform<?, ?>>() {
            @Override

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
- 47901
releaseNotes:
- |

		// in case the file changed concurrent with calling WatchUntil.
		eventHandler()
	}

	for {
		select {
		case <-ctx.Done():
			return

		case <-t.C:
			// Prioritize exiting if context is canceled
			if ctx.Err() != nil {
				return
			}

			// Try to re-establish the watcher if we previously got a watch error
			if attemptPeriodicRewatch {
				_ = watcher.Remove(path)

	PreemptVerb string
	// Verb for the prioritize call, empty if not supported. This verb is appended to the URLPrefix when issuing the prioritize call to extender.
	PrioritizeVerb string
	// The numeric multiplier for the node scores that the prioritize call generates.
	// The weight should be a positive integer
	Weight int64

		if !p1Found || !p2Found {
			// prioritize evicting the pod for which no stats were found
			return cmpBool(!p1Found, !p2Found)
		}

		p1Process := processUsage(p1Stats.ProcessStats)
		p2Process := processUsage(p2Stats.ProcessStats)
		// prioritize evicting the pod which has the larger consumption of process
		return int(p2Process - p1Process)
	}
}

                            logger.lifecycle(getName() + "profile=" + getProfile().get())
                        }
                    }
                }
                """
    }

    def "will prioritize built-in option over a task option with a conflicting name"() {
        when:
        buildScript """
            ${defineTaskWithProfileOption()}

            tasks.register('mytask', MyTask.class)
        """

    }

    // endregion

    public Binding<T> scope(Annotation scope) {
        this.scope = scope;
        return this;
    }

    public Binding<T> prioritize(int priority) {
        this.priority = priority;
        return this;
    }

    public Binding<T> withKey(Key<?> key) {
        this.originalKey = key;
        return this;
    }

}

// Prioritize based on extender implemented priority functions. Weight*priority is added
// up for each such priority function. The returned score is added to the score computed
// by Kubernetes scheduler. The total score is used to do the host selection.
func (h *HTTPExtender) Prioritize(pod *v1.Pod, nodes []*framework.NodeInfo) (*extenderv1.HostPriorityList, int64, error) {