1 /*
2 * Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "net/dcsctp/rx/data_tracker.h"
11
12 #include <cstdint>
13 #include <initializer_list>
14 #include <memory>
15
16 #include "absl/types/optional.h"
17 #include "api/array_view.h"
18 #include "api/task_queue/task_queue_base.h"
19 #include "net/dcsctp/common/handover_testing.h"
20 #include "net/dcsctp/packet/chunk/sack_chunk.h"
21 #include "net/dcsctp/timer/fake_timeout.h"
22 #include "net/dcsctp/timer/timer.h"
23 #include "rtc_base/gunit.h"
24 #include "test/gmock.h"
25
26 namespace dcsctp {
27 namespace {
28 using ::testing::ElementsAre;
29 using ::testing::IsEmpty;
30 using ::testing::SizeIs;
31 using ::testing::UnorderedElementsAre;
32
33 constexpr size_t kArwnd = 10000;
34 constexpr TSN kInitialTSN(11);
35
36 class DataTrackerTest : public testing::Test {
37 protected:
DataTrackerTest()38 DataTrackerTest()
39 : timeout_manager_([this]() { return now_; }),
__anone3f201540302(webrtc::TaskQueueBase::DelayPrecision precision) 40 timer_manager_([this](webrtc::TaskQueueBase::DelayPrecision precision) {
41 return timeout_manager_.CreateTimeout(precision);
42 }),
43 timer_(timer_manager_.CreateTimer(
44 "test/delayed_ack",
__anone3f201540402() 45 []() { return absl::nullopt; },
46 TimerOptions(DurationMs(0)))),
47 tracker_(
48 std::make_unique<DataTracker>("log: ", timer_.get(), kInitialTSN)) {
49 }
50
Observer(std::initializer_list<uint32_t> tsns,bool expect_as_duplicate=false)51 void Observer(std::initializer_list<uint32_t> tsns,
52 bool expect_as_duplicate = false) {
53 for (const uint32_t tsn : tsns) {
54 if (expect_as_duplicate) {
55 EXPECT_FALSE(
56 tracker_->Observe(TSN(tsn), AnyDataChunk::ImmediateAckFlag(false)));
57 } else {
58 EXPECT_TRUE(
59 tracker_->Observe(TSN(tsn), AnyDataChunk::ImmediateAckFlag(false)));
60 }
61 }
62 }
63
HandoverTracker()64 void HandoverTracker() {
65 EXPECT_TRUE(tracker_->GetHandoverReadiness().IsReady());
66 DcSctpSocketHandoverState state;
67 tracker_->AddHandoverState(state);
68 g_handover_state_transformer_for_test(&state);
69 tracker_ =
70 std::make_unique<DataTracker>("log: ", timer_.get(), kInitialTSN);
71 tracker_->RestoreFromState(state);
72 }
73
74 TimeMs now_ = TimeMs(0);
75 FakeTimeoutManager timeout_manager_;
76 TimerManager timer_manager_;
77 std::unique_ptr<Timer> timer_;
78 std::unique_ptr<DataTracker> tracker_;
79 };
80
TEST_F(DataTrackerTest,Empty)81 TEST_F(DataTrackerTest, Empty) {
82 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
83 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
84 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
85 EXPECT_THAT(sack.duplicate_tsns(), IsEmpty());
86 }
87
TEST_F(DataTrackerTest,ObserverSingleInOrderPacket)88 TEST_F(DataTrackerTest, ObserverSingleInOrderPacket) {
89 Observer({11});
90 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
91 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(11));
92 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
93 EXPECT_THAT(sack.duplicate_tsns(), IsEmpty());
94 }
95
TEST_F(DataTrackerTest,ObserverManyInOrderMovesCumulativeTsnAck)96 TEST_F(DataTrackerTest, ObserverManyInOrderMovesCumulativeTsnAck) {
97 Observer({11, 12, 13});
98 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
99 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(13));
100 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
101 EXPECT_THAT(sack.duplicate_tsns(), IsEmpty());
102 }
103
TEST_F(DataTrackerTest,ObserveOutOfOrderMovesCumulativeTsnAck)104 TEST_F(DataTrackerTest, ObserveOutOfOrderMovesCumulativeTsnAck) {
105 Observer({12, 13, 14, 11});
106 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
107 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(14));
108 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
109 EXPECT_THAT(sack.duplicate_tsns(), IsEmpty());
110 }
111
TEST_F(DataTrackerTest,SingleGap)112 TEST_F(DataTrackerTest, SingleGap) {
113 Observer({12});
114 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
115 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
116 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 2)));
117 EXPECT_THAT(sack.duplicate_tsns(), IsEmpty());
118 }
119
TEST_F(DataTrackerTest,ExampleFromRFC4960Section334)120 TEST_F(DataTrackerTest, ExampleFromRFC4960Section334) {
121 Observer({11, 12, 14, 15, 17});
122 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
123 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(12));
124 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 3),
125 SackChunk::GapAckBlock(5, 5)));
126 EXPECT_THAT(sack.duplicate_tsns(), IsEmpty());
127 }
128
TEST_F(DataTrackerTest,AckAlreadyReceivedChunk)129 TEST_F(DataTrackerTest, AckAlreadyReceivedChunk) {
130 Observer({11});
131 SackChunk sack1 = tracker_->CreateSelectiveAck(kArwnd);
132 EXPECT_EQ(sack1.cumulative_tsn_ack(), TSN(11));
133 EXPECT_THAT(sack1.gap_ack_blocks(), IsEmpty());
134
135 // Receive old chunk
136 Observer({8}, /*expect_as_duplicate=*/true);
137 SackChunk sack2 = tracker_->CreateSelectiveAck(kArwnd);
138 EXPECT_EQ(sack2.cumulative_tsn_ack(), TSN(11));
139 EXPECT_THAT(sack2.gap_ack_blocks(), IsEmpty());
140 }
141
TEST_F(DataTrackerTest,DoubleSendRetransmittedChunk)142 TEST_F(DataTrackerTest, DoubleSendRetransmittedChunk) {
143 Observer({11, 13, 14, 15});
144 SackChunk sack1 = tracker_->CreateSelectiveAck(kArwnd);
145 EXPECT_EQ(sack1.cumulative_tsn_ack(), TSN(11));
146 EXPECT_THAT(sack1.gap_ack_blocks(),
147 ElementsAre(SackChunk::GapAckBlock(2, 4)));
148
149 // Fill in the hole.
150 Observer({12, 16, 17, 18});
151 SackChunk sack2 = tracker_->CreateSelectiveAck(kArwnd);
152 EXPECT_EQ(sack2.cumulative_tsn_ack(), TSN(18));
153 EXPECT_THAT(sack2.gap_ack_blocks(), IsEmpty());
154
155 // Receive chunk 12 again.
156 Observer({12}, /*expect_as_duplicate=*/true);
157 Observer({19, 20, 21});
158 SackChunk sack3 = tracker_->CreateSelectiveAck(kArwnd);
159 EXPECT_EQ(sack3.cumulative_tsn_ack(), TSN(21));
160 EXPECT_THAT(sack3.gap_ack_blocks(), IsEmpty());
161 }
162
TEST_F(DataTrackerTest,ForwardTsnSimple)163 TEST_F(DataTrackerTest, ForwardTsnSimple) {
164 // Messages (11, 12, 13), (14, 15) - first message expires.
165 Observer({11, 12, 15});
166
167 tracker_->HandleForwardTsn(TSN(13));
168
169 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
170 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(13));
171 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 2)));
172 }
173
TEST_F(DataTrackerTest,ForwardTsnSkipsFromGapBlock)174 TEST_F(DataTrackerTest, ForwardTsnSkipsFromGapBlock) {
175 // Messages (11, 12, 13), (14, 15) - first message expires.
176 Observer({11, 12, 14});
177
178 tracker_->HandleForwardTsn(TSN(13));
179
180 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
181 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(14));
182 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
183 }
184
TEST_F(DataTrackerTest,ExampleFromRFC3758)185 TEST_F(DataTrackerTest, ExampleFromRFC3758) {
186 tracker_->HandleForwardTsn(TSN(102));
187
188 Observer({102}, /*expect_as_duplicate=*/true);
189 Observer({104, 105, 107});
190
191 tracker_->HandleForwardTsn(TSN(103));
192
193 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
194 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(105));
195 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 2)));
196 }
197
TEST_F(DataTrackerTest,EmptyAllAcks)198 TEST_F(DataTrackerTest, EmptyAllAcks) {
199 Observer({11, 13, 14, 15});
200
201 tracker_->HandleForwardTsn(TSN(100));
202
203 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
204 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(100));
205 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
206 }
207
TEST_F(DataTrackerTest,SetsArwndCorrectly)208 TEST_F(DataTrackerTest, SetsArwndCorrectly) {
209 SackChunk sack1 = tracker_->CreateSelectiveAck(/*a_rwnd=*/100);
210 EXPECT_EQ(sack1.a_rwnd(), 100u);
211
212 SackChunk sack2 = tracker_->CreateSelectiveAck(/*a_rwnd=*/101);
213 EXPECT_EQ(sack2.a_rwnd(), 101u);
214 }
215
TEST_F(DataTrackerTest,WillIncreaseCumAckTsn)216 TEST_F(DataTrackerTest, WillIncreaseCumAckTsn) {
217 EXPECT_EQ(tracker_->last_cumulative_acked_tsn(), TSN(10));
218 EXPECT_FALSE(tracker_->will_increase_cum_ack_tsn(TSN(10)));
219 EXPECT_TRUE(tracker_->will_increase_cum_ack_tsn(TSN(11)));
220 EXPECT_FALSE(tracker_->will_increase_cum_ack_tsn(TSN(12)));
221
222 Observer({11, 12, 13, 14, 15});
223 EXPECT_EQ(tracker_->last_cumulative_acked_tsn(), TSN(15));
224 EXPECT_FALSE(tracker_->will_increase_cum_ack_tsn(TSN(15)));
225 EXPECT_TRUE(tracker_->will_increase_cum_ack_tsn(TSN(16)));
226 EXPECT_FALSE(tracker_->will_increase_cum_ack_tsn(TSN(17)));
227 }
228
TEST_F(DataTrackerTest,ForceShouldSendSackImmediately)229 TEST_F(DataTrackerTest, ForceShouldSendSackImmediately) {
230 EXPECT_FALSE(tracker_->ShouldSendAck());
231
232 tracker_->ForceImmediateSack();
233
234 EXPECT_TRUE(tracker_->ShouldSendAck());
235 }
236
TEST_F(DataTrackerTest,WillAcceptValidTSNs)237 TEST_F(DataTrackerTest, WillAcceptValidTSNs) {
238 // The initial TSN is always one more than the last, which is our base.
239 TSN last_tsn = TSN(*kInitialTSN - 1);
240 int limit = static_cast<int>(DataTracker::kMaxAcceptedOutstandingFragments);
241
242 for (int i = -limit; i <= limit; ++i) {
243 EXPECT_TRUE(tracker_->IsTSNValid(TSN(*last_tsn + i)));
244 }
245 }
246
TEST_F(DataTrackerTest,WillNotAcceptInvalidTSNs)247 TEST_F(DataTrackerTest, WillNotAcceptInvalidTSNs) {
248 // The initial TSN is always one more than the last, which is our base.
249 TSN last_tsn = TSN(*kInitialTSN - 1);
250
251 size_t limit = DataTracker::kMaxAcceptedOutstandingFragments;
252 EXPECT_FALSE(tracker_->IsTSNValid(TSN(*last_tsn + limit + 1)));
253 EXPECT_FALSE(tracker_->IsTSNValid(TSN(*last_tsn - (limit + 1))));
254 EXPECT_FALSE(tracker_->IsTSNValid(TSN(*last_tsn + 0x8000000)));
255 EXPECT_FALSE(tracker_->IsTSNValid(TSN(*last_tsn - 0x8000000)));
256 }
257
TEST_F(DataTrackerTest,ReportSingleDuplicateTsns)258 TEST_F(DataTrackerTest, ReportSingleDuplicateTsns) {
259 Observer({11, 12});
260 Observer({11}, /*expect_as_duplicate=*/true);
261 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
262 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(12));
263 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
264 EXPECT_THAT(sack.duplicate_tsns(), UnorderedElementsAre(TSN(11)));
265 }
266
TEST_F(DataTrackerTest,ReportMultipleDuplicateTsns)267 TEST_F(DataTrackerTest, ReportMultipleDuplicateTsns) {
268 Observer({11, 12, 13, 14});
269 Observer({12, 13, 12, 13}, /*expect_as_duplicate=*/true);
270 Observer({15, 16});
271 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
272 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(16));
273 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
274 EXPECT_THAT(sack.duplicate_tsns(), UnorderedElementsAre(TSN(12), TSN(13)));
275 }
276
TEST_F(DataTrackerTest,ReportDuplicateTsnsInGapAckBlocks)277 TEST_F(DataTrackerTest, ReportDuplicateTsnsInGapAckBlocks) {
278 Observer({11, /*12,*/ 13, 14});
279 Observer({13, 14}, /*expect_as_duplicate=*/true);
280 Observer({15, 16});
281 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
282 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(11));
283 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 5)));
284 EXPECT_THAT(sack.duplicate_tsns(), UnorderedElementsAre(TSN(13), TSN(14)));
285 }
286
TEST_F(DataTrackerTest,ClearsDuplicateTsnsAfterCreatingSack)287 TEST_F(DataTrackerTest, ClearsDuplicateTsnsAfterCreatingSack) {
288 Observer({11, 12, 13, 14});
289 Observer({12, 13, 12, 13}, /*expect_as_duplicate=*/true);
290 Observer({15, 16});
291 SackChunk sack1 = tracker_->CreateSelectiveAck(kArwnd);
292 EXPECT_EQ(sack1.cumulative_tsn_ack(), TSN(16));
293 EXPECT_THAT(sack1.gap_ack_blocks(), IsEmpty());
294 EXPECT_THAT(sack1.duplicate_tsns(), UnorderedElementsAre(TSN(12), TSN(13)));
295
296 Observer({17});
297 SackChunk sack2 = tracker_->CreateSelectiveAck(kArwnd);
298 EXPECT_EQ(sack2.cumulative_tsn_ack(), TSN(17));
299 EXPECT_THAT(sack2.gap_ack_blocks(), IsEmpty());
300 EXPECT_THAT(sack2.duplicate_tsns(), IsEmpty());
301 }
302
TEST_F(DataTrackerTest,LimitsNumberOfDuplicatesReported)303 TEST_F(DataTrackerTest, LimitsNumberOfDuplicatesReported) {
304 for (size_t i = 0; i < DataTracker::kMaxDuplicateTsnReported + 10; ++i) {
305 TSN tsn(11 + i);
306 tracker_->Observe(tsn, AnyDataChunk::ImmediateAckFlag(false));
307 tracker_->Observe(tsn, AnyDataChunk::ImmediateAckFlag(false));
308 }
309
310 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
311 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
312 EXPECT_THAT(sack.duplicate_tsns(),
313 SizeIs(DataTracker::kMaxDuplicateTsnReported));
314 }
315
TEST_F(DataTrackerTest,LimitsNumberOfGapAckBlocksReported)316 TEST_F(DataTrackerTest, LimitsNumberOfGapAckBlocksReported) {
317 for (size_t i = 0; i < DataTracker::kMaxGapAckBlocksReported + 10; ++i) {
318 TSN tsn(11 + i * 2);
319 tracker_->Observe(tsn, AnyDataChunk::ImmediateAckFlag(false));
320 }
321
322 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
323 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(11));
324 EXPECT_THAT(sack.gap_ack_blocks(),
325 SizeIs(DataTracker::kMaxGapAckBlocksReported));
326 }
327
TEST_F(DataTrackerTest,SendsSackForFirstPacketObserved)328 TEST_F(DataTrackerTest, SendsSackForFirstPacketObserved) {
329 Observer({11});
330 tracker_->ObservePacketEnd();
331 EXPECT_TRUE(tracker_->ShouldSendAck());
332 EXPECT_FALSE(timer_->is_running());
333 }
334
TEST_F(DataTrackerTest,SendsSackEverySecondPacketWhenThereIsNoPacketLoss)335 TEST_F(DataTrackerTest, SendsSackEverySecondPacketWhenThereIsNoPacketLoss) {
336 Observer({11});
337 tracker_->ObservePacketEnd();
338 EXPECT_TRUE(tracker_->ShouldSendAck());
339 EXPECT_FALSE(timer_->is_running());
340 Observer({12});
341 tracker_->ObservePacketEnd();
342 EXPECT_FALSE(tracker_->ShouldSendAck());
343 EXPECT_TRUE(timer_->is_running());
344 Observer({13});
345 tracker_->ObservePacketEnd();
346 EXPECT_TRUE(tracker_->ShouldSendAck());
347 EXPECT_FALSE(timer_->is_running());
348 Observer({14});
349 tracker_->ObservePacketEnd();
350 EXPECT_FALSE(tracker_->ShouldSendAck());
351 EXPECT_TRUE(timer_->is_running());
352 Observer({15});
353 tracker_->ObservePacketEnd();
354 EXPECT_TRUE(tracker_->ShouldSendAck());
355 EXPECT_FALSE(timer_->is_running());
356 }
357
TEST_F(DataTrackerTest,SendsSackEveryPacketOnPacketLoss)358 TEST_F(DataTrackerTest, SendsSackEveryPacketOnPacketLoss) {
359 Observer({11});
360 tracker_->ObservePacketEnd();
361 EXPECT_TRUE(tracker_->ShouldSendAck());
362 EXPECT_FALSE(timer_->is_running());
363 Observer({13});
364 tracker_->ObservePacketEnd();
365 EXPECT_TRUE(tracker_->ShouldSendAck());
366 EXPECT_FALSE(timer_->is_running());
367 Observer({14});
368 tracker_->ObservePacketEnd();
369 EXPECT_TRUE(tracker_->ShouldSendAck());
370 EXPECT_FALSE(timer_->is_running());
371 Observer({15});
372 tracker_->ObservePacketEnd();
373 EXPECT_TRUE(tracker_->ShouldSendAck());
374 EXPECT_FALSE(timer_->is_running());
375 Observer({16});
376 tracker_->ObservePacketEnd();
377 EXPECT_TRUE(tracker_->ShouldSendAck());
378 EXPECT_FALSE(timer_->is_running());
379 // Fill the hole.
380 Observer({12});
381 tracker_->ObservePacketEnd();
382 EXPECT_FALSE(tracker_->ShouldSendAck());
383 EXPECT_TRUE(timer_->is_running());
384 // Goes back to every second packet
385 Observer({17});
386 tracker_->ObservePacketEnd();
387 EXPECT_TRUE(tracker_->ShouldSendAck());
388 EXPECT_FALSE(timer_->is_running());
389 Observer({18});
390 tracker_->ObservePacketEnd();
391 EXPECT_FALSE(tracker_->ShouldSendAck());
392 EXPECT_TRUE(timer_->is_running());
393 }
394
TEST_F(DataTrackerTest,SendsSackOnDuplicateDataChunks)395 TEST_F(DataTrackerTest, SendsSackOnDuplicateDataChunks) {
396 Observer({11});
397 tracker_->ObservePacketEnd();
398 EXPECT_TRUE(tracker_->ShouldSendAck());
399 EXPECT_FALSE(timer_->is_running());
400 Observer({11}, /*expect_as_duplicate=*/true);
401 tracker_->ObservePacketEnd();
402 EXPECT_TRUE(tracker_->ShouldSendAck());
403 EXPECT_FALSE(timer_->is_running());
404 Observer({12});
405 tracker_->ObservePacketEnd();
406 EXPECT_FALSE(tracker_->ShouldSendAck());
407 EXPECT_TRUE(timer_->is_running());
408 // Goes back to every second packet
409 Observer({13});
410 tracker_->ObservePacketEnd();
411 EXPECT_TRUE(tracker_->ShouldSendAck());
412 EXPECT_FALSE(timer_->is_running());
413 // Duplicate again
414 Observer({12}, /*expect_as_duplicate=*/true);
415 tracker_->ObservePacketEnd();
416 EXPECT_TRUE(tracker_->ShouldSendAck());
417 EXPECT_FALSE(timer_->is_running());
418 }
419
TEST_F(DataTrackerTest,GapAckBlockAddSingleBlock)420 TEST_F(DataTrackerTest, GapAckBlockAddSingleBlock) {
421 Observer({12});
422 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
423 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
424 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 2)));
425 }
426
TEST_F(DataTrackerTest,GapAckBlockAddsAnother)427 TEST_F(DataTrackerTest, GapAckBlockAddsAnother) {
428 Observer({12});
429 Observer({14});
430 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
431 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
432 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 2),
433 SackChunk::GapAckBlock(4, 4)));
434 }
435
TEST_F(DataTrackerTest,GapAckBlockAddsDuplicate)436 TEST_F(DataTrackerTest, GapAckBlockAddsDuplicate) {
437 Observer({12});
438 Observer({12}, /*expect_as_duplicate=*/true);
439 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
440 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
441 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 2)));
442 EXPECT_THAT(sack.duplicate_tsns(), ElementsAre(TSN(12)));
443 }
444
TEST_F(DataTrackerTest,GapAckBlockExpandsToRight)445 TEST_F(DataTrackerTest, GapAckBlockExpandsToRight) {
446 Observer({12});
447 Observer({13});
448 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
449 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
450 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 3)));
451 }
452
TEST_F(DataTrackerTest,GapAckBlockExpandsToRightWithOther)453 TEST_F(DataTrackerTest, GapAckBlockExpandsToRightWithOther) {
454 Observer({12});
455 Observer({20});
456 Observer({30});
457 Observer({21});
458 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
459 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
460 EXPECT_THAT(sack.gap_ack_blocks(),
461 ElementsAre(SackChunk::GapAckBlock(2, 2), //
462 SackChunk::GapAckBlock(10, 11), //
463 SackChunk::GapAckBlock(20, 20)));
464 }
465
TEST_F(DataTrackerTest,GapAckBlockExpandsToLeft)466 TEST_F(DataTrackerTest, GapAckBlockExpandsToLeft) {
467 Observer({13});
468 Observer({12});
469 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
470 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
471 EXPECT_THAT(sack.gap_ack_blocks(), ElementsAre(SackChunk::GapAckBlock(2, 3)));
472 }
473
TEST_F(DataTrackerTest,GapAckBlockExpandsToLeftWithOther)474 TEST_F(DataTrackerTest, GapAckBlockExpandsToLeftWithOther) {
475 Observer({12});
476 Observer({21});
477 Observer({30});
478 Observer({20});
479 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
480 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
481 EXPECT_THAT(sack.gap_ack_blocks(),
482 ElementsAre(SackChunk::GapAckBlock(2, 2), //
483 SackChunk::GapAckBlock(10, 11), //
484 SackChunk::GapAckBlock(20, 20)));
485 }
486
TEST_F(DataTrackerTest,GapAckBlockExpandsToLRightAndMerges)487 TEST_F(DataTrackerTest, GapAckBlockExpandsToLRightAndMerges) {
488 Observer({12});
489 Observer({20});
490 Observer({22});
491 Observer({30});
492 Observer({21});
493 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
494 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(10));
495 EXPECT_THAT(sack.gap_ack_blocks(),
496 ElementsAre(SackChunk::GapAckBlock(2, 2), //
497 SackChunk::GapAckBlock(10, 12), //
498 SackChunk::GapAckBlock(20, 20)));
499 }
500
TEST_F(DataTrackerTest,GapAckBlockMergesManyBlocksIntoOne)501 TEST_F(DataTrackerTest, GapAckBlockMergesManyBlocksIntoOne) {
502 Observer({22});
503 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
504 ElementsAre(SackChunk::GapAckBlock(12, 12)));
505 Observer({30});
506 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
507 ElementsAre(SackChunk::GapAckBlock(12, 12), //
508 SackChunk::GapAckBlock(20, 20)));
509 Observer({24});
510 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
511 ElementsAre(SackChunk::GapAckBlock(12, 12), //
512 SackChunk::GapAckBlock(14, 14), //
513 SackChunk::GapAckBlock(20, 20)));
514 Observer({28});
515 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
516 ElementsAre(SackChunk::GapAckBlock(12, 12), //
517 SackChunk::GapAckBlock(14, 14), //
518 SackChunk::GapAckBlock(18, 18), //
519 SackChunk::GapAckBlock(20, 20)));
520 Observer({26});
521 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
522 ElementsAre(SackChunk::GapAckBlock(12, 12), //
523 SackChunk::GapAckBlock(14, 14), //
524 SackChunk::GapAckBlock(16, 16), //
525 SackChunk::GapAckBlock(18, 18), //
526 SackChunk::GapAckBlock(20, 20)));
527 Observer({29});
528 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
529 ElementsAre(SackChunk::GapAckBlock(12, 12), //
530 SackChunk::GapAckBlock(14, 14), //
531 SackChunk::GapAckBlock(16, 16), //
532 SackChunk::GapAckBlock(18, 20)));
533 Observer({23});
534 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
535 ElementsAre(SackChunk::GapAckBlock(12, 14), //
536 SackChunk::GapAckBlock(16, 16), //
537 SackChunk::GapAckBlock(18, 20)));
538 Observer({27});
539 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
540 ElementsAre(SackChunk::GapAckBlock(12, 14), //
541 SackChunk::GapAckBlock(16, 20)));
542
543 Observer({25});
544 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
545 ElementsAre(SackChunk::GapAckBlock(12, 20)));
546 Observer({20});
547 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
548 ElementsAre(SackChunk::GapAckBlock(10, 10), //
549 SackChunk::GapAckBlock(12, 20)));
550 Observer({32});
551 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
552 ElementsAre(SackChunk::GapAckBlock(10, 10), //
553 SackChunk::GapAckBlock(12, 20), //
554 SackChunk::GapAckBlock(22, 22)));
555 Observer({21});
556 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
557 ElementsAre(SackChunk::GapAckBlock(10, 20), //
558 SackChunk::GapAckBlock(22, 22)));
559 Observer({31});
560 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
561 ElementsAre(SackChunk::GapAckBlock(10, 22)));
562 }
563
TEST_F(DataTrackerTest,GapAckBlockRemoveBeforeCumAckTsn)564 TEST_F(DataTrackerTest, GapAckBlockRemoveBeforeCumAckTsn) {
565 Observer({12, 13, 14, 20, 21, 22, 30, 31});
566
567 tracker_->HandleForwardTsn(TSN(8));
568 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(10));
569 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
570 ElementsAre(SackChunk::GapAckBlock(2, 4), //
571 SackChunk::GapAckBlock(10, 12),
572 SackChunk::GapAckBlock(20, 21)));
573 }
574
TEST_F(DataTrackerTest,GapAckBlockRemoveBeforeFirstBlock)575 TEST_F(DataTrackerTest, GapAckBlockRemoveBeforeFirstBlock) {
576 Observer({12, 13, 14, 20, 21, 22, 30, 31});
577
578 tracker_->HandleForwardTsn(TSN(11));
579 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(14));
580 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
581 ElementsAre(SackChunk::GapAckBlock(6, 8), //
582 SackChunk::GapAckBlock(16, 17)));
583 }
584
TEST_F(DataTrackerTest,GapAckBlockRemoveAtBeginningOfFirstBlock)585 TEST_F(DataTrackerTest, GapAckBlockRemoveAtBeginningOfFirstBlock) {
586 Observer({12, 13, 14, 20, 21, 22, 30, 31});
587
588 tracker_->HandleForwardTsn(TSN(12));
589 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(14));
590 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
591 ElementsAre(SackChunk::GapAckBlock(6, 8), //
592 SackChunk::GapAckBlock(16, 17)));
593 }
594
TEST_F(DataTrackerTest,GapAckBlockRemoveAtMiddleOfFirstBlock)595 TEST_F(DataTrackerTest, GapAckBlockRemoveAtMiddleOfFirstBlock) {
596 Observer({12, 13, 14, 20, 21, 22, 30, 31});
597 tracker_->HandleForwardTsn(TSN(13));
598 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(14));
599 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
600 ElementsAre(SackChunk::GapAckBlock(6, 8), //
601 SackChunk::GapAckBlock(16, 17)));
602 }
603
TEST_F(DataTrackerTest,GapAckBlockRemoveAtEndOfFirstBlock)604 TEST_F(DataTrackerTest, GapAckBlockRemoveAtEndOfFirstBlock) {
605 Observer({12, 13, 14, 20, 21, 22, 30, 31});
606 tracker_->HandleForwardTsn(TSN(14));
607 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(14));
608 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
609 ElementsAre(SackChunk::GapAckBlock(6, 8), //
610 SackChunk::GapAckBlock(16, 17)));
611 }
612
TEST_F(DataTrackerTest,GapAckBlockRemoveRightAfterFirstBlock)613 TEST_F(DataTrackerTest, GapAckBlockRemoveRightAfterFirstBlock) {
614 Observer({12, 13, 14, 20, 21, 22, 30, 31});
615
616 tracker_->HandleForwardTsn(TSN(18));
617 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(18));
618 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
619 ElementsAre(SackChunk::GapAckBlock(2, 4), //
620 SackChunk::GapAckBlock(12, 13)));
621 }
622
TEST_F(DataTrackerTest,GapAckBlockRemoveRightBeforeSecondBlock)623 TEST_F(DataTrackerTest, GapAckBlockRemoveRightBeforeSecondBlock) {
624 Observer({12, 13, 14, 20, 21, 22, 30, 31});
625
626 tracker_->HandleForwardTsn(TSN(19));
627 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(22));
628 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
629 ElementsAre(SackChunk::GapAckBlock(8, 9)));
630 }
631
TEST_F(DataTrackerTest,GapAckBlockRemoveRightAtStartOfSecondBlock)632 TEST_F(DataTrackerTest, GapAckBlockRemoveRightAtStartOfSecondBlock) {
633 Observer({12, 13, 14, 20, 21, 22, 30, 31});
634
635 tracker_->HandleForwardTsn(TSN(20));
636 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(22));
637 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
638 ElementsAre(SackChunk::GapAckBlock(8, 9)));
639 }
640
TEST_F(DataTrackerTest,GapAckBlockRemoveRightAtMiddleOfSecondBlock)641 TEST_F(DataTrackerTest, GapAckBlockRemoveRightAtMiddleOfSecondBlock) {
642 Observer({12, 13, 14, 20, 21, 22, 30, 31});
643
644 tracker_->HandleForwardTsn(TSN(21));
645 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(22));
646 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
647 ElementsAre(SackChunk::GapAckBlock(8, 9)));
648 }
649
TEST_F(DataTrackerTest,GapAckBlockRemoveRightAtEndOfSecondBlock)650 TEST_F(DataTrackerTest, GapAckBlockRemoveRightAtEndOfSecondBlock) {
651 Observer({12, 13, 14, 20, 21, 22, 30, 31});
652
653 tracker_->HandleForwardTsn(TSN(22));
654 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(22));
655 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(),
656 ElementsAre(SackChunk::GapAckBlock(8, 9)));
657 }
658
TEST_F(DataTrackerTest,GapAckBlockRemoveeFarAfterAllBlocks)659 TEST_F(DataTrackerTest, GapAckBlockRemoveeFarAfterAllBlocks) {
660 Observer({12, 13, 14, 20, 21, 22, 30, 31});
661
662 tracker_->HandleForwardTsn(TSN(40));
663 EXPECT_EQ(tracker_->CreateSelectiveAck(kArwnd).cumulative_tsn_ack(), TSN(40));
664 EXPECT_THAT(tracker_->CreateSelectiveAck(kArwnd).gap_ack_blocks(), IsEmpty());
665 }
666
TEST_F(DataTrackerTest,HandoverEmpty)667 TEST_F(DataTrackerTest, HandoverEmpty) {
668 HandoverTracker();
669 Observer({11});
670 SackChunk sack = tracker_->CreateSelectiveAck(kArwnd);
671 EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(11));
672 EXPECT_THAT(sack.gap_ack_blocks(), IsEmpty());
673 }
674
TEST_F(DataTrackerTest,HandoverWhileSendingSackEverySecondPacketWhenThereIsNoPacketLoss)675 TEST_F(DataTrackerTest,
676 HandoverWhileSendingSackEverySecondPacketWhenThereIsNoPacketLoss) {
677 Observer({11});
678 tracker_->ObservePacketEnd();
679 EXPECT_TRUE(tracker_->ShouldSendAck());
680
681 HandoverTracker();
682
683 Observer({12});
684 tracker_->ObservePacketEnd();
685 EXPECT_FALSE(tracker_->ShouldSendAck());
686 Observer({13});
687 tracker_->ObservePacketEnd();
688 EXPECT_TRUE(tracker_->ShouldSendAck());
689 EXPECT_FALSE(timer_->is_running());
690 Observer({14});
691 tracker_->ObservePacketEnd();
692 EXPECT_FALSE(tracker_->ShouldSendAck());
693 EXPECT_TRUE(timer_->is_running());
694 Observer({15});
695 tracker_->ObservePacketEnd();
696 EXPECT_TRUE(tracker_->ShouldSendAck());
697 EXPECT_FALSE(timer_->is_running());
698 }
699
TEST_F(DataTrackerTest,HandoverWhileSendingSackEveryPacketOnPacketLoss)700 TEST_F(DataTrackerTest, HandoverWhileSendingSackEveryPacketOnPacketLoss) {
701 Observer({11});
702 tracker_->ObservePacketEnd();
703 EXPECT_TRUE(tracker_->ShouldSendAck());
704 Observer({13});
705 EXPECT_EQ(tracker_->GetHandoverReadiness(),
706 HandoverReadinessStatus().Add(
707 HandoverUnreadinessReason::kDataTrackerTsnBlocksPending));
708 tracker_->ObservePacketEnd();
709 EXPECT_TRUE(tracker_->ShouldSendAck());
710 Observer({14});
711 tracker_->ObservePacketEnd();
712 EXPECT_TRUE(tracker_->ShouldSendAck());
713 EXPECT_EQ(tracker_->GetHandoverReadiness(),
714 HandoverReadinessStatus(
715 HandoverUnreadinessReason::kDataTrackerTsnBlocksPending));
716 Observer({15});
717 tracker_->ObservePacketEnd();
718 EXPECT_TRUE(tracker_->ShouldSendAck());
719 Observer({16});
720 tracker_->ObservePacketEnd();
721 EXPECT_TRUE(tracker_->ShouldSendAck());
722 // Fill the hole.
723 Observer({12});
724 tracker_->ObservePacketEnd();
725 EXPECT_FALSE(tracker_->ShouldSendAck());
726 // Goes back to every second packet
727 Observer({17});
728 tracker_->ObservePacketEnd();
729 EXPECT_TRUE(tracker_->ShouldSendAck());
730
731 HandoverTracker();
732
733 Observer({18});
734 tracker_->ObservePacketEnd();
735 EXPECT_FALSE(tracker_->ShouldSendAck());
736 EXPECT_TRUE(timer_->is_running());
737 }
738 } // namespace
739 } // namespace dcsctp
740