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

diff --git a/internal/ackhandler/packet_number_generator_test.go b/internal/ackhandler/packet_number_generator_test.go
index 4384c8f8eee255ccaf9a1921a1d0e142b8529cb7..9ec93c1583f1b326d5cb9c5f61df88927889636e 100644 (file)
--- 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))
 
-var _ = Describe("Skipping Packet Number Generator", func() {
-       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))
-       })
-
-       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)))
-       })
+       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)
 
-       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++
+       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
                }
-               Expect(png.Peek()).To(Equal(next))
-               Expect(png.Peek()).To(Equal(next))
-       })
-
-       It("skips a packet number", func() {
-               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
+               if i != 0 {
+                       require.Equal(t, num, last+1)
                }
-               Expect(skipped).To(BeTrue())
-       })
+               last = num
+       }
+       require.True(t, skipped)
+}
 
-       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}
+func TestSkippingPacketNumberGeneratorPeriods(t *testing.T) {
+       const initialPN protocol.PacketNumber = 8
+       const initialPeriod protocol.PacketNumber = 25
+       const maxPeriod protocol.PacketNumber = 300
+
+       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
-                               }
+       for i := range rep {
+               png := newSkippingPacketNumberGenerator(initialPN, initialPeriod, maxPeriod)
+               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)),
+               )
+       }
+}