1 // Copyright 2007, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 #include "base/basictypes.h"
31 #include "googleurl/src/url_parse.h"
32 #include "testing/gtest/include/gtest/gtest.h"
33
34 // Some implementations of base/basictypes.h may define ARRAYSIZE.
35 // If it's not defined, we define it to the ARRAYSIZE_UNSAFE macro
36 // which is in our version of basictypes.h.
37 #ifndef ARRAYSIZE
38 #define ARRAYSIZE ARRAYSIZE_UNSAFE
39 #endif
40
41 // Interesting IE file:isms...
42 //
43 // file:/foo/bar file:///foo/bar
44 // The result here seems totally invalid!?!? This isn't UNC.
45 //
46 // file:/
47 // file:// or any other number of slashes
48 // IE6 doesn't do anything at all if you click on this link. No error:
49 // nothing. IE6's history system seems to always color this link, so I'm
50 // guessing that it maps internally to the empty URL.
51 //
52 // C:\ file:///C:/
53 // / file:///C:/
54 // /foo file:///C:/foo
55 // Interestingly, IE treats "/" as an alias for "c:\", which makes sense,
56 // but is weird to think about on Windows.
57 //
58 // file:foo/ file:foo/ (invalid?!?!?)
59 // file:/foo/ file:///foo/ (invalid?!?!?)
60 // file://foo/ file://foo/ (UNC to server "foo")
61 // file:///foo/ file:///foo/ (invalid)
62 // file:////foo/ file://foo/ (UNC to server "foo")
63 // Any more than four slashes is also treated as UNC.
64 //
65 // file:C:/ file://C:/
66 // file:/C:/ file://C:/
67 // The number of slashes after "file:" don't matter if the thing following
68 // it looks like an absolute drive path. Also, slashes and backslashes are
69 // equally valid here.
70
71 namespace {
72
73 // Used for regular URL parse cases.
74 struct URLParseCase {
75 const char* input;
76
77 const char* scheme;
78 const char* username;
79 const char* password;
80 const char* host;
81 int port;
82 const char* path;
83 const char* query;
84 const char* ref;
85 };
86
87 // Simpler version of URLParseCase for testing path URLs.
88 struct PathURLParseCase {
89 const char* input;
90
91 const char* scheme;
92 const char* path;
93 };
94
95 // Simpler version of URLParseCase for testing mailto URLs.
96 struct MailtoURLParseCase {
97 const char* input;
98
99 const char* scheme;
100 const char* path;
101 const char* query;
102 };
103
104
ComponentMatches(const char * input,const char * reference,const url_parse::Component & component)105 bool ComponentMatches(const char* input,
106 const char* reference,
107 const url_parse::Component& component) {
108 // If the component is nonexistant (length == -1), it should begin at 0.
109 EXPECT_TRUE(component.len >= 0 || component.len == -1);
110
111 // Begin should be valid.
112 EXPECT_LE(0, component.begin);
113
114 // A NULL reference means the component should be nonexistant.
115 if (!reference)
116 return component.len == -1;
117 if (component.len < 0)
118 return false; // Reference is not NULL but we don't have anything
119
120 if (strlen(reference) != static_cast<size_t>(component.len))
121 return false; // Lengths don't match
122
123 // Now check the actual characters.
124 return strncmp(reference, &input[component.begin], component.len) == 0;
125 }
126
ExpectInvalidComponent(const url_parse::Component & component)127 void ExpectInvalidComponent(const url_parse::Component& component) {
128 EXPECT_EQ(0, component.begin);
129 EXPECT_EQ(-1, component.len);
130 }
131
132 } // namespace
133
134 // Parsed ----------------------------------------------------------------------
135
TEST(URLParser,Length)136 TEST(URLParser, Length) {
137 const char* length_cases[] = {
138 // One with everything in it.
139 "http://user:pass@host:99/foo?bar#baz",
140 // One with nothing in it.
141 "",
142 // Working backwards, let's start taking off stuff from the full one.
143 "http://user:pass@host:99/foo?bar#",
144 "http://user:pass@host:99/foo?bar",
145 "http://user:pass@host:99/foo?",
146 "http://user:pass@host:99/foo",
147 "http://user:pass@host:99/",
148 "http://user:pass@host:99",
149 "http://user:pass@host:",
150 "http://user:pass@host",
151 "http://host",
152 "http://user@",
153 "http:",
154 };
155 for (size_t i = 0; i < arraysize(length_cases); i++) {
156 int true_length = static_cast<int>(strlen(length_cases[i]));
157
158 url_parse::Parsed parsed;
159 url_parse::ParseStandardURL(length_cases[i], true_length, &parsed);
160
161 EXPECT_EQ(true_length, parsed.Length());
162 }
163 }
164
TEST(URLParser,CountCharactersBefore)165 TEST(URLParser, CountCharactersBefore) {
166 using namespace url_parse;
167 struct CountCase {
168 const char* url;
169 Parsed::ComponentType component;
170 bool include_delimiter;
171 int expected_count;
172 } count_cases[] = {
173 // Test each possibility in the case where all components are present.
174 // 0 1 2
175 // 0123456789012345678901
176 {"http://u:p@h:8/p?q#r", Parsed::SCHEME, true, 0},
177 {"http://u:p@h:8/p?q#r", Parsed::SCHEME, false, 0},
178 {"http://u:p@h:8/p?q#r", Parsed::USERNAME, true, 7},
179 {"http://u:p@h:8/p?q#r", Parsed::USERNAME, false, 7},
180 {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, true, 9},
181 {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, false, 9},
182 {"http://u:p@h:8/p?q#r", Parsed::HOST, true, 11},
183 {"http://u:p@h:8/p?q#r", Parsed::HOST, false, 11},
184 {"http://u:p@h:8/p?q#r", Parsed::PORT, true, 12},
185 {"http://u:p@h:8/p?q#r", Parsed::PORT, false, 13},
186 {"http://u:p@h:8/p?q#r", Parsed::PATH, false, 14},
187 {"http://u:p@h:8/p?q#r", Parsed::PATH, true, 14},
188 {"http://u:p@h:8/p?q#r", Parsed::QUERY, true, 16},
189 {"http://u:p@h:8/p?q#r", Parsed::QUERY, false, 17},
190 {"http://u:p@h:8/p?q#r", Parsed::REF, true, 18},
191 {"http://u:p@h:8/p?q#r", Parsed::REF, false, 19},
192 // Now test when the requested component is missing.
193 {"http://u:p@h:8/p?", Parsed::REF, true, 17},
194 {"http://u:p@h:8/p?q", Parsed::REF, true, 18},
195 {"http://u:p@h:8/p#r", Parsed::QUERY, true, 16},
196 {"http://u:p@h:8#r", Parsed::PATH, true, 14},
197 {"http://u:p@h/", Parsed::PORT, true, 12},
198 {"http://u:p@/", Parsed::HOST, true, 11},
199 // This case is a little weird. It will report that the password would
200 // start where the host begins. This is arguably correct, although you
201 // could also argue that it should start at the '@' sign. Doing it
202 // starting with the '@' sign is actually harder, so we don't bother.
203 {"http://u@h/", Parsed::PASSWORD, true, 9},
204 {"http://h/", Parsed::USERNAME, true, 7},
205 {"http:", Parsed::USERNAME, true, 5},
206 {"", Parsed::SCHEME, true, 0},
207 // Make sure a random component still works when there's nothing there.
208 {"", Parsed::REF, true, 0},
209 // File URLs are special with no host, so we test those.
210 {"file:///c:/foo", Parsed::USERNAME, true, 7},
211 {"file:///c:/foo", Parsed::PASSWORD, true, 7},
212 {"file:///c:/foo", Parsed::HOST, true, 7},
213 {"file:///c:/foo", Parsed::PATH, true, 7},
214 };
215 for (size_t i = 0; i < ARRAYSIZE(count_cases); i++) {
216 int length = static_cast<int>(strlen(count_cases[i].url));
217
218 // Simple test to distinguish file and standard URLs.
219 url_parse::Parsed parsed;
220 if (length > 0 && count_cases[i].url[0] == 'f')
221 url_parse::ParseFileURL(count_cases[i].url, length, &parsed);
222 else
223 url_parse::ParseStandardURL(count_cases[i].url, length, &parsed);
224
225 int chars_before = parsed.CountCharactersBefore(
226 count_cases[i].component, count_cases[i].include_delimiter);
227 EXPECT_EQ(count_cases[i].expected_count, chars_before);
228 }
229 }
230
231 // Standard --------------------------------------------------------------------
232
233 // Input Scheme Usrname Passwd Host Port Path Query Ref
234 // ------------------------------------ ------- ------- ---------- ------------ --- ---------- ------------ -----
235 static URLParseCase cases[] = {
236 // Regular URL with all the parts
237 {"http://user:pass@foo:21/bar;par?b#c", "http", "user", "pass", "foo", 21, "/bar;par","b", "c"},
238
239 // Known schemes should lean towards authority identification
240 {"http:foo.com", "http", NULL, NULL, "foo.com", -1, NULL, NULL, NULL},
241
242 // Spaces!
243 {"\t :foo.com \n", "", NULL, NULL, "foo.com", -1, NULL, NULL, NULL},
244 {" foo.com ", NULL, NULL, NULL, "foo.com", -1, NULL, NULL, NULL},
245 {"a:\t foo.com", "a", NULL, NULL, "\t foo.com", -1, NULL, NULL, NULL},
246 {"http://f:21/ b ? d # e ", "http", NULL, NULL, "f", 21, "/ b ", " d ", " e"},
247
248 // Invalid port numbers should be identified and turned into -2, empty port
249 // numbers should be -1. Spaces aren't allowed in port numbers
250 {"http://f:/c", "http", NULL, NULL, "f", -1, "/c", NULL, NULL},
251 {"http://f:0/c", "http", NULL, NULL, "f", 0, "/c", NULL, NULL},
252 {"http://f:00000000000000/c", "http", NULL, NULL, "f", 0, "/c", NULL, NULL},
253 {"http://f:00000000000000000000080/c", "http", NULL, NULL, "f", 80, "/c", NULL, NULL},
254 {"http://f:b/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
255 {"http://f: /c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
256 {"http://f:\n/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
257 {"http://f:fifty-two/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
258 {"http://f:999999/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
259 {"http://f: 21 / b ? d # e ", "http", NULL, NULL, "f", -2, "/ b ", " d ", " e"},
260
261 // Creative URLs missing key elements
262 {"", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
263 {" \t", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
264 {":foo.com/", "", NULL, NULL, "foo.com", -1, "/", NULL, NULL},
265 {":foo.com\\", "", NULL, NULL, "foo.com", -1, "\\", NULL, NULL},
266 {":", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
267 {":a", "", NULL, NULL, "a", -1, NULL, NULL, NULL},
268 {":/", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
269 {":\\", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
270 {":#", "", NULL, NULL, NULL, -1, NULL, NULL, ""},
271 {"#", NULL, NULL, NULL, NULL, -1, NULL, NULL, ""},
272 {"#/", NULL, NULL, NULL, NULL, -1, NULL, NULL, "/"},
273 {"#\\", NULL, NULL, NULL, NULL, -1, NULL, NULL, "\\"},
274 {"#;?", NULL, NULL, NULL, NULL, -1, NULL, NULL, ";?"},
275 {"?", NULL, NULL, NULL, NULL, -1, NULL, "", NULL},
276 {"/", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
277 {":23", "", NULL, NULL, "23", -1, NULL, NULL, NULL},
278 {"/:23", "/", NULL, NULL, "23", -1, NULL, NULL, NULL},
279 {"//", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
280 {"::", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
281 {"::23", "", NULL, NULL, NULL, 23, NULL, NULL, NULL},
282 {"foo://", "foo", NULL, NULL, NULL, -1, NULL, NULL, NULL},
283
284 // Username/passwords and things that look like them
285 {"http://a:b@c:29/d", "http", "a", "b", "c", 29, "/d", NULL, NULL},
286 {"http::@c:29", "http", "", "", "c", 29, NULL, NULL, NULL},
287 // ... "]" in the password field isn't allowed, but we tolerate it here...
288 {"http://&a:foo(b]c@d:2/", "http", "&a", "foo(b]c", "d", 2, "/", NULL, NULL},
289 {"http://::@c@d:2", "http", "", ":@c", "d", 2, NULL, NULL, NULL},
290 {"http://foo.com:b@d/", "http", "foo.com", "b", "d", -1, "/", NULL, NULL},
291
292 {"http://foo.com/\\@", "http", NULL, NULL, "foo.com", -1, "/\\@", NULL, NULL},
293 {"http:\\\\foo.com\\", "http", NULL, NULL, "foo.com", -1, "\\", NULL, NULL},
294 {"http:\\\\a\\b:c\\d@foo.com\\", "http", NULL, NULL, "a", -1, "\\b:c\\d@foo.com\\", NULL, NULL},
295
296 // Tolerate different numbers of slashes.
297 {"foo:/", "foo", NULL, NULL, NULL, -1, NULL, NULL, NULL},
298 {"foo:/bar.com/", "foo", NULL, NULL, "bar.com", -1, "/", NULL, NULL},
299 {"foo://///////", "foo", NULL, NULL, NULL, -1, NULL, NULL, NULL},
300 {"foo://///////bar.com/", "foo", NULL, NULL, "bar.com", -1, "/", NULL, NULL},
301 {"foo:////://///", "foo", NULL, NULL, NULL, -1, "/////", NULL, NULL},
302
303 // Raw file paths on Windows aren't handled by the parser.
304 {"c:/foo", "c", NULL, NULL, "foo", -1, NULL, NULL, NULL},
305 {"//foo/bar", NULL, NULL, NULL, "foo", -1, "/bar", NULL, NULL},
306
307 // Use the first question mark for the query and the ref.
308 {"http://foo/path;a??e#f#g", "http", NULL, NULL, "foo", -1, "/path;a", "?e", "f#g"},
309 {"http://foo/abcd?efgh?ijkl", "http", NULL, NULL, "foo", -1, "/abcd", "efgh?ijkl", NULL},
310 {"http://foo/abcd#foo?bar", "http", NULL, NULL, "foo", -1, "/abcd", NULL, "foo?bar"},
311
312 // IPv6, check also interesting uses of colons.
313 {"[61:24:74]:98", "[61", NULL, NULL, "24:74]", 98, NULL, NULL, NULL},
314 {"http://[61:27]:98", "http", NULL, NULL, "[61:27]", 98, NULL, NULL, NULL},
315 {"http:[61:27]/:foo", "http", NULL, NULL, "[61:27]", -1, "/:foo", NULL, NULL},
316 {"http://[1::2]:3:4", "http", NULL, NULL, "[1::2]:3", 4, NULL, NULL, NULL},
317
318 // Partially-complete IPv6 literals, and related cases.
319 {"http://2001::1", "http", NULL, NULL, "2001:", 1, NULL, NULL, NULL},
320 {"http://[2001::1", "http", NULL, NULL, "[2001::1", -1, NULL, NULL, NULL},
321 {"http://2001::1]", "http", NULL, NULL, "2001::1]", -1, NULL, NULL, NULL},
322 {"http://2001::1]:80", "http", NULL, NULL, "2001::1]", 80, NULL, NULL, NULL},
323 {"http://[2001::1]", "http", NULL, NULL, "[2001::1]", -1, NULL, NULL, NULL},
324 {"http://[2001::1]:80", "http", NULL, NULL, "[2001::1]", 80, NULL, NULL, NULL},
325 {"http://[[::]]", "http", NULL, NULL, "[[::]]", -1, NULL, NULL, NULL},
326
327 };
328
TEST(URLParser,Standard)329 TEST(URLParser, Standard) {
330 // Declared outside for loop to try to catch cases in init() where we forget
331 // to reset something that is reset by the construtor.
332 url_parse::Parsed parsed;
333 for (size_t i = 0; i < arraysize(cases); i++) {
334 const char* url = cases[i].input;
335 url_parse::ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
336 int port = url_parse::ParsePort(url, parsed.port);
337
338 EXPECT_TRUE(ComponentMatches(url, cases[i].scheme, parsed.scheme));
339 EXPECT_TRUE(ComponentMatches(url, cases[i].username, parsed.username));
340 EXPECT_TRUE(ComponentMatches(url, cases[i].password, parsed.password));
341 EXPECT_TRUE(ComponentMatches(url, cases[i].host, parsed.host));
342 EXPECT_EQ(cases[i].port, port);
343 EXPECT_TRUE(ComponentMatches(url, cases[i].path, parsed.path));
344 EXPECT_TRUE(ComponentMatches(url, cases[i].query, parsed.query));
345 EXPECT_TRUE(ComponentMatches(url, cases[i].ref, parsed.ref));
346 }
347 }
348
349 // PathURL --------------------------------------------------------------------
350
351 // Various incarnations of path URLs.
352 static PathURLParseCase path_cases[] = {
353 {"", NULL, NULL},
354 {":", "", NULL},
355 {":/", "", "/"},
356 {"/", NULL, "/"},
357 {" This is \\interesting// \t", NULL, "This is \\interesting//"},
358 {"about:", "about", NULL},
359 {"about:blank", "about", "blank"},
360 {" about: blank ", "about", " blank"},
361 {"javascript :alert(\"He:/l\\l#o?foo\"); ", "javascript ", "alert(\"He:/l\\l#o?foo\");"},
362 };
363
TEST(URLParser,PathURL)364 TEST(URLParser, PathURL) {
365 // Declared outside for loop to try to catch cases in init() where we forget
366 // to reset something that is reset by the construtor.
367 url_parse::Parsed parsed;
368 for (size_t i = 0; i < arraysize(path_cases); i++) {
369 const char* url = path_cases[i].input;
370 url_parse::ParsePathURL(url, static_cast<int>(strlen(url)), &parsed);
371
372 EXPECT_TRUE(ComponentMatches(url, path_cases[i].scheme, parsed.scheme));
373 EXPECT_TRUE(ComponentMatches(url, path_cases[i].path, parsed.path));
374
375 // The remaining components are never used for path urls.
376 ExpectInvalidComponent(parsed.username);
377 ExpectInvalidComponent(parsed.password);
378 ExpectInvalidComponent(parsed.host);
379 ExpectInvalidComponent(parsed.port);
380 ExpectInvalidComponent(parsed.query);
381 ExpectInvalidComponent(parsed.ref);
382 }
383 }
384
385 #ifdef WIN32
386
387 // WindowsFile ----------------------------------------------------------------
388
389 // Various incarnations of file URLs. These are for Windows only.
390 static URLParseCase file_cases[] = {
391 {"file:server", "file", NULL, NULL, "server", -1, NULL, NULL, NULL},
392 {" file: server \t", "file", NULL, NULL, " server",-1, NULL, NULL, NULL},
393 {"FiLe:c|", "FiLe", NULL, NULL, NULL, -1, "c|", NULL, NULL},
394 {"FILE:/\\\\/server/file", "FILE", NULL, NULL, "server", -1, "/file", NULL, NULL},
395 {"file://server/", "file", NULL, NULL, "server", -1, "/", NULL, NULL},
396 {"file://localhost/c:/", "file", NULL, NULL, NULL, -1, "/c:/", NULL, NULL},
397 {"file://127.0.0.1/c|\\", "file", NULL, NULL, NULL, -1, "/c|\\", NULL, NULL},
398 {"file:/", "file", NULL, NULL, NULL, -1, NULL, NULL, NULL},
399 {"file:", "file", NULL, NULL, NULL, -1, NULL, NULL, NULL},
400 // If there is a Windows drive letter, treat any number of slashes as the
401 // path part.
402 {"file:c:\\fo\\b", "file", NULL, NULL, NULL, -1, "c:\\fo\\b", NULL, NULL},
403 {"file:/c:\\foo/bar", "file", NULL, NULL, NULL, -1, "/c:\\foo/bar",NULL, NULL},
404 {"file://c:/f\\b", "file", NULL, NULL, NULL, -1, "/c:/f\\b", NULL, NULL},
405 {"file:///C:/foo", "file", NULL, NULL, NULL, -1, "/C:/foo", NULL, NULL},
406 {"file://///\\/\\/c:\\f\\b", "file", NULL, NULL, NULL, -1, "/c:\\f\\b", NULL, NULL},
407 // If there is not a drive letter, we should treat is as UNC EXCEPT for
408 // three slashes, which we treat as a Unix style path.
409 {"file:server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
410 {"file:/server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
411 {"file://server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
412 {"file:///server/file", "file", NULL, NULL, NULL, -1, "/server/file",NULL, NULL},
413 {"file://\\server/file", "file", NULL, NULL, NULL, -1, "\\server/file",NULL, NULL},
414 {"file:////server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
415 // Queries and refs are valid for file URLs as well.
416 {"file:///C:/foo.html?#", "file", NULL, NULL, NULL, -1, "/C:/foo.html", "", ""},
417 {"file:///C:/foo.html?query=yes#ref", "file", NULL, NULL, NULL, -1, "/C:/foo.html", "query=yes", "ref"},
418 };
419
TEST(URLParser,WindowsFile)420 TEST(URLParser, WindowsFile) {
421 // Declared outside for loop to try to catch cases in init() where we forget
422 // to reset something that is reset by the construtor.
423 url_parse::Parsed parsed;
424 for (int i = 0; i < arraysize(file_cases); i++) {
425 const char* url = file_cases[i].input;
426 url_parse::ParseFileURL(url, static_cast<int>(strlen(url)), &parsed);
427 int port = url_parse::ParsePort(url, parsed.port);
428
429 EXPECT_TRUE(ComponentMatches(url, file_cases[i].scheme, parsed.scheme));
430 EXPECT_TRUE(ComponentMatches(url, file_cases[i].username, parsed.username));
431 EXPECT_TRUE(ComponentMatches(url, file_cases[i].password, parsed.password));
432 EXPECT_TRUE(ComponentMatches(url, file_cases[i].host, parsed.host));
433 EXPECT_EQ(file_cases[i].port, port);
434 EXPECT_TRUE(ComponentMatches(url, file_cases[i].path, parsed.path));
435 EXPECT_TRUE(ComponentMatches(url, file_cases[i].query, parsed.query));
436 EXPECT_TRUE(ComponentMatches(url, file_cases[i].ref, parsed.ref));
437 }
438 }
439
440 #endif // WIN32
441
TEST(URLParser,ExtractFileName)442 TEST(URLParser, ExtractFileName) {
443 struct FileCase {
444 const char* input;
445 const char* expected;
446 } file_cases[] = {
447 {"http://www.google.com", NULL},
448 {"http://www.google.com/", ""},
449 {"http://www.google.com/search", "search"},
450 {"http://www.google.com/search/", ""},
451 {"http://www.google.com/foo/bar.html?baz=22", "bar.html"},
452 {"http://www.google.com/foo/bar.html#ref", "bar.html"},
453 {"http://www.google.com/search/;param", ""},
454 {"http://www.google.com/foo/bar.html;param#ref", "bar.html"},
455 {"http://www.google.com/foo/bar.html;foo;param#ref", "bar.html;foo"},
456 {"http://www.google.com/foo/bar.html?query#ref", "bar.html"},
457 };
458
459 for (size_t i = 0; i < ARRAYSIZE(file_cases); i++) {
460 const char* url = file_cases[i].input;
461 int len = static_cast<int>(strlen(url));
462
463 url_parse::Parsed parsed;
464 url_parse::ParseStandardURL(url, len, &parsed);
465
466 url_parse::Component file_name;
467 url_parse::ExtractFileName(url, parsed.path, &file_name);
468
469 EXPECT_TRUE(ComponentMatches(url, file_cases[i].expected, file_name));
470 }
471 }
472
473 // Returns true if the parameter with index |parameter| in the given URL's
474 // query string. The expected key can be NULL to indicate no such key index
475 // should exist. The parameter number is 1-based.
NthParameterIs(const char * url,int parameter,const char * expected_key,const char * expected_value)476 static bool NthParameterIs(const char* url,
477 int parameter,
478 const char* expected_key,
479 const char* expected_value) {
480 url_parse::Parsed parsed;
481 url_parse::ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
482
483 url_parse::Component query = parsed.query;
484
485 for (int i = 1; i <= parameter; i++) {
486 url_parse::Component key, value;
487 if (!url_parse::ExtractQueryKeyValue(url, &query, &key, &value)) {
488 if (parameter >= i && !expected_key)
489 return true; // Expected nonexistant key, got one.
490 return false; // Not enough keys.
491 }
492
493 if (i == parameter) {
494 if (!expected_key)
495 return false;
496
497 if (strncmp(&url[key.begin], expected_key, key.len) != 0)
498 return false;
499 if (strncmp(&url[value.begin], expected_value, value.len) != 0)
500 return false;
501 return true;
502 }
503 }
504 return expected_key == NULL; // We didn't find that many parameters.
505 }
506
TEST(URLParser,ExtractQueryKeyValue)507 TEST(URLParser, ExtractQueryKeyValue) {
508 EXPECT_TRUE(NthParameterIs("http://www.google.com", 1, NULL, NULL));
509
510 // Basic case.
511 char a[] = "http://www.google.com?arg1=1&arg2=2&bar";
512 EXPECT_TRUE(NthParameterIs(a, 1, "arg1", "1"));
513 EXPECT_TRUE(NthParameterIs(a, 2, "arg2", "2"));
514 EXPECT_TRUE(NthParameterIs(a, 3, "bar", ""));
515 EXPECT_TRUE(NthParameterIs(a, 4, NULL, NULL));
516
517 // Empty param at the end.
518 char b[] = "http://www.google.com?foo=bar&";
519 EXPECT_TRUE(NthParameterIs(b, 1, "foo", "bar"));
520 EXPECT_TRUE(NthParameterIs(b, 2, NULL, NULL));
521
522 // Empty param at the beginning.
523 char c[] = "http://www.google.com?&foo=bar";
524 EXPECT_TRUE(NthParameterIs(c, 1, "", ""));
525 EXPECT_TRUE(NthParameterIs(c, 2, "foo", "bar"));
526 EXPECT_TRUE(NthParameterIs(c, 3, NULL, NULL));
527
528 // Empty key with value.
529 char d[] = "http://www.google.com?=foo";
530 EXPECT_TRUE(NthParameterIs(d, 1, "", "foo"));
531 EXPECT_TRUE(NthParameterIs(d, 2, NULL, NULL));
532
533 // Empty value with key.
534 char e[] = "http://www.google.com?foo=";
535 EXPECT_TRUE(NthParameterIs(e, 1, "foo", ""));
536 EXPECT_TRUE(NthParameterIs(e, 2, NULL, NULL));
537
538 // Empty key and values.
539 char f[] = "http://www.google.com?&&==&=";
540 EXPECT_TRUE(NthParameterIs(f, 1, "", ""));
541 EXPECT_TRUE(NthParameterIs(f, 2, "", ""));
542 EXPECT_TRUE(NthParameterIs(f, 3, "", "="));
543 EXPECT_TRUE(NthParameterIs(f, 4, "", ""));
544 EXPECT_TRUE(NthParameterIs(f, 5, NULL, NULL));
545 }
546
547 // MailtoURL --------------------------------------------------------------------
548
549 static MailtoURLParseCase mailto_cases[] = {
550 //|input |scheme |path |query
551 {"mailto:foo@gmail.com", "mailto", "foo@gmail.com", NULL},
552 {" mailto: to \t", "mailto", " to", NULL},
553 {"mailto:addr1%2C%20addr2 ", "mailto", "addr1%2C%20addr2", NULL},
554 {"Mailto:addr1, addr2 ", "Mailto", "addr1, addr2", NULL},
555 {"mailto:addr1:addr2 ", "mailto", "addr1:addr2", NULL},
556 {"mailto:?to=addr1,addr2", "mailto", NULL, "to=addr1,addr2"},
557 {"mailto:?to=addr1%2C%20addr2", "mailto", NULL, "to=addr1%2C%20addr2"},
558 {"mailto:addr1?to=addr2", "mailto", "addr1", "to=addr2"},
559 {"mailto:?body=#foobar#", "mailto", NULL, "body=#foobar#",},
560 {"mailto:#?body=#foobar#", "mailto", "#", "body=#foobar#"},
561 };
562
TEST(URLParser,MailtoUrl)563 TEST(URLParser, MailtoUrl) {
564 // Declared outside for loop to try to catch cases in init() where we forget
565 // to reset something that is reset by the construtor.
566 url_parse::Parsed parsed;
567 for (size_t i = 0; i < arraysize(mailto_cases); ++i) {
568 const char* url = mailto_cases[i].input;
569 url_parse::ParseMailtoURL(url, static_cast<int>(strlen(url)), &parsed);
570 int port = url_parse::ParsePort(url, parsed.port);
571
572 EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].scheme, parsed.scheme));
573 EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].path, parsed.path));
574 EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].query, parsed.query));
575 EXPECT_EQ(url_parse::PORT_UNSPECIFIED, port);
576
577 // The remaining components are never used for mailto urls.
578 ExpectInvalidComponent(parsed.username);
579 ExpectInvalidComponent(parsed.password);
580 ExpectInvalidComponent(parsed.port);
581 ExpectInvalidComponent(parsed.ref);
582 }
583 }
584