From 597fee0b3442304f44f8a2e7a77623acc18b3e38 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Sun, 27 Apr 2025 17:27:28 +0800 Subject: [PATCH] ackhandler: migrate the packet number generator tests away from Ginkgo (#5081) --- .../packet_number_generator_test.go | 157 ++++++++---------- 1 file changed, 70 insertions(+), 87 deletions(-) diff --git a/internal/ackhandler/packet_number_generator_test.go b/internal/ackhandler/packet_number_generator_test.go index 4384c8f8e..9ec93c158 100644 --- a/internal/ackhandler/packet_number_generator_test.go +++ b/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)), + ) + } +}