}
    }

    static def assertSetContains(FileCollection set, String... filenames) {
        assertSetContains(set, filenames as Set)
    }

    static def assertSetContainsForAllTypes(FileCollection set, String... filenames) {
        assertSetContains(set, filenames as Set, FileCollection.AntType.values() as List)
    }

	}

	if o.Recursive != nil {
		flags.BoolVarP(o.Recursive, "recursive", "R", *o.Recursive, "Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory.")
	}
	if o.Filenames != nil {
		flags.StringSliceVarP(o.Filenames, "filename", "f", *o.Filenames, o.Usage)
		annotations := make([]string, 0, len(resource.FileExtensions))
		for _, ext := range resource.FileExtensions {

	}
}

func testFiles(t *testing.T, filenames <-chan string, done chan<- int) {
	b1 := new(bytes.Buffer)
	b2 := new(bytes.Buffer)
	for filename := range filenames {
		testFile(t, b1, b2, filename)
	}
	done <- 0
}

func genFilenames(t *testing.T, filenames chan<- string) {
	defer close(filenames)

	handleFile := func(filename string, d fs.DirEntry, err error) error {

				ctx.IstioNamespace(), manifestsPath, filenames, opts, verifier.WithLogger(l))
			if err != nil {
				return err
			}
			if formatting.IstioctlColorDefault(c.OutOrStdout()) {
				installationVerifier.Colorize()
			}
			return installationVerifier.Verify()
		},
	}

	flags := verifyInstallCmd.PersistentFlags()
	flags.StringSliceVarP(&filenames, "filename", "f", filenames, "Istio YAML installation file.")

func (t *Template) ParseFiles(filenames ...string) (*Template, error) {
	t.init()
	return parseFiles(t, readFileOS, filenames...)
}

// parseFiles is the helper for the method and function. If the argument
// template is nil, it is created from the first file.
func parseFiles(t *Template, readFile func(string) (string, []byte, error), filenames ...string) (*Template, error) {
	if len(filenames) == 0 {

}

func parseFiles(dir string, filenames []string) ([]*ast.File, error) {
	files := make([]*ast.File, len(filenames))
	errors := make([]error, len(filenames))

	var wg sync.WaitGroup
	for i, filename := range filenames {
		wg.Add(1)
		go func(i int, filepath string) {
			defer wg.Done()
			files[i], errors[i] = parse(filepath, nil)
		}(i, filepath.Join(dir, filename))
		if sequential {
			wg.Wait()
		}

    List<String> expectedFileNames = []
    List<Closure<?>> failureExpectations = []

    void expectFiles(String... fileNames) {
        expectFiles(fileNames as List<String>)
    }

    void expectFiles(List<String> fileNames) {
        expectedFileNames = fileNames.sort()
    }

    void noFiles() {
        expectedFileNames = []
    }

						t.Fatalf("failed to populate fake sdtin")
					}
					filenames = append(filenames, "-")
				} else {
					filenames = append(filenames, filename)
				}
			}
			got, err := readLayeredYAMLs(filenames, stdinReader)
			if (err != nil) != tt.wantErr {
				t.Errorf("ReadLayeredYAMLs() error = %v, wantErr %v", err, tt.wantErr)
				return
			}

			diff := util.YAMLDiff(got, want)
			if diff != "" {

func SetupEmptyFiles(t *testing.T, tmpdir string, fileNames ...string) {
	for _, fileName := range fileNames {
		newFile, err := os.Create(filepath.Join(tmpdir, fileName))
		if err != nil {
			t.Fatalf("Error creating file %s in %s: %v", fileName, tmpdir, err)
		}
		newFile.Close()
	}
}

        List<ScriptingLanguage> scriptingLanguages = ScriptingLanguages.all();
        String[] fileNames = new String[scriptingLanguages.size()];
        for (int i = 0; i < scriptingLanguages.size(); i++) {
            fileNames[i] = basename + scriptingLanguages.get(i).getExtension();
        }
        return fileNames;
    }