name: 02-test-04-wildcard-cert
  namespace: istio-system
type: Opaque
---
apiVersion: v1
data:
  cert: aHVzaCBodXNoIGh1c2gK
  key: c2VjcmV0IHNlY3JldAo=
kind: Secret
metadata:
  name: 01-test-05-wildcard-cert
  namespace: istio-system
type: Opaque
---
apiVersion: v1
data:
  cert: aHVzaCBodXNoIGh1c2gK
  key: c2VjcmV0IHNlY3JldAo=
kind: Secret
metadata:
  name: 02-test-05-wildcard-cert

     * 
     * @param wildcard
     * @param attributes
     */
    public DosFileFilter ( String wildcard, int attributes ) {
        this.wildcard = wildcard;
        this.attributes = attributes;
    }


    /**
     * This returns true if the file's attributes contain any of the attributes
     * specified for this filter. The wildcard has no influence on this

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: attaches-to-wildcard-example-com-with-hostname-intersection
  namespace: gateway-conformance-infra
spec:
  parentRefs:
    - name: isolation
      namespace: gateway-conformance-infra
      sectionName: wildcard-example-com
  hostnames:
    - "bar.com" # doesn't match wildcard-example-com listener
    - "*.example.com"

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

		return mostSpecificHostWildcardMatch(string(needle[1:]), wildcard)
	}

	// exact match first
	if v, ok := specific[needle]; ok {
		return needle, v, true
	}

	// check wildcard
	return mostSpecificHostWildcardMatch(string(needle), wildcard)
}

func mostSpecificHostWildcardMatch[V any](needle string, wildcard map[host.Name]V) (host.Name, V, bool) {
	found := false
	var matchHost host.Name
	var matchValue V

		{"/{w}x", "at offset 1: bad wildcard segment"},
		{"/x{w}", "at offset 1: bad wildcard segment"},
		{"/{wx", "at offset 1: bad wildcard segment"},
		{"/a/{/}/c", "at offset 3: bad wildcard segment"},
		{"/a/{%61}/c", "at offset 3: bad wildcard name"}, // wildcard names aren't unescaped
		{"/{a$}", "at offset 1: bad wildcard name"},
		{"/{}", "at offset 1: empty wildcard"},

        def objects = new ModelType<List<? extends Object>>() {}.typeVariables[0]

        expect:
        extendsString.wildcard
        superString.wildcard
        objects.wildcard
        anything.wildcard

        !extendsString.isClass()
        !superString.isClass()
        !objects.isClass()
        !anything.isClass()

        extendsString.rawClass == String

    static CloseableIterator<SmbResource> doEnum ( SmbFile parent, String wildcard, int searchAttributes, ResourceNameFilter fnf, ResourceFilter ff )
            throws CIFSException {
        DosFileFilter dff = unwrapDOSFilter(ff);
        if ( dff != null ) {
            if ( dff.wildcard != null )
                wildcard = dff.wildcard;
            searchAttributes = dff.attributes;
        }

            return false;
        }
        TypeMetaData that = (TypeMetaData) o;
        return arrayDimensions == that.arrayDimensions &&
            varargs == that.varargs &&
            wildcard == that.wildcard &&
            Objects.equals(name, that.name) &&
            Objects.equals(typeArgs, that.typeArgs) &&
            Objects.equals(upperBounds, that.upperBounds) &&

//     a literal or a wildcard of the form "{name}", "{name...}", or "{$}".
//
// METHOD, HOST and PATH are all optional; that is, the string can be "/".
// If METHOD is present, it must be followed by at least one space or tab.
// Wildcard names must be valid Go identifiers.
// The "{$}" and "{name...}" wildcard must occur at the end of PATH.
// PATH may end with a '/'.
// Wildcard names in a path must be distinct.