issue:
  - 45415

releaseNotes:
  - |
    **Fixed** a bug where overlapping wildcard hosts in a VirtualService would produce incorrect routing configuration when wildcard services were selected (e.g. in ServiceEntries).

upgradeNotes:
  - title: Overlapping Wildcard Conflicts
    content: |
      This fix changes the behavior of overlapping wildcard hosts in VirtualService. Previously, the oldest VirtualService would take precedence

John Howard <******@****.***> 1709052916 -0800

	// 6 is the magical number for inbound: 15006, 127.0.0.6, ::6
	InboundPassthroughBindIpv4 = "127.0.0.6"
	InboundPassthroughBindIpv6 = "::6"
)

var (
	// maintain 3 maps to return wildCards, localHosts and passthroughBindIPs according to IP mode of proxy
	wildCards = map[model.IPMode][]string{
		model.IPv4: {WildcardAddress},
		model.IPv6: {WildcardIPv6Address},
		model.Dual: {WildcardAddress, WildcardIPv6Address},
	}

        def xml = toXmlReader
        def other = new Project(new XmlTransformer(), pathFactory)
        other.load(xml)

        then:
        project.wildcards == other.wildcards
        project.modulePaths == other.modulePaths
        project.jdk == other.jdk
    }

    private InputStream getToXmlReader() {
        ByteArrayOutputStream toXmlText = new ByteArrayOutputStream()

def hooks = []

idea {
    project {
        ipr {
            beforeMerged {
                assert it.wildcards.contains('!?*.fooBar')
                it.wildcards << '!?*.fooBarTwo'
                hooks << 'before'
            }
            whenMerged {
                assert it.wildcards.contains('!?*.fooBarTwo')
                hooks << 'when'
            }
        }
    }
}

     *
     * @param includes Inclusions
     */
    void setIncludes(List<String> includes);

    /**
     * List of elements that should be included in check. Names can use wildcards (* and ?).
     * If left empty, all elements will be included. Defaults to [*].
     */
    @Input
    List<String> getIncludes();

    /**
     * Sets list of elements that should be excluded from check.
     *

    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added with a wildcard that is not in leftmost position! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
    check(rule.indexOf(WILDCARD_CHAR, 1) == -1) {
      """Wildcard Assertion Failure: '$rule'

// RegisterFormat registers an image format for use by [Decode].
// Name is the name of the format, like "jpeg" or "png".
// Magic is the magic prefix that identifies the format's encoding. The magic
// string can contain "?" wildcards that each match any one byte.
// [Decode] is the function that decodes the encoded image.
// [DecodeConfig] is the function that decodes just its configuration.

	// those with a multi wildcard.
	// We skip this step if the segment is a trailing slash, because single wildcards
	// don't match trailing slashes.
	if seg != "/" {
		if n, m := n.emptyChild.matchPath(rest, append(matches, seg)); n != nil {
			return n, m
		}
	}
	// Lastly, match the pattern (there can be at most one) that has a multi

		},
		{
			name: "glob deployments with labels and annotations",
			config: `
include:
  - ns1,ns2/d1,d2/p1,p2,p3,p4/l1=v1,l2=v2/k2=v2`,
			want:    p1,
			wantErr: "",
		},
		{
			name: "label wildcards",
			config: `
include:
  - n*/*/*/l1=v1,l2=v2*`,
			want:    joinSlices(p1, p2, p3),
			wantErr: "",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {