if genShorthand {
				g.emit("<th>Shorthand</th>")
			}
			g.emit("<th>Description</th>")
			g.emit("</tr>")
			g.emit("</thead>")
			g.emit("<tbody>")

			for _, n := range names {
				g.genFlag(f[n], genShorthand)
			}

			g.emit("</tbody>")
			g.emit("</table>")
		}
	}

	if len(cmd.Example) > 0 {
		g.emit("<h3 id=\"", normalizeID(cmd.CommandPath()), " Examples\">", "Examples", "</h3>")

	"cmd/go/internal/test/internal/genflags"
)

func main() {
	if err := regenerate(); err != nil {
		log.Fatal(err)
	}
}

func regenerate() error {
	vetAnalyzers, err := genflags.VetAnalyzers()
	if err != nil {
		return err
	}

	t := template.Must(template.New("fileTemplate").Parse(fileTemplate))
	tData := map[string][]string{
		"testFlags":    genflags.ShortTestFlags(),
		"vetAnalyzers": vetAnalyzers,

package test

import (
	"cmd/go/internal/cfg"
	"cmd/go/internal/test/internal/genflags"
	"internal/testenv"
	"maps"
	"os"
	"testing"
)

func TestMain(m *testing.M) {
	cfg.SetGOROOT(testenv.GOROOT(nil), false)
	os.Exit(m.Run())
}

func TestPassFlagToTest(t *testing.T) {
	wantNames := genflags.ShortTestFlags()

	missing := map[string]bool{}
	for _, name := range wantNames {

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().register("someTask", SomeTask.class, t -> {
                        t.getFlag().set(true);
                        t.getMessage().set("some value");
                        t.getNumber().set(1.23);
                        t.getList().set(Arrays.asList(1, 2));

            import ${TaskAction.name};
            import ${Internal.name};

            public abstract class SomeTask extends DefaultTask {
                @Internal
                public abstract Property<Boolean> getFlag();

                @Internal
                public abstract Property<String> getMessage();

                @Internal
                public abstract Property<Double> getNumber();

                @Internal

        Type1Message parsed = new Type1Message(t1.toByteArray());

        assertEquals(origFlags, parsed.getFlags());

        if ( parsed.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED) ) {
            assertEquals(suppliedDomain, parsed.getSuppliedDomain());
        }

        if ( parsed.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED) ) {
            assertEquals(suppliedWorkstation, parsed.getSuppliedWorkstation());
        }

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package genflags

import (
	"flag"
	"strings"
	"testing"
)

// ShortTestFlags returns the set of "-test." flag shorthand names that end
// users may pass to 'go test'.
func ShortTestFlags() []string {
	testing.Init()

	var names []string

        this(
            tc,
            getDefaultFlags(tc, type1),
            challenge,
            ( type1 != null && target == null && type1.getFlag(NTLMSSP_REQUEST_TARGET) ) ? tc.getConfig().getDefaultDomain() : target);
    }


    /**
     * Creates a Type-2 message with the specified parameters.
     * 
     * @param tc

                        || !msg2.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) ) ) {
                    throw new SmbUnsupportedOperationException("Server does not support extended NTLMv2 key exchange");
                }

                if ( !msg2.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_128) ) {

            passwordHash = NtlmUtil.getNTHash(password);
        }

        switch ( tc.getConfig().getLanManCompatibility() ) {
        case 0:
        case 1:
            if ( !getFlag(NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) ) {
                setLMResponse(getLMResponse(tc, type2, password));
                setNTResponse(getNTResponse(tc, type2, passwordHash));
            }
            else {