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