Move remaining tests from quic_protocol_test.cc into appropriate locations. These were missed duri…

net/quic/core/quic_frames_test.cc

Index: net/quic/core/quic_frames_test.cc
diff --git a/net/quic/core/quic_frames_test.cc b/net/quic/core/quic_frames_test.cc
index c4636c1e20fb9229580e2dbf4b75561e25b49b31..53ed26fa8cdcc830bfa88eff45869a8291615cb3 100644
--- a/net/quic/core/quic_frames_test.cc
+++ b/net/quic/core/quic_frames_test.cc
@@ -13,7 +13,7 @@ namespace {
 
 using testing::_;
 
-TEST(QuicProtocolTest, AckFrameToString) {
+TEST(QuicFramesTest, AckFrameToString) {
   QuicAckFrame frame;
   frame.largest_observed = 2;
   frame.ack_delay_time = QuicTime::Delta::FromMicroseconds(3);
@@ -29,7 +29,7 @@ TEST(QuicProtocolTest, AckFrameToString) {
       stream.str());
 }
 
-TEST(QuicProtocolTest, PaddingFrameToString) {
+TEST(QuicFramesTest, PaddingFrameToString) {
   QuicPaddingFrame frame;
   frame.num_padding_bytes = 1;
   std::ostringstream stream;
@@ -37,7 +37,7 @@ TEST(QuicProtocolTest, PaddingFrameToString) {
   EXPECT_EQ("{ num_padding_bytes: 1 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, RstStreamFrameToString) {
+TEST(QuicFramesTest, RstStreamFrameToString) {
   QuicRstStreamFrame frame;
   frame.stream_id = 1;
   frame.error_code = QUIC_STREAM_CANCELLED;
@@ -46,7 +46,7 @@ TEST(QuicProtocolTest, RstStreamFrameToString) {
   EXPECT_EQ("{ stream_id: 1, error_code: 6 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, ConnectionCloseFrameToString) {
+TEST(QuicFramesTest, ConnectionCloseFrameToString) {
   QuicConnectionCloseFrame frame;
   frame.error_code = QUIC_NETWORK_IDLE_TIMEOUT;
   frame.error_details = "No recent network activity.";
@@ -57,7 +57,7 @@ TEST(QuicProtocolTest, ConnectionCloseFrameToString) {
       stream.str());
 }
 
-TEST(QuicProtocolTest, GoAwayFrameToString) {
+TEST(QuicFramesTest, GoAwayFrameToString) {
   QuicGoAwayFrame frame;
   frame.error_code = QUIC_NETWORK_IDLE_TIMEOUT;
   frame.last_good_stream_id = 2;
@@ -69,7 +69,7 @@ TEST(QuicProtocolTest, GoAwayFrameToString) {
       stream.str());
 }
 
-TEST(QuicProtocolTest, WindowUpdateFrameToString) {
+TEST(QuicFramesTest, WindowUpdateFrameToString) {
   QuicWindowUpdateFrame frame;
   std::ostringstream stream;
   frame.stream_id = 1;
@@ -78,7 +78,7 @@ TEST(QuicProtocolTest, WindowUpdateFrameToString) {
   EXPECT_EQ("{ stream_id: 1, byte_offset: 2 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, BlockedFrameToString) {
+TEST(QuicFramesTest, BlockedFrameToString) {
   QuicBlockedFrame frame;
   frame.stream_id = 1;
   std::ostringstream stream;
@@ -86,7 +86,7 @@ TEST(QuicProtocolTest, BlockedFrameToString) {
   EXPECT_EQ("{ stream_id: 1 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, StreamFrameToString) {
+TEST(QuicFramesTest, StreamFrameToString) {
   QuicStreamFrame frame;
   frame.stream_id = 1;
   frame.fin = false;
@@ -97,7 +97,7 @@ TEST(QuicProtocolTest, StreamFrameToString) {
   EXPECT_EQ("{ stream_id: 1, fin: 0, offset: 2, length: 3 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, StopWaitingFrameToString) {
+TEST(QuicFramesTest, StopWaitingFrameToString) {
   QuicStopWaitingFrame frame;
   frame.least_unacked = 2;
   std::ostringstream stream;
@@ -105,7 +105,7 @@ TEST(QuicProtocolTest, StopWaitingFrameToString) {
   EXPECT_EQ("{ least_unacked: 2 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, PathCloseFrameToString) {
+TEST(QuicFramesTest, PathCloseFrameToString) {
   QuicPathCloseFrame frame;
   frame.path_id = 1;
   std::ostringstream stream;
@@ -113,6 +113,162 @@ TEST(QuicProtocolTest, PathCloseFrameToString) {
   EXPECT_EQ("{ path_id: 1 }\n", stream.str());
 }
 
+TEST(QuicFramesTest, IsAwaitingPacket) {
+  QuicAckFrame ack_frame1;
+  ack_frame1.largest_observed = 10u;
+  ack_frame1.packets.Add(1, 11);
+  EXPECT_TRUE(IsAwaitingPacket(ack_frame1, 11u, 0u));
+  EXPECT_FALSE(IsAwaitingPacket(ack_frame1, 1u, 0u));
+
+  ack_frame1.packets.Remove(10);
+  EXPECT_TRUE(IsAwaitingPacket(ack_frame1, 10u, 0u));
+
+  QuicAckFrame ack_frame2;
+  ack_frame2.largest_observed = 100u;
+  ack_frame2.packets.Add(21, 100);
+  EXPECT_FALSE(IsAwaitingPacket(ack_frame2, 11u, 20u));
+  EXPECT_FALSE(IsAwaitingPacket(ack_frame2, 80u, 20u));
+  EXPECT_TRUE(IsAwaitingPacket(ack_frame2, 101u, 20u));
+
+  ack_frame2.packets.Remove(50);
+  EXPECT_TRUE(IsAwaitingPacket(ack_frame2, 50u, 20u));
+}
+
+// Tests that a queue contains the expected data after calls to Add().
+TEST(PacketNumberQueueTest, AddRange) {
+  PacketNumberQueue queue;
+  queue.Add(1, 51);
+  queue.Add(53);
+
+  EXPECT_FALSE(queue.Contains(0));
+  for (int i = 1; i < 51; ++i) {
+    EXPECT_TRUE(queue.Contains(i));
+  }
+  EXPECT_FALSE(queue.Contains(51));
+  EXPECT_FALSE(queue.Contains(52));
+  EXPECT_TRUE(queue.Contains(53));
+  EXPECT_FALSE(queue.Contains(54));
+  EXPECT_EQ(51u, queue.NumPacketsSlow());
+  EXPECT_EQ(1u, queue.Min());
+  EXPECT_EQ(53u, queue.Max());
+
+  queue.Add(70);
+  EXPECT_EQ(70u, queue.Max());
+}
+
+// Tests that a queue contains the expected data after calls to Remove().
+TEST(PacketNumberQueueTest, Removal) {
+  PacketNumberQueue queue;
+  queue.Add(0, 100);
+
+  EXPECT_TRUE(queue.RemoveUpTo(51));
+  EXPECT_FALSE(queue.RemoveUpTo(51));
+  queue.Remove(53);
+
+  EXPECT_FALSE(queue.Contains(0));
+  for (int i = 1; i < 51; ++i) {
+    EXPECT_FALSE(queue.Contains(i));
+  }
+  EXPECT_TRUE(queue.Contains(51));
+  EXPECT_TRUE(queue.Contains(52));
+  EXPECT_FALSE(queue.Contains(53));
+  EXPECT_TRUE(queue.Contains(54));
+  EXPECT_EQ(48u, queue.NumPacketsSlow());
+  EXPECT_EQ(51u, queue.Min());
+  EXPECT_EQ(99u, queue.Max());
+
+  queue.Remove(51);
+  EXPECT_EQ(52u, queue.Min());
+  queue.Remove(99);
+  EXPECT_EQ(98u, queue.Max());
+}
+
+// Tests that a queue is empty when all of its elements are removed.
+TEST(PacketNumberQueueTest, Empty) {
+  PacketNumberQueue queue;
+  EXPECT_TRUE(queue.Empty());
+  EXPECT_EQ(0u, queue.NumPacketsSlow());
+
+  queue.Add(1, 100);
+  EXPECT_TRUE(queue.RemoveUpTo(100));
+  EXPECT_TRUE(queue.Empty());
+  EXPECT_EQ(0u, queue.NumPacketsSlow());
+}
+
+// Tests that logging the state of a PacketNumberQueue does not crash.
+TEST(PacketNumberQueueTest, LogDoesNotCrash) {
+  std::ostringstream oss;
+  PacketNumberQueue queue;
+  oss << queue;
+
+  queue.Add(1);
+  queue.Add(50, 100);
+  oss << queue;
+}
+
+// Tests that the iterators returned from a packet queue iterate over the queue.
+TEST(PacketNumberQueueTest, Iterators) {
+  PacketNumberQueue queue;
+  queue.Add(1, 100);
+
+  const std::vector<Interval<QuicPacketNumber>> actual_intervals(queue.begin(),
+                                                                 queue.end());
+
+  std::vector<Interval<QuicPacketNumber>> expected_intervals;
+  expected_intervals.push_back(Interval<QuicPacketNumber>(1, 100));
+
+  EXPECT_EQ(expected_intervals, actual_intervals);
+}
+
+TEST(PacketNumberQueueTest, LowerBoundEquals) {
+  PacketNumberQueue queue;
+  queue.Add(1, 100);
+
+  PacketNumberQueue::const_iterator it = queue.lower_bound(10);
+  ASSERT_NE(queue.end(), it);
+  EXPECT_TRUE(it->Contains(10u));
+
+  it = queue.lower_bound(101);
+  EXPECT_TRUE(queue.end() == it);
+}
+
+TEST(PacketNumberQueueTest, LowerBoundGreater) {
+  PacketNumberQueue queue;
+  queue.Add(15, 25);
+  queue.Add(50, 100);
+
+  PacketNumberQueue::const_iterator it = queue.lower_bound(10);
+  ASSERT_NE(queue.end(), it);
+  EXPECT_EQ(15u, it->min());
+  EXPECT_EQ(25u, it->max());
+}
+
+TEST(PacketNumberQueueTest, IntervalLengthAndRemoveInterval) {
+  PacketNumberQueue queue;
+  queue.Add(1, 10);
+  queue.Add(20, 30);
+  queue.Add(40, 50);
+  EXPECT_EQ(3u, queue.NumIntervals());
+  EXPECT_EQ(10u, queue.LastIntervalLength());
+  queue.Remove(9, 21);
+  EXPECT_EQ(3u, queue.NumIntervals());
+  EXPECT_FALSE(queue.Contains(9));
+  EXPECT_FALSE(queue.Contains(20));
+}
+
+TEST(PacketNumberQueueTest, Complement) {
+  PacketNumberQueue queue;
+  queue.Add(1, 10);
+  queue.Add(12, 20);
+  queue.Add(22, 30);
+  queue.Complement();
+  EXPECT_EQ(2u, queue.NumIntervals());
+  EXPECT_TRUE(queue.Contains(10));
+  EXPECT_TRUE(queue.Contains(11));
+  EXPECT_TRUE(queue.Contains(20));
+  EXPECT_TRUE(queue.Contains(21));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace net