}

    void assertInReadOnlyCache(String... fileNames) {
        def artifacts = resolvedArtifacts
        fileNames.each { fileName ->
            assertInReadOnlyCache(artifacts[fileName])
        }
    }

    void assertNotInReadOnlyCache(String... fileNames) {
        def artifacts = resolvedArtifacts
        fileNames.each { fileName ->
            assertNotInReadOnlyCache(artifacts[fileName])

		return nil, nil
	}
	var filenames []string
	for _, name := range pkg.GoFiles {
		filenames = append(filenames, filepath.Join(pkg.Dir, name))
	}
	if includeTest {
		for _, name := range pkg.TestGoFiles {
			filenames = append(filenames, filepath.Join(pkg.Dir, name))
		}
	}
	return filenames, nil
}

func walkPkgDirs(dir string, pkgh func(dir string, filenames []string), errh func(args ...interface{})) {

	// instead. Unfortunately, the local filesystem might apply arbitrary
	// normalization to the filenames, so we need to obtain those directly.
	//
	// 'svn export' prints the filenames as they are written, but from reading the
	// svn source code (as of revision 1868933), those filenames are encoded using
	// the system locale rather than preserved byte-for-byte from the origin. For

	// all package files. Also, compute sorted list of filenames, so that
	// subsequent iterations can always iterate in the same order.
	ndocs := 0
	ncomments := 0
	ndecls := 0
	filenames := make([]string, len(pkg.Files))
	var minPos, maxPos token.Pos
	i := 0
	for filename, f := range pkg.Files {
		filenames[i] = filename
		i++
		if f.Doc != nil {

	filenames []string, controlPlaneOpts clioptions.ControlPlaneOptions,
	options ...StatusVerifierOptions,
) (*StatusVerifier, error) {
	verifier := StatusVerifier{
		logger:           clog.NewDefaultLogger(),
		successMarker:    "✅",
		failureMarker:    "❌",
		istioNamespace:   istioNamespace,
		manifestsPath:    manifestsPath,
		filenames:        filenames,
		controlPlaneOpts: controlPlaneOpts,

    return regexs


def main():
    regexs = get_regexs()
    refs = get_refs()
    filenames = get_files(refs)

    for filename in filenames:
        if not file_passes(filename, refs, regexs):
            print(filename)

    return 0


if __name__ == "__main__":

	processedFiles := map[string]bool{}
	for _, filename := range filenames {
		var isDir bool
		if filename != "-" {
			fi, err := os.Stat(filename)
			if err != nil {
				errs = multierror.Append(errs, fmt.Errorf("cannot stat file %q: %v", filename, err))
				continue
			}
			isDir = fi.IsDir()
		}

		if !isDir {
			processFile(filename)
			processedFiles[filename] = true
			continue
		}

	var filenames []string
	for _, pattern := range patterns {
		list, err := fs.Glob(fsys, pattern)
		if err != nil {
			return nil, err
		}
		if len(list) == 0 {
			return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
		}
		filenames = append(filenames, list...)
	}
	return parseFiles(t, readFileFS(fsys), filenames...)
}

{{synopsis .Doc}}
PACKAGE {{.Name}}

IMPORTPATH
	{{.ImportPath}}

{{with .Imports}}IMPORTS
{{range .}}	{{.}}
{{end}}
{{end}}{{/*

*/}}FILENAMES
{{range .Filenames}}	{{.}}
{{end}}{{/*

*/}}{{with .Consts}}
CONSTANTS
{{range .}}	{{synopsis .Doc}}
	{{node .Decl $.FSet}}

{{end}}{{end}}{{/*

*/}}{{with .Vars}}
VARIABLES
{{range .}}	{{synopsis .Doc}}
	{{node .Decl $.FSet}}

{{end}}{{end}}{{/*

        }

        void assertHasSource(List<String> filenames) {
            assert source.collect { it.replaceFirst('!/$', '').split('/').last() } == filenames
        }

        void assertHasJavadoc(List<String> filenames) {
            assert javadoc.collect { it.replaceFirst('!/$', '').split('/').last() } == filenames
        }

        void assertHasNoJavadoc() {
            assert javadoc.empty