1 // Copyright (c) 2012 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_protocol.h" 6 7 #include "base/stl_util.h" 8 #include "testing/gtest/include/gtest/gtest.h" 9 10 namespace net { 11 namespace test { 12 namespace { 13 14 TEST(QuicProtocolTest, AdjustErrorForVersion) { 15 ASSERT_EQ(8, QUIC_STREAM_LAST_ERROR) 16 << "Any additions to QuicRstStreamErrorCode require an addition to " 17 << "AdjustErrorForVersion and this associated test."; 18 19 EXPECT_EQ(QUIC_STREAM_NO_ERROR, 20 AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, 21 QUIC_VERSION_16)); 22 EXPECT_EQ(QUIC_RST_FLOW_CONTROL_ACCOUNTING, AdjustErrorForVersion( 23 QUIC_RST_FLOW_CONTROL_ACCOUNTING, 24 QUIC_VERSION_18)); 25 } 26 27 TEST(QuicProtocolTest, MakeQuicTag) { 28 QuicTag tag = MakeQuicTag('A', 'B', 'C', 'D'); 29 char bytes[4]; 30 memcpy(bytes, &tag, 4); 31 EXPECT_EQ('A', bytes[0]); 32 EXPECT_EQ('B', bytes[1]); 33 EXPECT_EQ('C', bytes[2]); 34 EXPECT_EQ('D', bytes[3]); 35 } 36 37 TEST(QuicProtocolTest, IsAawaitingPacket) { 38 QuicAckFrame ack_frame; 39 ack_frame.largest_observed = 10u; 40 EXPECT_TRUE(IsAwaitingPacket(ack_frame, 11u)); 41 EXPECT_FALSE(IsAwaitingPacket(ack_frame, 1u)); 42 43 ack_frame.missing_packets.insert(10); 44 EXPECT_TRUE(IsAwaitingPacket(ack_frame, 10u)); 45 } 46 47 TEST(QuicProtocolTest, InsertMissingPacketsBetween) { 48 QuicAckFrame ack_frame; 49 InsertMissingPacketsBetween(&ack_frame, 4u, 10u); 50 EXPECT_EQ(6u, ack_frame.missing_packets.size()); 51 52 QuicPacketSequenceNumber i = 4; 53 for (SequenceNumberSet::iterator it = ack_frame.missing_packets.begin(); 54 it != ack_frame.missing_packets.end(); ++it, ++i) { 55 EXPECT_EQ(i, *it); 56 } 57 } 58 59 TEST(QuicProtocolTest, QuicVersionToQuicTag) { 60 // If you add a new version to the QuicVersion enum you will need to add a new 61 // case to QuicVersionToQuicTag, otherwise this test will fail. 62 63 // TODO(rtenneti): Enable checking of Log(ERROR) messages. 64 #if 0 65 // Any logs would indicate an unsupported version which we don't expect. 66 ScopedMockLog log(kDoNotCaptureLogsYet); 67 EXPECT_CALL(log, Log(_, _, _)).Times(0); 68 log.StartCapturingLogs(); 69 #endif 70 71 // Explicitly test a specific version. 72 EXPECT_EQ(MakeQuicTag('Q', '0', '1', '6'), 73 QuicVersionToQuicTag(QUIC_VERSION_16)); 74 75 // Loop over all supported versions and make sure that we never hit the 76 // default case (i.e. all supported versions should be successfully converted 77 // to valid QuicTags). 78 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { 79 QuicVersion version = kSupportedQuicVersions[i]; 80 EXPECT_LT(0u, QuicVersionToQuicTag(version)); 81 } 82 } 83 84 TEST(QuicProtocolTest, QuicVersionToQuicTagUnsupported) { 85 // TODO(rtenneti): Enable checking of Log(ERROR) messages. 86 #if 0 87 // TODO(rjshade): Change to DFATAL once we actually support multiple versions, 88 // and QuicConnectionTest::SendVersionNegotiationPacket can be changed to use 89 // mis-matched versions rather than relying on QUIC_VERSION_UNSUPPORTED. 90 ScopedMockLog log(kDoNotCaptureLogsYet); 91 EXPECT_CALL(log, Log(ERROR, _, "Unsupported QuicVersion: 0")).Times(1); 92 log.StartCapturingLogs(); 93 #endif 94 95 EXPECT_EQ(0u, QuicVersionToQuicTag(QUIC_VERSION_UNSUPPORTED)); 96 } 97 98 TEST(QuicProtocolTest, QuicTagToQuicVersion) { 99 // If you add a new version to the QuicVersion enum you will need to add a new 100 // case to QuicTagToQuicVersion, otherwise this test will fail. 101 102 // TODO(rtenneti): Enable checking of Log(ERROR) messages. 103 #if 0 104 // Any logs would indicate an unsupported version which we don't expect. 105 ScopedMockLog log(kDoNotCaptureLogsYet); 106 EXPECT_CALL(log, Log(_, _, _)).Times(0); 107 log.StartCapturingLogs(); 108 #endif 109 110 // Explicitly test specific versions. 111 EXPECT_EQ(QUIC_VERSION_16, 112 QuicTagToQuicVersion(MakeQuicTag('Q', '0', '1', '6'))); 113 114 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { 115 QuicVersion version = kSupportedQuicVersions[i]; 116 117 // Get the tag from the version (we can loop over QuicVersions easily). 118 QuicTag tag = QuicVersionToQuicTag(version); 119 EXPECT_LT(0u, tag); 120 121 // Now try converting back. 122 QuicVersion tag_to_quic_version = QuicTagToQuicVersion(tag); 123 EXPECT_EQ(version, tag_to_quic_version); 124 EXPECT_NE(QUIC_VERSION_UNSUPPORTED, tag_to_quic_version); 125 } 126 } 127 128 TEST(QuicProtocolTest, QuicTagToQuicVersionUnsupported) { 129 // TODO(rtenneti): Enable checking of Log(ERROR) messages. 130 #if 0 131 ScopedMockLog log(kDoNotCaptureLogsYet); 132 #ifndef NDEBUG 133 EXPECT_CALL(log, Log(INFO, _, "Unsupported QuicTag version: FAKE")).Times(1); 134 #endif 135 log.StartCapturingLogs(); 136 #endif 137 138 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, 139 QuicTagToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E'))); 140 } 141 142 TEST(QuicProtocolTest, QuicVersionToString) { 143 EXPECT_EQ("QUIC_VERSION_16", QuicVersionToString(QUIC_VERSION_16)); 144 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED", 145 QuicVersionToString(QUIC_VERSION_UNSUPPORTED)); 146 147 QuicVersion single_version[] = {QUIC_VERSION_16}; 148 QuicVersionVector versions_vector; 149 for (size_t i = 0; i < arraysize(single_version); ++i) { 150 versions_vector.push_back(single_version[i]); 151 } 152 EXPECT_EQ("QUIC_VERSION_16", QuicVersionVectorToString(versions_vector)); 153 154 QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_16}; 155 versions_vector.clear(); 156 for (size_t i = 0; i < arraysize(multiple_versions); ++i) { 157 versions_vector.push_back(multiple_versions[i]); 158 } 159 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_16", 160 QuicVersionVectorToString(versions_vector)); 161 162 // Make sure that all supported versions are present in QuicVersionToString. 163 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { 164 QuicVersion version = kSupportedQuicVersions[i]; 165 EXPECT_NE("QUIC_VERSION_UNSUPPORTED", QuicVersionToString(version)); 166 } 167 } 168 169 } // namespace 170 } // namespace test 171 } // namespace net 172