Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(431)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: net/spdy/spdy_frame_reader_test.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/spdy/spdy_frame_reader.cc ('k') | net/spdy/spdy_framer.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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 <algorithm>
6 #include <iostream>
7
8 #include "base/memory/scoped_ptr.h"
9 #include "base/sys_byteorder.h"
10 #include "net/spdy/spdy_frame_reader.h"
11 #include "testing/platform_test.h"
12
13 namespace net {
14
15 TEST(SpdyFrameReaderTest, ReadUInt16) {
16 // Frame data in network byte order.
17 const uint16 kFrameData[] = {
18 htons(1), htons(1<<15),
19 };
20
21 SpdyFrameReader frame_reader(reinterpret_cast<const char*>(kFrameData),
22 sizeof(kFrameData));
23 EXPECT_FALSE(frame_reader.IsDoneReading());
24
25 uint16 uint16_val;
26 EXPECT_TRUE(frame_reader.ReadUInt16(&uint16_val));
27 EXPECT_FALSE(frame_reader.IsDoneReading());
28 EXPECT_EQ(1, uint16_val);
29
30 EXPECT_TRUE(frame_reader.ReadUInt16(&uint16_val));
31 EXPECT_TRUE(frame_reader.IsDoneReading());
32 EXPECT_EQ(1<<15, uint16_val);
33 }
34
35 TEST(SpdyFrameReaderTest, ReadUInt32) {
36 // Frame data in network byte order.
37 const uint32 kFrameData[] = {
38 htonl(1), htonl(0x80000000),
39 };
40
41 SpdyFrameReader frame_reader(reinterpret_cast<const char *>(kFrameData),
42 arraysize(kFrameData) * sizeof(uint32));
43 EXPECT_FALSE(frame_reader.IsDoneReading());
44
45 uint32 uint32_val;
46 EXPECT_TRUE(frame_reader.ReadUInt32(&uint32_val));
47 EXPECT_FALSE(frame_reader.IsDoneReading());
48 EXPECT_EQ(1u, uint32_val);
49
50 EXPECT_TRUE(frame_reader.ReadUInt32(&uint32_val));
51 EXPECT_TRUE(frame_reader.IsDoneReading());
52 EXPECT_EQ(1u<<31, uint32_val);
53 }
54
55 TEST(SpdyFrameReaderTest, ReadStringPiece16) {
56 // Frame data in network byte order.
57 const char kFrameData[] = {
58 0x00, 0x02, // uint16(2)
59 0x48, 0x69, // "Hi"
60 0x00, 0x10, // uint16(16)
61 0x54, 0x65, 0x73, 0x74,
62 0x69, 0x6e, 0x67, 0x2c,
63 0x20, 0x31, 0x2c, 0x20,
64 0x32, 0x2c, 0x20, 0x33, // "Testing, 1, 2, 3"
65 };
66
67 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
68 EXPECT_FALSE(frame_reader.IsDoneReading());
69
70 base::StringPiece stringpiece_val;
71 EXPECT_TRUE(frame_reader.ReadStringPiece16(&stringpiece_val));
72 EXPECT_FALSE(frame_reader.IsDoneReading());
73 EXPECT_EQ(0, stringpiece_val.compare("Hi"));
74
75 EXPECT_TRUE(frame_reader.ReadStringPiece16(&stringpiece_val));
76 EXPECT_TRUE(frame_reader.IsDoneReading());
77 EXPECT_EQ(0, stringpiece_val.compare("Testing, 1, 2, 3"));
78 }
79
80 TEST(SpdyFrameReaderTest, ReadStringPiece32) {
81 // Frame data in network byte order.
82 const char kFrameData[] = {
83 0x00, 0x00, 0x00, 0x03, // uint32(3)
84 0x66, 0x6f, 0x6f, // "foo"
85 0x00, 0x00, 0x00, 0x10, // uint32(16)
86 0x54, 0x65, 0x73, 0x74,
87 0x69, 0x6e, 0x67, 0x2c,
88 0x20, 0x34, 0x2c, 0x20,
89 0x35, 0x2c, 0x20, 0x36, // "Testing, 4, 5, 6"
90 };
91
92 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
93 EXPECT_FALSE(frame_reader.IsDoneReading());
94
95 base::StringPiece stringpiece_val;
96 EXPECT_TRUE(frame_reader.ReadStringPiece32(&stringpiece_val));
97 EXPECT_FALSE(frame_reader.IsDoneReading());
98 EXPECT_EQ(0, stringpiece_val.compare("foo"));
99
100 EXPECT_TRUE(frame_reader.ReadStringPiece32(&stringpiece_val));
101 EXPECT_TRUE(frame_reader.IsDoneReading());
102 EXPECT_EQ(0, stringpiece_val.compare("Testing, 4, 5, 6"));
103 }
104
105 TEST(SpdyFrameReaderTest, ReadUInt16WithBufferTooSmall) {
106 // Frame data in network byte order.
107 const char kFrameData[] = {
108 0x00, // part of a uint16
109 };
110
111 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
112 EXPECT_FALSE(frame_reader.IsDoneReading());
113
114 uint16 uint16_val;
115 EXPECT_FALSE(frame_reader.ReadUInt16(&uint16_val));
116 }
117
118 TEST(SpdyFrameReaderTest, ReadUInt32WithBufferTooSmall) {
119 // Frame data in network byte order.
120 const char kFrameData[] = {
121 0x00, 0x00, 0x00, // part of a uint32
122 };
123
124 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
125 EXPECT_FALSE(frame_reader.IsDoneReading());
126
127 uint32 uint32_val;
128 EXPECT_FALSE(frame_reader.ReadUInt32(&uint32_val));
129
130 // Also make sure that trying to read a uint16, which technically could work,
131 // fails immediately due to previously encountered failed read.
132 uint16 uint16_val;
133 EXPECT_FALSE(frame_reader.ReadUInt16(&uint16_val));
134 }
135
136 // Tests ReadStringPiece16() with a buffer too small to fit the entire string.
137 TEST(SpdyFrameReaderTest, ReadStringPiece16WithBufferTooSmall) {
138 // Frame data in network byte order.
139 const char kFrameData[] = {
140 0x00, 0x03, // uint16(3)
141 0x48, 0x69, // "Hi"
142 };
143
144 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
145 EXPECT_FALSE(frame_reader.IsDoneReading());
146
147 base::StringPiece stringpiece_val;
148 EXPECT_FALSE(frame_reader.ReadStringPiece16(&stringpiece_val));
149
150 // Also make sure that trying to read a uint16, which technically could work,
151 // fails immediately due to previously encountered failed read.
152 uint16 uint16_val;
153 EXPECT_FALSE(frame_reader.ReadUInt16(&uint16_val));
154 }
155
156 // Tests ReadStringPiece16() with a buffer too small even to fit the length.
157 TEST(SpdyFrameReaderTest, ReadStringPiece16WithBufferWayTooSmall) {
158 // Frame data in network byte order.
159 const char kFrameData[] = {
160 0x00, // part of a uint16
161 };
162
163 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
164 EXPECT_FALSE(frame_reader.IsDoneReading());
165
166 base::StringPiece stringpiece_val;
167 EXPECT_FALSE(frame_reader.ReadStringPiece16(&stringpiece_val));
168
169 // Also make sure that trying to read a uint16, which technically could work,
170 // fails immediately due to previously encountered failed read.
171 uint16 uint16_val;
172 EXPECT_FALSE(frame_reader.ReadUInt16(&uint16_val));
173 }
174
175 // Tests ReadStringPiece32() with a buffer too small to fit the entire string.
176 TEST(SpdyFrameReaderTest, ReadStringPiece32WithBufferTooSmall) {
177 // Frame data in network byte order.
178 const char kFrameData[] = {
179 0x00, 0x00, 0x00, 0x03, // uint32(3)
180 0x48, 0x69, // "Hi"
181 };
182
183 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
184 EXPECT_FALSE(frame_reader.IsDoneReading());
185
186 base::StringPiece stringpiece_val;
187 EXPECT_FALSE(frame_reader.ReadStringPiece32(&stringpiece_val));
188
189 // Also make sure that trying to read a uint16, which technically could work,
190 // fails immediately due to previously encountered failed read.
191 uint16 uint16_val;
192 EXPECT_FALSE(frame_reader.ReadUInt16(&uint16_val));
193 }
194
195 // Tests ReadStringPiece32() with a buffer too small even to fit the length.
196 TEST(SpdyFrameReaderTest, ReadStringPiece32WithBufferWayTooSmall) {
197 // Frame data in network byte order.
198 const char kFrameData[] = {
199 0x00, 0x00, 0x00, // part of a uint32
200 };
201
202 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
203 EXPECT_FALSE(frame_reader.IsDoneReading());
204
205 base::StringPiece stringpiece_val;
206 EXPECT_FALSE(frame_reader.ReadStringPiece32(&stringpiece_val));
207
208 // Also make sure that trying to read a uint16, which technically could work,
209 // fails immediately due to previously encountered failed read.
210 uint16 uint16_val;
211 EXPECT_FALSE(frame_reader.ReadUInt16(&uint16_val));
212 }
213
214 TEST(SpdyFrameReaderTest, ReadBytes) {
215 // Frame data in network byte order.
216 const char kFrameData[] = {
217 0x66, 0x6f, 0x6f, // "foo"
218 0x48, 0x69, // "Hi"
219 };
220
221 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
222 EXPECT_FALSE(frame_reader.IsDoneReading());
223
224 char dest1[3] = {};
225 EXPECT_TRUE(frame_reader.ReadBytes(&dest1, arraysize(dest1)));
226 EXPECT_FALSE(frame_reader.IsDoneReading());
227 EXPECT_EQ("foo", base::StringPiece(dest1, arraysize(dest1)));
228
229 char dest2[2] = {};
230 EXPECT_TRUE(frame_reader.ReadBytes(&dest2, arraysize(dest2)));
231 EXPECT_TRUE(frame_reader.IsDoneReading());
232 EXPECT_EQ("Hi", base::StringPiece(dest2, arraysize(dest2)));
233 }
234
235 TEST(SpdyFrameReaderTest, ReadBytesWithBufferTooSmall) {
236 // Frame data in network byte order.
237 const char kFrameData[] = {
238 0x01,
239 };
240
241 SpdyFrameReader frame_reader(kFrameData, arraysize(kFrameData));
242 EXPECT_FALSE(frame_reader.IsDoneReading());
243
244 char dest[arraysize(kFrameData) + 2] = {};
245 EXPECT_FALSE(frame_reader.ReadBytes(&dest, arraysize(kFrameData) + 1));
246 EXPECT_STREQ("", dest);
247 }
248
249 } // namespace net
OLDNEW
« no previous file with comments | « net/spdy/spdy_frame_reader.cc ('k') | net/spdy/spdy_framer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698