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