static void assertDescription(CommandLineOption option, String desc) {
        assert option.description == desc
    }

    static void assertIncubatingDescription(CommandLineOption option, boolean incubating) {
        assertIncubatingDescription(option, incubating, DESCRIPTION)
    }

    static void assertIncubatingDescription(CommandLineOption option, boolean incubating, String desc) {

		{
			desc: "negative uint",
			in: `go test fuzz v1
uint(-32)`,
			reject: true,
		},
		{
			desc: "int8 too large",
			in: `go test fuzz v1
int8(1234456)`,
			reject: true,
		},
		{
			desc: "multiplication in int value",
			in: `go test fuzz v1
int(20*5)`,
			reject: true,
		},
		{
			desc: "double negation",
			in: `go test fuzz v1
int(--5)`,
			reject: true,
		},
		{

	}
}

func TestFailStrategy(t *testing.T) {
	cases := []struct {
		desc string
		in   *extensions.WasmPlugin
		out  bool
	}{
		{
			desc: "close",
			in: &extensions.WasmPlugin{
				Url:          "file://fake.wasm",
				FailStrategy: extensions.FailStrategy_FAIL_CLOSE,
			},
			out: false,
		},
		{
			desc: "open",
			in: &extensions.WasmPlugin{
				Url:          "file://fake.wasm",

func TestVersion(t *testing.T) {
	tests := []struct {
		desc    string
		yamlStr string
		want    Version
		wantErr string
	}{
		{
			desc: "nil success",
		},
		{
			desc:    "major success",
			yamlStr: "1",
			want:    NewVersion(1, 0, 0, ""),
		},
		{
			desc:    "major fail",
			yamlStr: "1..",
			wantErr: `Malformed version: 1..`,
		},
		{
			desc:    "major fail prefix",
			yamlStr: ".1",

	tests := []struct {
		desc     string
		function func(v reflect.Value) bool
		okValues []any
	}{
		{
			desc:     "IsValuePtr",
			function: IsValuePtr,
			okValues: []any{&testInt, &testStruct, &testSlice, &testMap},
		},
		{
			desc:     "IsValueStruct",
			function: IsValueStruct,
			okValues: []any{testStruct},
		},
		{
			desc:     "IsValueInterface",

func TestPanic(t *testing.T) {
	testenv.MustHaveExec(t)

	testCases := []struct {
		desc  string
		flags []string
		want  string
	}{{
		desc:  "root test panics",
		flags: []string{"-test_panic_test=TestPanicHelper"},
		want: `
--- FAIL: TestPanicHelper (N.NNs)
    panic_test.go:NNN: TestPanicHelper
`,
	}, {
		desc:  "subtest panics",
		flags: []string{"-test_panic_test=TestPanicHelper/1"},
		want: `

            desc: "use istio.io/istio/pkg/slices"
          - pkg: k8s.io/utils/pointer
            desc: "use istio.io/istio/pkg/ptr"
          - pkg: go.opencensus.io
            desc: "do not use OpenCensus; use OpenTelemetry instead"
          - pkg: golang.org/x/exp/maps
            desc: "do not use golang.org/x/exp/maps; use istio.io/istio/pkg/maps instead"
          - pkg: maps

	metrics := []string{
		"authenticated_user_requests",
		"authentication_attempts",
	}

	testCases := []struct {
		desc        string
		response    *authenticator.Response
		status      bool
		err         error
		apiAudience authenticator.Audiences
		want        string
	}{
		{
			desc: "auth ok",
			response: &authenticator.Response{
				User: &user.DefaultInfo{Name: "admin"},
			},
			status: true,
			want: `

	testCases := []struct {
		desc          string
		initialVerb   string
		suggestedVerb string
		request       *http.Request
		requestInfo   *request.RequestInfo
		expectedVerb  string
	}{
		{
			desc:         "An empty string should be designated as unknown",
			initialVerb:  "",
			request:      nil,
			expectedVerb: "other",
		},
		{
			desc:         "LIST should normally map to LIST",

			}
			ok := root.Run(tc.desc, tc.f)
			ctx.release()

			if ok != tc.ok {
				t.Errorf("%s:ok: got %v; want %v", tc.desc, ok, tc.ok)
			}
			if ok != !root.Failed() {
				t.Errorf("%s:root failed: got %v; want %v", tc.desc, !ok, root.Failed())
			}
			if ctx.running != 0 || ctx.numWaiting != 0 {
				t.Errorf("%s:running and waiting non-zero: got %d and %d", tc.desc, ctx.running, ctx.numWaiting)
			}