es = append(es, muxEntry{}) // try to grow the slice in place, any entry works.
	copy(es[i+1:], es[i:])      // Move shorter entries down
	es[i] = e
	return es
}

// Formerly ServeMux.HandleFunc.
func (mux *serveMux121) handleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if handler == nil {
		panic("http: nil handler")
	}
	mux.handle(pattern, HandlerFunc(handler))
}

// Formerly ServeMux.Handler.

}

func setupHTTPServer(handlers map[string]handlerFunc) (*httptest.Server, *url.URL) {
	handler := http.NewServeMux()
	for path, handle := range handlers {
		handler.HandleFunc(path, handle)
	}
	server := httptest.NewServer(handler)
	url, _ := url.Parse(server.URL)
	return server, url

	m.exposedPaths = append(m.exposedPaths, path)
	m.pathToHandler[path] = handler
	m.refreshMuxLocked()
}

// HandleFunc registers the handler function for the given pattern.
// If a handler already exists for pattern, Handle panics.
func (m *PathRecorderMux) HandleFunc(path string, handler func(http.ResponseWriter, *http.Request)) {
	m.Handle(path, http.HandlerFunc(handler))
}

	mux := dns.NewServeMux()
	mux.HandleFunc(".", func(resp dns.ResponseWriter, msg *dns.Msg) {
		answer := new(dns.Msg)
		answer.SetReply(msg)
		answer.Rcode = dns.RcodeNameError
		if err := resp.WriteMsg(answer); err != nil {
			t.Fatalf("err: %s", err)
		}
	})
	for hn, desiredResp := range responses {
		mux.HandleFunc(hn, func(resp dns.ResponseWriter, msg *dns.Msg) {
			answer := dns.Msg{

		ErrorLog:  log.New(&httpServerErrorLogWriter{}, "", 0),
		Handler:   s.httpsMux,
		TLSConfig: tlsConfig,
	}

	// register istiodReadyHandler on the httpsMux so that readiness can also be checked remotely
	s.httpsMux.HandleFunc("/ready", s.istiodReadyHandler)

	}
	loggingOptions := DefaultOptions()
	loggingOptions.JSONEncoding = true
	if err := Configure(loggingOptions.WithTeeToUDS(socketPath, "/")); err != nil {
		t.Fatal(err)
	}
	mux := http.NewServeMux()
	mux.HandleFunc("/", srv.handleLog)

	go func() {
		if err := http.Serve(unixListener, mux); err != nil {
			t.Error(err)
		}
	}()

	{
		t.Log("test sending normal log")

		WithLabels("k", "v").Info("test")

}

// Start starts the mock server.
func (ms *MockOpenIDDiscoveryServer) Start() error {
	var handler http.Handler
	router := mux.NewRouter()
	router.HandleFunc("/.well-known/openid-configuration", ms.openIDCfg).Methods("GET")
	router.HandleFunc("/oauth2/v3/certs", ms.jwtPubKey).Methods("GET")
	handler = router
	if ms.timeout != 0 {
		handler = withDelay(router, ms.timeout)
	}
	server := &http.Server{

			log.Fatal("Please provide both a key file and a cert file to enable TLS.")
		}
		serveFunc = func() error {
			return http.ListenAndServeTLS(":8080", certFile, keyFile, nil)
		}
	}

	http.HandleFunc("/", mainHandler)

	log.Print("Listening on :8080")
	log.Fatal(serveFunc())

func memstats() any {
	stats := new(runtime.MemStats)
	runtime.ReadMemStats(stats)
	return *stats
}

func init() {
	if godebug.New("httpmuxgo121").Value() == "1" {
		http.HandleFunc("/debug/vars", expvarHandler)
	} else {
		http.HandleFunc("GET /debug/vars", expvarHandler)
	}
	Publish("cmdline", Func(cmdline))
	Publish("memstats", Func(memstats))
}

// TODO: Use json.appendString instead.

		return nil, errors.New("expected mux to be passed, but was not passed")
	}
	wh := &Webhook{
		schemas:      o.Schemas,
		domainSuffix: o.DomainSuffix,
	}

	o.Mux.HandleFunc("/validate", wh.serveValidate)
	o.Mux.HandleFunc("/validate/", wh.serveValidate)

	return wh, nil
}

func toAdmissionResponse(err error) *kube.AdmissionResponse {