net/http: add support for running HTTP tests against HTTP/3

Add support within clientserver_test.go to bring up a test HTTP/3 server
and client when http3Mode testMode option is passed.

To be able to reuse net/http/httptest, net/http/httptest.Server.StartTLS
(and Start) have been modified so they can be called with a nil
Listener. In such cases, both methods will behave identically as usual,
but will not actually make its server serve or set its transport dialer,
both of which requires having a listener. This should be a no-op for
regular users of the package, whose entrypoint via functions such as
NewServer will automatically set a local listener.

Actually enabling HTTP/3 for our tests will be done in a separate CL.

For #70914

Change-Id: Ibc5fc83287b6a04b46e668a54924761a92b620a4
Reviewed-on: https://go-review.googlesource.com/c/go/+/740122
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Nicholas Husin <husin@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

1 files changed, 63 insertions, 0 deletions

diff --git a/src/vendor/golang.org/x/net/quic/queue.go b/src/vendor/golang.org/x/net/quic/queue.go
new file mode 100644
index 0000000000..f2712f4012
--- /dev/null
+++ b/src/vendor/golang.org/x/net/quic/queue.go
@@ -0,0 +1,63 @@
+// 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 quic
+
+import "context"
+
+// A queue is an unbounded queue of some item (new connections and streams).
+type queue[T any] struct {
+	// The gate condition is set if the queue is non-empty or closed.
+	gate gate
+	err  error
+	q    []T
+}
+
+func newQueue[T any]() queue[T] {
+	return queue[T]{gate: newGate()}
+}
+
+// close closes the queue, causing pending and future pop operations
+// to return immediately with err.
+func (q *queue[T]) close(err error) {
+	q.gate.lock()
+	defer q.unlock()
+	if q.err == nil {
+		q.err = err
+	}
+}
+
+// put appends an item to the queue.
+// It returns true if the item was added, false if the queue is closed.
+func (q *queue[T]) put(v T) bool {
+	q.gate.lock()
+	defer q.unlock()
+	if q.err != nil {
+		return false
+	}
+	q.q = append(q.q, v)
+	return true
+}
+
+// get removes the first item from the queue, blocking until ctx is done, an item is available,
+// or the queue is closed.
+func (q *queue[T]) get(ctx context.Context) (T, error) {
+	var zero T
+	if err := q.gate.waitAndLock(ctx); err != nil {
+		return zero, err
+	}
+	defer q.unlock()
+	if q.err != nil {
+		return zero, q.err
+	}
+	v := q.q[0]
+	copy(q.q[:], q.q[1:])
+	q.q[len(q.q)-1] = zero
+	q.q = q.q[:len(q.q)-1]
+	return v, nil
+}
+
+func (q *queue[T]) unlock() {
+	q.gate.unlock(q.err != nil || len(q.q) > 0)
+}