continue
		}
		if !slices.Contains(matches, tt.result) {
			t.Errorf("Glob(%#q) = %#v want %v", tt.pattern, matches, tt.result)
		}
	}
	for _, pattern := range []string{"no_match", "../*/no_match", `\*`} {
		matches, err := Glob(os.DirFS("."), pattern)
		if err != nil {
			t.Errorf("Glob error for %q: %s", pattern, err)
			continue
		}
		if len(matches) != 0 {

                    found = true;
                    break;
                }
            }
            if (!found) {
                return MatchResult.NO_MATCH;
            }
        }
        boolean exactMatch = explicitRequestedCapabilities.size() == providerCapabilitiesSet.size();
        return exactMatch ? MatchResult.EXACT_MATCH : MatchResult.MATCHES_ALL;
    }

			continue
		}
		if !slices.Contains(matches, result) {
			t.Errorf("Glob(%#q) = %#v want %v", pattern, matches, result)
		}
	}
	for _, pattern := range []string{"no_match", "../*/no_match"} {
		matches, err := Glob(pattern)
		if err != nil {
			t.Errorf("Glob error for %q: %s", pattern, err)
			continue
		}
		if len(matches) != 0 {

        int matchLength = 0;

        for (int a = 0; a < requestedAttributes.size(); a++) {
            MatchResult result = recordAndMatchCandidateValue(c, a);
            if (result == MatchResult.NO_MATCH) {
                compatible.clear(c);
                return;
            }
            if (result == MatchResult.MATCH) {
                matchLength++;
            }
        }

	}
}

static void
matchprint(regmatch_t* match, int nmatch, int nsub, char* ans, unsigned long test)
{
	int	i;

	for (; nmatch > nsub + 1; nmatch--)
		if ((match[nmatch-1].rm_so != -1 || match[nmatch-1].rm_eo != -1) && (!(test & TEST_IGNORE_POSITION) || match[nmatch-1].rm_so >= 0 && match[nmatch-1].rm_eo >= 0))
			break;
	for (i = 0; i < nmatch; i++)
	{
		printf("(");
		matchoffprint(match[i].rm_so);

		return true
	}
	switch r := predicate.Rule.(type) {
	case *listener.ListenerFilterChainMatchPredicate_NotMatch:
		return !EvaluateListenerFilterPredicates(r.NotMatch, port)
	case *listener.ListenerFilterChainMatchPredicate_OrMatch:
		matches := false
		for _, r := range r.OrMatch.Rules {
			matches = matches || EvaluateListenerFilterPredicates(r, port)
		}
		return matches

#	NOMATCH
#	(0,.)\((\(.\),\(.\))(?,?)(\2,\3)\)*
#	(0,.)\((\(.\),\(.\))(\2,\3)(?,?)\)*
# i.e., each 3-tuple has two identical elements and one (?,?)

E	((..)|(.))				NULL		NOMATCH
E	((..)|(.))((..)|(.))			NULL		NOMATCH
E	((..)|(.))((..)|(.))((..)|(.))		NULL		NOMATCH

E	((..)|(.)){1}				NULL		NOMATCH
E	((..)|(.)){2}				NULL		NOMATCH
E	((..)|(.)){3}				NULL		NOMATCH

	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/apiserver/pkg/admission"
)

type ruleTest struct {
	rule    adreg.RuleWithOperations
	match   []admission.Attributes
	noMatch []admission.Attributes
}
type tests map[string]ruleTest

func a(group, version, resource, subresource, name string, operation admission.Operation, operationOptions runtime.Object) admission.Attributes {

    }

    @Test
    public void testRenameNoMatch() {
        RegExpNameMapper mapper = new RegExpNameMapper("(.+).java", "$1Test.java");
        String noMatch = "NoMatch";
        assertEquals(noMatch, mapper.transform(noMatch));
    }

! stdout 'no tests to run'

# Tests where -run doesn't match any seed corpora.

go test -run FuzzFoo/nomatch
stdout ok

go test -run /nomatch
stdout ok

go test -v -run FuzzFoo/nomatch
stdout '=== RUN   FuzzFoo'
stdout '--- PASS: FuzzFoo'
stdout ok
! stdout 'no tests to run'

go test -v -run /nomatch
stdout '=== RUN   FuzzFoo'
stdout '--- PASS: FuzzFoo'
stdout ok
! stdout 'no tests to run'