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
10namespace net {
11namespace test {
12namespace {
13
14TEST(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
27TEST(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
37TEST(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
47TEST(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
59TEST(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
84TEST(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
98TEST(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
128TEST(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
142TEST(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