1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/quic/quic_stream_sequencer.h" 6 7 #include <utility> 8 #include <vector> 9 10 #include "base/rand_util.h" 11 #include "net/quic/reliable_quic_stream.h" 12 #include "testing/gmock/include/gmock/gmock.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 15 using base::StringPiece; 16 using std::min; 17 using std::pair; 18 using std::vector; 19 using testing::_; 20 using testing::AnyNumber; 21 using testing::InSequence; 22 using testing::Return; 23 using testing::StrEq; 24 25 namespace net { 26 namespace test { 27 28 class QuicStreamSequencerPeer : public QuicStreamSequencer { 29 public: 30 explicit QuicStreamSequencerPeer(ReliableQuicStream* stream) 31 : QuicStreamSequencer(stream) { 32 } 33 34 QuicStreamSequencerPeer(int32 max_mem, ReliableQuicStream* stream) 35 : QuicStreamSequencer(max_mem, stream) { 36 } 37 38 virtual bool OnFinFrame(QuicStreamOffset byte_offset, 39 const char* data) { 40 QuicStreamFrame frame; 41 frame.stream_id = 1; 42 frame.offset = byte_offset; 43 frame.data = StringPiece(data); 44 frame.fin = true; 45 return OnStreamFrame(frame); 46 } 47 48 virtual bool OnFrame(QuicStreamOffset byte_offset, 49 const char* data) { 50 QuicStreamFrame frame; 51 frame.stream_id = 1; 52 frame.offset = byte_offset; 53 frame.data = StringPiece(data); 54 frame.fin = false; 55 return OnStreamFrame(frame); 56 } 57 58 void SetMemoryLimit(size_t limit) { 59 max_frame_memory_ = limit; 60 } 61 62 const ReliableQuicStream* stream() const { return stream_; } 63 uint64 num_bytes_consumed() const { return num_bytes_consumed_; } 64 const FrameMap* frames() const { return &frames_; } 65 int32 max_frame_memory() const { return max_frame_memory_; } 66 QuicStreamOffset close_offset() const { return close_offset_; } 67 }; 68 69 class MockStream : public ReliableQuicStream { 70 public: 71 MockStream(QuicSession* session, QuicStreamId id) 72 : ReliableQuicStream(id, session) { 73 } 74 75 MOCK_METHOD1(TerminateFromPeer, void(bool half_close)); 76 MOCK_METHOD2(ProcessData, uint32(const char* data, uint32 data_len)); 77 MOCK_METHOD1(Close, void(QuicRstStreamErrorCode error)); 78 MOCK_METHOD0(OnCanWrite, void()); 79 }; 80 81 namespace { 82 83 static const char kPayload[] = 84 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; 85 86 class QuicStreamSequencerTest : public ::testing::Test { 87 protected: 88 QuicStreamSequencerTest() 89 : session_(NULL), 90 stream_(session_, 1), 91 sequencer_(new QuicStreamSequencerPeer(&stream_)) { 92 } 93 94 bool VerifyReadableRegions(const char** expected, size_t num_expected) { 95 iovec iovecs[5]; 96 size_t num_iovecs = sequencer_->GetReadableRegions(iovecs, 97 arraysize(iovecs)); 98 return VerifyIovecs(iovecs, num_iovecs, expected, num_expected); 99 } 100 101 bool VerifyIovecs(iovec* iovecs, 102 size_t num_iovecs, 103 const char** expected, 104 size_t num_expected) { 105 if (num_expected != num_iovecs) { 106 LOG(ERROR) << "Incorrect number of iovecs. Expected: " 107 << num_expected << " Actual: " << num_iovecs; 108 return false; 109 } 110 for (size_t i = 0; i < num_expected; ++i) { 111 if (!VerifyIovec(iovecs[i], expected[i])) { 112 return false; 113 } 114 } 115 return true; 116 } 117 118 bool VerifyIovec(const iovec& iovec, StringPiece expected) { 119 if (iovec.iov_len != expected.length()) { 120 LOG(ERROR) << "Invalid length: " << iovec.iov_len 121 << " vs " << expected.length(); 122 return false; 123 } 124 if (memcmp(iovec.iov_base, expected.data(), expected.length()) != 0) { 125 LOG(ERROR) << "Invalid data: " << static_cast<char*>(iovec.iov_base) 126 << " vs " << expected.data(); 127 return false; 128 } 129 return true; 130 } 131 132 QuicSession* session_; 133 testing::StrictMock<MockStream> stream_; 134 scoped_ptr<QuicStreamSequencerPeer> sequencer_; 135 }; 136 137 TEST_F(QuicStreamSequencerTest, RejectOldFrame) { 138 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)) 139 .WillOnce(Return(3)); 140 141 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 142 EXPECT_EQ(0u, sequencer_->frames()->size()); 143 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); 144 // Ignore this - it matches a past sequence number and we should not see it 145 // again. 146 EXPECT_TRUE(sequencer_->OnFrame(0, "def")); 147 EXPECT_EQ(0u, sequencer_->frames()->size()); 148 } 149 150 TEST_F(QuicStreamSequencerTest, RejectOverlyLargeFrame) { 151 // TODO(rch): enable when chromium supports EXPECT_DFATAL. 152 /* 153 EXPECT_DFATAL(sequencer_.reset(new QuicStreamSequencerPeer(2, &stream_)), 154 "Setting max frame memory to 2. " 155 "Some frames will be impossible to handle."); 156 157 EXPECT_DEBUG_DEATH(sequencer_->OnFrame(0, "abc"), ""); 158 */ 159 } 160 161 TEST_F(QuicStreamSequencerTest, DropFramePastBuffering) { 162 sequencer_->SetMemoryLimit(3); 163 164 EXPECT_FALSE(sequencer_->OnFrame(3, "abc")); 165 } 166 167 TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) { 168 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)); 169 170 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 171 EXPECT_EQ(1u, sequencer_->frames()->size()); 172 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 173 // Ignore this - it matches a buffered frame. 174 // Right now there's no checking that the payload is consistent. 175 EXPECT_TRUE(sequencer_->OnFrame(0, "def")); 176 EXPECT_EQ(1u, sequencer_->frames()->size()); 177 } 178 179 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) { 180 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 181 182 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 183 EXPECT_EQ(0u, sequencer_->frames()->size()); 184 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); 185 } 186 187 TEST_F(QuicStreamSequencerTest, EmptyFrame) { 188 EXPECT_TRUE(sequencer_->OnFrame(0, "")); 189 EXPECT_EQ(0u, sequencer_->frames()->size()); 190 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 191 } 192 193 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) { 194 EXPECT_CALL(stream_, TerminateFromPeer(true)); 195 EXPECT_TRUE(sequencer_->OnFinFrame(0, "")); 196 EXPECT_EQ(0u, sequencer_->frames()->size()); 197 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 198 } 199 200 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) { 201 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(2)); 202 203 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 204 EXPECT_EQ(1u, sequencer_->frames()->size()); 205 EXPECT_EQ(2u, sequencer_->num_bytes_consumed()); 206 EXPECT_EQ("c", sequencer_->frames()->find(2)->second); 207 } 208 209 TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) { 210 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(0)); 211 212 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 213 EXPECT_EQ(1u, sequencer_->frames()->size()); 214 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 215 EXPECT_EQ("abc", sequencer_->frames()->find(0)->second); 216 } 217 218 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) { 219 EXPECT_TRUE(sequencer_->OnFrame(3, "abc")); 220 EXPECT_EQ(1u, sequencer_->frames()->size()); 221 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 222 EXPECT_EQ("abc", sequencer_->frames()->find(3)->second); 223 } 224 225 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) { 226 // Buffer the first 227 EXPECT_TRUE(sequencer_->OnFrame(6, "ghi")); 228 EXPECT_EQ(1u, sequencer_->frames()->size()); 229 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 230 // Buffer the second 231 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 232 EXPECT_EQ(2u, sequencer_->frames()->size()); 233 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 234 235 InSequence s; 236 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 237 EXPECT_CALL(stream_, ProcessData(StrEq("def"), 3)).WillOnce(Return(3)); 238 EXPECT_CALL(stream_, ProcessData(StrEq("ghi"), 3)).WillOnce(Return(3)); 239 240 // Ack right away 241 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 242 EXPECT_EQ(9u, sequencer_->num_bytes_consumed()); 243 244 EXPECT_EQ(0u, sequencer_->frames()->size()); 245 } 246 247 TEST_F(QuicStreamSequencerTest, OutOfOrderFramesProcessedWithBuffering) { 248 sequencer_->SetMemoryLimit(9); 249 250 // Too far to buffer. 251 EXPECT_FALSE(sequencer_->OnFrame(9, "jkl")); 252 253 // We can afford to buffer this. 254 EXPECT_TRUE(sequencer_->OnFrame(6, "ghi")); 255 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); 256 257 InSequence s; 258 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 259 260 // Ack right away 261 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 262 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); 263 264 // We should be willing to buffer this now. 265 EXPECT_TRUE(sequencer_->OnFrame(9, "jkl")); 266 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); 267 268 EXPECT_CALL(stream_, ProcessData(StrEq("def"), 3)).WillOnce(Return(3)); 269 EXPECT_CALL(stream_, ProcessData(StrEq("ghi"), 3)).WillOnce(Return(3)); 270 EXPECT_CALL(stream_, ProcessData(StrEq("jkl"), 3)).WillOnce(Return(3)); 271 272 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 273 EXPECT_EQ(12u, sequencer_->num_bytes_consumed()); 274 EXPECT_EQ(0u, sequencer_->frames()->size()); 275 } 276 277 TEST_F(QuicStreamSequencerTest, OutOfOrderFramesBlockignWithReadv) { 278 sequencer_->SetMemoryLimit(9); 279 char buffer[20]; 280 iovec iov[2]; 281 iov[0].iov_base = &buffer[0]; 282 iov[0].iov_len = 1; 283 iov[1].iov_base = &buffer[1]; 284 iov[1].iov_len = 2; 285 286 // Push abc - process. 287 // Push jkl - buffer (not next data) 288 // Push def - don't process. 289 // Push mno - drop (too far out) 290 // Push ghi - buffer (def not processed) 291 // Read 2. 292 // Push mno - buffer (not all read) 293 // Read all 294 // Push pqr - process 295 296 InSequence s; 297 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 298 EXPECT_CALL(stream_, ProcessData(StrEq("def"), 3)).WillOnce(Return(0)); 299 EXPECT_CALL(stream_, ProcessData(StrEq("pqr"), 3)).WillOnce(Return(3)); 300 301 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 302 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 303 EXPECT_TRUE(sequencer_->OnFrame(9, "jkl")); 304 EXPECT_FALSE(sequencer_->OnFrame(12, "mno")); 305 EXPECT_TRUE(sequencer_->OnFrame(6, "ghi")); 306 307 // Read 3 bytes. 308 EXPECT_EQ(3, sequencer_->Readv(iov, 2)); 309 EXPECT_EQ(0, strncmp(buffer, "def", 3)); 310 311 // Now we have space to bufer this. 312 EXPECT_TRUE(sequencer_->OnFrame(12, "mno")); 313 314 // Read the remaining 9 bytes. 315 iov[1].iov_len = 19; 316 EXPECT_EQ(9, sequencer_->Readv(iov, 2)); 317 EXPECT_EQ(0, strncmp(buffer, "ghijklmno", 9)); 318 319 EXPECT_TRUE(sequencer_->OnFrame(15, "pqr")); 320 } 321 322 // Same as above, just using a different method for reading. 323 TEST_F(QuicStreamSequencerTest, OutOfOrderFramesBlockignWithGetReadableRegion) { 324 sequencer_->SetMemoryLimit(9); 325 326 InSequence s; 327 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 328 EXPECT_CALL(stream_, ProcessData(StrEq("def"), 3)).WillOnce(Return(0)); 329 EXPECT_CALL(stream_, ProcessData(StrEq("pqr"), 3)).WillOnce(Return(3)); 330 331 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 332 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 333 EXPECT_TRUE(sequencer_->OnFrame(9, "jkl")); 334 EXPECT_FALSE(sequencer_->OnFrame(12, "mno")); 335 EXPECT_TRUE(sequencer_->OnFrame(6, "ghi")); 336 337 // Read 3 bytes. 338 const char* expected[] = {"def", "ghi", "jkl"}; 339 ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected))); 340 char buffer[9]; 341 iovec read_iov = { &buffer[0], 3 }; 342 ASSERT_EQ(3, sequencer_->Readv(&read_iov, 1)); 343 344 // Now we have space to bufer this. 345 EXPECT_TRUE(sequencer_->OnFrame(12, "mno")); 346 347 // Read the remaining 9 bytes. 348 const char* expected2[] = {"ghi", "jkl", "mno"}; 349 ASSERT_TRUE(VerifyReadableRegions(expected2, arraysize(expected2))); 350 read_iov.iov_len = 9; 351 ASSERT_EQ(9, sequencer_->Readv(&read_iov, 1)); 352 353 EXPECT_TRUE(sequencer_->OnFrame(15, "pqr")); 354 } 355 356 // Same as above, just using a different method for reading. 357 TEST_F(QuicStreamSequencerTest, MarkConsumed) { 358 sequencer_->SetMemoryLimit(9); 359 360 InSequence s; 361 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(0)); 362 363 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 364 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 365 EXPECT_TRUE(sequencer_->OnFrame(6, "ghi")); 366 367 // Peek into the data. 368 const char* expected[] = {"abc", "def", "ghi"}; 369 ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected))); 370 371 // Consume 1 byte. 372 sequencer_->MarkConsumed(1); 373 // Verify data. 374 const char* expected2[] = {"bc", "def", "ghi"}; 375 ASSERT_TRUE(VerifyReadableRegions(expected2, arraysize(expected2))); 376 377 // Consume 2 bytes. 378 sequencer_->MarkConsumed(2); 379 // Verify data. 380 const char* expected3[] = {"def", "ghi"}; 381 ASSERT_TRUE(VerifyReadableRegions(expected3, arraysize(expected3))); 382 383 // Consume 5 bytes. 384 sequencer_->MarkConsumed(5); 385 // Verify data. 386 const char* expected4[] = {"i"}; 387 ASSERT_TRUE(VerifyReadableRegions(expected4, arraysize(expected4))); 388 } 389 390 TEST_F(QuicStreamSequencerTest, MarkConsumedError) { 391 // TODO(rch): enable when chromium supports EXPECT_DFATAL. 392 /* 393 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(0)); 394 395 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 396 EXPECT_TRUE(sequencer_->OnFrame(9, "jklmnopqrstuvwxyz")); 397 398 // Peek into the data. Only the first chunk should be readable 399 // because of the missing data. 400 const char* expected[] = {"abc"}; 401 ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected))); 402 403 // Now, attempt to mark consumed more data than was readable 404 // and expect the stream to be closed. 405 EXPECT_CALL(stream_, Close(QUIC_SERVER_ERROR_PROCESSING_STREAM)); 406 EXPECT_DFATAL(sequencer_->MarkConsumed(4), 407 "Invalid argument to MarkConsumed. num_bytes_consumed_: 3 " 408 "end_offset: 4 offset: 9 length: 17"); 409 */ 410 } 411 412 TEST_F(QuicStreamSequencerTest, MarkConsumedWithMissingPacket) { 413 InSequence s; 414 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(0)); 415 416 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 417 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 418 // Missing packet: 6, ghi 419 EXPECT_TRUE(sequencer_->OnFrame(9, "jkl")); 420 421 const char* expected[] = {"abc", "def"}; 422 ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected))); 423 424 sequencer_->MarkConsumed(6); 425 } 426 427 TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) { 428 InSequence s; 429 430 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 431 EXPECT_CALL(stream_, TerminateFromPeer(true)); 432 EXPECT_TRUE(sequencer_->OnFinFrame(0, "abc")); 433 434 EXPECT_EQ(3u, sequencer_->close_offset()); 435 } 436 437 TEST_F(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) { 438 sequencer_->OnFinFrame(6, ""); 439 EXPECT_EQ(6u, sequencer_->close_offset()); 440 InSequence s; 441 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 442 EXPECT_CALL(stream_, ProcessData(StrEq("def"), 3)).WillOnce(Return(3)); 443 EXPECT_CALL(stream_, TerminateFromPeer(true)); 444 445 EXPECT_TRUE(sequencer_->OnFrame(3, "def")); 446 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 447 } 448 449 TEST_F(QuicStreamSequencerTest, BasicHalfUnordered) { 450 sequencer_->OnFinFrame(3, ""); 451 EXPECT_EQ(3u, sequencer_->close_offset()); 452 InSequence s; 453 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(3)); 454 EXPECT_CALL(stream_, TerminateFromPeer(true)); 455 456 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 457 } 458 459 TEST_F(QuicStreamSequencerTest, TerminateWithReadv) { 460 char buffer[3]; 461 462 sequencer_->OnFinFrame(3, ""); 463 EXPECT_EQ(3u, sequencer_->close_offset()); 464 465 EXPECT_FALSE(sequencer_->IsHalfClosed()); 466 467 EXPECT_CALL(stream_, ProcessData(StrEq("abc"), 3)).WillOnce(Return(0)); 468 EXPECT_TRUE(sequencer_->OnFrame(0, "abc")); 469 470 iovec iov = { &buffer[0], 3 }; 471 int bytes_read = sequencer_->Readv(&iov, 1); 472 EXPECT_EQ(3, bytes_read); 473 EXPECT_TRUE(sequencer_->IsHalfClosed()); 474 } 475 476 TEST_F(QuicStreamSequencerTest, MutipleOffsets) { 477 sequencer_->OnFinFrame(3, ""); 478 EXPECT_EQ(3u, sequencer_->close_offset()); 479 480 EXPECT_CALL(stream_, Close(QUIC_MULTIPLE_TERMINATION_OFFSETS)); 481 sequencer_->OnFinFrame(5, ""); 482 EXPECT_EQ(3u, sequencer_->close_offset()); 483 484 EXPECT_CALL(stream_, Close(QUIC_MULTIPLE_TERMINATION_OFFSETS)); 485 sequencer_->OnFinFrame(1, ""); 486 EXPECT_EQ(3u, sequencer_->close_offset()); 487 488 sequencer_->OnFinFrame(3, ""); 489 EXPECT_EQ(3u, sequencer_->close_offset()); 490 } 491 492 class QuicSequencerRandomTest : public QuicStreamSequencerTest { 493 public: 494 typedef pair<int, string> Frame; 495 typedef vector<Frame> FrameList; 496 497 void CreateFrames() { 498 int payload_size = arraysize(kPayload) - 1; 499 int remaining_payload = payload_size; 500 while (remaining_payload != 0) { 501 int size = min(OneToN(6), remaining_payload); 502 int index = payload_size - remaining_payload; 503 list_.push_back(make_pair(index, string(kPayload + index, size))); 504 remaining_payload -= size; 505 } 506 } 507 508 QuicSequencerRandomTest() { 509 CreateFrames(); 510 } 511 512 int OneToN(int n) { 513 return base::RandInt(1, n); 514 } 515 516 int MaybeProcessMaybeBuffer(const char* data, uint32 len) { 517 int to_process = len; 518 if (base::RandUint64() % 2 != 0) { 519 to_process = base::RandInt(0, len); 520 } 521 output_.append(data, to_process); 522 return to_process; 523 } 524 525 string output_; 526 FrameList list_; 527 }; 528 529 // All frames are processed as soon as we have sequential data. 530 // Infinite buffering, so all frames are acked right away. 531 TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) { 532 InSequence s; 533 for (size_t i = 0; i < list_.size(); ++i) { 534 string* data = &list_[i].second; 535 EXPECT_CALL(stream_, ProcessData(StrEq(*data), data->size())) 536 .WillOnce(Return(data->size())); 537 } 538 539 while (list_.size() != 0) { 540 int index = OneToN(list_.size()) - 1; 541 LOG(ERROR) << "Sending index " << index << " " 542 << list_[index].second.data(); 543 EXPECT_TRUE(sequencer_->OnFrame(list_[index].first, 544 list_[index].second.data())); 545 546 list_.erase(list_.begin() + index); 547 } 548 } 549 550 // All frames are processed as soon as we have sequential data. 551 // Buffering, so some frames are rejected. 552 TEST_F(QuicSequencerRandomTest, RandomFramesDroppingNoBackup) { 553 sequencer_->SetMemoryLimit(26); 554 555 InSequence s; 556 for (size_t i = 0; i < list_.size(); ++i) { 557 string* data = &list_[i].second; 558 EXPECT_CALL(stream_, ProcessData(StrEq(*data), data->size())) 559 .WillOnce(Return(data->size())); 560 } 561 562 while (list_.size() != 0) { 563 int index = OneToN(list_.size()) - 1; 564 LOG(ERROR) << "Sending index " << index << " " 565 << list_[index].second.data(); 566 bool acked = sequencer_->OnFrame(list_[index].first, 567 list_[index].second.data()); 568 569 if (acked) { 570 list_.erase(list_.begin() + index); 571 } 572 } 573 } 574 575 } // namespace 576 } // namespace test 577 } // namespace net 578