| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master