src/net/quic/quic_stream_sequencer_test.cc

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