Home | History | Annotate | Download | only in quic 
      1 // Copyright 2014 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_write_blocked_list.h"
      6 
      7 #include "net/quic/test_tools/quic_test_utils.h"
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 
     10 namespace net {
     11 namespace test {
     12 namespace {
     13 
     14 TEST(QuicWriteBlockedListTest, PriorityOrder) {
     15   QuicWriteBlockedList write_blocked_list;
     16 
     17   // Mark streams blocked in roughly reverse priority order, and
     18   // verify that streams are sorted.
     19   write_blocked_list.PushBack(40,
     20                               QuicWriteBlockedList::kLowestPriority);
     21   write_blocked_list.PushBack(23,
     22                               QuicWriteBlockedList::kHighestPriority);
     23   write_blocked_list.PushBack(17,
     24                               QuicWriteBlockedList::kHighestPriority);
     25   write_blocked_list.PushBack(kHeadersStreamId,
     26                               QuicWriteBlockedList::kHighestPriority);
     27   write_blocked_list.PushBack(kCryptoStreamId,
     28                               QuicWriteBlockedList::kHighestPriority);
     29 
     30   EXPECT_EQ(5u, write_blocked_list.NumBlockedStreams());
     31   EXPECT_TRUE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     32   EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams());
     33   // The Crypto stream is highest priority.
     34   EXPECT_EQ(kCryptoStreamId, write_blocked_list.PopFront());
     35   // Followed by the Headers stream.
     36   EXPECT_EQ(kHeadersStreamId, write_blocked_list.PopFront());
     37   // Streams with same priority are popped in the order they were inserted.
     38   EXPECT_EQ(23u, write_blocked_list.PopFront());
     39   EXPECT_EQ(17u, write_blocked_list.PopFront());
     40   // Low priority stream appears last.
     41   EXPECT_EQ(40u, write_blocked_list.PopFront());
     42 
     43   EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
     44   EXPECT_FALSE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     45   EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams());
     46 }
     47 
     48 TEST(QuicWriteBlockedListTest, CryptoStream) {
     49   QuicWriteBlockedList write_blocked_list;
     50   write_blocked_list.PushBack(kCryptoStreamId,
     51                               QuicWriteBlockedList::kHighestPriority);
     52 
     53   EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams());
     54   EXPECT_TRUE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     55   EXPECT_EQ(kCryptoStreamId, write_blocked_list.PopFront());
     56   EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
     57   EXPECT_FALSE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     58 }
     59 
     60 TEST(QuicWriteBlockedListTest, HeadersStream) {
     61   QuicWriteBlockedList write_blocked_list;
     62   write_blocked_list.PushBack(kHeadersStreamId,
     63                               QuicWriteBlockedList::kHighestPriority);
     64 
     65   EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams());
     66   EXPECT_TRUE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     67   EXPECT_EQ(kHeadersStreamId, write_blocked_list.PopFront());
     68   EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
     69   EXPECT_FALSE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     70 }
     71 
     72 TEST(QuicWriteBlockedListTest, VerifyHeadersStream) {
     73   QuicWriteBlockedList write_blocked_list;
     74   write_blocked_list.PushBack(5,
     75                               QuicWriteBlockedList::kHighestPriority);
     76   write_blocked_list.PushBack(kHeadersStreamId,
     77                               QuicWriteBlockedList::kHighestPriority);
     78 
     79   EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
     80   EXPECT_TRUE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     81   EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams());
     82   // In newer QUIC versions, there is a headers stream which is
     83   // higher priority than data streams.
     84   EXPECT_EQ(kHeadersStreamId, write_blocked_list.PopFront());
     85   EXPECT_EQ(5u, write_blocked_list.PopFront());
     86   EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
     87   EXPECT_FALSE(write_blocked_list.HasWriteBlockedCryptoOrHeadersStream());
     88   EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams());
     89 }
     90 
     91 TEST(QuicWriteBlockedListTest, NoDuplicateEntries) {
     92   // Test that QuicWriteBlockedList doesn't allow duplicate entries.
     93   QuicWriteBlockedList write_blocked_list;
     94 
     95   // Try to add a stream to the write blocked list multiple times at the same
     96   // priority.
     97   const QuicStreamId kBlockedId = kClientDataStreamId1;
     98   write_blocked_list.PushBack(kBlockedId,
     99                               QuicWriteBlockedList::kHighestPriority);
    100   write_blocked_list.PushBack(kBlockedId,
    101                               QuicWriteBlockedList::kHighestPriority);
    102   write_blocked_list.PushBack(kBlockedId,
    103                               QuicWriteBlockedList::kHighestPriority);
    104 
    105   // This should only result in one blocked stream being added.
    106   EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams());
    107   EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams());
    108 
    109   // There should only be one stream to pop off the front.
    110   EXPECT_EQ(kBlockedId, write_blocked_list.PopFront());
    111   EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
    112   EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams());
    113 }
    114 
    115 }  // namespace
    116 }  // namespace test
    117 }  // namespace net
    118