Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

net/quic/core/frames/quic_frame_test.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/quic/core/quic_protocol.h"
+#include "net/quic/core/frames/quic_frame.h"
 
-#include <sstream>
-
-#include "base/stl_util.h"
-#include "net/quic/core/quic_flags.h"
-#include "net/quic/core/quic_utils.h"
-#include "net/quic/test_tools/quic_test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 namespace {
 
-TEST(QuicProtocolTest, MakeQuicTag) {
-  QuicTag tag = MakeQuicTag('A', 'B', 'C', 'D');
-  char bytes[4];
-  memcpy(bytes, &tag, 4);
-  EXPECT_EQ('A', bytes[0]);
-  EXPECT_EQ('B', bytes[1]);
-  EXPECT_EQ('C', bytes[2]);
-  EXPECT_EQ('D', bytes[3]);
-}
+using testing::_;
 
-TEST(QuicProtocolTest, 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));
-}
-
-TEST(QuicProtocolTest, AckFrameToString) {
+TEST(QuicFramesTest, AckFrameToString) {
   QuicAckFrame frame;
   frame.largest_observed = 2;
   frame.ack_delay_time = QuicTime::Delta::FromMicroseconds(3);
   frame.packets.Add(4);
   frame.packets.Add(5);
   frame.received_packet_times = {
       {6, QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(7)}};
   std::ostringstream stream;
   stream << frame;
   EXPECT_EQ(
       "{ largest_observed: 2, ack_delay_time: 3, "
       "packets: [ 4 5  ], received_packets: [ 6 at 7  ] }\n",
       stream.str());
 }
 
-TEST(QuicProtocolTest, PaddingFrameToString) {
+TEST(QuicFramesTest, PaddingFrameToString) {
   QuicPaddingFrame frame;
   frame.num_padding_bytes = 1;
   std::ostringstream stream;
   stream << frame;
   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;
   std::ostringstream stream;
   stream << frame;
   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.";
   std::ostringstream stream;
   stream << frame;
   EXPECT_EQ(
       "{ error_code: 25, error_details: 'No recent network activity.' }\n",
       stream.str());
 }
 
-TEST(QuicProtocolTest, GoAwayFrameToString) {
+TEST(QuicFramesTest, GoAwayFrameToString) {
   QuicGoAwayFrame frame;
   frame.error_code = QUIC_NETWORK_IDLE_TIMEOUT;
   frame.last_good_stream_id = 2;
   frame.reason_phrase = "Reason";
   std::ostringstream stream;
   stream << frame;
   EXPECT_EQ(
       "{ error_code: 25, last_good_stream_id: 2, reason_phrase: 'Reason' }\n",
       stream.str());
 }
 
-TEST(QuicProtocolTest, WindowUpdateFrameToString) {
+TEST(QuicFramesTest, WindowUpdateFrameToString) {
   QuicWindowUpdateFrame frame;
   std::ostringstream stream;
   frame.stream_id = 1;
   frame.byte_offset = 2;
   stream << frame;
   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;
   stream << frame;
   EXPECT_EQ("{ stream_id: 1 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, StreamFrameToString) {
+TEST(QuicFramesTest, StreamFrameToString) {
   QuicStreamFrame frame;
   frame.stream_id = 1;
   frame.fin = false;
   frame.offset = 2;
   frame.data_length = 3;
   std::ostringstream stream;
   stream << frame;
   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;
   stream << frame;
   EXPECT_EQ("{ least_unacked: 2 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, PathCloseFrameToString) {
+TEST(QuicFramesTest, PathCloseFrameToString) {
   QuicPathCloseFrame frame;
   frame.path_id = 1;
   std::ostringstream stream;
   stream << frame;
   EXPECT_EQ("{ path_id: 1 }\n", stream.str());
 }
 
-TEST(QuicProtocolTest, QuicVersionManager) {
-  QuicFlagSaver flags;
-  FLAGS_quic_enable_version_36_v3 = false;
-  QuicVersionManager manager(AllSupportedVersions());
-  EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
-            manager.GetSupportedVersions());
-  FLAGS_quic_enable_version_36_v3 = true;
-  EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
-            manager.GetSupportedVersions());
-  EXPECT_EQ(QUIC_VERSION_36, manager.GetSupportedVersions()[0]);
-  EXPECT_EQ(QUIC_VERSION_35, manager.GetSupportedVersions()[1]);
+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) {
@@ skipping 120 matching lines @@
   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