Upstream version 5.34.92.0
[platform/framework/web/crosswalk.git] / src / url / gurl_unittest.cc
1 // Copyright 2013 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 "testing/gtest/include/gtest/gtest.h"
6 #include "url/gurl.h"
7 #include "url/url_canon.h"
8 #include "url/url_test_utils.h"
9
10 // Some implementations of base/basictypes.h may define ARRAYSIZE.
11 // If it's not defined, we define it to the ARRAYSIZE_UNSAFE macro
12 // which is in our version of basictypes.h.
13 #ifndef ARRAYSIZE
14 #define ARRAYSIZE ARRAYSIZE_UNSAFE
15 #endif
16
17 using url_test_utils::WStringToUTF16;
18 using url_test_utils::ConvertUTF8ToUTF16;
19
20 namespace {
21
22 template<typename CHAR>
23 void SetupReplacement(void (url_canon::Replacements<CHAR>::*func)(const CHAR*,
24                           const url_parse::Component&),
25                       url_canon::Replacements<CHAR>* replacements,
26                       const CHAR* str) {
27   if (str) {
28     url_parse::Component comp;
29     if (str[0])
30       comp.len = static_cast<int>(strlen(str));
31     (replacements->*func)(str, comp);
32   }
33 }
34
35 // Returns the canonicalized string for the given URL string for the
36 // GURLTest.Types test.
37 std::string TypesTestCase(const char* src) {
38   GURL gurl(src);
39   return gurl.possibly_invalid_spec();
40 }
41
42 }  // namespace
43
44 // Different types of URLs should be handled differently by url_util, and
45 // handed off to different canonicalizers.
46 TEST(GURLTest, Types) {
47   // URLs with unknown schemes should be treated as path URLs, even when they
48   // have things like "://".
49   EXPECT_EQ("something:///HOSTNAME.com/",
50             TypesTestCase("something:///HOSTNAME.com/"));
51
52   // In the reverse, known schemes should always trigger standard URL handling.
53   EXPECT_EQ("http://hostname.com/", TypesTestCase("http:HOSTNAME.com"));
54   EXPECT_EQ("http://hostname.com/", TypesTestCase("http:/HOSTNAME.com"));
55   EXPECT_EQ("http://hostname.com/", TypesTestCase("http://HOSTNAME.com"));
56   EXPECT_EQ("http://hostname.com/", TypesTestCase("http:///HOSTNAME.com"));
57
58 #ifdef WIN32
59   // URLs that look like absolute Windows drive specs.
60   EXPECT_EQ("file:///C:/foo.txt", TypesTestCase("c:\\foo.txt"));
61   EXPECT_EQ("file:///Z:/foo.txt", TypesTestCase("Z|foo.txt"));
62   EXPECT_EQ("file://server/foo.txt", TypesTestCase("\\\\server\\foo.txt"));
63   EXPECT_EQ("file://server/foo.txt", TypesTestCase("//server/foo.txt"));
64 #endif
65 }
66
67 // Test the basic creation and querying of components in a GURL. We assume
68 // the parser is already tested and works, so we are mostly interested if the
69 // object does the right thing with the results.
70 TEST(GURLTest, Components) {
71   GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
72   EXPECT_TRUE(url.is_valid());
73   EXPECT_TRUE(url.SchemeIs("http"));
74   EXPECT_FALSE(url.SchemeIsFile());
75
76   // This is the narrow version of the URL, which should match the wide input.
77   EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url.spec());
78
79   EXPECT_EQ("http", url.scheme());
80   EXPECT_EQ("user", url.username());
81   EXPECT_EQ("pass", url.password());
82   EXPECT_EQ("google.com", url.host());
83   EXPECT_EQ("99", url.port());
84   EXPECT_EQ(99, url.IntPort());
85   EXPECT_EQ("/foo;bar", url.path());
86   EXPECT_EQ("q=a", url.query());
87   EXPECT_EQ("ref", url.ref());
88 }
89
90 TEST(GURLTest, Empty) {
91   GURL url;
92   EXPECT_FALSE(url.is_valid());
93   EXPECT_EQ("", url.spec());
94
95   EXPECT_EQ("", url.scheme());
96   EXPECT_EQ("", url.username());
97   EXPECT_EQ("", url.password());
98   EXPECT_EQ("", url.host());
99   EXPECT_EQ("", url.port());
100   EXPECT_EQ(url_parse::PORT_UNSPECIFIED, url.IntPort());
101   EXPECT_EQ("", url.path());
102   EXPECT_EQ("", url.query());
103   EXPECT_EQ("", url.ref());
104 }
105
106 TEST(GURLTest, Copy) {
107   GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
108
109   GURL url2(url);
110   EXPECT_TRUE(url2.is_valid());
111
112   EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
113   EXPECT_EQ("http", url2.scheme());
114   EXPECT_EQ("user", url2.username());
115   EXPECT_EQ("pass", url2.password());
116   EXPECT_EQ("google.com", url2.host());
117   EXPECT_EQ("99", url2.port());
118   EXPECT_EQ(99, url2.IntPort());
119   EXPECT_EQ("/foo;bar", url2.path());
120   EXPECT_EQ("q=a", url2.query());
121   EXPECT_EQ("ref", url2.ref());
122
123   // Copying of invalid URL should be invalid
124   GURL invalid;
125   GURL invalid2(invalid);
126   EXPECT_FALSE(invalid2.is_valid());
127   EXPECT_EQ("", invalid2.spec());
128   EXPECT_EQ("", invalid2.scheme());
129   EXPECT_EQ("", invalid2.username());
130   EXPECT_EQ("", invalid2.password());
131   EXPECT_EQ("", invalid2.host());
132   EXPECT_EQ("", invalid2.port());
133   EXPECT_EQ(url_parse::PORT_UNSPECIFIED, invalid2.IntPort());
134   EXPECT_EQ("", invalid2.path());
135   EXPECT_EQ("", invalid2.query());
136   EXPECT_EQ("", invalid2.ref());
137 }
138
139 TEST(GURLTest, Assign) {
140   GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
141
142   GURL url2;
143   url2 = url;
144   EXPECT_TRUE(url2.is_valid());
145
146   EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
147   EXPECT_EQ("http", url2.scheme());
148   EXPECT_EQ("user", url2.username());
149   EXPECT_EQ("pass", url2.password());
150   EXPECT_EQ("google.com", url2.host());
151   EXPECT_EQ("99", url2.port());
152   EXPECT_EQ(99, url2.IntPort());
153   EXPECT_EQ("/foo;bar", url2.path());
154   EXPECT_EQ("q=a", url2.query());
155   EXPECT_EQ("ref", url2.ref());
156
157   // Assignment of invalid URL should be invalid
158   GURL invalid;
159   GURL invalid2;
160   invalid2 = invalid;
161   EXPECT_FALSE(invalid2.is_valid());
162   EXPECT_EQ("", invalid2.spec());
163   EXPECT_EQ("", invalid2.scheme());
164   EXPECT_EQ("", invalid2.username());
165   EXPECT_EQ("", invalid2.password());
166   EXPECT_EQ("", invalid2.host());
167   EXPECT_EQ("", invalid2.port());
168   EXPECT_EQ(url_parse::PORT_UNSPECIFIED, invalid2.IntPort());
169   EXPECT_EQ("", invalid2.path());
170   EXPECT_EQ("", invalid2.query());
171   EXPECT_EQ("", invalid2.ref());
172 }
173
174 // This is a regression test for http://crbug.com/309975 .
175 TEST(GURLTest, SelfAssign) {
176   GURL a("filesystem:http://example.com/temporary/");
177   // This should not crash.
178   a = a;
179 }
180
181 TEST(GURLTest, CopyFileSystem) {
182   GURL url(WStringToUTF16(L"filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref"));
183
184   GURL url2(url);
185   EXPECT_TRUE(url2.is_valid());
186
187   EXPECT_EQ("filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref", url2.spec());
188   EXPECT_EQ("filesystem", url2.scheme());
189   EXPECT_EQ("", url2.username());
190   EXPECT_EQ("", url2.password());
191   EXPECT_EQ("", url2.host());
192   EXPECT_EQ("", url2.port());
193   EXPECT_EQ(url_parse::PORT_UNSPECIFIED, url2.IntPort());
194   EXPECT_EQ("/foo;bar", url2.path());
195   EXPECT_EQ("q=a", url2.query());
196   EXPECT_EQ("ref", url2.ref());
197
198   const GURL* inner = url2.inner_url();
199   ASSERT_TRUE(inner);
200   EXPECT_EQ("https", inner->scheme());
201   EXPECT_EQ("user", inner->username());
202   EXPECT_EQ("pass", inner->password());
203   EXPECT_EQ("google.com", inner->host());
204   EXPECT_EQ("99", inner->port());
205   EXPECT_EQ(99, inner->IntPort());
206   EXPECT_EQ("/t", inner->path());
207   EXPECT_EQ("", inner->query());
208   EXPECT_EQ("", inner->ref());
209 }
210
211 // Given an invalid URL, we should still get most of the components.
212 TEST(GURLTest, Invalid) {
213   GURL url("http:google.com:foo");
214   EXPECT_FALSE(url.is_valid());
215   EXPECT_EQ("http://google.com:foo/", url.possibly_invalid_spec());
216
217   EXPECT_EQ("http", url.scheme());
218   EXPECT_EQ("", url.username());
219   EXPECT_EQ("", url.password());
220   EXPECT_EQ("google.com", url.host());
221   EXPECT_EQ("foo", url.port());
222   EXPECT_EQ(url_parse::PORT_INVALID, url.IntPort());
223   EXPECT_EQ("/", url.path());
224   EXPECT_EQ("", url.query());
225   EXPECT_EQ("", url.ref());
226 }
227
228 TEST(GURLTest, Resolve) {
229   // The tricky cases for relative URL resolving are tested in the
230   // canonicalizer unit test. Here, we just test that the GURL integration
231   // works properly.
232   struct ResolveCase {
233     const char* base;
234     const char* relative;
235     bool expected_valid;
236     const char* expected;
237   } resolve_cases[] = {
238     {"http://www.google.com/", "foo.html", true, "http://www.google.com/foo.html"},
239     {"http://www.google.com/", "http://images.google.com/foo.html", true, "http://images.google.com/foo.html"},
240     {"http://www.google.com/blah/bloo?c#d", "../../../hello/./world.html?a#b", true, "http://www.google.com/hello/world.html?a#b"},
241     {"http://www.google.com/foo#bar", "#com", true, "http://www.google.com/foo#com"},
242     {"http://www.google.com/", "Https:images.google.com", true, "https://images.google.com/"},
243       // A non-standard base can be replaced with a standard absolute URL.
244     {"data:blahblah", "http://google.com/", true, "http://google.com/"},
245     {"data:blahblah", "http:google.com", true, "http://google.com/"},
246       // Filesystem URLs have different paths to test.
247     {"filesystem:http://www.google.com/type/", "foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
248     {"filesystem:http://www.google.com/type/", "../foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
249   };
250
251   for (size_t i = 0; i < ARRAYSIZE(resolve_cases); i++) {
252     // 8-bit code path.
253     GURL input(resolve_cases[i].base);
254     GURL output = input.Resolve(resolve_cases[i].relative);
255     EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid()) << i;
256     EXPECT_EQ(resolve_cases[i].expected, output.spec()) << i;
257     EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
258
259     // Wide code path.
260     GURL inputw(ConvertUTF8ToUTF16(resolve_cases[i].base));
261     GURL outputw =
262         input.Resolve(ConvertUTF8ToUTF16(resolve_cases[i].relative));
263     EXPECT_EQ(resolve_cases[i].expected_valid, outputw.is_valid()) << i;
264     EXPECT_EQ(resolve_cases[i].expected, outputw.spec()) << i;
265     EXPECT_EQ(outputw.SchemeIsFileSystem(), outputw.inner_url() != NULL);
266   }
267 }
268
269 TEST(GURLTest, GetOrigin) {
270   struct TestCase {
271     const char* input;
272     const char* expected;
273   } cases[] = {
274     {"http://www.google.com", "http://www.google.com/"},
275     {"javascript:window.alert(\"hello,world\");", ""},
276     {"http://user:pass@www.google.com:21/blah#baz", "http://www.google.com:21/"},
277     {"http://user@www.google.com", "http://www.google.com/"},
278     {"http://:pass@www.google.com", "http://www.google.com/"},
279     {"http://:@www.google.com", "http://www.google.com/"},
280     {"filesystem:http://www.google.com/temp/foo?q#b", "http://www.google.com/"},
281     {"filesystem:http://user:pass@google.com:21/blah#baz", "http://google.com:21/"},
282   };
283   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
284     GURL url(cases[i].input);
285     GURL origin = url.GetOrigin();
286     EXPECT_EQ(cases[i].expected, origin.spec());
287   }
288 }
289
290 TEST(GURLTest, GetWithEmptyPath) {
291   struct TestCase {
292     const char* input;
293     const char* expected;
294   } cases[] = {
295     {"http://www.google.com", "http://www.google.com/"},
296     {"javascript:window.alert(\"hello, world\");", ""},
297     {"http://www.google.com/foo/bar.html?baz=22", "http://www.google.com/"},
298     {"filesystem:http://www.google.com/temporary/bar.html?baz=22", "filesystem:http://www.google.com/temporary/"},
299     {"filesystem:file:///temporary/bar.html?baz=22", "filesystem:file:///temporary/"},
300   };
301
302   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
303     GURL url(cases[i].input);
304     GURL empty_path = url.GetWithEmptyPath();
305     EXPECT_EQ(cases[i].expected, empty_path.spec());
306   }
307 }
308
309 TEST(GURLTest, Replacements) {
310   // The url canonicalizer replacement test will handle most of these case.
311   // The most important thing to do here is to check that the proper
312   // canonicalizer gets called based on the scheme of the input.
313   struct ReplaceCase {
314     const char* base;
315     const char* scheme;
316     const char* username;
317     const char* password;
318     const char* host;
319     const char* port;
320     const char* path;
321     const char* query;
322     const char* ref;
323     const char* expected;
324   } replace_cases[] = {
325     {"http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "http://www.google.com/"},
326     {"http://www.google.com/foo/bar.html?foo#bar", "javascript", "", "", "", "", "window.open('foo');", "", "", "javascript:window.open('foo');"},
327     {"file:///C:/foo/bar.txt", "http", NULL, NULL, "www.google.com", "99", "/foo","search", "ref", "http://www.google.com:99/foo?search#ref"},
328 #ifdef WIN32
329     {"http://www.google.com/foo/bar.html?foo#bar", "file", "", "", "", "", "c:\\", "", "", "file:///C:/"},
330 #endif
331     {"filesystem:http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "filesystem:http://www.google.com/foo/"},
332   };
333
334   for (size_t i = 0; i < ARRAYSIZE(replace_cases); i++) {
335     const ReplaceCase& cur = replace_cases[i];
336     GURL url(cur.base);
337     GURL::Replacements repl;
338     SetupReplacement(&GURL::Replacements::SetScheme, &repl, cur.scheme);
339     SetupReplacement(&GURL::Replacements::SetUsername, &repl, cur.username);
340     SetupReplacement(&GURL::Replacements::SetPassword, &repl, cur.password);
341     SetupReplacement(&GURL::Replacements::SetHost, &repl, cur.host);
342     SetupReplacement(&GURL::Replacements::SetPort, &repl, cur.port);
343     SetupReplacement(&GURL::Replacements::SetPath, &repl, cur.path);
344     SetupReplacement(&GURL::Replacements::SetQuery, &repl, cur.query);
345     SetupReplacement(&GURL::Replacements::SetRef, &repl, cur.ref);
346     GURL output = url.ReplaceComponents(repl);
347
348     EXPECT_EQ(replace_cases[i].expected, output.spec());
349     EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
350   }
351 }
352
353 TEST(GURLTest, ClearFragmentOnDataUrl) {
354   // http://crbug.com/291747 - a data URL may legitimately have trailing
355   // whitespace in the spec after the ref is cleared. Test this does not trigger
356   // the url_parse::Parsed importing validation DCHECK in GURL.
357   GURL url(" data: one ? two # three ");
358
359   // By default the trailing whitespace will have been stripped.
360   EXPECT_EQ("data: one ? two # three", url.spec());
361   GURL::Replacements repl;
362   repl.ClearRef();
363   GURL url_no_ref = url.ReplaceComponents(repl);
364
365   EXPECT_EQ("data: one ? two ", url_no_ref.spec());
366
367   // Importing a parsed url via this constructor overload will retain trailing
368   // whitespace.
369   GURL import_url(url_no_ref.spec(),
370                   url_no_ref.parsed_for_possibly_invalid_spec(),
371                   url_no_ref.is_valid());
372   EXPECT_EQ(url_no_ref, import_url);
373   EXPECT_EQ(import_url.query(), " two ");
374 }
375
376 TEST(GURLTest, PathForRequest) {
377   struct TestCase {
378     const char* input;
379     const char* expected;
380     const char* inner_expected;
381   } cases[] = {
382     {"http://www.google.com", "/", NULL},
383     {"http://www.google.com/", "/", NULL},
384     {"http://www.google.com/foo/bar.html?baz=22", "/foo/bar.html?baz=22", NULL},
385     {"http://www.google.com/foo/bar.html#ref", "/foo/bar.html", NULL},
386     {"http://www.google.com/foo/bar.html?query#ref", "/foo/bar.html?query", NULL},
387     {"filesystem:http://www.google.com/temporary/foo/bar.html?query#ref", "/foo/bar.html?query", "/temporary"},
388     {"filesystem:http://www.google.com/temporary/foo/bar.html?query", "/foo/bar.html?query", "/temporary"},
389   };
390
391   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
392     GURL url(cases[i].input);
393     std::string path_request = url.PathForRequest();
394     EXPECT_EQ(cases[i].expected, path_request);
395     EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL);
396     if (url.inner_url() && cases[i].inner_expected)
397       EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest());
398   }
399 }
400
401 TEST(GURLTest, EffectiveIntPort) {
402   struct PortTest {
403     const char* spec;
404     int expected_int_port;
405   } port_tests[] = {
406     // http
407     {"http://www.google.com/", 80},
408     {"http://www.google.com:80/", 80},
409     {"http://www.google.com:443/", 443},
410
411     // https
412     {"https://www.google.com/", 443},
413     {"https://www.google.com:443/", 443},
414     {"https://www.google.com:80/", 80},
415
416     // ftp
417     {"ftp://www.google.com/", 21},
418     {"ftp://www.google.com:21/", 21},
419     {"ftp://www.google.com:80/", 80},
420
421     // gopher
422     {"gopher://www.google.com/", 70},
423     {"gopher://www.google.com:70/", 70},
424     {"gopher://www.google.com:80/", 80},
425
426     // file - no port
427     {"file://www.google.com/", url_parse::PORT_UNSPECIFIED},
428     {"file://www.google.com:443/", url_parse::PORT_UNSPECIFIED},
429
430     // data - no port
431     {"data:www.google.com:90", url_parse::PORT_UNSPECIFIED},
432     {"data:www.google.com", url_parse::PORT_UNSPECIFIED},
433
434     // filesystem - no port
435     {"filesystem:http://www.google.com:90/t/foo", url_parse::PORT_UNSPECIFIED},
436     {"filesystem:file:///t/foo", url_parse::PORT_UNSPECIFIED},
437   };
438
439   for (size_t i = 0; i < ARRAYSIZE(port_tests); i++) {
440     GURL url(port_tests[i].spec);
441     EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort());
442   }
443 }
444
445 TEST(GURLTest, IPAddress) {
446   struct IPTest {
447     const char* spec;
448     bool expected_ip;
449   } ip_tests[] = {
450     {"http://www.google.com/", false},
451     {"http://192.168.9.1/", true},
452     {"http://192.168.9.1.2/", false},
453     {"http://192.168.m.1/", false},
454     {"http://2001:db8::1/", false},
455     {"http://[2001:db8::1]/", true},
456     {"", false},
457     {"some random input!", false},
458   };
459
460   for (size_t i = 0; i < ARRAYSIZE(ip_tests); i++) {
461     GURL url(ip_tests[i].spec);
462     EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
463   }
464 }
465
466 TEST(GURLTest, HostNoBrackets) {
467   struct TestCase {
468     const char* input;
469     const char* expected_host;
470     const char* expected_plainhost;
471   } cases[] = {
472     {"http://www.google.com", "www.google.com", "www.google.com"},
473     {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"},
474     {"http://[::]/", "[::]", "::"},
475
476     // Don't require a valid URL, but don't crash either.
477     {"http://[]/", "[]", ""},
478     {"http://[x]/", "[x]", "x"},
479     {"http://[x/", "[x", "[x"},
480     {"http://x]/", "x]", "x]"},
481     {"http://[/", "[", "["},
482     {"http://]/", "]", "]"},
483     {"", "", ""},
484   };
485   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
486     GURL url(cases[i].input);
487     EXPECT_EQ(cases[i].expected_host, url.host());
488     EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
489   }
490 }
491
492 TEST(GURLTest, DomainIs) {
493   const char google_domain[] = "google.com";
494
495   GURL url_1("http://www.google.com:99/foo");
496   EXPECT_TRUE(url_1.DomainIs(google_domain));
497
498   GURL url_2("http://google.com:99/foo");
499   EXPECT_TRUE(url_2.DomainIs(google_domain));
500
501   GURL url_3("http://google.com./foo");
502   EXPECT_TRUE(url_3.DomainIs(google_domain));
503
504   GURL url_4("http://google.com/foo");
505   EXPECT_FALSE(url_4.DomainIs("google.com."));
506
507   GURL url_5("http://google.com./foo");
508   EXPECT_TRUE(url_5.DomainIs("google.com."));
509
510   GURL url_6("http://www.google.com./foo");
511   EXPECT_TRUE(url_6.DomainIs(".com."));
512
513   GURL url_7("http://www.balabala.com/foo");
514   EXPECT_FALSE(url_7.DomainIs(google_domain));
515
516   GURL url_8("http://www.google.com.cn/foo");
517   EXPECT_FALSE(url_8.DomainIs(google_domain));
518
519   GURL url_9("http://www.iamnotgoogle.com/foo");
520   EXPECT_FALSE(url_9.DomainIs(google_domain));
521
522   GURL url_10("http://www.iamnotgoogle.com../foo");
523   EXPECT_FALSE(url_10.DomainIs(".com"));
524
525   GURL url_11("filesystem:http://www.google.com:99/foo/");
526   EXPECT_TRUE(url_11.DomainIs(google_domain));
527
528   GURL url_12("filesystem:http://www.iamnotgoogle.com/foo/");
529   EXPECT_FALSE(url_12.DomainIs(google_domain));
530 }
531
532 // Newlines should be stripped from inputs.
533 TEST(GURLTest, Newlines) {
534   // Constructor.
535   GURL url_1(" \t ht\ntp://\twww.goo\rgle.com/as\ndf \n ");
536   EXPECT_EQ("http://www.google.com/asdf", url_1.spec());
537
538   // Relative path resolver.
539   GURL url_2 = url_1.Resolve(" \n /fo\to\r ");
540   EXPECT_EQ("http://www.google.com/foo", url_2.spec());
541
542   // Note that newlines are NOT stripped from ReplaceComponents.
543 }
544
545 TEST(GURLTest, IsStandard) {
546   GURL a("http:foo/bar");
547   EXPECT_TRUE(a.IsStandard());
548
549   GURL b("foo:bar/baz");
550   EXPECT_FALSE(b.IsStandard());
551
552   GURL c("foo://bar/baz");
553   EXPECT_FALSE(c.IsStandard());
554 }
555
556 TEST(GURLTest, SchemeIsHTTPOrHTTPS) {
557   EXPECT_TRUE(GURL("http://bar/").SchemeIsHTTPOrHTTPS());
558   EXPECT_TRUE(GURL("HTTPS://BAR").SchemeIsHTTPOrHTTPS());
559   EXPECT_FALSE(GURL("ftp://bar/").SchemeIsHTTPOrHTTPS());
560 }
561
562 TEST(GURLTest, SchemeIsWSOrWSS) {
563   EXPECT_TRUE(GURL("WS://BAR/").SchemeIsWSOrWSS());
564   EXPECT_TRUE(GURL("wss://bar/").SchemeIsWSOrWSS());
565   EXPECT_FALSE(GURL("http://bar/").SchemeIsWSOrWSS());
566 }