use synctest for the stateless reset tests (#5415)

integrationtests/self/stateless_reset_test.go

@@ -3,13 +3,14 @@ package self_test
 import (
 	"context"
 	"crypto/rand"
-	"net"
 	"sync/atomic"
 	"testing"
 	"time"
 
 	"github.com/quic-go/quic-go"
-	quicproxy "github.com/quic-go/quic-go/integrationtests/tools/proxy"
+	"github.com/quic-go/quic-go/internal/synctest"
+	"github.com/quic-go/quic-go/testutils/simnet"
+
 	"github.com/stretchr/testify/require"
 )
 
@@ -23,15 +24,23 @@ func TestStatelessResets(t *testing.T) {
 }
 
 func testStatelessReset(t *testing.T, connIDLen int) {
+	synctest.Test(t, func(t *testing.T) {
+		var drop atomic.Bool
+		clientPacketConn, serverPacketConn, closeFn := newSimnetLinkWithRouter(t,
+			time.Millisecond,
+			&droppingRouter{Drop: func(p simnet.Packet) bool { return drop.Load() }},
+		)
+		defer closeFn(t)
+
 		var statelessResetKey quic.StatelessResetKey
 		rand.Read(statelessResetKey[:])
 
-	c := newUDPConnLocalhost(t)
 		tr := &quic.Transport{
-		Conn:              c,
+			Conn:              serverPacketConn,
 			StatelessResetKey: &statelessResetKey,
 		}
 		defer tr.Close()
+
 		ln, err := tr.Listen(getTLSConfig(), getQuicConfig(nil))
 		require.NoError(t, err)
 
@@ -55,26 +64,17 @@ func testStatelessReset(t *testing.T, connIDLen int) {
 			close(serverErr)
 		}()
 
-	var drop atomic.Bool
-	proxy := quicproxy.Proxy{
-		Conn:       newUDPConnLocalhost(t),
-		ServerAddr: ln.Addr().(*net.UDPAddr),
-		DropPacket: func(quicproxy.Direction, net.Addr, net.Addr, []byte) bool { return drop.Load() },
-	}
-	require.NoError(t, proxy.Start())
-	defer proxy.Close()
-
 		var conn *quic.Conn
 		if connIDLen > 0 {
 			cl := &quic.Transport{
-			Conn:               newUDPConnLocalhost(t),
+				Conn:               clientPacketConn,
 				ConnectionIDLength: connIDLen,
 			}
 			defer cl.Close()
 			var err error
 			conn, err = cl.Dial(
 				context.Background(),
-			proxy.LocalAddr(),
+				serverPacketConn.LocalAddr(),
 				getTLSClientConfig(),
 				getQuicConfig(&quic.Config{MaxIdleTimeout: 2 * time.Second}),
 			)
@@ -82,8 +82,8 @@ func testStatelessReset(t *testing.T, connIDLen int) {
 		} else {
 			conn, err = quic.Dial(
 				context.Background(),
-			newUDPConnLocalhost(t),
-			proxy.LocalAddr(),
+				clientPacketConn,
+				serverPacketConn.LocalAddr(),
 				getTLSClientConfig(),
 				getQuicConfig(&quic.Config{MaxIdleTimeout: 2 * time.Second}),
 			)
@@ -106,7 +106,7 @@ func testStatelessReset(t *testing.T, connIDLen int) {
 		// We need to create a new Transport here, since the old one is still sending out
 		// CONNECTION_CLOSE packets for (recently) closed connections).
 		tr2 := &quic.Transport{
-		Conn:              c,
+			Conn:              serverPacketConn,
 			StatelessResetKey: &statelessResetKey,
 		}
 		defer tr2.Close()
@@ -123,4 +123,5 @@ func testStatelessReset(t *testing.T, connIDLen int) {
 		require.Error(t, serr)
 		require.IsType(t, &quic.StatelessResetError{}, serr)
 		require.NoError(t, ln2.Close())
+	})
 }