gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

better test structurve for OutgoingPacketAckHandler

Browse Source
This commit is contained in:
Marten Seemann
2016-04-25 12:17:49 +07:00
parent c9b01a3785
commit bf7875426a
2 changed files with 187 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
ackhandler/outgoing_packet_ack_handler_test.go
View File

@@ -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)
expectedEntropy.Add(packet1.PacketNumber, packet1.EntropyBit)
entropy := EntropyAccumulator(0)
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)
Expect(handler.packetHistory[2].Entropy).To(Equal(expectedEntropy))
entropy.Add(packet2.PacketNumber, packet2.EntropyBit)
Expect(handler.packetHistory[2].Entropy).To(Equal(entropy))
})
})
Context("ACK handling", func() {
var (
packets []*Packet
)
Context("ACK entropy checks", func() {
var 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: 6, Plaintext: []byte{0x54, 0x32}, EntropyBit: true},
&Packet{PacketNumber: 5, Plaintext: []byte{0x12, 0x42}, 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(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)))
Expect(handler.highestInOrderAckedEntropy).To(Equal(entropy))
})
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)
expectedEntropy.Add(1, packets[0].EntropyBit)
entropy := EntropyAccumulator(0)
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)
expectedEntropy.Add(1, packets[0].EntropyBit)
entropy := EntropyAccumulator(0)
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)
expectedEntropy.Add(3, packets[2].EntropyBit)
entropy.Add(2, packets[1].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() {
nackRange := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
It("accepts an ACK with one NACK range and one missing packet", func() {
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.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)))
Expect(handler.highestInOrderAckedEntropy).To(Equal(highestInOrderAckedEntropy))
})
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)
expectedEntropy.Add(1, packets[0].EntropyBit)
entropy := EntropyAccumulator(0)
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() {
It("queues a packet for retransmission", func() {
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)))
})
Context("Retransmission handler", func() {
var packets []*Packet
It("dequeues a packet for retransmission", func() {
retransmissionThreshold = 1
nackRange := 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{nackRange},
}
err := handler.ReceivedAck(&ack1)
Expect(err).ToNot(HaveOccurred())
entropy.Add(4, packets[3].EntropyBit)
ack2 := frames.AckFrame{
LargestObserved: 4,
Entropy: byte(entropy),
NackRanges: []frames.NackRange{nackRange},
}
err = handler.ReceivedAck(&ack2)
Expect(err).ToNot(HaveOccurred())
Expect(handler.DequeuePacketForRetransmission()).ToNot(BeNil())
Expect(handler.DequeuePacketForRetransmission()).To(BeNil())
})
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{0x12, 0x42}, EntropyBit: false},
&Packet{PacketNumber: 6, Plaintext: []byte{0xCA, 0xFE}, EntropyBit: false},
}
for _, packet := range packets {
handler.SentPacket(packet)
}
})
It("queues a packet for retransmission", func() {
retransmissionThreshold = 1
nackRange1 := frames.NackRange{FirstPacketNumber: 4, LastPacketNumber: 4}
nackRange2 := frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 2}
ack1 := frames.AckFrame{
LargestObserved: 3,
NackRanges: []frames.NackRange{nackRange2},
}
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())
})
})
})