ackhandler: migrate the packet number generator tests away from Ginkgo (#5081)

internal/ackhandler/packet_number_generator_test.go

@@ -1,109 +1,92 @@
 package ackhandler
 
 import (
-	"fmt"
 	"math"
+	"testing"
 
 	"github.com/quic-go/quic-go/internal/protocol"
 
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/require"
 )
 
-var _ = Describe("Sequential Packet Number Generator", func() {
-	It("generates sequential packet numbers", func() {
-		const initialPN protocol.PacketNumber = 123
-		png := newSequentialPacketNumberGenerator(initialPN)
+func TestSequentialPacketNumberGenerator(t *testing.T) {
+	const initialPN protocol.PacketNumber = 123
+	png := newSequentialPacketNumberGenerator(initialPN)
 
-		for i := initialPN; i < initialPN+1000; i++ {
-			Expect(png.Peek()).To(Equal(i))
-			Expect(png.Peek()).To(Equal(i))
-			skipNext, pn := png.Pop()
-			Expect(skipNext).To(BeFalse())
-			Expect(pn).To(Equal(i))
+	for i := initialPN; i < initialPN+1000; i++ {
+		require.Equal(t, i, png.Peek())
+		require.Equal(t, i, png.Peek())
+		skipNext, pn := png.Pop()
+		require.False(t, skipNext)
+		require.Equal(t, i, pn)
+	}
+}
+
+func TestSkippingPacketNumberGenerator(t *testing.T) {
+	// the maximum period must be sufficiently small such that using a 32-bit random number is ok
+	require.Less(t, 2*protocol.SkipPacketMaxPeriod, protocol.PacketNumber(math.MaxInt32))
+
+	const initialPeriod protocol.PacketNumber = 25
+	const maxPeriod protocol.PacketNumber = 300
+
+	png := newSkippingPacketNumberGenerator(100, initialPeriod, maxPeriod)
+	require.Equal(t, protocol.PacketNumber(100), png.Peek())
+	require.Equal(t, protocol.PacketNumber(100), png.Peek())
+	require.Equal(t, protocol.PacketNumber(100), png.Peek())
+	_, pn := png.Pop()
+	require.Equal(t, protocol.PacketNumber(100), pn)
+
+	var last protocol.PacketNumber
+	var skipped bool
+	for i := range maxPeriod {
+		didSkip, num := png.Pop()
+		if didSkip {
+			skipped = true
+			_, nextNum := png.Pop()
+			require.Equal(t, num+1, nextNum)
+			break
 		}
-	})
-})
+		if i != 0 {
+			require.Equal(t, num, last+1)
+		}
+		last = num
+	}
+	require.True(t, skipped)
+}
 
-var _ = Describe("Skipping Packet Number Generator", func() {
+func TestSkippingPacketNumberGeneratorPeriods(t *testing.T) {
 	const initialPN protocol.PacketNumber = 8
 	const initialPeriod protocol.PacketNumber = 25
 	const maxPeriod protocol.PacketNumber = 300
 
-	It("uses a maximum period that is sufficiently small such that using a 32-bit random number is ok", func() {
-		Expect(2 * protocol.SkipPacketMaxPeriod).To(BeNumerically("<", math.MaxInt32))
-	})
+	const rep = 2500
+	periods := make([][]protocol.PacketNumber, rep)
+	expectedPeriods := []protocol.PacketNumber{25, 50, 100, 200, 300, 300, 300}
 
-	It("can be initialized to return any first packet number", func() {
-		png := newSkippingPacketNumberGenerator(12345, initialPeriod, maxPeriod)
-		_, pn := png.Pop()
-		Expect(pn).To(Equal(protocol.PacketNumber(12345)))
-	})
-
-	It("allows peeking", func() {
-		png := newSkippingPacketNumberGenerator(initialPN, initialPeriod, maxPeriod).(*skippingPacketNumberGenerator)
-		Expect(png.Peek()).To(Equal(initialPN))
-		Expect(png.Peek()).To(Equal(initialPN))
-		skipped, pn := png.Pop()
-		Expect(pn).To(Equal(initialPN))
-		next := initialPN + 1
-		if skipped {
-			next++
-		}
-		Expect(png.Peek()).To(Equal(next))
-		Expect(png.Peek()).To(Equal(next))
-	})
-
-	It("skips a packet number", func() {
+	for i := range rep {
 		png := newSkippingPacketNumberGenerator(initialPN, initialPeriod, maxPeriod)
-		var last protocol.PacketNumber
-		var skipped bool
-		for i := 0; i < int(maxPeriod); i++ {
-			didSkip, num := png.Pop()
-			if didSkip {
-				skipped = true
-				_, nextNum := png.Pop()
-				Expect(nextNum).To(Equal(num + 1))
-				break
-			}
-			if i != 0 {
-				Expect(num).To(Equal(last + 1))
-			}
-			last = num
-		}
-		Expect(skipped).To(BeTrue())
-	})
-
-	It("generates a new packet number to skip", func() {
-		const rep = 2500
-		periods := make([][]protocol.PacketNumber, rep)
-		expectedPeriods := []protocol.PacketNumber{25, 50, 100, 200, 300, 300, 300}
-
-		for i := 0; i < rep; i++ {
-			png := newSkippingPacketNumberGenerator(initialPN, initialPeriod, maxPeriod)
-			lastSkip := initialPN
-			for len(periods[i]) < len(expectedPeriods) {
-				skipNext, next := png.Pop()
-				if skipNext {
-					skipped := next + 1
-					Expect(skipped).To(BeNumerically(">", lastSkip+1))
-					periods[i] = append(periods[i], skipped-lastSkip-1)
-					lastSkip = skipped
-				}
+		lastSkip := initialPN
+		for len(periods[i]) < len(expectedPeriods) {
+			skipNext, next := png.Pop()
+			if skipNext {
+				skipped := next + 1
+				require.Greater(t, skipped, lastSkip+1)
+				periods[i] = append(periods[i], skipped-lastSkip-1)
+				lastSkip = skipped
 			}
 		}
+	}
 
-		for j := 0; j < len(expectedPeriods); j++ {
-			var average float64
-			for i := 0; i < rep; i++ {
-				average += float64(periods[i][j]) / float64(len(periods))
-			}
-			fmt.Fprintf(GinkgoWriter, "Period %d: %.2f (expected %d)\n", j, average, expectedPeriods[j])
-			tolerance := protocol.PacketNumber(5)
-			if t := expectedPeriods[j] / 10; t > tolerance {
-				tolerance = t
-			}
-			Expect(average).To(BeNumerically("~", expectedPeriods[j]+1 /* we never skip two packet numbers at the same time */, tolerance))
+	for j := range expectedPeriods {
+		var average float64
+		for i := range rep {
+			average += float64(periods[i][j]) / float64(len(periods))
 		}
-	})
-})
+		t.Logf("Period %d: %.2f (expected %d)\n", j, average, expectedPeriods[j])
+		require.InDelta(t,
+			float64(expectedPeriods[j]+1),
+			average,
+			float64(max(protocol.PacketNumber(5), expectedPeriods[j]/10)),
+		)
+	}
+}