| // Copyright 2023 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package quic | |
| import ( | |
| "fmt" | |
| "testing" | |
| "time" | |
| ) | |
| func TestLossAntiAmplificationLimit(t *testing.T) { | |
| test := newLossTest(t, serverSide, lossTestOpts{}) | |
| test.datagramReceived(1200) | |
| t.Logf("# consume anti-amplification capacity in a mix of packets") | |
| test.send(initialSpace, 0, sentPacket{ | |
| size: 1200, | |
| ackEliciting: true, | |
| inFlight: true, | |
| }) | |
| test.send(initialSpace, 1, sentPacket{ | |
| size: 1200, | |
| ackEliciting: false, | |
| inFlight: false, | |
| }) | |
| test.send(initialSpace, 2, sentPacket{ | |
| size: 1200, | |
| ackEliciting: false, | |
| inFlight: true, | |
| }) | |
| t.Logf("# send blocked by anti-amplification limit") | |
| test.wantSendLimit(ccBlocked) | |
| t.Logf("# receiving a datagram unblocks server") | |
| test.datagramReceived(100) | |
| test.wantSendLimit(ccOK) | |
| t.Logf("# validating client address removes anti-amplification limit") | |
| test.validateClientAddress() | |
| test.wantSendLimit(ccOK) | |
| } | |
| func TestLossRTTSampleNotGenerated(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0, 1) | |
| test.send(initialSpace, 2, sentPacket{ | |
| ackEliciting: false, | |
| inFlight: false, | |
| }) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.wantVar("latest_rtt", 10*time.Millisecond) | |
| t.Logf("# smoothed_rtt = latest_rtt") | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| t.Logf("# rttvar = latest_rtt / 2") | |
| test.wantVar("rttvar", 5*time.Millisecond) | |
| // "...an ACK frame SHOULD NOT be used to update RTT estimates if | |
| // it does not newly acknowledge the largest acknowledged packet." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.1-6 | |
| t.Logf("# acks for older packets do not generate an RTT sample") | |
| test.advance(1 * time.Millisecond) | |
| test.ack(initialSpace, 1*time.Millisecond, i64range[packetNumber]{0, 2}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| // "An RTT sample MUST NOT be generated on receiving an ACK frame | |
| // that does not newly acknowledge at least one ack-eliciting packet." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.1-7 | |
| t.Logf("# acks for non-ack-eliciting packets do not generate an RTT sample") | |
| test.advance(1 * time.Millisecond) | |
| test.ack(initialSpace, 1*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| test.wantAck(initialSpace, 2) | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| } | |
| func TestLossMinRTT(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| // "min_rtt MUST be set to the latest_rtt on the first RTT sample." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2 | |
| t.Logf("# min_rtt set on first sample") | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantVar("min_rtt", 10*time.Millisecond) | |
| // "min_rtt MUST be set to the lesser of min_rtt and latest_rtt [...] | |
| // on all other samples." | |
| t.Logf("# min_rtt does not increase") | |
| test.send(initialSpace, 1) | |
| test.advance(20 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.wantVar("min_rtt", 10*time.Millisecond) | |
| t.Logf("# min_rtt decreases") | |
| test.send(initialSpace, 2) | |
| test.advance(5 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| test.wantAck(initialSpace, 2) | |
| test.wantVar("min_rtt", 5*time.Millisecond) | |
| } | |
| func TestLossMinRTTAfterCongestion(t *testing.T) { | |
| // "Endpoints SHOULD set the min_rtt to the newest RTT sample | |
| // after persistent congestion is established." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-5 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# establish initial RTT sample") | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantVar("min_rtt", 10*time.Millisecond) | |
| t.Logf("# send two packets spanning persistent congestion duration") | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) | |
| t.Logf("# 2000ms >> persistent congestion duration") | |
| test.advance(2000 * time.Millisecond) | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 2, testSentPacketSize(1200)) | |
| t.Logf("# trigger loss of previous packets") | |
| test.advance(10 * time.Millisecond) | |
| test.send(initialSpace, 3, testSentPacketSize(1200)) | |
| test.advance(20 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{3, 4}) | |
| test.wantAck(initialSpace, 3) | |
| test.wantLoss(initialSpace, 1, 2) | |
| t.Logf("# persistent congestion detected") | |
| test.send(initialSpace, 4, testSentPacketSize(1200)) | |
| test.advance(20 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{4, 5}) | |
| test.wantAck(initialSpace, 4) | |
| t.Logf("# min_rtt set from first sample after persistent congestion") | |
| test.wantVar("min_rtt", 20*time.Millisecond) | |
| } | |
| func TestLossInitialRTTSample(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.setMaxAckDelay(2 * time.Millisecond) | |
| t.Logf("# initial smoothed_rtt and rtt values") | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) | |
| test.wantVar("rttvar", 333*time.Millisecond/2) | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-11 | |
| t.Logf("# first RTT sample") | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantVar("latest_rtt", 10*time.Millisecond) | |
| t.Logf("# smoothed_rtt = latest_rtt") | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| t.Logf("# rttvar = latest_rtt / 2") | |
| test.wantVar("rttvar", 5*time.Millisecond) | |
| } | |
| func TestLossSmoothedRTTIgnoresMaxAckDelayBeforeHandshakeConfirmed(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.setMaxAckDelay(1 * time.Millisecond) | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| smoothedRTT := 10 * time.Millisecond | |
| rttvar := 5 * time.Millisecond | |
| // "[...] an endpoint [...] SHOULD ignore the peer's max_ack_delay | |
| // until the handshake is confirmed [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-7.2 | |
| t.Logf("# subsequent RTT sample") | |
| test.send(handshakeSpace, 0) | |
| test.advance(20 * time.Millisecond) | |
| test.ack(handshakeSpace, 10*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(handshakeSpace, 0) | |
| test.wantVar("latest_rtt", 20*time.Millisecond) | |
| t.Logf("# ack_delay > max_ack_delay") | |
| t.Logf("# handshake not confirmed, so ignore max_ack_delay") | |
| t.Logf("# adjusted_rtt = latest_rtt - ackDelay") | |
| adjustedRTT := 10 * time.Millisecond | |
| t.Logf("# smoothed_rtt = 7/8 * smoothed_rtt + 1/8 * adjusted_rtt") | |
| smoothedRTT = (7*smoothedRTT + adjustedRTT) / 8 | |
| test.wantVar("smoothed_rtt", smoothedRTT) | |
| rttvarSample := abs(smoothedRTT - adjustedRTT) | |
| t.Logf("# rttvar_sample = abs(smoothed_rtt - adjusted_rtt) = %v", rttvarSample) | |
| t.Logf("# rttvar = 3/4 * rttvar + 1/4 * rttvar_sample") | |
| rttvar = (3*rttvar + rttvarSample) / 4 | |
| test.wantVar("rttvar", rttvar) | |
| } | |
| func TestLossSmoothedRTTUsesMaxAckDelayAfterHandshakeConfirmed(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.setMaxAckDelay(25 * time.Millisecond) | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| smoothedRTT := 10 * time.Millisecond | |
| rttvar := 5 * time.Millisecond | |
| test.confirmHandshake() | |
| // "[...] an endpoint [...] MUST use the lesser of the acknowledgment | |
| // delay and the peer's max_ack_delay after the handshake is confirmed [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-7.3 | |
| t.Logf("# subsequent RTT sample") | |
| test.send(handshakeSpace, 0) | |
| test.advance(50 * time.Millisecond) | |
| test.ack(handshakeSpace, 40*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(handshakeSpace, 0) | |
| test.wantVar("latest_rtt", 50*time.Millisecond) | |
| t.Logf("# ack_delay > max_ack_delay") | |
| t.Logf("# handshake confirmed, so adjusted_rtt clamps to max_ack_delay") | |
| t.Logf("# adjusted_rtt = max_ack_delay") | |
| adjustedRTT := 25 * time.Millisecond | |
| rttvarSample := abs(smoothedRTT - adjustedRTT) | |
| t.Logf("# rttvar_sample = abs(smoothed_rtt - adjusted_rtt) = %v", rttvarSample) | |
| t.Logf("# rttvar = 3/4 * rttvar + 1/4 * rttvar_sample") | |
| rttvar = (3*rttvar + rttvarSample) / 4 | |
| test.wantVar("rttvar", rttvar) | |
| t.Logf("# smoothed_rtt = 7/8 * smoothed_rtt + 1/8 * adjusted_rtt") | |
| smoothedRTT = (7*smoothedRTT + adjustedRTT) / 8 | |
| test.wantVar("smoothed_rtt", smoothedRTT) | |
| } | |
| func TestLossAckDelayReducesRTTBelowMinRTT(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| smoothedRTT := 10 * time.Millisecond | |
| rttvar := 5 * time.Millisecond | |
| // "[...] an endpoint [...] MUST NOT subtract the acknowledgment delay | |
| // from the RTT sample if the resulting value is smaller than the min_rtt." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-7.4 | |
| t.Logf("# subsequent RTT sample") | |
| test.send(handshakeSpace, 0) | |
| test.advance(12 * time.Millisecond) | |
| test.ack(handshakeSpace, 4*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(handshakeSpace, 0) | |
| test.wantVar("latest_rtt", 12*time.Millisecond) | |
| t.Logf("# latest_rtt - ack_delay < min_rtt, so adjusted_rtt = latest_rtt") | |
| adjustedRTT := 12 * time.Millisecond | |
| rttvarSample := abs(smoothedRTT - adjustedRTT) | |
| t.Logf("# rttvar_sample = abs(smoothed_rtt - adjusted_rtt) = %v", rttvarSample) | |
| t.Logf("# rttvar = 3/4 * rttvar + 1/4 * rttvar_sample") | |
| rttvar = (3*rttvar + rttvarSample) / 4 | |
| test.wantVar("rttvar", rttvar) | |
| t.Logf("# smoothed_rtt = 7/8 * smoothed_rtt + 1/8 * adjusted_rtt") | |
| smoothedRTT = (7*smoothedRTT + adjustedRTT) / 8 | |
| test.wantVar("smoothed_rtt", smoothedRTT) | |
| } | |
| func TestLossPacketThreshold(t *testing.T) { | |
| // "[...] the packet was sent kPacketThreshold packets before an | |
| // acknowledged packet [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.1 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# acking a packet triggers loss of packets sent kPacketThreshold earlier") | |
| test.send(appDataSpace, 0, 1, 2, 3, 4, 5, 6) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{4, 5}) | |
| test.wantAck(appDataSpace, 4) | |
| test.wantLoss(appDataSpace, 0, 1) | |
| } | |
| func TestLossOutOfOrderAcks(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# out of order acks, no loss") | |
| test.send(appDataSpace, 0, 1, 2) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{2, 3}) | |
| test.wantAck(appDataSpace, 2) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(appDataSpace, 1) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(appDataSpace, 0) | |
| } | |
| func TestLossSendAndAck(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(appDataSpace, 0, 1, 2) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| test.wantAck(appDataSpace, 0, 1, 2) | |
| // Redundant ACK doesn't trigger more ACK events. | |
| // (If we did get an extra ACK, the test cleanup would notice and complain.) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| } | |
| func TestLossAckEveryOtherPacket(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(appDataSpace, 0, 1, 2, 3, 4, 5, 6) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(appDataSpace, 0) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{2, 3}) | |
| test.wantAck(appDataSpace, 2) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{4, 5}) | |
| test.wantAck(appDataSpace, 4) | |
| test.wantLoss(appDataSpace, 1) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{6, 7}) | |
| test.wantAck(appDataSpace, 6) | |
| test.wantLoss(appDataSpace, 3) | |
| } | |
| func TestLossMultipleSpaces(t *testing.T) { | |
| // "Loss detection is separate per packet number space [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6-3 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# send packets in different spaces") | |
| test.send(initialSpace, 0, 1, 2) | |
| test.send(handshakeSpace, 0, 1, 2) | |
| test.send(appDataSpace, 0, 1, 2) | |
| t.Logf("# ack one packet in each space") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(handshakeSpace, 1) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(appDataSpace, 1) | |
| t.Logf("# send more packets") | |
| test.send(initialSpace, 3, 4, 5) | |
| test.send(handshakeSpace, 3, 4, 5) | |
| test.send(appDataSpace, 3, 4, 5) | |
| t.Logf("# ack the last packet, triggering loss") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{5, 6}) | |
| test.wantAck(initialSpace, 5) | |
| test.wantLoss(initialSpace, 0, 2) | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{5, 6}) | |
| test.wantAck(handshakeSpace, 5) | |
| test.wantLoss(handshakeSpace, 0, 2) | |
| test.ack(appDataSpace, 0*time.Millisecond, i64range[packetNumber]{5, 6}) | |
| test.wantAck(appDataSpace, 5) | |
| test.wantLoss(appDataSpace, 0, 2) | |
| } | |
| func TestLossTimeThresholdFirstPacketLost(t *testing.T) { | |
| // "[...] the packet [...] was sent long enough in the past." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1-3.2 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# packet 0 lost after time threshold passes") | |
| test.send(initialSpace, 0, 1) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| t.Logf("# latest_rtt == smoothed_rtt") | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| test.wantVar("latest_rtt", 10*time.Millisecond) | |
| t.Logf("# timeout = 9/8 * max(smoothed_rtt, latest_rtt) - time_since_packet_sent") | |
| test.wantTimeout(((10 * time.Millisecond * 9) / 8) - 10*time.Millisecond) | |
| test.advanceToLossTimer() | |
| test.wantLoss(initialSpace, 0) | |
| } | |
| func TestLossTimeThreshold(t *testing.T) { | |
| // "The time threshold is: | |
| // max(kTimeThreshold * max(smoothed_rtt, latest_rtt), kGranularity)" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2-2 | |
| for _, tc := range []struct { | |
| name string | |
| initialRTT time.Duration | |
| latestRTT time.Duration | |
| wantTimeout time.Duration | |
| }{{ | |
| name: "rtt increasing", | |
| initialRTT: 10 * time.Millisecond, | |
| latestRTT: 20 * time.Millisecond, | |
| wantTimeout: 20 * time.Millisecond * 9 / 8, | |
| }, { | |
| name: "rtt decreasing", | |
| initialRTT: 10 * time.Millisecond, | |
| latestRTT: 5 * time.Millisecond, | |
| wantTimeout: ((7*10*time.Millisecond + 5*time.Millisecond) / 8) * 9 / 8, | |
| }, { | |
| name: "rtt less than timer granularity", | |
| initialRTT: 500 * time.Microsecond, | |
| latestRTT: 500 * time.Microsecond, | |
| wantTimeout: 1 * time.Millisecond, | |
| }} { | |
| t.Run(tc.name, func(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# first ack establishes smoothed_rtt") | |
| test.send(initialSpace, 0) | |
| test.advance(tc.initialRTT) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# ack of packet 2 starts loss timer for packet 1") | |
| test.send(initialSpace, 1, 2) | |
| test.advance(tc.latestRTT) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{2, 3}) | |
| test.wantAck(initialSpace, 2) | |
| t.Logf("# smoothed_rtt = %v", test.c.rtt.smoothedRTT) | |
| t.Logf("# latest_rtt = %v", test.c.rtt.latestRTT) | |
| t.Logf("# timeout = max(9/8 * max(smoothed_rtt, latest_rtt), 1ms)") | |
| t.Logf("# (measured since packet 1 sent)") | |
| test.wantTimeout(tc.wantTimeout - tc.latestRTT) | |
| t.Logf("# advancing to the loss time causes loss of packet 1") | |
| test.advanceToLossTimer() | |
| test.wantLoss(initialSpace, 1) | |
| }) | |
| } | |
| } | |
| func TestLossPTONotAckEliciting(t *testing.T) { | |
| // "When an ack-eliciting packet is transmitted, | |
| // the sender schedules a timer for the PTO period [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-1 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# PTO timer for first packet") | |
| test.send(initialSpace, 0) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // initial value | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // initial value | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(999 * time.Millisecond) | |
| t.Logf("# sending a non-ack-eliciting packet doesn't adjust PTO") | |
| test.advance(333 * time.Millisecond) | |
| test.send(initialSpace, 1, sentPacket{ | |
| ackEliciting: false, | |
| }) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // unchanged | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // unchanged | |
| test.wantTimeout(666 * time.Millisecond) | |
| } | |
| func TestLossPTOMaxAckDelay(t *testing.T) { | |
| // "When the PTO is armed for Initial or Handshake packet number spaces, | |
| // the max_ack_delay in the PTO period computation is set to 0 [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-4 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# PTO timer for first packet") | |
| test.send(initialSpace, 0) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // initial value | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // initial value | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(999 * time.Millisecond) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# PTO timer for handshake packet") | |
| test.send(handshakeSpace, 0) | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| test.wantVar("rttvar", 5*time.Millisecond) | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(30 * time.Millisecond) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(handshakeSpace, 0) | |
| test.confirmHandshake() | |
| t.Logf("# PTO timer for appdata packet") | |
| test.send(appDataSpace, 0) | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| test.wantVar("rttvar", 3750*time.Microsecond) | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms) + max_ack_delay (25ms)") | |
| test.wantTimeout(50 * time.Millisecond) | |
| } | |
| func TestLossPTOUnderTimerGranularity(t *testing.T) { | |
| // "The PTO period MUST be at least kGranularity [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-5 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Microsecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.send(initialSpace, 1) | |
| test.wantVar("smoothed_rtt", 10*time.Microsecond) | |
| test.wantVar("rttvar", 5*time.Microsecond) | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(10*time.Microsecond + 1*time.Millisecond) | |
| } | |
| func TestLossPTOMultipleSpaces(t *testing.T) { | |
| // "[...] the timer MUST be set to the earlier value of the Initial and Handshake | |
| // packet number spaces." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-6 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# PTO timer for first packet") | |
| test.send(initialSpace, 0) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // initial value | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // initial value | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(999 * time.Millisecond) | |
| t.Logf("# Initial and Handshake packets in flight, first takes precedence") | |
| test.advance(333 * time.Millisecond) | |
| test.send(handshakeSpace, 0) | |
| test.wantTimeout(666 * time.Millisecond) | |
| t.Logf("# Initial packet acked, Handshake PTO timer armed") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantTimeout(999 * time.Millisecond) | |
| t.Logf("# send Initial, earlier Handshake PTO takes precedence") | |
| test.advance(333 * time.Millisecond) | |
| test.send(initialSpace, 1) | |
| test.wantTimeout(666 * time.Millisecond) | |
| } | |
| func TestLossPTOHandshakeConfirmation(t *testing.T) { | |
| // "An endpoint MUST NOT set its PTO timer for the Application Data | |
| // packet number space until the handshake is confirmed." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-7 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.send(handshakeSpace, 0) | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(handshakeSpace, 0) | |
| test.send(appDataSpace, 0) | |
| test.wantNoTimeout() | |
| } | |
| func TestLossPTOBackoffDoubles(t *testing.T) { | |
| // "When a PTO timer expires, the PTO backoff MUST be increased, | |
| // resulting in the PTO period being set to twice its current value." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 | |
| test := newLossTest(t, serverSide, lossTestOpts{}) | |
| test.datagramReceived(1200) | |
| test.send(initialSpace, 0) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // initial value | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // initial value | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(999 * time.Millisecond) | |
| t.Logf("# wait for PTO timer expiration") | |
| test.advanceToLossTimer() | |
| test.wantPTOExpired() | |
| test.wantNoTimeout() | |
| t.Logf("# PTO timer doubles") | |
| test.send(initialSpace, 1) | |
| test.wantTimeout(2 * 999 * time.Millisecond) | |
| test.advanceToLossTimer() | |
| test.wantPTOExpired() | |
| test.wantNoTimeout() | |
| t.Logf("# PTO timer doubles again") | |
| test.send(initialSpace, 2) | |
| test.wantTimeout(4 * 999 * time.Millisecond) | |
| test.advanceToLossTimer() | |
| test.wantPTOExpired() | |
| test.wantNoTimeout() | |
| } | |
| func TestLossPTOBackoffResetOnAck(t *testing.T) { | |
| // "The PTO backoff factor is reset when an acknowledgment is received [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 | |
| test := newLossTest(t, serverSide, lossTestOpts{}) | |
| test.datagramReceived(1200) | |
| t.Logf("# first ack establishes smoothed_rtt = 10ms") | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# set rttvar for simplicity") | |
| test.setRTTVar(0) | |
| t.Logf("# send packet 1 and wait for PTO") | |
| test.send(initialSpace, 1) | |
| test.wantTimeout(11 * time.Millisecond) | |
| test.advanceToLossTimer() | |
| test.wantPTOExpired() | |
| test.wantNoTimeout() | |
| t.Logf("# send packet 2 & 3, PTO doubles") | |
| test.send(initialSpace, 2, 3) | |
| test.wantTimeout(22 * time.Millisecond) | |
| test.advance(10 * time.Millisecond) | |
| t.Logf("# check remaining PTO (22ms - 10ms elapsed)") | |
| test.wantTimeout(12 * time.Millisecond) | |
| t.Logf("# ACK to packet 2 resets PTO") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| test.wantAck(initialSpace, 1) | |
| test.wantAck(initialSpace, 2) | |
| t.Logf("# check remaining PTO (11ms - 10ms elapsed)") | |
| test.wantTimeout(1 * time.Millisecond) | |
| } | |
| func TestLossPTOBackoffNotResetOnClientInitialAck(t *testing.T) { | |
| // "[...] a client does not reset the PTO backoff factor on | |
| // receiving acknowledgments in Initial packets." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# first ack establishes smoothed_rtt = 10ms") | |
| test.send(initialSpace, 0) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# set rttvar for simplicity") | |
| test.setRTTVar(0) | |
| t.Logf("# send packet 1 and wait for PTO") | |
| test.send(initialSpace, 1) | |
| test.wantTimeout(11 * time.Millisecond) | |
| test.advanceToLossTimer() | |
| test.wantPTOExpired() | |
| test.wantNoTimeout() | |
| t.Logf("# send more packets, PTO doubles") | |
| test.send(initialSpace, 2, 3) | |
| test.send(handshakeSpace, 0) | |
| test.wantTimeout(22 * time.Millisecond) | |
| test.advance(10 * time.Millisecond) | |
| t.Logf("# check remaining PTO (22ms - 10ms elapsed)") | |
| test.wantTimeout(12 * time.Millisecond) | |
| // TODO: Is this right? 6.2.1-9 says we don't reset the PTO *backoff*, not the PTO. | |
| // 6.2.1-8 says we reset the PTO timer when an ack-eliciting packet is sent *or | |
| // acknowledged*, but the pseudocode in appendix A doesn't appear to do the latter. | |
| t.Logf("# ACK to Initial packet does not reset PTO for client") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| test.wantAck(initialSpace, 1) | |
| test.wantAck(initialSpace, 2) | |
| t.Logf("# check remaining PTO (22ms - 10ms elapsed)") | |
| test.wantTimeout(12 * time.Millisecond) | |
| t.Logf("# ACK to handshake packet does reset PTO") | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(handshakeSpace, 0) | |
| t.Logf("# check remaining PTO (12ms - 10ms elapsed)") | |
| test.wantTimeout(1 * time.Millisecond) | |
| } | |
| func TestLossPTONotSetWhenLossTimerSet(t *testing.T) { | |
| // "The PTO timer MUST NOT be set if a timer is set | |
| // for time threshold loss detection [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-12 | |
| test := newLossTest(t, serverSide, lossTestOpts{}) | |
| test.datagramReceived(1200) | |
| t.Logf("# PTO timer set for first packets sent") | |
| test.send(initialSpace, 0, 1) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // initial value | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // initial value | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(999 * time.Millisecond) | |
| t.Logf("# ack of packet 1 starts loss timer for 0, PTO overridden") | |
| test.advance(333 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| t.Logf("# latest_rtt == smoothed_rtt") | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) | |
| test.wantVar("latest_rtt", 333*time.Millisecond) | |
| t.Logf("# timeout = 9/8 * max(smoothed_rtt, latest_rtt) - time_since_packet_sent") | |
| test.wantTimeout(((333 * time.Millisecond * 9) / 8) - 333*time.Millisecond) | |
| } | |
| func TestLossDiscardingKeysResetsTimers(t *testing.T) { | |
| // "When Initial or Handshake keys are discarded, | |
| // the PTO and loss detection timers MUST be reset" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2-3 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| t.Logf("# handshake packet sent 1ms after initial") | |
| test.send(initialSpace, 0, 1) | |
| test.advance(1 * time.Millisecond) | |
| test.send(handshakeSpace, 0, 1) | |
| test.advance(9 * time.Millisecond) | |
| t.Logf("# ack of Initial packet 2 starts loss timer for packet 1") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.advance(1 * time.Millisecond) | |
| t.Logf("# smoothed_rtt = %v", 10*time.Millisecond) | |
| t.Logf("# latest_rtt = %v", 10*time.Millisecond) | |
| t.Logf("# timeout = max(9/8 * max(smoothed_rtt, latest_rtt), 1ms)") | |
| t.Logf("# (measured since Initial packet 1 sent)") | |
| test.wantTimeout((10 * time.Millisecond * 9 / 8) - 11*time.Millisecond) | |
| t.Logf("# ack of Handshake packet 2 starts loss timer for packet 1") | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(handshakeSpace, 1) | |
| t.Logf("# dropping Initial keys sets timer to Handshake timeout") | |
| test.discardKeys(initialSpace) | |
| test.wantTimeout((10 * time.Millisecond * 9 / 8) - 10*time.Millisecond) | |
| } | |
| func TestLossNoPTOAtAntiAmplificationLimit(t *testing.T) { | |
| // "If no additional data can be sent [because the server is at the | |
| // anti-amplification limit], the server's PTO timer MUST NOT be armed [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-1 | |
| test := newLossTest(t, serverSide, lossTestOpts{ | |
| maxDatagramSize: 1 << 20, // large initial congestion window | |
| }) | |
| test.datagramReceived(1200) | |
| test.send(initialSpace, 0, sentPacket{ | |
| ackEliciting: true, | |
| inFlight: true, | |
| size: 1200, | |
| }) | |
| test.wantTimeout(999 * time.Millisecond) | |
| t.Logf("PTO timer should be disabled when at the anti-amplification limit") | |
| test.send(initialSpace, 1, sentPacket{ | |
| ackEliciting: false, | |
| inFlight: true, | |
| size: 2 * 1200, | |
| }) | |
| test.wantNoTimeout() | |
| // "When the server receives a datagram from the client, the amplification | |
| // limit is increased and the server resets the PTO timer." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-2 | |
| t.Logf("PTO timer should be reset when datagrams are received") | |
| test.datagramReceived(1200) | |
| test.wantTimeout(999 * time.Millisecond) | |
| // "If the PTO timer is then set to a time in the past, it is executed immediately." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-2 | |
| test.send(initialSpace, 2, sentPacket{ | |
| ackEliciting: true, | |
| inFlight: true, | |
| size: 3 * 1200, | |
| }) | |
| test.wantNoTimeout() | |
| t.Logf("resetting expired PTO timer should exeute immediately") | |
| test.advance(1000 * time.Millisecond) | |
| test.datagramReceived(1200) | |
| test.wantPTOExpired() | |
| test.wantNoTimeout() | |
| } | |
| func TestLossClientSetsPTOWhenHandshakeUnacked(t *testing.T) { | |
| // "[...] the client MUST set the PTO timer if the client has not | |
| // received an acknowledgment for any of its Handshake packets and | |
| // the handshake is not confirmed [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-3 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0) | |
| test.wantVar("smoothed_rtt", 333*time.Millisecond) // initial value | |
| test.wantVar("rttvar", 333*time.Millisecond/2) // initial value | |
| t.Logf("# PTO = smoothed_rtt + max(4*rttvar, 1ms)") | |
| test.wantTimeout(999 * time.Millisecond) | |
| test.advance(333 * time.Millisecond) | |
| test.wantTimeout(666 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# PTO timer set for a client before handshake ack even if no packets in flight") | |
| test.wantTimeout(999 * time.Millisecond) | |
| test.advance(333 * time.Millisecond) | |
| test.wantTimeout(666 * time.Millisecond) | |
| } | |
| func TestLossKeysDiscarded(t *testing.T) { | |
| // "The sender MUST discard all recovery state associated with | |
| // [packets in number spaces with discarded keys] and MUST remove | |
| // them from the count of bytes in flight." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.4-1 | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) // will be acked | |
| test.send(initialSpace, 2, testSentPacketSize(1200)) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.send(handshakeSpace, 0, testSentPacketSize(600)) | |
| test.send(handshakeSpace, 1, testSentPacketSize(600)) // will be acked | |
| test.send(handshakeSpace, 2, testSentPacketSize(600)) | |
| test.ack(handshakeSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(handshakeSpace, 1) | |
| test.wantVar("bytes_in_flight", 1200+1200+600+600) // 3600 | |
| test.discardKeys(initialSpace) | |
| test.wantVar("bytes_in_flight", 600+600) // 1200 | |
| test.discardKeys(handshakeSpace) | |
| test.wantVar("bytes_in_flight", 0) | |
| } | |
| func TestLossDiscardPackets(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{}) | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) // will be acked | |
| test.send(initialSpace, 2, testSentPacketSize(1200)) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.discardPackets(initialSpace) | |
| test.wantLoss(initialSpace, 0) | |
| test.wantLoss(initialSpace, 2) | |
| test.wantVar("bytes_in_flight", 0) | |
| } | |
| func TestLossInitialCongestionWindow(t *testing.T) { | |
| // "Endpoints SHOULD use an initial congestion window of [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-1 | |
| // "[...] 10 times the maximum datagram size [...]" | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# congestion_window = 10*max_datagram_size (1200)") | |
| test.wantVar("congestion_window", 12000) | |
| // "[...] while limiting the window to the larger of 14720 bytes [...]" | |
| test = newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1500, | |
| }) | |
| t.Logf("# congestion_window limited to 14720 bytes") | |
| test.wantVar("congestion_window", 14720) | |
| // "[...] or twice the maximum datagram size." | |
| test = newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 10000, | |
| }) | |
| t.Logf("# congestion_window limited to 2*max_datagram_size (10000)") | |
| test.wantVar("congestion_window", 20000) | |
| for _, tc := range []struct { | |
| maxDatagramSize int | |
| wantInitialBurst int | |
| }{{ | |
| // "[...] 10 times the maximum datagram size [...]" | |
| maxDatagramSize: 1200, | |
| wantInitialBurst: 12000, | |
| }, { | |
| // "[...] while limiting the window to the larger of 14720 bytes [...]" | |
| maxDatagramSize: 1500, | |
| wantInitialBurst: 14720, | |
| }, { | |
| // "[...] or twice the maximum datagram size." | |
| maxDatagramSize: 10000, | |
| wantInitialBurst: 20000, | |
| }} { | |
| t.Run(fmt.Sprintf("max_datagram_size=%v", tc.maxDatagramSize), func(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: tc.maxDatagramSize, | |
| }) | |
| var num packetNumber | |
| window := tc.wantInitialBurst | |
| for window >= tc.maxDatagramSize { | |
| t.Logf("# %v bytes of initial congestion window remain", window) | |
| test.send(initialSpace, num, sentPacket{ | |
| ackEliciting: true, | |
| inFlight: true, | |
| size: tc.maxDatagramSize, | |
| }) | |
| window -= tc.maxDatagramSize | |
| num++ | |
| } | |
| t.Logf("# congestion window (%v) < max_datagram_size, congestion control blocks send", window) | |
| test.wantSendLimit(ccLimited) | |
| }) | |
| } | |
| } | |
| func TestLossBytesInFlight(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# sent packets are added to bytes_in_flight") | |
| test.wantVar("bytes_in_flight", 0) | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.wantVar("bytes_in_flight", 1200) | |
| test.send(initialSpace, 1, testSentPacketSize(800)) | |
| test.wantVar("bytes_in_flight", 2000) | |
| t.Logf("# acked packets are removed from bytes_in_flight") | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{1, 2}) | |
| test.wantAck(initialSpace, 1) | |
| test.wantVar("bytes_in_flight", 1200) | |
| t.Logf("# lost packets are removed from bytes_in_flight") | |
| test.advanceToLossTimer() | |
| test.wantLoss(initialSpace, 0) | |
| test.wantVar("bytes_in_flight", 0) | |
| } | |
| func TestLossCongestionWindowLimit(t *testing.T) { | |
| // "An endpoint MUST NOT send a packet if it would cause bytes_in_flight | |
| // [...] to be larger than the congestion window [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7-7 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# consume the initial congestion window") | |
| test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) | |
| test.wantSendLimit(ccLimited) | |
| t.Logf("# give the pacer bucket time to refill") | |
| test.advance(333 * time.Millisecond) // initial RTT | |
| t.Logf("# sending limited by congestion window, not the pacer") | |
| test.wantVar("congestion_window", 12000) | |
| test.wantVar("bytes_in_flight", 12000) | |
| test.wantVar("pacer_bucket", 12000) | |
| test.wantSendLimit(ccLimited) | |
| t.Logf("# receiving an ack opens up the congestion window") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantSendLimit(ccOK) | |
| } | |
| func TestLossCongestionStates(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# consume the initial congestion window") | |
| test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) | |
| test.wantSendLimit(ccLimited) | |
| test.wantVar("congestion_window", 12000) | |
| // "While a sender is in slow start, the congestion window | |
| // increases by the number of bytes acknowledged [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.1-2 | |
| test.advance(333 * time.Millisecond) | |
| t.Logf("# congestion window increases by number of bytes acked (1200)") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| test.wantVar("congestion_window", 13200) // 12000 + 1200 | |
| t.Logf("# congestion window increases by number of bytes acked (2400)") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 3}) | |
| test.wantAck(initialSpace, 1, 2) | |
| test.wantVar("congestion_window", 15600) // 12000 + 3*1200 | |
| // TODO: ECN-CE count | |
| // "The sender MUST exit slow start and enter a recovery period | |
| // when a packet is lost [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.1-3 | |
| t.Logf("# loss of a packet triggers entry to a recovery period") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{6, 7}) | |
| test.wantAck(initialSpace, 6) | |
| test.wantLoss(initialSpace, 3) | |
| // "On entering a recovery period, a sender MUST set the slow start | |
| // threshold to half the value of the congestion window when loss is detected." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-2 | |
| t.Logf("# slow_start_threshold = congestion_window / 2") | |
| test.wantVar("slow_start_threshold", 7800) // 15600/2 | |
| // "[...] a single packet can be sent prior to reduction [of the congestion window]." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-3 | |
| test.send(initialSpace, 10, testSentPacketSize(1200)) | |
| // "The congestion window MUST be set to the reduced value of the slow start | |
| // threshold before exiting the recovery period." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-2 | |
| t.Logf("# congestion window reduced to slow start threshold") | |
| test.wantVar("congestion_window", 7800) | |
| t.Logf("# acks for packets sent before recovery started do not affect congestion") | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 10}) | |
| test.wantAck(initialSpace, 4, 5, 7, 8, 9) | |
| test.wantVar("slow_start_threshold", 7800) | |
| test.wantVar("congestion_window", 7800) | |
| // "A recovery period ends and the sender enters congestion avoidance when | |
| // a packet sent during the recovery period is acknowledged." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-5 | |
| t.Logf("# recovery ends and congestion avoidance begins when packet 10 is acked") | |
| test.advance(333 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 11}) | |
| test.wantAck(initialSpace, 10) | |
| // "[...] limit the increase to the congestion window to at most one | |
| // maximum datagram size for each congestion window that is acknowledged." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.3-2 | |
| t.Logf("# after processing acks for one congestion window's worth of data...") | |
| test.send(initialSpace, 11, 12, 13, 14, 15, 16, testSentPacketSize(1200)) | |
| test.advance(333 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 17}) | |
| test.wantAck(initialSpace, 11, 12, 13, 14, 15, 16) | |
| t.Logf("# ...congestion window increases by max_datagram_size") | |
| test.wantVar("congestion_window", 9000) // 7800 + 1200 | |
| // "The sender exits congestion avoidance and enters a recovery period | |
| // when a packet is lost [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.3-3 | |
| test.send(initialSpace, 17, 18, 19, 20, 21, testSentPacketSize(1200)) | |
| test.advance(333 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{18, 21}) | |
| test.wantAck(initialSpace, 18, 19, 20) | |
| test.wantLoss(initialSpace, 17) | |
| t.Logf("# slow_start_threshold = congestion_window / 2") | |
| test.wantVar("slow_start_threshold", 4500) | |
| } | |
| func TestLossMinimumCongestionWindow(t *testing.T) { | |
| // "The RECOMMENDED [minimum congestion window] is 2 * max_datagram_size." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-4 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| test.send(initialSpace, 0, 1, 2, 3, testSentPacketSize(1200)) | |
| test.wantVar("congestion_window", 12000) | |
| t.Logf("# enter recovery") | |
| test.advance(333 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{3, 4}) | |
| test.wantAck(initialSpace, 3) | |
| test.wantLoss(initialSpace, 0) | |
| test.wantVar("congestion_window", 6000) | |
| t.Logf("# enter congestion avoidance and return to recovery") | |
| test.send(initialSpace, 4, 5, 6, 7) | |
| test.advance(333 * time.Millisecond) | |
| test.wantLoss(initialSpace, 1, 2) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{7, 8}) | |
| test.wantAck(initialSpace, 7) | |
| test.wantLoss(initialSpace, 4) | |
| test.wantVar("congestion_window", 3000) | |
| t.Logf("# enter congestion avoidance and return to recovery") | |
| test.send(initialSpace, 8, 9, 10, 11) | |
| test.advance(333 * time.Millisecond) | |
| test.wantLoss(initialSpace, 5, 6) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{11, 12}) | |
| test.wantAck(initialSpace, 11) | |
| test.wantLoss(initialSpace, 8) | |
| t.Logf("# congestion window does not fall below 2*max_datagram_size") | |
| test.wantVar("congestion_window", 2400) | |
| t.Logf("# enter congestion avoidance and return to recovery") | |
| test.send(initialSpace, 12, 13, 14, 15) | |
| test.advance(333 * time.Millisecond) | |
| test.wantLoss(initialSpace, 9, 10) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{15, 16}) | |
| test.wantAck(initialSpace, 15) | |
| test.wantLoss(initialSpace, 12) | |
| t.Logf("# congestion window does not fall below 2*max_datagram_size") | |
| test.wantVar("congestion_window", 2400) | |
| } | |
| func TestLossPersistentCongestion(t *testing.T) { | |
| // "When persistent congestion is declared, the sender's congestion | |
| // window MUST be reduced to the minimum congestion window [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-6 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.c.cc.setUnderutilized(nil, true) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# set rttvar for simplicity") | |
| test.setRTTVar(0) | |
| test.wantVar("smoothed_rtt", 10*time.Millisecond) | |
| t.Logf("# persistent congestion duration = 3*(smoothed_rtt + timerGranularity + max_ack_delay)") | |
| t.Logf("# persistent congestion duration = 108ms") | |
| t.Logf("# sending packets 1-5 over 108ms") | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) | |
| test.advance(11 * time.Millisecond) // total 11ms | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 2, testSentPacketSize(1200)) | |
| test.advance(22 * time.Millisecond) // total 33ms | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 3, testSentPacketSize(1200)) | |
| test.advance(44 * time.Millisecond) // total 77ms | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 4, testSentPacketSize(1200)) | |
| test.advance(31 * time.Millisecond) // total 108ms | |
| test.send(initialSpace, 5, testSentPacketSize(1200)) | |
| t.Logf("# 108ms between packets 1-5") | |
| test.wantVar("congestion_window", 12000) | |
| t.Logf("# triggering loss of packets 1-5") | |
| test.send(initialSpace, 6, 7, 8, testSentPacketSize(1200)) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{8, 9}) | |
| test.wantAck(initialSpace, 8) | |
| test.wantLoss(initialSpace, 1, 2, 3, 4, 5) | |
| t.Logf("# lost packets spanning persistent congestion duration") | |
| t.Logf("# congestion_window = 2 * max_datagram_size (minimum)") | |
| test.wantVar("congestion_window", 2400) | |
| } | |
| func TestLossSimplePersistentCongestion(t *testing.T) { | |
| // Simpler version of TestLossPersistentCongestion which acts as a | |
| // base for subsequent tests. | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# establish initial RTT sample") | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# send two packets spanning persistent congestion duration") | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) | |
| t.Logf("# 2000ms >> persistent congestion duration") | |
| test.advance(2000 * time.Millisecond) | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 2, testSentPacketSize(1200)) | |
| t.Logf("# trigger loss of previous packets") | |
| test.advance(10 * time.Millisecond) | |
| test.send(initialSpace, 3, testSentPacketSize(1200)) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{3, 4}) | |
| test.wantAck(initialSpace, 3) | |
| test.wantLoss(initialSpace, 1, 2) | |
| t.Logf("# persistent congestion detected") | |
| test.wantVar("congestion_window", 2400) | |
| } | |
| func TestLossPersistentCongestionAckElicitingPackets(t *testing.T) { | |
| // "These two packets MUST be ack-eliciting [...]" | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-3 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# establish initial RTT sample") | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# send two packets spanning persistent congestion duration") | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) | |
| t.Logf("# 2000ms >> persistent congestion duration") | |
| test.advance(2000 * time.Millisecond) | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 2, sentPacket{ | |
| inFlight: true, | |
| ackEliciting: false, | |
| size: 1200, | |
| }) | |
| test.send(initialSpace, 3, testSentPacketSize(1200)) // PTO probe | |
| t.Logf("# trigger loss of previous packets") | |
| test.advance(10 * time.Millisecond) | |
| test.send(initialSpace, 4, testSentPacketSize(1200)) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{3, 5}) | |
| test.wantAck(initialSpace, 3) | |
| test.wantAck(initialSpace, 4) | |
| test.wantLoss(initialSpace, 1, 2) | |
| t.Logf("# persistent congestion not detected: packet 2 is not ack-eliciting") | |
| test.wantVar("congestion_window", (12000+1200+1200-1200)/2) | |
| } | |
| func TestLossNoPersistentCongestionWithoutRTTSample(t *testing.T) { | |
| // "The persistent congestion period SHOULD NOT start until there | |
| // is at least one RTT sample." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-4 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# packets sent before initial RTT sample") | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.advance(2000 * time.Millisecond) | |
| test.wantPTOExpired() | |
| test.send(initialSpace, 1, testSentPacketSize(1200)) | |
| test.advance(10 * time.Millisecond) | |
| test.send(initialSpace, 2, testSentPacketSize(1200)) | |
| t.Logf("# first ack establishes RTT sample") | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{2, 3}) | |
| test.wantAck(initialSpace, 2) | |
| test.wantLoss(initialSpace, 0, 1) | |
| t.Logf("# loss of packets before initial RTT sample does not cause persistent congestion") | |
| test.wantVar("congestion_window", 12000/2) | |
| } | |
| func TestLossPacerRefillRate(t *testing.T) { | |
| // "A sender SHOULD pace sending of all in-flight packets based on | |
| // input from the congestion controller." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.7-1 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# consume the initial congestion window") | |
| test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) | |
| test.wantSendLimit(ccLimited) | |
| test.wantVar("pacer_bucket", 0) | |
| test.wantVar("congestion_window", 12000) | |
| t.Logf("# first RTT sample establishes smoothed_rtt") | |
| rtt := 100 * time.Millisecond | |
| test.advance(rtt) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 10}) | |
| test.wantAck(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) | |
| test.wantVar("congestion_window", 24000) // 12000 + 10*1200 | |
| test.wantVar("smoothed_rtt", rtt) | |
| t.Logf("# advance 1 RTT to let the pacer bucket refill completely") | |
| test.advance(100 * time.Millisecond) | |
| t.Logf("# pacer_bucket = initial_congestion_window") | |
| test.wantVar("pacer_bucket", 12000) | |
| t.Logf("# consume capacity from the pacer bucket") | |
| test.send(initialSpace, 10, testSentPacketSize(1200)) | |
| test.wantVar("pacer_bucket", 10800) // 12000 - 1200 | |
| test.send(initialSpace, 11, testSentPacketSize(600)) | |
| test.wantVar("pacer_bucket", 10200) // 10800 - 600 | |
| test.send(initialSpace, 12, testSentPacketSize(600)) | |
| test.wantVar("pacer_bucket", 9600) // 10200 - 600 | |
| test.send(initialSpace, 13, 14, 15, 16, testSentPacketSize(1200)) | |
| test.wantVar("pacer_bucket", 4800) // 9600 - 4*1200 | |
| t.Logf("# advance 1/10 of an RTT, bucket refills") | |
| test.advance(rtt / 10) | |
| t.Logf("# pacer_bucket += 1.25 * (1/10) * congestion_window") | |
| t.Logf("# += 3000") | |
| test.wantVar("pacer_bucket", 7800) | |
| } | |
| func TestLossPacerNextSendTime(t *testing.T) { | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| t.Logf("# consume the initial congestion window") | |
| test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) | |
| test.wantSendLimit(ccLimited) | |
| test.wantVar("pacer_bucket", 0) | |
| test.wantVar("congestion_window", 12000) | |
| t.Logf("# first RTT sample establishes smoothed_rtt") | |
| rtt := 100 * time.Millisecond | |
| test.advance(rtt) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 10}) | |
| test.wantAck(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) | |
| test.wantVar("congestion_window", 24000) // 12000 + 10*1200 | |
| test.wantVar("smoothed_rtt", rtt) | |
| t.Logf("# advance 1 RTT to let the pacer bucket refill completely") | |
| test.advance(100 * time.Millisecond) | |
| t.Logf("# pacer_bucket = initial_congestion_window") | |
| test.wantVar("pacer_bucket", 12000) | |
| t.Logf("# consume the refilled pacer bucket") | |
| test.send(initialSpace, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, testSentPacketSize(1200)) | |
| test.wantSendLimit(ccPaced) | |
| t.Logf("# refill rate = 1.25 * congestion_window / rtt") | |
| test.wantSendDelay(rtt / 25) // rtt / (1.25 * 24000 / 1200) | |
| t.Logf("# no capacity available yet") | |
| test.advance(rtt / 50) | |
| test.wantVar("pacer_bucket", -600) | |
| test.wantSendLimit(ccPaced) | |
| t.Logf("# capacity available") | |
| test.advance(rtt / 50) | |
| test.wantVar("pacer_bucket", 0) | |
| test.wantSendLimit(ccOK) | |
| } | |
| func TestLossCongestionWindowUnderutilized(t *testing.T) { | |
| // "When bytes in flight is smaller than the congestion window | |
| // and sending is not pacing limited [...] the congestion window | |
| // SHOULD NOT be increased in either slow start or congestion avoidance." | |
| // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.8-1 | |
| test := newLossTest(t, clientSide, lossTestOpts{ | |
| maxDatagramSize: 1200, | |
| }) | |
| test.send(initialSpace, 0, testSentPacketSize(1200)) | |
| test.setUnderutilized(true) | |
| t.Logf("# underutilized: %v", test.c.cc.underutilized) | |
| test.wantVar("congestion_window", 12000) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 1}) | |
| test.wantAck(initialSpace, 0) | |
| t.Logf("# congestion window does not increase, because window is underutilized") | |
| test.wantVar("congestion_window", 12000) | |
| t.Logf("# refill pacer bucket") | |
| test.advance(10 * time.Millisecond) | |
| test.wantVar("pacer_bucket", 12000) | |
| test.send(initialSpace, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, testSentPacketSize(1200)) | |
| test.setUnderutilized(false) | |
| test.advance(10 * time.Millisecond) | |
| test.ack(initialSpace, 0*time.Millisecond, i64range[packetNumber]{0, 11}) | |
| test.wantAck(initialSpace, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) | |
| t.Logf("# congestion window increases") | |
| test.wantVar("congestion_window", 24000) | |
| } | |
| type lossTest struct { | |
| t *testing.T | |
| c lossState | |
| now time.Time | |
| fates map[spaceNum]packetFate | |
| failed bool | |
| } | |
| type lossTestOpts struct { | |
| maxDatagramSize int | |
| } | |
| func newLossTest(t *testing.T, side connSide, opts lossTestOpts) *lossTest { | |
| c := &lossTest{ | |
| t: t, | |
| now: time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), | |
| fates: make(map[spaceNum]packetFate), | |
| } | |
| maxDatagramSize := 1200 | |
| if opts.maxDatagramSize != 0 { | |
| maxDatagramSize = opts.maxDatagramSize | |
| } | |
| c.c.init(side, maxDatagramSize, c.now) | |
| t.Cleanup(func() { | |
| if !c.failed { | |
| c.checkUnexpectedEvents() | |
| } | |
| }) | |
| return c | |
| } | |
| type spaceNum struct { | |
| space numberSpace | |
| num packetNumber | |
| } | |
| func (c *lossTest) checkUnexpectedEvents() { | |
| c.t.Helper() | |
| for sn, fate := range c.fates { | |
| c.t.Errorf("ERROR: unexpected %v: %v %v", fate, sn.space, sn.num) | |
| } | |
| if c.c.ptoExpired { | |
| c.t.Errorf("ERROR: PTO timer unexpectedly expired") | |
| } | |
| } | |
| func (c *lossTest) setSmoothedRTT(d time.Duration) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("set smoothed_rtt to %v", d) | |
| c.c.rtt.smoothedRTT = d | |
| } | |
| func (c *lossTest) setRTTVar(d time.Duration) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("set rttvar to %v", d) | |
| c.c.rtt.rttvar = d | |
| } | |
| func (c *lossTest) setUnderutilized(v bool) { | |
| c.t.Logf("set congestion window underutilized: %v", v) | |
| c.c.cc.setUnderutilized(nil, v) | |
| } | |
| func (c *lossTest) advance(d time.Duration) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("advance time %v", d) | |
| c.now = c.now.Add(d) | |
| c.c.advance(c.now, c.onAckOrLoss) | |
| } | |
| func (c *lossTest) advanceToLossTimer() { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| d := c.c.timer.Sub(c.now) | |
| c.t.Logf("advance time %v (up to loss timer)", d) | |
| if d < 0 { | |
| c.t.Fatalf("loss timer is in the past") | |
| } | |
| c.now = c.c.timer | |
| c.c.advance(c.now, c.onAckOrLoss) | |
| } | |
| type testSentPacketSize int | |
| func (c *lossTest) send(spaceID numberSpace, opts ...any) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| var nums []packetNumber | |
| prototype := sentPacket{ | |
| ackEliciting: true, | |
| inFlight: true, | |
| } | |
| for _, o := range opts { | |
| switch o := o.(type) { | |
| case sentPacket: | |
| prototype = o | |
| case testSentPacketSize: | |
| prototype.size = int(o) | |
| case int: | |
| nums = append(nums, packetNumber(o)) | |
| case packetNumber: | |
| nums = append(nums, o) | |
| case i64range[packetNumber]: | |
| for num := o.start; num < o.end; num++ { | |
| nums = append(nums, num) | |
| } | |
| } | |
| } | |
| c.t.Logf("send %v %v", spaceID, nums) | |
| limit, _ := c.c.sendLimit(c.now) | |
| if prototype.inFlight && limit != ccOK { | |
| c.t.Fatalf("congestion control blocks sending packet") | |
| } | |
| if !prototype.inFlight && limit == ccBlocked { | |
| c.t.Fatalf("congestion control blocks sending packet") | |
| } | |
| for _, num := range nums { | |
| sent := &sentPacket{} | |
| *sent = prototype | |
| sent.num = num | |
| c.c.packetSent(c.now, nil, spaceID, sent) | |
| } | |
| } | |
| func (c *lossTest) datagramReceived(size int) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("receive %v-byte datagram", size) | |
| c.c.datagramReceived(c.now, size) | |
| } | |
| func (c *lossTest) ack(spaceID numberSpace, ackDelay time.Duration, rs ...i64range[packetNumber]) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.c.receiveAckStart() | |
| var acked rangeset[packetNumber] | |
| for _, r := range rs { | |
| c.t.Logf("ack %v delay=%v [%v,%v)", spaceID, ackDelay, r.start, r.end) | |
| acked.add(r.start, r.end) | |
| } | |
| for i, r := range rs { | |
| c.t.Logf("ack %v delay=%v [%v,%v)", spaceID, ackDelay, r.start, r.end) | |
| c.c.receiveAckRange(c.now, spaceID, i, r.start, r.end, c.onAckOrLoss) | |
| } | |
| c.c.receiveAckEnd(c.now, nil, spaceID, ackDelay, c.onAckOrLoss) | |
| } | |
| func (c *lossTest) onAckOrLoss(space numberSpace, sent *sentPacket, fate packetFate) { | |
| c.t.Logf("%v %v %v", fate, space, sent.num) | |
| if _, ok := c.fates[spaceNum{space, sent.num}]; ok { | |
| c.t.Errorf("ERROR: duplicate %v for %v %v", fate, space, sent.num) | |
| } | |
| c.fates[spaceNum{space, sent.num}] = fate | |
| } | |
| func (c *lossTest) confirmHandshake() { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("confirm handshake") | |
| c.c.confirmHandshake() | |
| } | |
| func (c *lossTest) validateClientAddress() { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("validate client address") | |
| c.c.validateClientAddress() | |
| } | |
| func (c *lossTest) discardKeys(spaceID numberSpace) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("discard %s keys", spaceID) | |
| c.c.discardKeys(c.now, nil, spaceID) | |
| } | |
| func (c *lossTest) discardPackets(spaceID numberSpace) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("discard packets in %s", spaceID) | |
| c.c.discardPackets(spaceID, nil, c.onAckOrLoss) | |
| } | |
| func (c *lossTest) setMaxAckDelay(d time.Duration) { | |
| c.t.Helper() | |
| c.checkUnexpectedEvents() | |
| c.t.Logf("set max_ack_delay = %v", d) | |
| c.c.setMaxAckDelay(d) | |
| } | |
| func (c *lossTest) wantAck(spaceID numberSpace, nums ...packetNumber) { | |
| c.t.Helper() | |
| for _, num := range nums { | |
| if c.fates[spaceNum{spaceID, num}] != packetAcked { | |
| c.t.Fatalf("expected ack for %v %v\n", spaceID, num) | |
| } | |
| delete(c.fates, spaceNum{spaceID, num}) | |
| } | |
| } | |
| func (c *lossTest) wantLoss(spaceID numberSpace, nums ...packetNumber) { | |
| c.t.Helper() | |
| for _, num := range nums { | |
| if c.fates[spaceNum{spaceID, num}] != packetLost { | |
| c.t.Fatalf("expected loss of %v %v\n", spaceID, num) | |
| } | |
| delete(c.fates, spaceNum{spaceID, num}) | |
| } | |
| } | |
| func (c *lossTest) wantPTOExpired() { | |
| c.t.Helper() | |
| if !c.c.ptoExpired { | |
| c.t.Fatalf("expected PTO timer to expire") | |
| } else { | |
| c.t.Logf("PTO TIMER EXPIRED") | |
| } | |
| c.c.ptoExpired = false | |
| } | |
| func (l ccLimit) String() string { | |
| switch l { | |
| case ccOK: | |
| return "ccOK" | |
| case ccBlocked: | |
| return "ccBlocked" | |
| case ccLimited: | |
| return "ccLimited" | |
| case ccPaced: | |
| return "ccPaced" | |
| } | |
| return "BUG" | |
| } | |
| func (c *lossTest) wantSendLimit(want ccLimit) { | |
| c.t.Helper() | |
| if got, _ := c.c.sendLimit(c.now); got != want { | |
| c.t.Fatalf("congestion control send limit is %v, want %v", got, want) | |
| } | |
| } | |
| func (c *lossTest) wantSendDelay(want time.Duration) { | |
| c.t.Helper() | |
| limit, next := c.c.sendLimit(c.now) | |
| if limit != ccPaced { | |
| c.t.Fatalf("congestion control limit is %v, want %v", limit, ccPaced) | |
| } | |
| got := next.Sub(c.now) | |
| if got != want { | |
| c.t.Fatalf("delay until next send is %v, want %v", got, want) | |
| } | |
| } | |
| func (c *lossTest) wantVar(name string, want any) { | |
| c.t.Helper() | |
| var got any | |
| switch name { | |
| case "latest_rtt": | |
| got = c.c.rtt.latestRTT | |
| case "min_rtt": | |
| got = c.c.rtt.minRTT | |
| case "smoothed_rtt": | |
| got = c.c.rtt.smoothedRTT | |
| case "rttvar": | |
| got = c.c.rtt.rttvar | |
| case "congestion_window": | |
| got = c.c.cc.congestionWindow | |
| case "slow_start_threshold": | |
| got = c.c.cc.slowStartThreshold | |
| case "bytes_in_flight": | |
| got = c.c.cc.bytesInFlight | |
| case "pacer_bucket": | |
| got = c.c.pacer.bucket | |
| default: | |
| c.t.Fatalf("unknown var %q", name) | |
| } | |
| if got != want { | |
| c.t.Fatalf("%v = %v, want %v\n", name, got, want) | |
| } else { | |
| c.t.Logf("%v = %v", name, got) | |
| } | |
| } | |
| func (c *lossTest) wantTimeout(want time.Duration) { | |
| c.t.Helper() | |
| if c.c.timer.IsZero() { | |
| c.t.Fatalf("loss detection timer is not set, want %v", want) | |
| } | |
| got := c.c.timer.Sub(c.now) | |
| if got != want { | |
| c.t.Fatalf("loss detection timer expires in %v, want %v", got, want) | |
| } | |
| c.t.Logf("loss detection timer expires in %v", got) | |
| } | |
| func (c *lossTest) wantNoTimeout() { | |
| c.t.Helper() | |
| if !c.c.timer.IsZero() { | |
| d := c.c.timer.Sub(c.now) | |
| c.t.Fatalf("loss detection timer expires in %v, want not set", d) | |
| } | |
| c.t.Logf("loss detection timer is not set") | |
| } | |
| func (f packetFate) String() string { | |
| switch f { | |
| case packetAcked: | |
| return "ACK" | |
| case packetLost: | |
| return "LOSS" | |
| default: | |
| panic("unknown packetFate") | |
| } | |
| } |