1 /* 2 * Copyright (C) 2010 Google Inc. 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 31 // Basic tests that verify our KURL's interface behaves the same as the 32 // original KURL's. 33 34 #include "config.h" 35 36 #include <gtest/gtest.h> 37 38 #include "KURL.h" 39 40 namespace WTF { 41 // Output stream operator so gTest's macros work with WebCore strings. 42 std::ostream& operator<<(std::ostream& out, const String& str) 43 { 44 return str.isEmpty() ? out : out << str.utf8().data(); 45 } 46 } // namespace WTF 47 48 namespace { 49 50 51 struct ComponentCase { 52 const char* url; 53 const char* protocol; 54 const char* host; 55 const int port; 56 const char* user; 57 const char* pass; 58 const char* path; 59 const char* lastPath; 60 const char* query; 61 const char* ref; 62 }; 63 64 // Test the cases where we should be the same as WebKit's old KURL. 65 TEST(KURLTest, SameGetters) 66 { 67 struct GetterCase { 68 const char* url; 69 const char* protocol; 70 const char* host; 71 int port; 72 const char* user; 73 const char* pass; 74 const char* lastPathComponent; 75 const char* query; 76 const char* ref; 77 bool hasRef; 78 } cases[] = { 79 {"http://www.google.com/foo/blah?bar=baz#ref", "http", "www.google.com", 0, "", 0, "blah", "bar=baz", "ref", true}, 80 {"http://foo.com:1234/foo/bar/", "http", "foo.com", 1234, "", 0, "bar", 0, 0, false}, 81 {"http://www.google.com?#", "http", "www.google.com", 0, "", 0, 0, "", "", true}, 82 {"https://me:pass@google.com:23#foo", "https", "google.com", 23, "me", "pass", 0, 0, "foo", true}, 83 {"javascript:hello!//world", "javascript", "", 0, "", 0, "world", 0, 0, false}, 84 }; 85 86 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) { 87 // UTF-8 88 WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); 89 90 EXPECT_EQ(cases[i].protocol, kurl.protocol()); 91 EXPECT_EQ(cases[i].host, kurl.host()); 92 EXPECT_EQ(cases[i].port, kurl.port()); 93 EXPECT_EQ(cases[i].user, kurl.user()); 94 EXPECT_EQ(cases[i].pass, kurl.pass()); 95 EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent()); 96 EXPECT_EQ(cases[i].query, kurl.query()); 97 EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier()); 98 EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); 99 100 // UTF-16 101 WTF::String utf16(cases[i].url); 102 kurl = WebCore::KURL(WebCore::ParsedURLString, utf16); 103 104 EXPECT_EQ(cases[i].protocol, kurl.protocol()); 105 EXPECT_EQ(cases[i].host, kurl.host()); 106 EXPECT_EQ(cases[i].port, kurl.port()); 107 EXPECT_EQ(cases[i].user, kurl.user()); 108 EXPECT_EQ(cases[i].pass, kurl.pass()); 109 EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent()); 110 EXPECT_EQ(cases[i].query, kurl.query()); 111 EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier()); 112 EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); 113 } 114 } 115 116 // Test a few cases where we're different just to make sure we give reasonable 117 // output. 118 TEST(KURLTest, DifferentGetters) 119 { 120 ComponentCase cases[] = { 121 // url protocol host port user pass path lastPath query ref 122 123 // Old WebKit allows references and queries in what we call "path" URLs 124 // like javascript, so the path here will only consist of "hello!". 125 {"javascript:hello!?#/\\world", "javascript", "", 0, "", 0, "hello!?#/\\world", "world", 0, 0}, 126 127 // Old WebKit doesn't handle "parameters" in paths, so will 128 // disagree with us about where the path is for this URL. 129 {"http://a.com/hello;world", "http", "a.com", 0, "", 0, "/hello;world", "hello", 0, 0}, 130 131 // WebKit doesn't like UTF-8 or UTF-16 input. 132 {"http://\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd/", "http", "xn--6qqa088eba", 0, "", 0, "/", 0, 0, 0}, 133 134 // WebKit %-escapes non-ASCII characters in reference, but we don't. 135 {"http://www.google.com/foo/blah?bar=baz#\xce\xb1\xce\xb2", "http", "www.google.com", 0, "", 0, "/foo/blah/", "blah", "bar=baz", "\xce\xb1\xce\xb2"}, 136 }; 137 138 for (size_t i = 0; i < arraysize(cases); i++) { 139 WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); 140 141 EXPECT_EQ(cases[i].protocol, kurl.protocol()); 142 EXPECT_EQ(cases[i].host, kurl.host()); 143 EXPECT_EQ(cases[i].port, kurl.port()); 144 EXPECT_EQ(cases[i].user, kurl.user()); 145 EXPECT_EQ(cases[i].pass, kurl.pass()); 146 EXPECT_EQ(cases[i].lastPath, kurl.lastPathComponent()); 147 EXPECT_EQ(cases[i].query, kurl.query()); 148 // Want to compare UCS-16 refs (or to null). 149 if (cases[i].ref) 150 EXPECT_EQ(WTF::String::fromUTF8(cases[i].ref), kurl.fragmentIdentifier()); 151 else 152 EXPECT_TRUE(kurl.fragmentIdentifier().isNull()); 153 } 154 } 155 156 // Ensures that both ASCII and UTF-8 canonical URLs are handled properly and we 157 // get the correct string object out. 158 TEST(KURLTest, UTF8) 159 { 160 const char asciiURL[] = "http://foo/bar#baz"; 161 WebCore::KURL asciiKURL(WebCore::ParsedURLString, asciiURL); 162 EXPECT_TRUE(asciiKURL.string() == WTF::String(asciiURL)); 163 164 // When the result is ASCII, we should get an ASCII String. Some 165 // code depends on being able to compare the result of the .string() 166 // getter with another String, and the isASCIIness of the two 167 // strings must match for these functions (like equalIgnoringCase). 168 EXPECT_TRUE(WTF::equalIgnoringCase(asciiKURL, WTF::String(asciiURL))); 169 170 // Reproduce code path in FrameLoader.cpp -- equalIgnoringCase implicitly 171 // expects gkurl.protocol() to have been created as ascii. 172 WebCore::KURL mailto(WebCore::ParsedURLString, "mailto:foo (at) foo.com"); 173 EXPECT_TRUE(WTF::equalIgnoringCase(mailto.protocol(), "mailto")); 174 175 const char utf8URL[] = "http://foo/bar#\xe4\xbd\xa0\xe5\xa5\xbd"; 176 WebCore::KURL utf8KURL(WebCore::ParsedURLString, utf8URL); 177 178 EXPECT_TRUE(utf8KURL.string() == WTF::String::fromUTF8(utf8URL)); 179 } 180 181 TEST(KURLTest, Setters) 182 { 183 // Replace the starting URL with the given components one at a time and 184 // verify that we're always the same as the old KURL. 185 // 186 // Note that old KURL won't canonicalize the default port away, so we 187 // can't set setting the http port to "80" (or even "0"). 188 // 189 // We also can't test clearing the query. 190 // 191 // The format is every other row is a test, and the row that follows it is the 192 // expected result. 193 struct ExpectedComponentCase { 194 const char* url; 195 const char* protocol; 196 const char* host; 197 const int port; 198 const char* user; 199 const char* pass; 200 const char* path; 201 const char* query; 202 const char* ref; 203 204 // The full expected URL with the given "set" applied. 205 const char* expectedProtocol; 206 const char* expectedHost; 207 const char* expectedPort; 208 const char* expectedUser; 209 const char* expectedPass; 210 const char* expectedPath; 211 const char* expectedQuery; 212 const char* expectedRef; 213 } cases[] = { 214 // url protocol host port user pass path query ref 215 {"http://www.google.com/", "https", "news.google.com", 8888, "me", "pass", "/foo", "?q=asdf", "heehee", 216 "https://www.google.com/", 217 "https://news.google.com/", 218 "https://news.google.com:8888/", 219 "https://me@news.google.com:8888/", 220 "https://me:pass@news.google.com:8888/", 221 "https://me:pass@news.google.com:8888/foo", 222 "https://me:pass@news.google.com:8888/foo?q=asdf", 223 "https://me:pass@news.google.com:8888/foo?q=asdf#heehee"}, 224 225 {"https://me:pass@google.com:88/a?f#b", "http", "goo.com", 92, "", "", "/", 0, "", 226 "http://me:pass@google.com:88/a?f#b", 227 "http://me:pass@goo.com:88/a?f#b", 228 "http://me:pass@goo.com:92/a?f#b", 229 "http://:pass@goo.com:92/a?f#b", 230 "http://goo.com:92/a?f#b", 231 "http://goo.com:92/?f#b", 232 "http://goo.com:92/#b", 233 "https://goo.com:92/"}, 234 }; 235 236 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) { 237 WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); 238 239 kurl.setProtocol(cases[i].protocol); 240 EXPECT_STREQ(cases[i].expectedProtocol, kurl.string().utf8().data()); 241 242 kurl.setHost(cases[i].host); 243 EXPECT_STREQ(cases[i].expectedHost, kurl.string().utf8().data()); 244 245 kurl.setPort(cases[i].port); 246 EXPECT_STREQ(cases[i].expectedPort, kurl.string().utf8().data()); 247 248 kurl.setUser(cases[i].user); 249 EXPECT_STREQ(cases[i].expectedUser, kurl.string().utf8().data()); 250 251 kurl.setPass(cases[i].pass); 252 EXPECT_STREQ(cases[i].expectedPass, kurl.string().utf8().data()); 253 254 kurl.setPath(cases[i].path); 255 EXPECT_STREQ(cases[i].expectedPath, kurl.string().utf8().data()); 256 257 kurl.setQuery(cases[i].query); 258 EXPECT_STREQ(cases[i].expectedQuery, kurl.string().utf8().data()); 259 260 // Refs are tested below. On the Safari 3.1 branch, we don't match their 261 // KURL since we integrated a fix from their trunk. 262 } 263 } 264 265 // Tests that KURL::decodeURLEscapeSequences works as expected 266 #if USE(GOOGLEURL) 267 TEST(KURLTest, Decode) 268 { 269 struct DecodeCase { 270 const char* input; 271 const char* output; 272 } decodeCases[] = { 273 {"hello, world", "hello, world"}, 274 {"%01%02%03%04%05%06%07%08%09%0a%0B%0C%0D%0e%0f/", "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0B\x0C\x0D\x0e\x0f/"}, 275 {"%10%11%12%13%14%15%16%17%18%19%1a%1B%1C%1D%1e%1f/", "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1B\x1C\x1D\x1e\x1f/"}, 276 {"%20%21%22%23%24%25%26%27%28%29%2a%2B%2C%2D%2e%2f/", " !\"#$%&'()*+,-.//"}, 277 {"%30%31%32%33%34%35%36%37%38%39%3a%3B%3C%3D%3e%3f/", "0123456789:;<=>?/"}, 278 {"%40%41%42%43%44%45%46%47%48%49%4a%4B%4C%4D%4e%4f/", "@ABCDEFGHIJKLMNO/"}, 279 {"%50%51%52%53%54%55%56%57%58%59%5a%5B%5C%5D%5e%5f/", "PQRSTUVWXYZ[\\]^_/"}, 280 {"%60%61%62%63%64%65%66%67%68%69%6a%6B%6C%6D%6e%6f/", "`abcdefghijklmno/"}, 281 {"%70%71%72%73%74%75%76%77%78%79%7a%7B%7C%7D%7e%7f/", "pqrstuvwxyz{|}~\x7f/"}, 282 // Test un-UTF-8-ization. 283 {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"}, 284 }; 285 286 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decodeCases); i++) { 287 WTF::String input(decodeCases[i].input); 288 WTF::String str = WebCore::decodeURLEscapeSequences(input); 289 EXPECT_STREQ(decodeCases[i].output, str.utf8().data()); 290 } 291 292 // Our decode should decode %00 293 WTF::String zero = WebCore::decodeURLEscapeSequences("%00"); 294 EXPECT_STRNE("%00", zero.utf8().data()); 295 296 // Test the error behavior for invalid UTF-8 (we differ from WebKit here). 297 WTF::String invalid = WebCore::decodeURLEscapeSequences( 298 "%e4%a0%e5%a5%bd"); 299 char16 invalidExpectedHelper[4] = { 0x00e4, 0x00a0, 0x597d, 0 }; 300 WTF::String invalidExpected( 301 reinterpret_cast<const ::UChar*>(invalidExpectedHelper), 302 3); 303 EXPECT_EQ(invalidExpected, invalid); 304 } 305 #endif 306 307 TEST(KURLTest, Encode) 308 { 309 // Also test that it gets converted to UTF-8 properly. 310 char16 wideInputHelper[3] = { 0x4f60, 0x597d, 0 }; 311 WTF::String wideInput( 312 reinterpret_cast<const ::UChar*>(wideInputHelper), 2); 313 WTF::String wideReference("\xe4\xbd\xa0\xe5\xa5\xbd", 6); 314 WTF::String wideOutput = 315 WebCore::encodeWithURLEscapeSequences(wideInput); 316 EXPECT_EQ(wideReference, wideOutput); 317 318 // Our encode only escapes NULLs for safety (see the implementation for 319 // more), so we only bother to test a few cases. 320 WTF::String input( 321 "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16); 322 WTF::String reference( 323 "%00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 18); 324 WTF::String output = WebCore::encodeWithURLEscapeSequences(input); 325 EXPECT_EQ(reference, output); 326 } 327 328 TEST(KURLTest, ResolveEmpty) 329 { 330 WebCore::KURL emptyBase; 331 332 // WebKit likes to be able to resolve absolute input agains empty base URLs, 333 // which would normally be invalid since the base URL is invalid. 334 const char abs[] = "http://www.google.com/"; 335 WebCore::KURL resolveAbs(emptyBase, abs); 336 EXPECT_TRUE(resolveAbs.isValid()); 337 EXPECT_STREQ(abs, resolveAbs.string().utf8().data()); 338 339 // Resolving a non-relative URL agains the empty one should still error. 340 const char rel[] = "foo.html"; 341 WebCore::KURL resolveErr(emptyBase, rel); 342 EXPECT_FALSE(resolveErr.isValid()); 343 } 344 345 // WebKit will make empty URLs and set components on them. kurl doesn't allow 346 // replacements on invalid URLs, but here we do. 347 TEST(KURLTest, ReplaceInvalid) 348 { 349 WebCore::KURL kurl; 350 351 EXPECT_FALSE(kurl.isValid()); 352 EXPECT_TRUE(kurl.isEmpty()); 353 EXPECT_STREQ("", kurl.string().utf8().data()); 354 355 kurl.setProtocol("http"); 356 // GKURL will say that a URL with just a scheme is invalid, KURL will not. 357 #if USE(GOOGLEURL) 358 EXPECT_FALSE(kurl.isValid()); 359 #else 360 EXPECT_TRUE(kurl.isValid()); 361 #endif 362 EXPECT_FALSE(kurl.isEmpty()); 363 // At this point, we do things slightly differently if there is only a scheme. 364 // We check the results here to make it more obvious what is going on, but it 365 // shouldn't be a big deal if these change. 366 #if USE(GOOGLEURL) 367 EXPECT_STREQ("http:", kurl.string().utf8().data()); 368 #else 369 EXPECT_STREQ("http:/", kurl.string().utf8().data()); 370 #endif 371 372 kurl.setHost("www.google.com"); 373 EXPECT_TRUE(kurl.isValid()); 374 EXPECT_FALSE(kurl.isEmpty()); 375 EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); 376 377 kurl.setPort(8000); 378 EXPECT_TRUE(kurl.isValid()); 379 EXPECT_FALSE(kurl.isEmpty()); 380 EXPECT_STREQ("http://www.google.com:8000/", kurl.string().utf8().data()); 381 382 kurl.setPath("/favicon.ico"); 383 EXPECT_TRUE(kurl.isValid()); 384 EXPECT_FALSE(kurl.isEmpty()); 385 EXPECT_STREQ("http://www.google.com:8000/favicon.ico", kurl.string().utf8().data()); 386 387 // Now let's test that giving an invalid replacement fails. Invalid 388 // protocols fail without modifying the URL, which should remain valid. 389 #if USE(GOOGLEURL) 390 EXPECT_FALSE(kurl.setProtocol("f/sj#@")); 391 EXPECT_TRUE(kurl.isValid()); 392 #endif 393 } 394 395 TEST(KURLTest, Path) 396 { 397 const char initial[] = "http://www.google.com/path/foo"; 398 WebCore::KURL kurl(WebCore::ParsedURLString, initial); 399 400 // Clear by setting a null string. 401 WTF::String nullString; 402 EXPECT_TRUE(nullString.isNull()); 403 kurl.setPath(nullString); 404 EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); 405 } 406 407 // Test that setting the query to different things works. Thq query is handled 408 // a littler differently than some of the other components. 409 TEST(KURLTest, Query) 410 { 411 const char initial[] = "http://www.google.com/search?q=awesome"; 412 WebCore::KURL kurl(WebCore::ParsedURLString, initial); 413 414 // Clear by setting a null string. 415 WTF::String nullString; 416 EXPECT_TRUE(nullString.isNull()); 417 kurl.setQuery(nullString); 418 EXPECT_STREQ("http://www.google.com/search", kurl.string().utf8().data()); 419 420 // Clear by setting an empty string. 421 kurl = WebCore::KURL(WebCore::ParsedURLString, initial); 422 WTF::String emptyString(""); 423 EXPECT_FALSE(emptyString.isNull()); 424 kurl.setQuery(emptyString); 425 EXPECT_STREQ("http://www.google.com/search?", kurl.string().utf8().data()); 426 427 // Set with something that begins in a question mark. 428 const char question[] = "?foo=bar"; 429 kurl.setQuery(question); 430 EXPECT_STREQ("http://www.google.com/search?foo=bar", 431 kurl.string().utf8().data()); 432 433 // Set with something that doesn't begin in a question mark. 434 const char query[] = "foo=bar"; 435 kurl.setQuery(query); 436 EXPECT_STREQ("http://www.google.com/search?foo=bar", 437 kurl.string().utf8().data()); 438 } 439 440 TEST(KURLTest, Ref) 441 { 442 WebCore::KURL kurl(WebCore::ParsedURLString, "http://foo/bar#baz"); 443 444 // Basic ref setting. 445 WebCore::KURL cur(WebCore::ParsedURLString, "http://foo/bar"); 446 cur.setFragmentIdentifier("asdf"); 447 EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data()); 448 cur = kurl; 449 cur.setFragmentIdentifier("asdf"); 450 EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data()); 451 452 // Setting a ref to the empty string will set it to "#". 453 cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); 454 cur.setFragmentIdentifier(""); 455 EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data()); 456 cur = kurl; 457 cur.setFragmentIdentifier(""); 458 EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data()); 459 460 // Setting the ref to the null string will clear it altogether. 461 cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); 462 cur.setFragmentIdentifier(WTF::String()); 463 EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); 464 cur = kurl; 465 cur.setFragmentIdentifier(WTF::String()); 466 EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); 467 } 468 469 TEST(KURLTest, Empty) 470 { 471 WebCore::KURL kurl; 472 473 // First test that regular empty URLs are the same. 474 EXPECT_TRUE(kurl.isEmpty()); 475 EXPECT_FALSE(kurl.isValid()); 476 EXPECT_TRUE(kurl.isNull()); 477 EXPECT_TRUE(kurl.string().isNull()); 478 EXPECT_TRUE(kurl.string().isEmpty()); 479 480 // Test resolving a null URL on an empty string. 481 WebCore::KURL kurl2(kurl, ""); 482 EXPECT_FALSE(kurl2.isNull()); 483 EXPECT_TRUE(kurl2.isEmpty()); 484 EXPECT_FALSE(kurl2.isValid()); 485 EXPECT_FALSE(kurl2.string().isNull()); 486 EXPECT_TRUE(kurl2.string().isEmpty()); 487 EXPECT_FALSE(kurl2.string().isNull()); 488 EXPECT_TRUE(kurl2.string().isEmpty()); 489 490 // Resolve the null URL on a null string. 491 WebCore::KURL kurl22(kurl, WTF::String()); 492 EXPECT_FALSE(kurl22.isNull()); 493 EXPECT_TRUE(kurl22.isEmpty()); 494 EXPECT_FALSE(kurl22.isValid()); 495 EXPECT_FALSE(kurl22.string().isNull()); 496 EXPECT_TRUE(kurl22.string().isEmpty()); 497 EXPECT_FALSE(kurl22.string().isNull()); 498 EXPECT_TRUE(kurl22.string().isEmpty()); 499 500 // Test non-hierarchical schemes resolving. The actual URLs will be different. 501 // WebKit's one will set the string to "something.gif" and we'll set it to an 502 // empty string. I think either is OK, so we just check our behavior. 503 #if USE(GOOGLEURL) 504 WebCore::KURL kurl3(WebCore::KURL(WebCore::ParsedURLString, "data:foo"), 505 "something.gif"); 506 EXPECT_TRUE(kurl3.isEmpty()); 507 EXPECT_FALSE(kurl3.isValid()); 508 #endif 509 510 // Test for weird isNull string input, 511 // see: http://bugs.webkit.org/show_bug.cgi?id=16487 512 WebCore::KURL kurl4(WebCore::ParsedURLString, kurl.string()); 513 EXPECT_TRUE(kurl4.isEmpty()); 514 EXPECT_FALSE(kurl4.isValid()); 515 EXPECT_TRUE(kurl4.string().isNull()); 516 EXPECT_TRUE(kurl4.string().isEmpty()); 517 518 // Resolving an empty URL on an invalid string. 519 WebCore::KURL kurl5(WebCore::KURL(), "foo.js"); 520 // We'll be empty in this case, but KURL won't be. Should be OK. 521 // EXPECT_EQ(kurl5.isEmpty(), kurl5.isEmpty()); 522 // EXPECT_EQ(kurl5.string().isEmpty(), kurl5.string().isEmpty()); 523 EXPECT_FALSE(kurl5.isValid()); 524 EXPECT_FALSE(kurl5.string().isNull()); 525 526 // Empty string as input 527 WebCore::KURL kurl6(WebCore::ParsedURLString, ""); 528 EXPECT_TRUE(kurl6.isEmpty()); 529 EXPECT_FALSE(kurl6.isValid()); 530 EXPECT_FALSE(kurl6.string().isNull()); 531 EXPECT_TRUE(kurl6.string().isEmpty()); 532 533 // Non-empty but invalid C string as input. 534 WebCore::KURL kurl7(WebCore::ParsedURLString, "foo.js"); 535 // WebKit will actually say this URL has the string "foo.js" but is invalid. 536 // We don't do that. 537 // EXPECT_EQ(kurl7.isEmpty(), kurl7.isEmpty()); 538 EXPECT_FALSE(kurl7.isValid()); 539 EXPECT_FALSE(kurl7.string().isNull()); 540 } 541 542 TEST(KURLTest, UserPass) 543 { 544 const char* src = "http://user:pass@google.com/"; 545 WebCore::KURL kurl(WebCore::ParsedURLString, src); 546 547 // Clear just the username. 548 kurl.setUser(""); 549 EXPECT_EQ("http://:pass@google.com/", kurl.string()); 550 551 // Clear just the password. 552 kurl = WebCore::KURL(WebCore::ParsedURLString, src); 553 kurl.setPass(""); 554 EXPECT_EQ("http://user@google.com/", kurl.string()); 555 556 // Now clear both. 557 kurl.setUser(""); 558 EXPECT_EQ("http://google.com/", kurl.string()); 559 } 560 561 TEST(KURLTest, Offsets) 562 { 563 const char* src1 = "http://user:pass@google.com/foo/bar.html?baz=query#ref"; 564 WebCore::KURL kurl1(WebCore::ParsedURLString, src1); 565 566 EXPECT_EQ(17u, kurl1.hostStart()); 567 EXPECT_EQ(27u, kurl1.hostEnd()); 568 EXPECT_EQ(27u, kurl1.pathStart()); 569 EXPECT_EQ(40u, kurl1.pathEnd()); 570 EXPECT_EQ(32u, kurl1.pathAfterLastSlash()); 571 572 const char* src2 = "http://google.com/foo/"; 573 WebCore::KURL kurl2(WebCore::ParsedURLString, src2); 574 575 EXPECT_EQ(7u, kurl2.hostStart()); 576 EXPECT_EQ(17u, kurl2.hostEnd()); 577 EXPECT_EQ(17u, kurl2.pathStart()); 578 EXPECT_EQ(22u, kurl2.pathEnd()); 579 EXPECT_EQ(22u, kurl2.pathAfterLastSlash()); 580 581 const char* src3 = "javascript:foobar"; 582 WebCore::KURL kurl3(WebCore::ParsedURLString, src3); 583 584 EXPECT_EQ(11u, kurl3.hostStart()); 585 EXPECT_EQ(11u, kurl3.hostEnd()); 586 EXPECT_EQ(11u, kurl3.pathStart()); 587 EXPECT_EQ(17u, kurl3.pathEnd()); 588 EXPECT_EQ(11u, kurl3.pathAfterLastSlash()); 589 } 590 591 TEST(KURLTest, DeepCopy) 592 { 593 const char url[] = "http://www.google.com/"; 594 WebCore::KURL src(WebCore::ParsedURLString, url); 595 EXPECT_TRUE(src.string() == url); // This really just initializes the cache. 596 WebCore::KURL dest = src.copy(); 597 EXPECT_TRUE(dest.string() == url); // This really just initializes the cache. 598 599 // The pointers should be different for both UTF-8 and UTF-16. 600 EXPECT_NE(dest.string().characters(), src.string().characters()); 601 EXPECT_NE(dest.utf8String().data(), src.utf8String().data()); 602 } 603 604 TEST(KURLTest, ProtocolIs) 605 { 606 WebCore::KURL url1(WebCore::ParsedURLString, "foo://bar"); 607 EXPECT_TRUE(url1.protocolIs("foo")); 608 EXPECT_FALSE(url1.protocolIs("foo-bar")); 609 610 WebCore::KURL url2(WebCore::ParsedURLString, "foo-bar:"); 611 EXPECT_TRUE(url2.protocolIs("foo-bar")); 612 EXPECT_FALSE(url2.protocolIs("foo")); 613 } 614 615 } // namespace 616
