use synctest to make the datagram queue tests fully deterministic (#5305)

datagram_queue_test.go

@@ -3,8 +3,8 @@ package quic
 import (
 	"context"
 	"testing"
-	"time"
 
+	"github.com/quic-go/quic-go/internal/synctest"
 	"github.com/quic-go/quic-go/internal/utils"
 	"github.com/quic-go/quic-go/internal/wire"
 
@@ -27,43 +27,49 @@ func TestDatagramQueuePeekAndPop(t *testing.T) {
 }
 
 func TestDatagramQueueSendQueueLength(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
 		queue := newDatagramQueue(func() {}, utils.DefaultLogger)
 
-	for i := 0; i < maxDatagramSendQueueLen; i++ {
+		for range maxDatagramSendQueueLen {
 			require.NoError(t, queue.Add(&wire.DatagramFrame{Data: []byte{0}}))
 		}
 		errChan := make(chan error, 1)
 		go func() { errChan <- queue.Add(&wire.DatagramFrame{Data: []byte("foobar")}) }()
 
+		synctest.Wait()
+
 		select {
 		case <-errChan:
 			t.Fatal("expected to not receive error")
-	case <-time.After(scaleDuration(10 * time.Millisecond)):
+		default:
 		}
 
 		// peeking doesn't remove the datagram from the queue...
 		require.NotNil(t, queue.Peek())
+		synctest.Wait()
 		select {
 		case <-errChan:
 			t.Fatal("expected to not receive error")
-	case <-time.After(scaleDuration(10 * time.Millisecond)):
+		default:
 		}
 
 		// ...but popping does
 		queue.Pop()
+		synctest.Wait()
 		select {
 		case err := <-errChan:
 			require.NoError(t, err)
-	case <-time.After(time.Second):
+		default:
 			t.Fatal("timeout")
 		}
 		// pop all the remaining datagrams
-	for i := 1; i < maxDatagramSendQueueLen; i++ {
+		for range maxDatagramSendQueueLen - 1 {
 			queue.Pop()
 		}
 		f := queue.Peek()
 		require.NotNil(t, f)
 		require.Equal(t, &wire.DatagramFrame{Data: []byte("foobar")}, f)
+	})
 }
 
 func TestDatagramQueueReceive(t *testing.T) {
@@ -81,6 +87,7 @@ func TestDatagramQueueReceive(t *testing.T) {
 }
 
 func TestDatagramQueueReceiveBlocking(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
 		queue := newDatagramQueue(func() {}, utils.DefaultLogger)
 
 		// block until a new frame is received
@@ -94,18 +101,21 @@ func TestDatagramQueueReceiveBlocking(t *testing.T) {
 			resultChan <- result{data, err}
 		}()
 
+		synctest.Wait()
+
 		select {
 		case <-resultChan:
 			t.Fatal("expected to not receive result")
-	case <-time.After(scaleDuration(10 * time.Millisecond)):
+		default:
 		}
 		queue.HandleDatagramFrame(&wire.DatagramFrame{Data: []byte("foobar")})
+		synctest.Wait()
 		select {
 		case result := <-resultChan:
 			require.NoError(t, result.err)
 			require.Equal(t, []byte("foobar"), result.data)
-	case <-time.After(time.Second):
-		t.Fatal("timeout")
+		default:
+			t.Fatal("should have received a datagram frame")
 		}
 
 		// unblock when the context is canceled
@@ -115,24 +125,31 @@ func TestDatagramQueueReceiveBlocking(t *testing.T) {
 			_, err := queue.Receive(ctx)
 			errChan <- err
 		}()
+
+		synctest.Wait()
 		select {
 		case <-errChan:
 			t.Fatal("expected to not receive error")
-	case <-time.After(scaleDuration(10 * time.Millisecond)):
+		default:
 		}
+
 		cancel()
+		synctest.Wait()
+
 		select {
 		case err := <-errChan:
 			require.ErrorIs(t, err, context.Canceled)
-	case <-time.After(time.Second):
-		t.Fatal("timeout")
+		default:
+			t.Fatal("should have received a context canceled error")
 		}
+	})
 }
 
 func TestDatagramQueueClose(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
 		queue := newDatagramQueue(func() {}, utils.DefaultLogger)
 
-	for i := 0; i < maxDatagramSendQueueLen; i++ {
+		for range maxDatagramSendQueueLen {
 			require.NoError(t, queue.Add(&wire.DatagramFrame{Data: []byte{0}}))
 		}
 		errChan1 := make(chan error, 1)
@@ -144,18 +161,20 @@ func TestDatagramQueueClose(t *testing.T) {
 		}()
 
 		queue.CloseWithError(assert.AnError)
+		synctest.Wait()
 
 		select {
 		case err := <-errChan1:
 			require.ErrorIs(t, err, assert.AnError)
-	case <-time.After(time.Second):
-		t.Fatal("timeout")
+		default:
+			t.Fatal("should have received an error")
 		}
 
 		select {
 		case err := <-errChan2:
 			require.ErrorIs(t, err, assert.AnError)
-	case <-time.After(time.Second):
-		t.Fatal("timeout")
+		default:
+			t.Fatal("should have received an error")
 		}
+	})
 }