Go 1.23 changed the behavior of [X509KeyPair] and [LoadX509KeyPair]
to populate the [Certificate.Leaf] field of the returned [Certificate].

[Server.TLSNextProto] (for servers) to a non-nil, empty
map. Alternatively, the following GODEBUG settings are
currently supported:

	GODEBUG=http2client=0  # disable HTTP/2 client support
	GODEBUG=http2server=0  # disable HTTP/2 server support
	GODEBUG=http2debug=1   # enable verbose HTTP/2 debug logs
	GODEBUG=http2debug=2   # ... even more verbose, with frame dumps

// before normal init functions are run. env is set by runtime if the OS supports
// cpu feature options in GODEBUG.
func Initialize(env string) {
	doinit()
	processOptions(env)
}

// options contains the cpu debug options that can be used in GODEBUG.
// Options are arch dependent and are added by the arch specific doinit functions.

package fuzz

import (
	"bytes"
	"fmt"
	"os"
	"strconv"
	"testing"
)

func BenchmarkMutatorBytes(b *testing.B) {
	origEnv := os.Getenv("GODEBUG")
	defer func() { os.Setenv("GODEBUG", origEnv) }()
	os.Setenv("GODEBUG", fmt.Sprintf("%s,fuzzseed=123", origEnv))
	m := newMutator()

	for _, size := range []int{
		1,
		10,
		100,
		1000,
		10000,
		100000,
	} {

# Test case for #67623 in go.mod files: make sure the error for
# an unknown godebug is printed on a line starting with the file
# and line number, so it can be easily parsed by tools.

! go list
stderr '^go.mod:3: unknown godebug "foo"$'

-- go.mod --
module example.com/bar

	// Doing the same on Unix would be a problem because it wouldn't
	// propagate signals and such, but there are no signals on Windows.
	// We also use the exec case when GODEBUG=gotoolchainexec=0,
	// to allow testing this code even when not on Windows.
	if godebug.New("#gotoolchainexec").Value() == "0" || runtime.GOOS == "windows" {
		cmd := exec.Command(exe, os.Args[1:]...)
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout

	goDebug := netdns.Value()
	parsePart := func(s string) {
		if s == "" {
			return
		}
		if '0' <= s[0] && s[0] <= '9' {
			debugLevel, _, _ = dtoi(s)
		} else {
			dnsMode = s
		}
	}
	if i := bytealg.IndexByteString(goDebug, '+'); i != -1 {
		parsePart(goDebug[:i])
		parsePart(goDebug[i+1:])
		return
	}
	parsePart(goDebug)
	return
}

	runDebugOptionsTest(t, "TestAllCapabilitiesDisabled", "cpu.all=off")
}

func TestAllCapabilitiesDisabled(t *testing.T) {
	MustHaveDebugOptionsSupport(t)

	if godebug.New("#cpu.all").Value() != "off" {
		t.Skipf("skipping test: GODEBUG=cpu.all=off not set")
	}

	for _, o := range Options {
		want := false
		if got := *o.Feature; got != want {
			t.Errorf("%v: expected %v, got %v", o.Name, want, got)
		}
	}

		checkPanicNil(t, new(runtime.PanicNilError))
	})
	t.Run("GODEBUG=panicnil=0", func(t *testing.T) {
		t.Setenv("GODEBUG", "panicnil=0")
		checkPanicNil(t, new(runtime.PanicNilError))
	})
	t.Run("GODEBUG=panicnil=1", func(t *testing.T) {
		t.Setenv("GODEBUG", "panicnil=1")
		checkPanicNil(t, nil)
	})
}

func checkPanicNil(t *testing.T, want any) {
	name := "/godebug/non-default-behavior/panicnil:events"

		if test.godebug != "" {
			name += fmt.Sprintf("/godebug=%v", test.godebug)
		}
		t.Run(name, func(t *testing.T) {
			if test.godebug != "" {
				t.Setenv("GODEBUG", test.godebug)
			}
			var buf bytes.Buffer
			fw := NewWriter(&buf)
			for i := 0; i < test.values; i++ {
				w, _ := fw.CreateFormField(fmt.Sprintf("field%v", i))