@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/net/http/httptest/server.go

@@ -12,25 +12,123 @@ import (
 	"crypto/x509"
 	"flag"
 	"fmt"
+	"internal/nettest"
 	"log"
 	"net"
 	"net/http"
 	"net/http/internal/testcert"
 	"os"
+	"runtime"
 	"strings"
 	"sync"
+	"testing"
 	"time"
+	_ "unsafe" // for linkname
 )
 
-// A Server is an HTTP server listening on a system-chosen port on the
-// local loopback interface, for use in end-to-end HTTP tests.
+// A Server is an HTTP server for use in end-to-end HTTP tests.
+//
+// Most tests should create a server with [NewTestServer].
+// The [Server.Client] method returns a client which sends requests to the test server.
+//
+//	// Create a test server and send a request to it.
+//	server := httptest.NewTestServer(t, handler)
+//	resp, err := server.Client().Get("http://www.example.com/")
+//
+// # Configuration
+//
+// Tests may change a Server's configuration prior to using it.
+// The configuration must not be changed after the first call to
+// [Server.Client], [Server.Start], or [Server.StartTLS].
+//
+//	// Configure a test server before using.
+//	server := httptest.NewTestServer(t, handler)
+//	server.Config.MaxHeaderBytes = 1024
+//	resp, err := server.Client().Get("http://www.example.com/")
+//
+// # Tests
+//
+// Servers created with [NewTestServer] will:
+//
+//   - Fail the test if the server handler panics with
+//     any value other than [http.ErrAbortHandler].
+//   - Register a Cleanup function to shut down the server at the end of the test.
+//
+// Servers created in any other way must be manually shut down with [Server.Close].
+//
+// # In-Memory Network
+//
+// A Server may use an in-memory network implementation or
+// listen on a local network loopback interface.
+// Most tests should use the in-memory network,
+// which avoids port exhaustion and other transient networking issues
+// and is suitable for use with the [testing/synctest] package.
+//
+// To use the in-memory network, create a server with [NewTestServer].
+// Do not call [Server.Start] or [Server.StartTLS].
+//
+// When using the in-memory network, the [http.Client] returned by [Server.Client]
+// is configured to send all requests to the server.
+// The client will direct HTTP and HTTPS requests,
+// regardless of destination address or hostname, to the server.
+// Requests do not need to use [Server.URL] as the base URL.
+//
+//	server := httptest.NewTestServer(t, handler)
+//	client := server.Client()
+//
+//	// All of these requests are sent to the test server.
+//	// https:// requests use TLS over the in-memory network.
+//	_, _ = client.Get("http://www.example.com/")
+//	_, _ = client.Get("https://go.dev/")
+//	_, _ = client.Get("http://10.0.0.1/")
+//
+// The [Server.Listener] field is not set when using the in-memory network.
+//
+// # Loopback Network
+//
+// To listen on a loopback interface, call [Server.Start] or [Server.StartTLS].
+// The server will listen on a system-chosen port.
+//
+// Loopback servers serve one of HTTP (when started with [Server.Start])
+// or HTTPS (when started with [Server.StartTLS]).
+//
+// When using the loopback network, the [http.Client] returned by [Server.Client]
+// is configured to send requests with a hostname of "example.com" or a subdomain
+// of ".example.com" to the server.
+//
+// Requests may also be sent to the server's loopback address.
+// The [Server.URL] field is set to a base URL containing the server's address.
+//
+//	server := httptest.NewTestServer(t, handler)
+//	server.Start()
+//	client := server.Client()
+//
+//	// This request is sent to the test server.
+//	_, _ = server.Client().Get(server.URL + "/")
+//
+//	// This request (using http.DefaultClient) is also sent to the test server,
+//	// since server.URL contains the server's local IP address.
+//	_, _ = http.Get(server.URL + "/")
 type Server struct {
-	URL      string // base URL of form http://ipaddr:port with no trailing slash
+	// URL is the base URL of the server, of the form http://address:port
+	// with no trailing slash.
+	//
+	// It is set by the first call to Client, Start, or StartTLS.
+	//
+	// For servers listening on loopback, the address is the loopback IP address
+	// of the server.
+	//
+	// For servers using the in-memory network, this address is "example.com".
+	// Requests sent to servers using the in-memory network may use any address.
+	// It is not necessary to use this base URL.
+	URL string
+
+	// Listener is the network listener for servers listening on loopback.
+	// It is not set for servers using the in-memory network.
 	Listener net.Listener
 
-	// EnableHTTP2 controls whether HTTP/2 is enabled
-	// on the server. It must be set between calling
-	// NewUnstartedServer and calling Server.StartTLS.
+	// EnableHTTP2 controls whether HTTP/2 is enabled on the server.
+	// It must be set before calling Client, Start, or StartTLS.
 	EnableHTTP2 bool
 
 	// TLS is the optional TLS configuration, populated with a new config
@@ -38,13 +136,24 @@ type Server struct {
 	// is called, existing fields are copied into the new config.
 	TLS *tls.Config
 
-	// Config may be changed after calling NewUnstartedServer and
-	// before Start or StartTLS.
+	// Config may be changed before calling Client, Start, or StartTLS.
 	Config *http.Server
 
+	t testing.TB
+
 	// certificate is a parsed version of the TLS config certificate, if present.
 	certificate *x509.Certificate
 
+	// startOnce is used to start fakenet servers once.
+	startOnce sync.Once
+
+	// started indicates whether the server has been started.
+	started bool
+
+	// Fake network listeners, one for HTTP and one for HTTPS.
+	fakeListener    *nettest.Listener
+	fakeTLSListener *nettest.Listener
+
 	// wg counts the number of outstanding HTTP requests on this server.
 	// Close blocks until all requests are finished.
 	wg sync.WaitGroup
@@ -58,6 +167,51 @@ type Server struct {
 	client *http.Client
 }
 
+// NewTestServer returns a new [Server] for a test.
+// The server will use an in-memory network implementation by default.
+//
+// If the handler is nil, the server will serve 500 responses to all requests.
+// It will not use [http.DefaultServeMux].
+//
+// See the [Server] documentation for more details.
+func NewTestServer(t testing.TB, handler http.Handler) *Server {
+	s := &Server{
+		t:      t,
+		Config: &http.Server{Handler: testServerHandler{t: t, h: handler}},
+	}
+	t.Cleanup(func() {
+		s.Close()
+	})
+	return s
+}
+
+type testServerHandler struct {
+	t testing.TB
+	h http.Handler
+}
+
+func (h testServerHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	defer func() {
+		if err := recover(); err != nil {
+			if err != http.ErrAbortHandler {
+				// This is the same logging http.Server would do,
+				// but we can put it into the test output rather than stderr.
+				const size = 64 << 10
+				buf := make([]byte, size)
+				buf = buf[:runtime.Stack(buf, false)]
+				h.t.Errorf("httptest: panic in server handler: %v\n%s", err, buf)
+			}
+			// Convert panic to ErrAbortHandler to suppress http.Server's logging.
+			panic(http.ErrAbortHandler)
+		}
+	}()
+	if h.h != nil {
+		h.h.ServeHTTP(w, req)
+	} else {
+		w.WriteHeader(500)
+	}
+}
+
 func newLocalListener() net.Listener {
 	if serveFlag != "" {
 		l, err := net.Listen("tcp", serveFlag)
@@ -101,20 +255,30 @@ func strSliceContainsPrefix(v []string, pre string) bool {
 	return false
 }
 
-// NewServer starts and returns a new [Server].
-// The caller should call Close when finished, to shut it down.
+// NewServer starts and returns a new [Server] listening on a
+// local network loopback interface.
+// This is equivalent to calling [NewUnstartedServer] followed by [Server.Start].
+//
+// The caller should call [Server.Close] when finished, to shut it down.
+//
+// Most users should use [NewTestServer] instead.
+// See the [Server] documentation for details.
 func NewServer(handler http.Handler) *Server {
 	ts := NewUnstartedServer(handler)
 	ts.Start()
 	return ts
 }
 
-// NewUnstartedServer returns a new [Server] but doesn't start it.
+// NewUnstartedServer returns a new [Server] listening on a
+// local network loopback interface. It does not start the server.
+//
+// After changing the server's configuration, the caller should
+// call [Server.Start] or [Server.StartTLS].
 //
-// After changing its configuration, the caller should call Start or
-// StartTLS.
+// The caller should call [Server.Close] when finished, to shut it down.
 //
-// The caller should call Close when finished, to shut it down.
+// Most users should use [NewTestServer] instead.
+// See the [Server] documentation for details.
 func NewUnstartedServer(handler http.Handler) *Server {
 	return &Server{
 		Listener: newLocalListener(),
@@ -122,50 +286,69 @@ func NewUnstartedServer(handler http.Handler) *Server {
 	}
 }
 
-// Start starts a server from NewUnstartedServer.
-func (s *Server) Start() {
-	if s.URL != "" {
+func (s *Server) startCommon(useLoopback bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.started {
 		panic("Server already started")
 	}
-
-	if s.client == nil {
-		tr := &http.Transport{}
-		dialer := net.Dialer{}
-		// User code may set either of Dial or DialContext, with DialContext taking precedence.
-		// We set DialContext here to preserve any context values that are passed in,
-		// but fall back to Dial if the user has set it.
-		tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
-			if tr.Dial != nil {
-				return tr.Dial(network, addr)
-			}
-			if addr == "example.com:80" || strings.HasSuffix(addr, ".example.com:80") {
-				addr = s.Listener.Addr().String()
-			}
-			return dialer.DialContext(ctx, network, addr)
+	if s.closed {
+		panic("Start of closed Server")
+	}
+	s.started = true
+	if s.t != nil && useLoopback {
+		// We're being called from Start or StartTLS.
+		// Don't try to start the server again when Client is called.
+		s.startOnce.Do(func() {})
+
+		// NewTestServer servers create their listener at start time.
+		//
+		// We might want to permit the user to provide their own Listener
+		// in the future. For now, we panic.
+		if s.Listener != nil {
+			panic("Server.Listener is unexpectedly set")
 		}
-		s.client = &http.Client{Transport: tr}
+		s.Listener = newLocalListener()
+	}
+	s.wrap()
+}
+
+// Start starts a server on a local loopback network interface.
+//
+// The server should have been created by [NewTestServer] or [NewUnstartedServer].
+func (s *Server) Start() {
+	s.startCommon(true)
 
+	tr := &http.Transport{}
+	s.client = &http.Client{Transport: tr}
+	if s.Listener == nil {
+		return
+	}
+	dialer := net.Dialer{}
+	// User code may set either of Dial or DialContext, with DialContext taking precedence.
+	// We set DialContext here to preserve any context values that are passed in,
+	// but fall back to Dial if the user has set it.
+	tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
+		if tr.Dial != nil {
+			return tr.Dial(network, addr)
+		}
+		if addr == "example.com:80" || strings.HasSuffix(addr, ".example.com:80") {
+			addr = s.Listener.Addr().String()
+		}
+		return dialer.DialContext(ctx, network, addr)
 	}
 	s.URL = "http://" + s.Listener.Addr().String()
-	s.wrap()
-	s.goServe()
+	s.goServe(s.Listener)
 	if serveFlag != "" {
 		fmt.Fprintln(os.Stderr, "httptest: serving on", s.URL)
 		select {}
 	}
 }
 
-// StartTLS starts TLS on a server from NewUnstartedServer.
-func (s *Server) StartTLS() {
-	if s.URL != "" {
-		panic("Server already started")
-	}
-	if s.client == nil {
-		s.client = &http.Client{}
-	}
+func (s *Server) initTLS() (tlsClientConfig *tls.Config, err error) {
 	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
-		panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
+		return nil, err
 	}
 
 	existingConfig := s.TLS
@@ -186,16 +369,37 @@ func (s *Server) StartTLS() {
 	}
 	s.certificate, err = x509.ParseCertificate(s.TLS.Certificates[0].Certificate[0])
 	if err != nil {
-		panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
+		return nil, err
 	}
 	certpool := x509.NewCertPool()
 	certpool.AddCert(s.certificate)
+	return &tls.Config{
+		RootCAs: certpool,
+	}, nil
+}
+
+// Start starts TLS on a server on a local loopback network interface.
+//
+// The server should have been created by [NewTestServer] or [NewUnstartedServer].
+func (s *Server) StartTLS() {
+	s.startCommon(true)
+
+	s.client = &http.Client{}
+
+	tlsClientConfig, err := s.initTLS()
+	if err != nil {
+		panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
+	}
+
 	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{
-			RootCAs: certpool,
-		},
+		TLSClientConfig:   tlsClientConfig,
 		ForceAttemptHTTP2: s.EnableHTTP2,
 	}
+	s.client.Transport = tr
+
+	if s.Listener == nil {
+		return
+	}
 	dialer := net.Dialer{}
 	tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
 		if tr.Dial != nil {
@@ -206,15 +410,51 @@ func (s *Server) StartTLS() {
 		}
 		return dialer.DialContext(ctx, network, addr)
 	}
-	s.client.Transport = tr
 	s.Listener = tls.NewListener(s.Listener, s.TLS)
 	s.URL = "https://" + s.Listener.Addr().String()
-	s.wrap()
-	s.goServe()
+	s.goServe(s.Listener)
+}
+
+func (s *Server) startFakeNet() {
+	s.startCommon(false)
+
+	s.client = &http.Client{}
+
+	tlsClientConfig, err := s.initTLS()
+	if err != nil {
+		panic(fmt.Sprintf("httptest: NewTestServer: %v", err))
+	}
+
+	tr := &http.Transport{
+		TLSClientConfig:   tlsClientConfig,
+		ForceAttemptHTTP2: s.EnableHTTP2,
+	}
+	s.client.Transport = tr
+
+	s.fakeListener = nettest.NewListener()
+	s.fakeTLSListener = nettest.NewListener()
+
+	// Set InsecureSkipVerify rather than depending on a specific server hostname.
+	tr.TLSClientConfig.InsecureSkipVerify = true
+	tr.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+		return s.fakeListener.NewConn(), nil
+	}
+	tr.DialTLSContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+		return tls.Client(s.fakeTLSListener.NewConn(), tr.TLSClientConfig), nil
+	}
+	s.URL = "http://example.com"
+	s.goServe(s.fakeListener)
+	s.goServe(tls.NewListener(s.fakeTLSListener, s.TLS))
 }
 
-// NewTLSServer starts and returns a new [Server] using TLS.
-// The caller should call Close when finished, to shut it down.
+// NewTLSServer starts and returns a new [Server] using TLS and listening on a
+// local network loopback interface.
+// This is equivalent to calling [NewUnstartedServer] followed by [Server.StartTLS].
+//
+// The caller should call [Server.Close] when finished, to shut it down.
+//
+// Most users should use [NewTestServer] instead.
+// See the [Server] documentation for details.
 func NewTLSServer(handler http.Handler) *Server {
 	ts := NewUnstartedServer(handler)
 	ts.StartTLS()
@@ -231,7 +471,13 @@ func (s *Server) Close() {
 	s.mu.Lock()
 	if !s.closed {
 		s.closed = true
-		s.Listener.Close()
+		if s.Listener != nil {
+			s.Listener.Close()
+		}
+		if s.fakeListener != nil {
+			s.fakeListener.Close()
+			s.fakeTLSListener.Close()
+		}
 		s.Config.SetKeepAlivesEnabled(false)
 		for c, st := range s.conns {
 			// Force-close any idle connections (those between
@@ -275,7 +521,6 @@ func (s *Server) Close() {
 			t.CloseIdleConnections()
 		}
 	}
-
 	s.wg.Wait()
 }
 
@@ -327,18 +572,18 @@ func (s *Server) Certificate() *x509.Certificate {
 // Client returns an HTTP client configured for making requests to the server.
 // It is configured to trust the server's TLS test certificate and will
 // close its idle connections on [Server.Close].
-// Use Server.URL as the base URL to send requests to the server.
-// The returned client will also redirect any requests to "example.com"
-// or its subdomains to the server.
 func (s *Server) Client() *http.Client {
+	if s.t != nil {
+		s.startOnce.Do(s.startFakeNet)
+	}
 	return s.client
 }
 
-func (s *Server) goServe() {
+func (s *Server) goServe(li net.Listener) {
 	s.wg.Add(1)
 	go func() {
 		defer s.wg.Done()
-		s.Config.Serve(s.Listener)
+		s.Config.Serve(li)
 	}()
 }
 

package/bin/go/src/net/http/httptrace/trace.go

@@ -12,7 +12,6 @@ import (
 	"internal/nettrace"
 	"net"
 	"net/textproto"
-	"reflect"
 	"time"
 )
 
@@ -176,34 +175,86 @@ func (t *ClientTrace) compose(old *ClientTrace) {
 	if old == nil {
 		return
 	}
-	tv := reflect.ValueOf(t).Elem()
-	ov := reflect.ValueOf(old).Elem()
-	structType := tv.Type()
-	for i := 0; i < structType.NumField(); i++ {
-		tf := tv.Field(i)
-		hookType := tf.Type()
-		if hookType.Kind() != reflect.Func {
-			continue
-		}
-		of := ov.Field(i)
-		if of.IsNil() {
-			continue
-		}
-		if tf.IsNil() {
-			tf.Set(of)
-			continue
-		}
+	t.GetConn = compose1to0(t.GetConn, old.GetConn)
+	t.GotConn = compose1to0(t.GotConn, old.GotConn)
+	t.PutIdleConn = compose1to0(t.PutIdleConn, old.PutIdleConn)
+	t.GotFirstResponseByte = compose0to0(t.GotFirstResponseByte, old.GotFirstResponseByte)
+	t.Got100Continue = compose0to0(t.Got100Continue, old.Got100Continue)
+	t.Got1xxResponse = compose2to1(t.Got1xxResponse, old.Got1xxResponse)
+	t.DNSStart = compose1to0(t.DNSStart, old.DNSStart)
+	t.DNSDone = compose1to0(t.DNSDone, old.DNSDone)
+	t.ConnectStart = compose2to0(t.ConnectStart, old.ConnectStart)
+	t.ConnectDone = compose3to0(t.ConnectDone, old.ConnectDone)
+	t.TLSHandshakeStart = compose0to0(t.TLSHandshakeStart, old.TLSHandshakeStart)
+	t.TLSHandshakeDone = compose2to0(t.TLSHandshakeDone, old.TLSHandshakeDone)
+	t.WroteHeaderField = compose2to0(t.WroteHeaderField, old.WroteHeaderField)
+	t.WroteHeaders = compose0to0(t.WroteHeaders, old.WroteHeaders)
+	t.Wait100Continue = compose0to0(t.Wait100Continue, old.Wait100Continue)
+	t.WroteRequest = compose1to0(t.WroteRequest, old.WroteRequest)
+}
 
-		// Make a copy of tf for tf to call. (Otherwise it
-		// creates a recursive call cycle and stack overflows)
-		tfCopy := reflect.ValueOf(tf.Interface())
+func compose0to0[F func()](f1, f2 F) F {
+	if f1 == nil {
+		return f2
+	}
+	if f2 == nil {
+		return f1
+	}
+	return func() {
+		f1()
+		f2()
+	}
+}
+
+func compose1to0[F func(A), A any](f1, f2 F) F {
+	if f1 == nil {
+		return f2
+	}
+	if f2 == nil {
+		return f1
+	}
+	return func(a A) {
+		f1(a)
+		f2(a)
+	}
+}
 
-		// We need to call both tf and of in some order.
-		newFunc := reflect.MakeFunc(hookType, func(args []reflect.Value) []reflect.Value {
-			tfCopy.Call(args)
-			return of.Call(args)
-		})
-		tv.Field(i).Set(newFunc)
+func compose2to0[F func(A, B), A, B any](f1, f2 F) F {
+	if f1 == nil {
+		return f2
+	}
+	if f2 == nil {
+		return f1
+	}
+	return func(a A, b B) {
+		f1(a, b)
+		f2(a, b)
+	}
+}
+
+func compose2to1[F func(A, B) R, A, B, R any](f1, f2 F) F {
+	if f1 == nil {
+		return f2
+	}
+	if f2 == nil {
+		return f1
+	}
+	return func(a A, b B) R {
+		f1(a, b)
+		return f2(a, b)
+	}
+}
+
+func compose3to0[F func(A, B, C), A, B, C any](f1, f2 F) F {
+	if f1 == nil {
+		return f2
+	}
+	if f2 == nil {
+		return f1
+	}
+	return func(a A, b B, c C) {
+		f1(a, b, c)
+		f2(a, b, c)
 	}
 }
 

package/bin/go/src/net/http/httputil/reverseproxy.go

@@ -22,7 +22,6 @@ import (
 	"net/url"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"golang.org/x/net/http/httpguts"
@@ -437,18 +436,6 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 		outreq.Body = nil // Issue 16036: nil Body for http.Transport retries
 	}
 	if outreq.Body != nil {
-		// Wrap the body in a reader where Close does nothing. This is done
-		// because p.Transport.RoundTrip would close the reverse proxy's
-		// outbound request body if it fails to connect to upstream. If we do
-		// not wrap the body, when we close the reverse proxy's outbound
-		// request, it will also close the reverse proxy's inbound request body
-		// (i.e. the client's outbound request body). This is because
-		// http.(*Request).Clone creates a shallow copy of the body. This can
-		// cause an infinite hang in cases where the body is not yet received
-		// from the client (e.g. 100-continue requests): Close, which
-		// internally tries to consume the body content, would be called too
-		// early and would hang.
-		outreq.Body = &noopCloseReader{readCloser: outreq.Body}
 		// Reading from the request body after returning from a handler is not
 		// allowed, and the RoundTrip goroutine that reads the Body can outlive
 		// this handler. This can lead to a crash if the handler panics (see
@@ -983,20 +970,3 @@ func ishex(c byte) bool {
 	}
 	return false
 }
-
-type noopCloseReader struct {
-	readCloser io.ReadCloser
-	closed     atomic.Bool
-}
-
-func (ncr *noopCloseReader) Close() error {
-	ncr.closed.Store(true)
-	return nil
-}
-
-func (ncr *noopCloseReader) Read(p []byte) (int, error) {
-	if ncr.closed.Load() {
-		return 0, errors.New("ReverseProxy does an invalid Read on closed Body")
-	}
-	return ncr.readCloser.Read(p)
-}

package/bin/go/src/net/http/internal/common.go

@@ -0,0 +1,14 @@
+// Copyright 2026 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 internal
+
+import "errors"
+
+var (
+	ErrAbortHandler    = errors.New("net/http: abort Handler")
+	ErrBodyNotAllowed  = errors.New("http: request method or response status code does not allow body")
+	ErrRequestCanceled = errors.New("net/http: request canceled")
+	ErrSkipAltProtocol = errors.New("net/http: skip alternate protocol")
+)