better test structurve for OutgoingPacketAckHandler

ackhandler/outgoing_packet_ack_handler.go

@@ -9,6 +9,7 @@ import (
 )
 
 var (
+	errAckForUnsentPacket   = errors.New("OutgoingPacketAckHandler: Received ACK for an unsent package")
 	errEntropy              = errors.New("OutgoingPacketAckHandler: Wrong entropy")
 	errMapAccess            = errors.New("OutgoingPacketAckHandler: Packet does not exist in PacketHistory")
 	retransmissionThreshold = uint8(3)
@@ -109,7 +110,7 @@ func (h *outgoingPacketAckHandler) calculateExpectedEntropy(ackFrame *frames.Ack
 
 func (h *outgoingPacketAckHandler) ReceivedAck(ackFrame *frames.AckFrame) error {
 	if ackFrame.LargestObserved > h.lastSentPacketNumber {
-		return errors.New("OutgoingPacketAckHandler: Received ACK for an unsent package")
+		return errAckForUnsentPacket
 	}
 
 	if ackFrame.LargestObserved <= h.LargestObserved { // duplicate or out-of-order AckFrame

ackhandler/outgoing_packet_ack_handler_test.go

@@ -62,26 +62,24 @@ var _ = Describe("AckHandler", func() {
 			packet2 := Packet{PacketNumber: 2, Plaintext: []byte{0xBE, 0xEF}, EntropyBit: true}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
-			expectedEntropy := EntropyAccumulator(0)
+			entropy := EntropyAccumulator(0)
-			expectedEntropy.Add(packet1.PacketNumber, packet1.EntropyBit)
+			entropy.Add(packet1.PacketNumber, packet1.EntropyBit)
 			ack := frames.AckFrame{
 				LargestObserved: 1,
-				Entropy:         byte(expectedEntropy),
+				Entropy:         byte(entropy),
 			}
 			err = handler.ReceivedAck(&ack)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.lastSentPacketNumber).To(Equal(protocol.PacketNumber(2)))
-			expectedEntropy.Add(packet2.PacketNumber, packet2.EntropyBit)
+			entropy.Add(packet2.PacketNumber, packet2.EntropyBit)
-			Expect(handler.packetHistory[2].Entropy).To(Equal(expectedEntropy))
+			Expect(handler.packetHistory[2].Entropy).To(Equal(entropy))
 		})
 	})
 
-	Context("ACK handling", func() {
+	Context("ACK entropy checks", func() {
-		var (
+		var packets []*Packet
-			packets []*Packet
-		)
 
 		BeforeEach(func() {
 			packets = []*Packet{
@@ -89,43 +87,28 @@ var _ = Describe("AckHandler", func() {
 				&Packet{PacketNumber: 2, Plaintext: []byte{0xBE, 0xEF}, EntropyBit: true},
 				&Packet{PacketNumber: 3, Plaintext: []byte{0xCA, 0xFE}, EntropyBit: true},
 				&Packet{PacketNumber: 4, Plaintext: []byte{0x54, 0x32}, EntropyBit: true},
-				&Packet{PacketNumber: 5, Plaintext: []byte{0x54, 0x32}, EntropyBit: true},
+				&Packet{PacketNumber: 5, Plaintext: []byte{0x12, 0x42}, EntropyBit: true},
-				&Packet{PacketNumber: 6, Plaintext: []byte{0x54, 0x32}, EntropyBit: true},
+				&Packet{PacketNumber: 6, Plaintext: []byte{0xCA, 0xFE}, EntropyBit: true},
 			}
 			for _, packet := range packets {
 				handler.SentPacket(packet)
 			}
 		})
 
-		It("rejects ACKs with a too high LargestObserved packet number", func() {
-			ack := frames.AckFrame{
-				LargestObserved: 1337,
-			}
-			err := handler.ReceivedAck(&ack)
-			Expect(err).To(HaveOccurred())
-			Expect(handler.highestInOrderAckedPacketNumber).To(Equal(protocol.PacketNumber(0)))
-		})
-
 		Context("ACKs without NACK ranges", func() {
 			It("handles an ACK with the correct entropy", func() {
-				expectedEntropy := EntropyAccumulator(0)
+				entropy := EntropyAccumulator(0)
 				largestObserved := 4
 				for i := 0; i < largestObserved; i++ {
-					expectedEntropy.Add(packets[i].PacketNumber, packets[i].EntropyBit)
+					entropy.Add(packets[i].PacketNumber, packets[i].EntropyBit)
 				}
 				ack := frames.AckFrame{
 					LargestObserved: protocol.PacketNumber(largestObserved),
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 				}
 				err := handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(handler.highestInOrderAckedPacketNumber).To(Equal(protocol.PacketNumber(largestObserved)))
+				Expect(handler.highestInOrderAckedEntropy).To(Equal(entropy))
-				Expect(handler.highestInOrderAckedEntropy).To(Equal(expectedEntropy))
-				// all packets with packetNumbers smaller or equal largestObserved should be deleted
-				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
-				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(4)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(5)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(6)))
 			})
 
 			It("rejects an ACK with incorrect entropy", func() {
@@ -144,37 +127,37 @@ var _ = Describe("AckHandler", func() {
 			})
 
 			It("checks the entropy after an previous ACK was already received", func() {
-				expectedEntropy := EntropyAccumulator(0)
+				entropy := EntropyAccumulator(0)
-				expectedEntropy.Add(1, packets[0].EntropyBit)
+				entropy.Add(1, packets[0].EntropyBit)
 				ack := frames.AckFrame{
 					LargestObserved: 1,
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 				}
 				err := handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
-				expectedEntropy.Add(2, packets[1].EntropyBit)
+				entropy.Add(2, packets[1].EntropyBit)
 				ack = frames.AckFrame{
 					LargestObserved: 2,
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 				}
 				err = handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("checks the entropy of an ACK after a previous ACK was already received", func() {
-				expectedEntropy := EntropyAccumulator(0)
+				entropy := EntropyAccumulator(0)
-				expectedEntropy.Add(1, packets[0].EntropyBit)
+				entropy.Add(1, packets[0].EntropyBit)
 				ack := frames.AckFrame{
 					LargestObserved: 1,
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 				}
 				err := handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
-				expectedEntropy.Add(2, packets[1].EntropyBit)
+				entropy.Add(2, packets[1].EntropyBit)
-				expectedEntropy.Add(3, packets[2].EntropyBit)
+				entropy.Add(3, packets[2].EntropyBit)
 				ack = frames.AckFrame{
 					LargestObserved: 3,
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 				}
 				err = handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
@@ -182,68 +165,20 @@ var _ = Describe("AckHandler", func() {
 		})
 
 		Context("ACKs with NACK ranges", func() {
-			It("handles an ACK with one NACK range and one missing packet", func() {
+			It("accepts an ACK with one NACK range and one missing packet", func() {
-				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
 				entropy := EntropyAccumulator(0)
+				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
 				entropy.Add(packets[0].PacketNumber, packets[0].EntropyBit) // Packet 1
+				highestInOrderAckedEntropy := entropy
 				entropy.Add(packets[2].PacketNumber, packets[2].EntropyBit) // Packet 3
 				ack := frames.AckFrame{
 					LargestObserved: 3,
-					Entropy:         byte(entropy),
 					NackRanges:      []frames.NackRange{nackRange},
-				}
-				err := handler.ReceivedAck(&ack)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(2)))
-				Expect(handler.packetHistory[2].MissingReports).To(Equal(uint8(1)))
-				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(3)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(4)))
-			})
-
-			It("handles an ACK with one NACK range and two missing packets", func() {
-				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 3}
-				entropy := EntropyAccumulator(0)
-				entropy.Add(packets[0].PacketNumber, packets[0].EntropyBit) // Packet 1
-				entropy.Add(packets[3].PacketNumber, packets[3].EntropyBit) // Packet 4
-				ack := frames.AckFrame{
-					LargestObserved: 4,
 					Entropy:         byte(entropy),
-					NackRanges:      []frames.NackRange{nackRange},
 				}
 				err := handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
+				Expect(handler.highestInOrderAckedEntropy).To(Equal(highestInOrderAckedEntropy))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(2)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(3)))
-				Expect(handler.packetHistory[2].MissingReports).To(Equal(uint8(1)))
-				Expect(handler.packetHistory[3].MissingReports).To(Equal(uint8(1)))
-				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(4)))
-			})
-
-			It("handles an ACK with multiple NACK ranges", func() {
-				nackRanges := []frames.NackRange{
-					frames.NackRange{FirstPacketNumber: 4, LastPacketNumber: 4},
-					frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2},
-				}
-				entropy := EntropyAccumulator(0)
-				entropy.Add(packets[0].PacketNumber, packets[0].EntropyBit) // Packet 1
-				entropy.Add(packets[2].PacketNumber, packets[2].EntropyBit) // Packet 3
-				entropy.Add(packets[4].PacketNumber, packets[4].EntropyBit) // Packet 5
-				ack := frames.AckFrame{
-					LargestObserved: 5,
-					Entropy:         byte(entropy),
-					NackRanges:      nackRanges,
-				}
-				err := handler.ReceivedAck(&ack)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(2)))
-				Expect(handler.packetHistory[2].MissingReports).To(Equal(uint8(1)))
-				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(3)))
-				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(4)))
-				Expect(handler.packetHistory[4].MissingReports).To(Equal(uint8(1)))
-				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(5)))
 			})
 
 			It("rejects an ACK with a NACK that has incorrect entropy", func() {
@@ -264,42 +199,134 @@ var _ = Describe("AckHandler", func() {
 			})
 
 			It("checks the entropy of an ACK with a NACK after a previous ACK was already received", func() {
-				expectedEntropy := EntropyAccumulator(0)
+				entropy := EntropyAccumulator(0)
-				expectedEntropy.Add(1, packets[0].EntropyBit)
+				entropy.Add(1, packets[0].EntropyBit)
 				ack := frames.AckFrame{
 					LargestObserved: 1,
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 				}
 				err := handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
-				expectedEntropy.Add(4, packets[3].EntropyBit)
+				entropy.Add(4, packets[3].EntropyBit)
 				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 3}
 				ack = frames.AckFrame{
 					LargestObserved: 4,
-					Entropy:         byte(expectedEntropy),
+					Entropy:         byte(entropy),
 					NackRanges:      []frames.NackRange{nackRange},
 				}
 				err = handler.ReceivedAck(&ack)
 				Expect(err).ToNot(HaveOccurred())
 			})
+		})
+	})
+
+	Context("ACK processing", func() { // in all these tests, the EntropyBit of each Packet is set to false, so that the resulting EntropyByte will always be 0
+		var packets []*Packet
+
+		BeforeEach(func() {
+			packets = []*Packet{
+				&Packet{PacketNumber: 1, Plaintext: []byte{0x13, 0x37}, EntropyBit: false},
+				&Packet{PacketNumber: 2, Plaintext: []byte{0xBE, 0xEF}, EntropyBit: false},
+				&Packet{PacketNumber: 3, Plaintext: []byte{0xCA, 0xFE}, EntropyBit: false},
+				&Packet{PacketNumber: 4, Plaintext: []byte{0x54, 0x32}, EntropyBit: false},
+				&Packet{PacketNumber: 5, Plaintext: []byte{0x54, 0x32}, EntropyBit: false},
+				&Packet{PacketNumber: 6, Plaintext: []byte{0x54, 0x32}, EntropyBit: false},
+			}
+			for _, packet := range packets {
+				handler.SentPacket(packet)
+			}
+		})
+
+		Context("ACKs without NACK ranges", func() {
+			It("handles an ACK", func() {
+				largestObserved := 4
+				ack := frames.AckFrame{
+					LargestObserved: protocol.PacketNumber(largestObserved),
+				}
+				err := handler.ReceivedAck(&ack)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(handler.highestInOrderAckedPacketNumber).To(Equal(protocol.PacketNumber(largestObserved)))
+				// all packets with packetNumbers smaller or equal largestObserved should be deleted
+				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
+				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(4)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(5)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(6)))
+			})
+
+			It("rejects ACKs with a LargestObserved packet number higher than what was sent out previously", func() {
+				ack := frames.AckFrame{
+					LargestObserved: packets[len(packets)-1].PacketNumber + 1337,
+				}
+				err := handler.ReceivedAck(&ack)
+				Expect(err).To(HaveOccurred())
+				Expect(err).To(Equal(errAckForUnsentPacket))
+				Expect(handler.highestInOrderAckedPacketNumber).To(Equal(protocol.PacketNumber(0)))
+			})
+		})
+
+		Context("ACKs with NACK ranges", func() {
+			It("handles an ACK with one NACK range and one missing packet", func() {
+				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
+				ack := frames.AckFrame{
+					LargestObserved: 3,
+					NackRanges:      []frames.NackRange{nackRange},
+				}
+				err := handler.ReceivedAck(&ack)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(2)))
+				Expect(handler.packetHistory[2].MissingReports).To(Equal(uint8(1)))
+				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(3)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(4)))
+			})
+
+			It("handles an ACK with one NACK range and two missing packets", func() {
+				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 3}
+				ack := frames.AckFrame{
+					LargestObserved: 4,
+					NackRanges:      []frames.NackRange{nackRange},
+				}
+				err := handler.ReceivedAck(&ack)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(2)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(3)))
+				Expect(handler.packetHistory[2].MissingReports).To(Equal(uint8(1)))
+				Expect(handler.packetHistory[3].MissingReports).To(Equal(uint8(1)))
+				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(4)))
+			})
+
+			It("handles an ACK with multiple NACK ranges", func() {
+				nackRanges := []frames.NackRange{
+					frames.NackRange{FirstPacketNumber: 4, LastPacketNumber: 4},
+					frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2},
+				}
+				ack := frames.AckFrame{
+					LargestObserved: 5,
+					NackRanges:      nackRanges,
+				}
+				err := handler.ReceivedAck(&ack)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(1)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(2)))
+				Expect(handler.packetHistory[2].MissingReports).To(Equal(uint8(1)))
+				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(3)))
+				Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(4)))
+				Expect(handler.packetHistory[4].MissingReports).To(Equal(uint8(1)))
+				// Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(5)))
+			})
 
 			It("increments the missingReports counter every time a NACK for a packet is received", func() {
 				nackRange1 := frames.NackRange{FirstPacketNumber: 4, LastPacketNumber: 4}
 				nackRange2 := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
-				entropy := EntropyAccumulator(0)
-				entropy.Add(1, packets[0].EntropyBit)
-				entropy.Add(3, packets[2].EntropyBit)
 				ack1 := frames.AckFrame{
 					LargestObserved: 3,
-					Entropy:         byte(entropy),
 					NackRanges:      []frames.NackRange{nackRange2},
 				}
 				err := handler.ReceivedAck(&ack1)
 				Expect(err).ToNot(HaveOccurred())
-				entropy.Add(5, packets[4].EntropyBit)
 				ack2 := frames.AckFrame{
 					LargestObserved: 5,
-					Entropy:         byte(entropy),
 					NackRanges:      []frames.NackRange{nackRange1, nackRange2},
 				}
 				err = handler.ReceivedAck(&ack2)
@@ -310,58 +337,62 @@ var _ = Describe("AckHandler", func() {
 				Expect(handler.packetHistory[4].MissingReports).To(Equal(uint8(1)))
 			})
 		})
+	})
 
-		Context("Retransmission handler", func() {
+	Context("Retransmission handler", func() {
-			It("queues a packet for retransmission", func() {
+		var packets []*Packet
-				retransmissionThreshold = 1
-				nackRange1 := frames.NackRange{FirstPacketNumber: 4, LastPacketNumber: 4}
-				nackRange2 := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
-				entropy := EntropyAccumulator(0)
-				entropy.Add(1, packets[0].EntropyBit)
-				entropy.Add(3, packets[2].EntropyBit)
-				ack1 := frames.AckFrame{
-					LargestObserved: 3,
-					Entropy:         byte(entropy),
-					NackRanges:      []frames.NackRange{nackRange2},
-				}
-				err := handler.ReceivedAck(&ack1)
-				Expect(err).ToNot(HaveOccurred())
-				entropy.Add(5, packets[4].EntropyBit)
-				ack2 := frames.AckFrame{
-					LargestObserved: 5,
-					Entropy:         byte(entropy),
-					NackRanges:      []frames.NackRange{nackRange1, nackRange2},
-				}
-				err = handler.ReceivedAck(&ack2)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(len(handler.retransmissionQueue)).To(Equal(1))
-				Expect(handler.retransmissionQueue[0].PacketNumber).To(Equal(protocol.PacketNumber(2)))
-			})
 
-			It("dequeues a packet for retransmission", func() {
+		BeforeEach(func() {
-				retransmissionThreshold = 1
+			packets = []*Packet{
-				nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
+				&Packet{PacketNumber: 1, Plaintext: []byte{0x13, 0x37}, EntropyBit: false},
-				entropy := EntropyAccumulator(0)
+				&Packet{PacketNumber: 2, Plaintext: []byte{0xBE, 0xEF}, EntropyBit: false},
-				entropy.Add(1, packets[0].EntropyBit)
+				&Packet{PacketNumber: 3, Plaintext: []byte{0xCA, 0xFE}, EntropyBit: false},
-				entropy.Add(3, packets[2].EntropyBit)
+				&Packet{PacketNumber: 4, Plaintext: []byte{0x54, 0x32}, EntropyBit: false},
-				ack1 := frames.AckFrame{
+				&Packet{PacketNumber: 5, Plaintext: []byte{0x12, 0x42}, EntropyBit: false},
-					LargestObserved: 3,
+				&Packet{PacketNumber: 6, Plaintext: []byte{0xCA, 0xFE}, EntropyBit: false},
-					Entropy:         byte(entropy),
+			}
-					NackRanges:      []frames.NackRange{nackRange},
+			for _, packet := range packets {
-				}
+				handler.SentPacket(packet)
-				err := handler.ReceivedAck(&ack1)
+			}
-				Expect(err).ToNot(HaveOccurred())
+		})
-				entropy.Add(4, packets[3].EntropyBit)
+
-				ack2 := frames.AckFrame{
+		It("queues a packet for retransmission", func() {
-					LargestObserved: 4,
+			retransmissionThreshold = 1
-					Entropy:         byte(entropy),
+			nackRange1 := frames.NackRange{FirstPacketNumber: 4, LastPacketNumber: 4}
-					NackRanges:      []frames.NackRange{nackRange},
+			nackRange2 := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
-				}
+			ack1 := frames.AckFrame{
-				err = handler.ReceivedAck(&ack2)
+				LargestObserved: 3,
-				Expect(err).ToNot(HaveOccurred())
+				NackRanges:      []frames.NackRange{nackRange2},
-				Expect(handler.DequeuePacketForRetransmission()).ToNot(BeNil())
+			}
-				Expect(handler.DequeuePacketForRetransmission()).To(BeNil())
+			err := handler.ReceivedAck(&ack1)
-			})
+			Expect(err).ToNot(HaveOccurred())
+			ack2 := frames.AckFrame{
+				LargestObserved: 5,
+				NackRanges:      []frames.NackRange{nackRange1, nackRange2},
+			}
+			err = handler.ReceivedAck(&ack2)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(handler.retransmissionQueue)).To(Equal(1))
+			Expect(handler.retransmissionQueue[0].PacketNumber).To(Equal(protocol.PacketNumber(2)))
+		})
+
+		It("dequeues a packet for retransmission", func() {
+			retransmissionThreshold = 1
+			nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
+			ack1 := frames.AckFrame{
+				LargestObserved: 3,
+				NackRanges:      []frames.NackRange{nackRange},
+			}
+			err := handler.ReceivedAck(&ack1)
+			Expect(err).ToNot(HaveOccurred())
+			ack2 := frames.AckFrame{
+				LargestObserved: 4,
+				NackRanges:      []frames.NackRange{nackRange},
+			}
+			err = handler.ReceivedAck(&ack2)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(handler.DequeuePacketForRetransmission()).ToNot(BeNil())
+			Expect(handler.DequeuePacketForRetransmission()).To(BeNil())
 		})
 	})
 })