stat.setTryStatement(replace(stat.getTryStatement()));
        replaceAll(stat.getCatchStatements());
        stat.setFinallyStatement(replace(stat.getFinallyStatement()));
    }

    @Override
    @SuppressWarnings("unchecked")
    public void visitSwitch(SwitchStatement stat) {
        stat.setExpression(replaceExpr(stat.getExpression()));
        replaceAll(stat.getCaseStatements());

    }

    @Override
    void renameTests() {
        def newTest = file("src/test/java/NewTest.java")
        file('src/test/java/SomeOtherTest.java').renameTo(newTest)
        newTest.text = newTest.text.replaceAll("SomeOtherTest", "NewTest")
    }

    @Override
    String getTestTaskName() {
        return "test"
    }

    @Override
    String getPassingTestCaseName() {
        return "pass()"
    }

            QueryContext context) {
        assertEquals(query, context.getQueryBuilder().toString().replaceAll("\\s", ""));
        assertFieldLogs(fieldLogMap);
        assertHighlightedQueries(highlightedQuerySet);
        if (sorts != null) {
            assertEquals(sorts, context.sortBuilders().stream().map(s -> s.toString().replaceAll("\\s", "")).collect(Collectors.joining()));
        }
    }

				t.Errorf("output:\ngot:\n%s\nwant:\n%s", got, want)
			}
		})
	}
}

func makeRegexp(s string) string {
	s = regexp.QuoteMeta(s)
	s = strings.ReplaceAll(s, ":NNN:", `:\d+:`)
	s = strings.ReplaceAll(s, "N\\.NNs", `\d*\.\d*s`)
	return s
}

func TestPanicHelper(t *testing.T) {
	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
		return
	}
	t.Log(t.Name())

			base.SetExitStatus(2)
			base.Exit()
		}
		if args[used] == "help" {
			// Accept 'go mod help' and 'go mod help foo' for 'go help mod' and 'go help mod foo'.
			telemetry.Inc("go/subcommand:" + strings.ReplaceAll(cfg.CmdName, " ", "-") + "-" + strings.Join(args[used:], "-"))
			help.Help(os.Stdout, append(slices.Clip(args[:used]), args[used+1:]...))
			base.Exit()
		}
		helpArg := ""
		if used > 0 {

    public static String replace(final Object input, final String regex, final String replacement) {
        if (input == null) {
            return StringUtil.EMPTY;
        }
        return input.toString().replaceAll(regex, replacement);
    }

    public static String formatCode(final String prefix, final String style, final String mimetype, final String input) {
        if (input == null) {
            return StringUtil.EMPTY;

    }

    public List<String> getPluginList() {
        return Collections.singletonList(getNormalizedPluginName());
    }

    private String getNormalizedPluginName() {
        return getSourceType().replaceAll("([a-z])([A-Z])", "$1-$2").toLowerCase();
    }

    public String getPluginScript() {
        StringBuilder builder = new StringBuilder();
        for (String plugin : getPluginList()) {

	path = strings.TrimSuffix(path, pathSeparator)
	pv := splitEscaped(path, []rune(pathSeparator)[0])
	var r []string
	for _, str := range pv {
		if str != "" {
			str = strings.ReplaceAll(str, escapedPathSeparator, pathSeparator)
			// Is str of the form node[expr], convert to "node", "[expr]"?
			nBracket := strings.IndexRune(str, '[')
			if nBracket > 0 {
				r = append(r, str[:nBracket], str[nBracket:])

		RootMode = oldRootMode
	}()
	allowMissingModuleImports = true
	RootMode = NoRoot

	ctx := context.Background()
	rs := LoadModFile(ctx)

	for _, tt := range importTests {
		t.Run(strings.ReplaceAll(tt.path, "/", "_"), func(t *testing.T) {
			// Note that there is no build list, so Import should always fail.
			m, err := queryImport(ctx, tt.path, rs)

			if tt.err == "" {
				if err != nil {

import (
	"fmt"
	"os"
	"os/exec"
	"strings"
)

func main() {
	dir := os.Args[1]
	gopath := os.Args[2]
	switch os.Args[3] {
		case "IDENTITY":
		case "REPLACE_SLASH": gopath = strings.ReplaceAll(gopath, `\`, `/`)
		case "UPPER": gopath = strings.ToUpper(gopath)
		case "LOWER": gopath = strings.ToLower(gopath)
		default: fmt.Fprintln(os.Stderr, "bad op"); os.Exit(1)
	}
	cmd := exec.Command("go", os.Args[4:]...)