| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2016 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/core/quic_frames.h" | |
| 6 | |
| 7 #include "testing/gmock/include/gmock/gmock.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 | |
| 10 namespace net { | |
| 11 namespace test { | |
| 12 namespace { | |
| 13 | |
| 14 using testing::_; | |
| 15 | |
| 16 TEST(QuicFramesTest, AckFrameToString) { | |
| 17 QuicAckFrame frame; | |
| 18 frame.largest_observed = 2; | |
| 19 frame.ack_delay_time = QuicTime::Delta::FromMicroseconds(3); | |
| 20 frame.packets.Add(4); | |
| 21 frame.packets.Add(5); | |
| 22 frame.received_packet_times = { | |
| 23 {6, QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(7)}}; | |
| 24 std::ostringstream stream; | |
| 25 stream << frame; | |
| 26 EXPECT_EQ( | |
| 27 "{ largest_observed: 2, ack_delay_time: 3, " | |
| 28 "packets: [ 4 5 ], received_packets: [ 6 at 7 ] }\n", | |
| 29 stream.str()); | |
| 30 } | |
| 31 | |
| 32 TEST(QuicFramesTest, PaddingFrameToString) { | |
| 33 QuicPaddingFrame frame; | |
| 34 frame.num_padding_bytes = 1; | |
| 35 std::ostringstream stream; | |
| 36 stream << frame; | |
| 37 EXPECT_EQ("{ num_padding_bytes: 1 }\n", stream.str()); | |
| 38 } | |
| 39 | |
| 40 TEST(QuicFramesTest, RstStreamFrameToString) { | |
| 41 QuicRstStreamFrame frame; | |
| 42 frame.stream_id = 1; | |
| 43 frame.error_code = QUIC_STREAM_CANCELLED; | |
| 44 std::ostringstream stream; | |
| 45 stream << frame; | |
| 46 EXPECT_EQ("{ stream_id: 1, error_code: 6 }\n", stream.str()); | |
| 47 } | |
| 48 | |
| 49 TEST(QuicFramesTest, ConnectionCloseFrameToString) { | |
| 50 QuicConnectionCloseFrame frame; | |
| 51 frame.error_code = QUIC_NETWORK_IDLE_TIMEOUT; | |
| 52 frame.error_details = "No recent network activity."; | |
| 53 std::ostringstream stream; | |
| 54 stream << frame; | |
| 55 EXPECT_EQ( | |
| 56 "{ error_code: 25, error_details: 'No recent network activity.' }\n", | |
| 57 stream.str()); | |
| 58 } | |
| 59 | |
| 60 TEST(QuicFramesTest, GoAwayFrameToString) { | |
| 61 QuicGoAwayFrame frame; | |
| 62 frame.error_code = QUIC_NETWORK_IDLE_TIMEOUT; | |
| 63 frame.last_good_stream_id = 2; | |
| 64 frame.reason_phrase = "Reason"; | |
| 65 std::ostringstream stream; | |
| 66 stream << frame; | |
| 67 EXPECT_EQ( | |
| 68 "{ error_code: 25, last_good_stream_id: 2, reason_phrase: 'Reason' }\n", | |
| 69 stream.str()); | |
| 70 } | |
| 71 | |
| 72 TEST(QuicFramesTest, WindowUpdateFrameToString) { | |
| 73 QuicWindowUpdateFrame frame; | |
| 74 std::ostringstream stream; | |
| 75 frame.stream_id = 1; | |
| 76 frame.byte_offset = 2; | |
| 77 stream << frame; | |
| 78 EXPECT_EQ("{ stream_id: 1, byte_offset: 2 }\n", stream.str()); | |
| 79 } | |
| 80 | |
| 81 TEST(QuicFramesTest, BlockedFrameToString) { | |
| 82 QuicBlockedFrame frame; | |
| 83 frame.stream_id = 1; | |
| 84 std::ostringstream stream; | |
| 85 stream << frame; | |
| 86 EXPECT_EQ("{ stream_id: 1 }\n", stream.str()); | |
| 87 } | |
| 88 | |
| 89 TEST(QuicFramesTest, StreamFrameToString) { | |
| 90 QuicStreamFrame frame; | |
| 91 frame.stream_id = 1; | |
| 92 frame.fin = false; | |
| 93 frame.offset = 2; | |
| 94 frame.data_length = 3; | |
| 95 std::ostringstream stream; | |
| 96 stream << frame; | |
| 97 EXPECT_EQ("{ stream_id: 1, fin: 0, offset: 2, length: 3 }\n", stream.str()); | |
| 98 } | |
| 99 | |
| 100 TEST(QuicFramesTest, StopWaitingFrameToString) { | |
| 101 QuicStopWaitingFrame frame; | |
| 102 frame.least_unacked = 2; | |
| 103 std::ostringstream stream; | |
| 104 stream << frame; | |
| 105 EXPECT_EQ("{ least_unacked: 2 }\n", stream.str()); | |
| 106 } | |
| 107 | |
| 108 TEST(QuicFramesTest, PathCloseFrameToString) { | |
| 109 QuicPathCloseFrame frame; | |
| 110 frame.path_id = 1; | |
| 111 std::ostringstream stream; | |
| 112 stream << frame; | |
| 113 EXPECT_EQ("{ path_id: 1 }\n", stream.str()); | |
| 114 } | |
| 115 | |
| 116 TEST(QuicFramesTest, IsAwaitingPacket) { | |
| 117 QuicAckFrame ack_frame1; | |
| 118 ack_frame1.largest_observed = 10u; | |
| 119 ack_frame1.packets.Add(1, 11); | |
| 120 EXPECT_TRUE(IsAwaitingPacket(ack_frame1, 11u, 0u)); | |
| 121 EXPECT_FALSE(IsAwaitingPacket(ack_frame1, 1u, 0u)); | |
| 122 | |
| 123 ack_frame1.packets.Remove(10); | |
| 124 EXPECT_TRUE(IsAwaitingPacket(ack_frame1, 10u, 0u)); | |
| 125 | |
| 126 QuicAckFrame ack_frame2; | |
| 127 ack_frame2.largest_observed = 100u; | |
| 128 ack_frame2.packets.Add(21, 100); | |
| 129 EXPECT_FALSE(IsAwaitingPacket(ack_frame2, 11u, 20u)); | |
| 130 EXPECT_FALSE(IsAwaitingPacket(ack_frame2, 80u, 20u)); | |
| 131 EXPECT_TRUE(IsAwaitingPacket(ack_frame2, 101u, 20u)); | |
| 132 | |
| 133 ack_frame2.packets.Remove(50); | |
| 134 EXPECT_TRUE(IsAwaitingPacket(ack_frame2, 50u, 20u)); | |
| 135 } | |
| 136 | |
| 137 // Tests that a queue contains the expected data after calls to Add(). | |
| 138 TEST(PacketNumberQueueTest, AddRange) { | |
| 139 PacketNumberQueue queue; | |
| 140 queue.Add(1, 51); | |
| 141 queue.Add(53); | |
| 142 | |
| 143 EXPECT_FALSE(queue.Contains(0)); | |
| 144 for (int i = 1; i < 51; ++i) { | |
| 145 EXPECT_TRUE(queue.Contains(i)); | |
| 146 } | |
| 147 EXPECT_FALSE(queue.Contains(51)); | |
| 148 EXPECT_FALSE(queue.Contains(52)); | |
| 149 EXPECT_TRUE(queue.Contains(53)); | |
| 150 EXPECT_FALSE(queue.Contains(54)); | |
| 151 EXPECT_EQ(51u, queue.NumPacketsSlow()); | |
| 152 EXPECT_EQ(1u, queue.Min()); | |
| 153 EXPECT_EQ(53u, queue.Max()); | |
| 154 | |
| 155 queue.Add(70); | |
| 156 EXPECT_EQ(70u, queue.Max()); | |
| 157 } | |
| 158 | |
| 159 // Tests that a queue contains the expected data after calls to Remove(). | |
| 160 TEST(PacketNumberQueueTest, Removal) { | |
| 161 PacketNumberQueue queue; | |
| 162 queue.Add(0, 100); | |
| 163 | |
| 164 EXPECT_TRUE(queue.RemoveUpTo(51)); | |
| 165 EXPECT_FALSE(queue.RemoveUpTo(51)); | |
| 166 queue.Remove(53); | |
| 167 | |
| 168 EXPECT_FALSE(queue.Contains(0)); | |
| 169 for (int i = 1; i < 51; ++i) { | |
| 170 EXPECT_FALSE(queue.Contains(i)); | |
| 171 } | |
| 172 EXPECT_TRUE(queue.Contains(51)); | |
| 173 EXPECT_TRUE(queue.Contains(52)); | |
| 174 EXPECT_FALSE(queue.Contains(53)); | |
| 175 EXPECT_TRUE(queue.Contains(54)); | |
| 176 EXPECT_EQ(48u, queue.NumPacketsSlow()); | |
| 177 EXPECT_EQ(51u, queue.Min()); | |
| 178 EXPECT_EQ(99u, queue.Max()); | |
| 179 | |
| 180 queue.Remove(51); | |
| 181 EXPECT_EQ(52u, queue.Min()); | |
| 182 queue.Remove(99); | |
| 183 EXPECT_EQ(98u, queue.Max()); | |
| 184 } | |
| 185 | |
| 186 // Tests that a queue is empty when all of its elements are removed. | |
| 187 TEST(PacketNumberQueueTest, Empty) { | |
| 188 PacketNumberQueue queue; | |
| 189 EXPECT_TRUE(queue.Empty()); | |
| 190 EXPECT_EQ(0u, queue.NumPacketsSlow()); | |
| 191 | |
| 192 queue.Add(1, 100); | |
| 193 EXPECT_TRUE(queue.RemoveUpTo(100)); | |
| 194 EXPECT_TRUE(queue.Empty()); | |
| 195 EXPECT_EQ(0u, queue.NumPacketsSlow()); | |
| 196 } | |
| 197 | |
| 198 // Tests that logging the state of a PacketNumberQueue does not crash. | |
| 199 TEST(PacketNumberQueueTest, LogDoesNotCrash) { | |
| 200 std::ostringstream oss; | |
| 201 PacketNumberQueue queue; | |
| 202 oss << queue; | |
| 203 | |
| 204 queue.Add(1); | |
| 205 queue.Add(50, 100); | |
| 206 oss << queue; | |
| 207 } | |
| 208 | |
| 209 // Tests that the iterators returned from a packet queue iterate over the queue. | |
| 210 TEST(PacketNumberQueueTest, Iterators) { | |
| 211 PacketNumberQueue queue; | |
| 212 queue.Add(1, 100); | |
| 213 | |
| 214 const std::vector<Interval<QuicPacketNumber>> actual_intervals(queue.begin(), | |
| 215 queue.end()); | |
| 216 | |
| 217 std::vector<Interval<QuicPacketNumber>> expected_intervals; | |
| 218 expected_intervals.push_back(Interval<QuicPacketNumber>(1, 100)); | |
| 219 | |
| 220 EXPECT_EQ(expected_intervals, actual_intervals); | |
| 221 } | |
| 222 | |
| 223 TEST(PacketNumberQueueTest, LowerBoundEquals) { | |
| 224 PacketNumberQueue queue; | |
| 225 queue.Add(1, 100); | |
| 226 | |
| 227 PacketNumberQueue::const_iterator it = queue.lower_bound(10); | |
| 228 ASSERT_NE(queue.end(), it); | |
| 229 EXPECT_TRUE(it->Contains(10u)); | |
| 230 | |
| 231 it = queue.lower_bound(101); | |
| 232 EXPECT_TRUE(queue.end() == it); | |
| 233 } | |
| 234 | |
| 235 TEST(PacketNumberQueueTest, LowerBoundGreater) { | |
| 236 PacketNumberQueue queue; | |
| 237 queue.Add(15, 25); | |
| 238 queue.Add(50, 100); | |
| 239 | |
| 240 PacketNumberQueue::const_iterator it = queue.lower_bound(10); | |
| 241 ASSERT_NE(queue.end(), it); | |
| 242 EXPECT_EQ(15u, it->min()); | |
| 243 EXPECT_EQ(25u, it->max()); | |
| 244 } | |
| 245 | |
| 246 TEST(PacketNumberQueueTest, IntervalLengthAndRemoveInterval) { | |
| 247 PacketNumberQueue queue; | |
| 248 queue.Add(1, 10); | |
| 249 queue.Add(20, 30); | |
| 250 queue.Add(40, 50); | |
| 251 EXPECT_EQ(3u, queue.NumIntervals()); | |
| 252 EXPECT_EQ(10u, queue.LastIntervalLength()); | |
| 253 queue.Remove(9, 21); | |
| 254 EXPECT_EQ(3u, queue.NumIntervals()); | |
| 255 EXPECT_FALSE(queue.Contains(9)); | |
| 256 EXPECT_FALSE(queue.Contains(20)); | |
| 257 } | |
| 258 | |
| 259 TEST(PacketNumberQueueTest, Complement) { | |
| 260 PacketNumberQueue queue; | |
| 261 queue.Add(1, 10); | |
| 262 queue.Add(12, 20); | |
| 263 queue.Add(22, 30); | |
| 264 queue.Complement(); | |
| 265 EXPECT_EQ(2u, queue.NumIntervals()); | |
| 266 EXPECT_TRUE(queue.Contains(10)); | |
| 267 EXPECT_TRUE(queue.Contains(11)); | |
| 268 EXPECT_TRUE(queue.Contains(20)); | |
| 269 EXPECT_TRUE(queue.Contains(21)); | |
| 270 } | |
| 271 | |
| 272 } // namespace | |
| 273 } // namespace test | |
| 274 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2545543003:
Split up quic_frames.{h,cc} into files for each frame type. (Closed)
