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},
	}

    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'

	// 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

    @Test
    fun `recognizes segments that are partially wildcarded`() {
        val instance = createFromPaths(listOf("foo*/*bar*/*baz/*.xml"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("foo/bar/baz/.xml")))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("foo1/2bar3/4baz/abc.xml")))
    }

    @Test
    fun `recognizes double-asterisk wildcards across path segments`() {

	errWildcardObjectLookup       = errors.New("Object wildcard used on non-object value")
	errWildcardArrayLookup        = errors.New("Array wildcard used on non-array value")
	errWildcardObjectUsageInvalid = errors.New("Invalid usage of object wildcard")
)

// jsonpathEval evaluates a JSON path and returns the value at the path.
// If the value should be considered flat (from wildcards) any array returned should be considered individual values.

}

// generatePatterns generates all possible patterns using a representative
// sample of parts.
func generatePatterns() []*pattern {
	var pats []*pattern

	collect := func(s string) {
		// Replace duplicate wildcards with unique ones.
		var b strings.Builder
		wc := 0
		for {
			i := strings.Index(s, "{x}")
			if i < 0 {
				b.WriteString(s)
				break
			}
			b.WriteString(s[:i])
			fmt.Fprintf(&b, "{x%d}", wc)

		{
			host.Names{"b", "a", "aa"},
			host.Names{"aa", "a", "b"},
		},
		{
			host.Names{"foo.com", "bar.com", "foo.bar.com"},
			host.Names{"foo.bar.com", "bar.com", "foo.com"},
		},
		// We sort wildcards last, always
		{
			host.Names{"a", "*", "z"},
			host.Names{"a", "z", "*"},
		},
		{
			host.Names{"foo.com", "bar.com", "*.com"},
			host.Names{"bar.com", "foo.com", "*.com"},
		},
		{

# 'go install pkg@version' should report an error if an argument is not
# a main package.
! go install example.com/cmd/a@v1.0.0 example.com/cmd/err@v1.0.0
stderr '^package example.com/cmd/err is not a main package$'

# Wildcards should match only main packages. This module has a non-main package
# with an error, so we'll know if that gets built.
mkdir tmp
cd tmp
go mod init m
go get example.com/cmd@v1.0.0
! go build example.com/cmd/...

Ben Leggett <******@****.***> 1710179183 -0400