Match(...Tag) (Tag, int, int)
}

type matcher struct {
	tags []Tag
}

func (m *matcher) Match(prefs ...Tag) (Tag, int, int) {
	for _, pref := range prefs {
		for _, tag := range m.tags {
			if tag == pref || strings.HasPrefix(string(pref), string(tag+"-")) || strings.HasPrefix(string(tag), string(pref+"-")) {
				return tag, 0, 0
			}
		}
	}
	return m.tags[0], 0, 0

package testing

import (
	"os"
	"path"
)

// PathPrefix returns the prefix set via the ETCD_PREFIX environment variable (if any).
func PathPrefix() string {
	pref := os.Getenv("ETCD_PREFIX")
	if pref == "" {
		pref = "registry"
	}
	return path.Join("/", pref)
}

// AddPrefix adds the ETCD_PREFIX to the provided key
func AddPrefix(in string) string {
	return path.Join(PathPrefix(), in)

	Match(...Tag) (Tag, int, int)
}

type matcher struct {
	tags []Tag
}

func (m *matcher) Match(prefs ...Tag) (Tag, int, int) {
	for _, pref := range prefs {
		for _, tag := range m.tags {
			if tag == pref || strings.HasPrefix(string(pref), string(tag+"-")) || strings.HasPrefix(string(tag), string(pref+"-")) {
				return tag, 0, 0
			}
		}
	}
	return m.tags[0], 0, 0

        final String pref = ComponentUtil.getFessConfig().getQueryJsonDefaultPreference();
        if (PREFERENCE_QUERY.equals(pref)) {
            return Integer.toString(query.hashCode());
        }
        if (StringUtil.isNotBlank(pref)) {
            return pref;
        }
        return null;
    }

package genChecker0

var FailCount int

//go:noinline
func NoteFailure(fidx int, pkg string, pref string, parmNo int, _ uint64) {
	FailCount += 1
	if FailCount > 10 {
		panic("bad")
	}
}

//go:noinline
func NoteFailureElem(fidx int, pkg string, pref string, parmNo int, elem int, _ uint64) {
	FailCount += 1
	if FailCount > 10 {
		panic("bad")
	}
}

type StructF0S0 struct {

		}
		expected, err := nslookupMX(server)
		if err != nil {
			t.Skipf("skipping failed nslookup %s test: %s", server, err)
		}
		byPrefAndHost := func(a, b *MX) int {
			if r := cmp.Compare(a.Pref, b.Pref); r != 0 {
				return r
			}
			return strings.Compare(a.Host, b.Host)
		}
		slices.SortFunc(expected, byPrefAndHost)
		slices.SortFunc(mx, byPrefAndHost)
		if !reflect.DeepEqual(expected, mx) {

type UtilsType int

//go:noinline
func NoteFailure(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, isret bool, _ uint64) {
	if isret {
		if ParamFailCount != 0 {
			return
		}
		ReturnFailCount++
	} else {
		ParamFailCount++
	}
	fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo)

	if ParamFailCount+FailCount+ReturnFailCount > 9999 {
		os.Exit(1)
	}

type MX struct {
	Host string
	Pref uint16
}

// byPref sorts MX records by preference
type byPref []*MX

// sort reorders MX records as specified in RFC 5321.
func (s byPref) sort() {
	for i := range s {
		j := randIntn(i + 1)
		s[i], s[j] = s[j], s[i]
	}
	slices.SortFunc(s, func(a, b *MX) int {
		return cmp.Compare(a.Pref, b.Pref)
	})
}

    }

    def "serializes version constraint"() {
        given:
        ModuleComponentSelector selection = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId('group-one', 'name-one'), constraint('req', 'pref', 'strict', ['rej']))

        when:
        ModuleComponentSelector result = serialize(selection, serializer)

        then:
        result.group == 'group-one'
        result.module == 'name-one'

	var rules []*netlink.Rule
	families := []int{unix.AF_INET}
	if cfg.EnableIPv6 {
		families = append(families, unix.AF_INET6)
	}
	for _, family := range families {
		// Equiv:
		// ip rule add fwmark 0x111/0xfff pref 32764 lookup 100
		//
		// Adds in-pod rules for marking packets with the istio-specific TPROXY mark.
		// A very similar mechanism is used for sidecar TPROXY.
		//