github.com/ck00004/CobaltStrikeParser-Go@v1.0.14/lib/url/url_test.go (about) 1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package url 6 7 import ( 8 "bytes" 9 encodingPkg "encoding" 10 "encoding/gob" 11 "encoding/json" 12 "fmt" 13 "io" 14 "net" 15 "reflect" 16 "strings" 17 "testing" 18 ) 19 20 type URLTest struct { 21 in string 22 out *URL // expected parse 23 roundtrip string // expected result of reserializing the URL; empty means same as "in". 24 } 25 26 var urltests = []URLTest{ 27 // no path 28 { 29 "http://www.google.com", 30 &URL{ 31 Scheme: "http", 32 Host: "www.google.com", 33 }, 34 "", 35 }, 36 // path 37 { 38 "http://www.google.com/", 39 &URL{ 40 Scheme: "http", 41 Host: "www.google.com", 42 Path: "/", 43 }, 44 "", 45 }, 46 // path with hex escaping 47 { 48 "http://www.google.com/file%20one%26two", 49 &URL{ 50 Scheme: "http", 51 Host: "www.google.com", 52 Path: "/file one&two", 53 RawPath: "/file%20one%26two", 54 }, 55 "", 56 }, 57 // fragment with hex escaping 58 { 59 "http://www.google.com/#file%20one%26two", 60 &URL{ 61 Scheme: "http", 62 Host: "www.google.com", 63 Path: "/", 64 Fragment: "file one&two", 65 RawFragment: "file%20one%26two", 66 }, 67 "", 68 }, 69 // user 70 { 71 "ftp://webmaster@www.google.com/", 72 &URL{ 73 Scheme: "ftp", 74 User: User("webmaster"), 75 Host: "www.google.com", 76 Path: "/", 77 }, 78 "", 79 }, 80 // escape sequence in username 81 { 82 "ftp://john%20doe@www.google.com/", 83 &URL{ 84 Scheme: "ftp", 85 User: User("john doe"), 86 Host: "www.google.com", 87 Path: "/", 88 }, 89 "ftp://john%20doe@www.google.com/", 90 }, 91 // empty query 92 { 93 "http://www.google.com/?", 94 &URL{ 95 Scheme: "http", 96 Host: "www.google.com", 97 Path: "/", 98 ForceQuery: true, 99 }, 100 "", 101 }, 102 // query ending in question mark (Issue 14573) 103 { 104 "http://www.google.com/?foo=bar?", 105 &URL{ 106 Scheme: "http", 107 Host: "www.google.com", 108 Path: "/", 109 RawQuery: "foo=bar?", 110 }, 111 "", 112 }, 113 // query 114 { 115 "http://www.google.com/?q=go+language", 116 &URL{ 117 Scheme: "http", 118 Host: "www.google.com", 119 Path: "/", 120 RawQuery: "q=go+language", 121 }, 122 "", 123 }, 124 // query with hex escaping: NOT parsed 125 { 126 "http://www.google.com/?q=go%20language", 127 &URL{ 128 Scheme: "http", 129 Host: "www.google.com", 130 Path: "/", 131 RawQuery: "q=go%20language", 132 }, 133 "", 134 }, 135 // %20 outside query 136 { 137 "http://www.google.com/a%20b?q=c+d", 138 &URL{ 139 Scheme: "http", 140 Host: "www.google.com", 141 Path: "/a b", 142 RawQuery: "q=c+d", 143 }, 144 "", 145 }, 146 // path without leading /, so no parsing 147 { 148 "http:www.google.com/?q=go+language", 149 &URL{ 150 Scheme: "http", 151 Opaque: "www.google.com/", 152 RawQuery: "q=go+language", 153 }, 154 "http:www.google.com/?q=go+language", 155 }, 156 // path without leading /, so no parsing 157 { 158 "http:%2f%2fwww.google.com/?q=go+language", 159 &URL{ 160 Scheme: "http", 161 Opaque: "%2f%2fwww.google.com/", 162 RawQuery: "q=go+language", 163 }, 164 "http:%2f%2fwww.google.com/?q=go+language", 165 }, 166 // non-authority with path 167 { 168 "mailto:/webmaster@golang.org", 169 &URL{ 170 Scheme: "mailto", 171 Path: "/webmaster@golang.org", 172 }, 173 "mailto:///webmaster@golang.org", // unfortunate compromise 174 }, 175 // non-authority 176 { 177 "mailto:webmaster@golang.org", 178 &URL{ 179 Scheme: "mailto", 180 Opaque: "webmaster@golang.org", 181 }, 182 "", 183 }, 184 // unescaped :// in query should not create a scheme 185 { 186 "/foo?query=http://bad", 187 &URL{ 188 Path: "/foo", 189 RawQuery: "query=http://bad", 190 }, 191 "", 192 }, 193 // leading // without scheme should create an authority 194 { 195 "//foo", 196 &URL{ 197 Host: "foo", 198 }, 199 "", 200 }, 201 // leading // without scheme, with userinfo, path, and query 202 { 203 "//user@foo/path?a=b", 204 &URL{ 205 User: User("user"), 206 Host: "foo", 207 Path: "/path", 208 RawQuery: "a=b", 209 }, 210 "", 211 }, 212 // Three leading slashes isn't an authority, but doesn't return an error. 213 // (We can't return an error, as this code is also used via 214 // ServeHTTP -> ReadRequest -> Parse, which is arguably a 215 // different URL parsing context, but currently shares the 216 // same codepath) 217 { 218 "///threeslashes", 219 &URL{ 220 Path: "///threeslashes", 221 }, 222 "", 223 }, 224 { 225 "http://user:password@google.com", 226 &URL{ 227 Scheme: "http", 228 User: UserPassword("user", "password"), 229 Host: "google.com", 230 }, 231 "http://user:password@google.com", 232 }, 233 // unescaped @ in username should not confuse host 234 { 235 "http://j@ne:password@google.com", 236 &URL{ 237 Scheme: "http", 238 User: UserPassword("j@ne", "password"), 239 Host: "google.com", 240 }, 241 "http://j%40ne:password@google.com", 242 }, 243 // unescaped @ in password should not confuse host 244 { 245 "http://jane:p@ssword@google.com", 246 &URL{ 247 Scheme: "http", 248 User: UserPassword("jane", "p@ssword"), 249 Host: "google.com", 250 }, 251 "http://jane:p%40ssword@google.com", 252 }, 253 { 254 "http://j@ne:password@google.com/p@th?q=@go", 255 &URL{ 256 Scheme: "http", 257 User: UserPassword("j@ne", "password"), 258 Host: "google.com", 259 Path: "/p@th", 260 RawQuery: "q=@go", 261 }, 262 "http://j%40ne:password@google.com/p@th?q=@go", 263 }, 264 { 265 "http://www.google.com/?q=go+language#foo", 266 &URL{ 267 Scheme: "http", 268 Host: "www.google.com", 269 Path: "/", 270 RawQuery: "q=go+language", 271 Fragment: "foo", 272 }, 273 "", 274 }, 275 { 276 "http://www.google.com/?q=go+language#foo&bar", 277 &URL{ 278 Scheme: "http", 279 Host: "www.google.com", 280 Path: "/", 281 RawQuery: "q=go+language", 282 Fragment: "foo&bar", 283 }, 284 "http://www.google.com/?q=go+language#foo&bar", 285 }, 286 { 287 "http://www.google.com/?q=go+language#foo%26bar", 288 &URL{ 289 Scheme: "http", 290 Host: "www.google.com", 291 Path: "/", 292 RawQuery: "q=go+language", 293 Fragment: "foo&bar", 294 RawFragment: "foo%26bar", 295 }, 296 "http://www.google.com/?q=go+language#foo%26bar", 297 }, 298 { 299 "file:///home/adg/rabbits", 300 &URL{ 301 Scheme: "file", 302 Host: "", 303 Path: "/home/adg/rabbits", 304 }, 305 "file:///home/adg/rabbits", 306 }, 307 // "Windows" paths are no exception to the rule. 308 // See golang.org/issue/6027, especially comment #9. 309 { 310 "file:///C:/FooBar/Baz.txt", 311 &URL{ 312 Scheme: "file", 313 Host: "", 314 Path: "/C:/FooBar/Baz.txt", 315 }, 316 "file:///C:/FooBar/Baz.txt", 317 }, 318 // case-insensitive scheme 319 { 320 "MaIlTo:webmaster@golang.org", 321 &URL{ 322 Scheme: "mailto", 323 Opaque: "webmaster@golang.org", 324 }, 325 "mailto:webmaster@golang.org", 326 }, 327 // Relative path 328 { 329 "a/b/c", 330 &URL{ 331 Path: "a/b/c", 332 }, 333 "a/b/c", 334 }, 335 // escaped '?' in username and password 336 { 337 "http://%3Fam:pa%3Fsword@google.com", 338 &URL{ 339 Scheme: "http", 340 User: UserPassword("?am", "pa?sword"), 341 Host: "google.com", 342 }, 343 "", 344 }, 345 // host subcomponent; IPv4 address in RFC 3986 346 { 347 "http://192.168.0.1/", 348 &URL{ 349 Scheme: "http", 350 Host: "192.168.0.1", 351 Path: "/", 352 }, 353 "", 354 }, 355 // host and port subcomponents; IPv4 address in RFC 3986 356 { 357 "http://192.168.0.1:8080/", 358 &URL{ 359 Scheme: "http", 360 Host: "192.168.0.1:8080", 361 Path: "/", 362 }, 363 "", 364 }, 365 // host subcomponent; IPv6 address in RFC 3986 366 { 367 "http://[fe80::1]/", 368 &URL{ 369 Scheme: "http", 370 Host: "[fe80::1]", 371 Path: "/", 372 }, 373 "", 374 }, 375 // host and port subcomponents; IPv6 address in RFC 3986 376 { 377 "http://[fe80::1]:8080/", 378 &URL{ 379 Scheme: "http", 380 Host: "[fe80::1]:8080", 381 Path: "/", 382 }, 383 "", 384 }, 385 // host subcomponent; IPv6 address with zone identifier in RFC 6874 386 { 387 "http://[fe80::1%25en0]/", // alphanum zone identifier 388 &URL{ 389 Scheme: "http", 390 Host: "[fe80::1%en0]", 391 Path: "/", 392 }, 393 "", 394 }, 395 // host and port subcomponents; IPv6 address with zone identifier in RFC 6874 396 { 397 "http://[fe80::1%25en0]:8080/", // alphanum zone identifier 398 &URL{ 399 Scheme: "http", 400 Host: "[fe80::1%en0]:8080", 401 Path: "/", 402 }, 403 "", 404 }, 405 // host subcomponent; IPv6 address with zone identifier in RFC 6874 406 { 407 "http://[fe80::1%25%65%6e%301-._~]/", // percent-encoded+unreserved zone identifier 408 &URL{ 409 Scheme: "http", 410 Host: "[fe80::1%en01-._~]", 411 Path: "/", 412 }, 413 "http://[fe80::1%25en01-._~]/", 414 }, 415 // host and port subcomponents; IPv6 address with zone identifier in RFC 6874 416 { 417 "http://[fe80::1%25%65%6e%301-._~]:8080/", // percent-encoded+unreserved zone identifier 418 &URL{ 419 Scheme: "http", 420 Host: "[fe80::1%en01-._~]:8080", 421 Path: "/", 422 }, 423 "http://[fe80::1%25en01-._~]:8080/", 424 }, 425 // alternate escapings of path survive round trip 426 { 427 "http://rest.rsc.io/foo%2fbar/baz%2Fquux?alt=media", 428 &URL{ 429 Scheme: "http", 430 Host: "rest.rsc.io", 431 Path: "/foo/bar/baz/quux", 432 RawPath: "/foo%2fbar/baz%2Fquux", 433 RawQuery: "alt=media", 434 }, 435 "", 436 }, 437 // issue 12036 438 { 439 "mysql://a,b,c/bar", 440 &URL{ 441 Scheme: "mysql", 442 Host: "a,b,c", 443 Path: "/bar", 444 }, 445 "", 446 }, 447 // worst case host, still round trips 448 { 449 "scheme://!$&'()*+,;=hello!:1/path", 450 &URL{ 451 Scheme: "scheme", 452 Host: "!$&'()*+,;=hello!:1", 453 Path: "/path", 454 }, 455 "", 456 }, 457 // worst case path, still round trips 458 { 459 "http://host/!$&'()*+,;=:@[hello]", 460 &URL{ 461 Scheme: "http", 462 Host: "host", 463 Path: "/!$&'()*+,;=:@[hello]", 464 RawPath: "/!$&'()*+,;=:@[hello]", 465 }, 466 "", 467 }, 468 // golang.org/issue/5684 469 { 470 "http://example.com/oid/[order_id]", 471 &URL{ 472 Scheme: "http", 473 Host: "example.com", 474 Path: "/oid/[order_id]", 475 RawPath: "/oid/[order_id]", 476 }, 477 "", 478 }, 479 // golang.org/issue/12200 (colon with empty port) 480 { 481 "http://192.168.0.2:8080/foo", 482 &URL{ 483 Scheme: "http", 484 Host: "192.168.0.2:8080", 485 Path: "/foo", 486 }, 487 "", 488 }, 489 { 490 "http://192.168.0.2:/foo", 491 &URL{ 492 Scheme: "http", 493 Host: "192.168.0.2:", 494 Path: "/foo", 495 }, 496 "", 497 }, 498 { 499 // Malformed IPv6 but still accepted. 500 "http://2b01:e34:ef40:7730:8e70:5aff:fefe:edac:8080/foo", 501 &URL{ 502 Scheme: "http", 503 Host: "2b01:e34:ef40:7730:8e70:5aff:fefe:edac:8080", 504 Path: "/foo", 505 }, 506 "", 507 }, 508 { 509 // Malformed IPv6 but still accepted. 510 "http://2b01:e34:ef40:7730:8e70:5aff:fefe:edac:/foo", 511 &URL{ 512 Scheme: "http", 513 Host: "2b01:e34:ef40:7730:8e70:5aff:fefe:edac:", 514 Path: "/foo", 515 }, 516 "", 517 }, 518 { 519 "http://[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:8080/foo", 520 &URL{ 521 Scheme: "http", 522 Host: "[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:8080", 523 Path: "/foo", 524 }, 525 "", 526 }, 527 { 528 "http://[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:/foo", 529 &URL{ 530 Scheme: "http", 531 Host: "[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:", 532 Path: "/foo", 533 }, 534 "", 535 }, 536 // golang.org/issue/7991 and golang.org/issue/12719 (non-ascii %-encoded in host) 537 { 538 "http://hello.世界.com/foo", 539 &URL{ 540 Scheme: "http", 541 Host: "hello.世界.com", 542 Path: "/foo", 543 }, 544 "http://hello.%E4%B8%96%E7%95%8C.com/foo", 545 }, 546 { 547 "http://hello.%e4%b8%96%e7%95%8c.com/foo", 548 &URL{ 549 Scheme: "http", 550 Host: "hello.世界.com", 551 Path: "/foo", 552 }, 553 "http://hello.%E4%B8%96%E7%95%8C.com/foo", 554 }, 555 { 556 "http://hello.%E4%B8%96%E7%95%8C.com/foo", 557 &URL{ 558 Scheme: "http", 559 Host: "hello.世界.com", 560 Path: "/foo", 561 }, 562 "", 563 }, 564 // golang.org/issue/10433 (path beginning with //) 565 { 566 "http://example.com//foo", 567 &URL{ 568 Scheme: "http", 569 Host: "example.com", 570 Path: "//foo", 571 }, 572 "", 573 }, 574 // test that we can reparse the host names we accept. 575 { 576 "myscheme://authority<\"hi\">/foo", 577 &URL{ 578 Scheme: "myscheme", 579 Host: "authority<\"hi\">", 580 Path: "/foo", 581 }, 582 "", 583 }, 584 // spaces in hosts are disallowed but escaped spaces in IPv6 scope IDs are grudgingly OK. 585 // This happens on Windows. 586 // golang.org/issue/14002 587 { 588 "tcp://[2020::2020:20:2020:2020%25Windows%20Loves%20Spaces]:2020", 589 &URL{ 590 Scheme: "tcp", 591 Host: "[2020::2020:20:2020:2020%Windows Loves Spaces]:2020", 592 }, 593 "", 594 }, 595 // test we can roundtrip magnet url 596 // fix issue https://golang.org/issue/20054 597 { 598 "magnet:?xt=urn:btih:c12fe1c06bba254a9dc9f519b335aa7c1367a88a&dn", 599 &URL{ 600 Scheme: "magnet", 601 Host: "", 602 Path: "", 603 RawQuery: "xt=urn:btih:c12fe1c06bba254a9dc9f519b335aa7c1367a88a&dn", 604 }, 605 "magnet:?xt=urn:btih:c12fe1c06bba254a9dc9f519b335aa7c1367a88a&dn", 606 }, 607 { 608 "mailto:?subject=hi", 609 &URL{ 610 Scheme: "mailto", 611 Host: "", 612 Path: "", 613 RawQuery: "subject=hi", 614 }, 615 "mailto:?subject=hi", 616 }, 617 } 618 619 // more useful string for debugging than fmt's struct printer 620 func ufmt(u *URL) string { 621 var user, pass interface{} 622 if u.User != nil { 623 user = u.User.Username() 624 if p, ok := u.User.Password(); ok { 625 pass = p 626 } 627 } 628 return fmt.Sprintf("opaque=%q, scheme=%q, user=%#v, pass=%#v, host=%q, path=%q, rawpath=%q, rawq=%q, frag=%q, rawfrag=%q, forcequery=%v", 629 u.Opaque, u.Scheme, user, pass, u.Host, u.Path, u.RawPath, u.RawQuery, u.Fragment, u.RawFragment, u.ForceQuery) 630 } 631 632 func BenchmarkString(b *testing.B) { 633 b.StopTimer() 634 b.ReportAllocs() 635 for _, tt := range urltests { 636 u, err := Parse(tt.in) 637 if err != nil { 638 b.Errorf("Parse(%q) returned error %s", tt.in, err) 639 continue 640 } 641 if tt.roundtrip == "" { 642 continue 643 } 644 b.StartTimer() 645 var g string 646 for i := 0; i < b.N; i++ { 647 g = u.String() 648 } 649 b.StopTimer() 650 if w := tt.roundtrip; b.N > 0 && g != w { 651 b.Errorf("Parse(%q).String() == %q, want %q", tt.in, g, w) 652 } 653 } 654 } 655 656 func TestParse(t *testing.T) { 657 for _, tt := range urltests { 658 u, err := Parse(tt.in) 659 if err != nil { 660 t.Errorf("Parse(%q) returned error %v", tt.in, err) 661 continue 662 } 663 if !reflect.DeepEqual(u, tt.out) { 664 t.Errorf("Parse(%q):\n\tgot %v\n\twant %v\n", tt.in, ufmt(u), ufmt(tt.out)) 665 } 666 } 667 } 668 669 const pathThatLooksSchemeRelative = "//not.a.user@not.a.host/just/a/path" 670 671 var parseRequestURLTests = []struct { 672 url string 673 expectedValid bool 674 }{ 675 {"http://foo.com", true}, 676 {"http://foo.com/", true}, 677 {"http://foo.com/path", true}, 678 {"/", true}, 679 {pathThatLooksSchemeRelative, true}, 680 {"//not.a.user@%66%6f%6f.com/just/a/path/also", true}, 681 {"*", true}, 682 {"http://192.168.0.1/", true}, 683 {"http://192.168.0.1:8080/", true}, 684 {"http://[fe80::1]/", true}, 685 {"http://[fe80::1]:8080/", true}, 686 687 // Tests exercising RFC 6874 compliance: 688 {"http://[fe80::1%25en0]/", true}, // with alphanum zone identifier 689 {"http://[fe80::1%25en0]:8080/", true}, // with alphanum zone identifier 690 {"http://[fe80::1%25%65%6e%301-._~]/", true}, // with percent-encoded+unreserved zone identifier 691 {"http://[fe80::1%25%65%6e%301-._~]:8080/", true}, // with percent-encoded+unreserved zone identifier 692 693 {"foo.html", false}, 694 {"../dir/", false}, 695 {" http://foo.com", false}, 696 {"http://192.168.0.%31/", false}, 697 {"http://192.168.0.%31:8080/", false}, 698 {"http://[fe80::%31]/", false}, 699 {"http://[fe80::%31]:8080/", false}, 700 {"http://[fe80::%31%25en0]/", false}, 701 {"http://[fe80::%31%25en0]:8080/", false}, 702 703 // These two cases are valid as textual representations as 704 // described in RFC 4007, but are not valid as address 705 // literals with IPv6 zone identifiers in URIs as described in 706 // RFC 6874. 707 {"http://[fe80::1%en0]/", false}, 708 {"http://[fe80::1%en0]:8080/", false}, 709 } 710 711 func TestParseRequestURI(t *testing.T) { 712 for _, test := range parseRequestURLTests { 713 _, err := ParseRequestURI(test.url) 714 if test.expectedValid && err != nil { 715 t.Errorf("ParseRequestURI(%q) gave err %v; want no error", test.url, err) 716 } else if !test.expectedValid && err == nil { 717 t.Errorf("ParseRequestURI(%q) gave nil error; want some error", test.url) 718 } 719 } 720 721 url, err := ParseRequestURI(pathThatLooksSchemeRelative) 722 if err != nil { 723 t.Fatalf("Unexpected error %v", err) 724 } 725 if url.Path != pathThatLooksSchemeRelative { 726 t.Errorf("ParseRequestURI path:\ngot %q\nwant %q", url.Path, pathThatLooksSchemeRelative) 727 } 728 } 729 730 var stringURLTests = []struct { 731 url URL 732 want string 733 }{ 734 // No leading slash on path should prepend slash on String() call 735 { 736 url: URL{ 737 Scheme: "http", 738 Host: "www.google.com", 739 Path: "search", 740 }, 741 want: "http://www.google.com/search", 742 }, 743 // Relative path with first element containing ":" should be prepended with "./", golang.org/issue/17184 744 { 745 url: URL{ 746 Path: "this:that", 747 }, 748 want: "./this:that", 749 }, 750 // Relative path with second element containing ":" should not be prepended with "./" 751 { 752 url: URL{ 753 Path: "here/this:that", 754 }, 755 want: "here/this:that", 756 }, 757 // Non-relative path with first element containing ":" should not be prepended with "./" 758 { 759 url: URL{ 760 Scheme: "http", 761 Host: "www.google.com", 762 Path: "this:that", 763 }, 764 want: "http://www.google.com/this:that", 765 }, 766 } 767 768 func TestURLString(t *testing.T) { 769 for _, tt := range urltests { 770 u, err := Parse(tt.in) 771 if err != nil { 772 t.Errorf("Parse(%q) returned error %s", tt.in, err) 773 continue 774 } 775 expected := tt.in 776 if tt.roundtrip != "" { 777 expected = tt.roundtrip 778 } 779 s := u.String() 780 if s != expected { 781 t.Errorf("Parse(%q).String() == %q (expected %q)", tt.in, s, expected) 782 } 783 } 784 785 for _, tt := range stringURLTests { 786 if got := tt.url.String(); got != tt.want { 787 t.Errorf("%+v.String() = %q; want %q", tt.url, got, tt.want) 788 } 789 } 790 } 791 792 func TestURLRedacted(t *testing.T) { 793 cases := []struct { 794 name string 795 url *URL 796 want string 797 }{ 798 { 799 name: "non-blank Password", 800 url: &URL{ 801 Scheme: "http", 802 Host: "host.tld", 803 Path: "this:that", 804 User: UserPassword("user", "password"), 805 }, 806 want: "http://user:xxxxx@host.tld/this:that", 807 }, 808 { 809 name: "blank Password", 810 url: &URL{ 811 Scheme: "http", 812 Host: "host.tld", 813 Path: "this:that", 814 User: User("user"), 815 }, 816 want: "http://user@host.tld/this:that", 817 }, 818 { 819 name: "nil User", 820 url: &URL{ 821 Scheme: "http", 822 Host: "host.tld", 823 Path: "this:that", 824 User: UserPassword("", "password"), 825 }, 826 want: "http://:xxxxx@host.tld/this:that", 827 }, 828 { 829 name: "blank Username, blank Password", 830 url: &URL{ 831 Scheme: "http", 832 Host: "host.tld", 833 Path: "this:that", 834 }, 835 want: "http://host.tld/this:that", 836 }, 837 { 838 name: "empty URL", 839 url: &URL{}, 840 want: "", 841 }, 842 { 843 name: "nil URL", 844 url: nil, 845 want: "", 846 }, 847 } 848 849 for _, tt := range cases { 850 t := t 851 t.Run(tt.name, func(t *testing.T) { 852 if g, w := tt.url.Redacted(), tt.want; g != w { 853 t.Fatalf("got: %q\nwant: %q", g, w) 854 } 855 }) 856 } 857 } 858 859 type EscapeTest struct { 860 in string 861 out string 862 err error 863 } 864 865 var unescapeTests = []EscapeTest{ 866 { 867 "", 868 "", 869 nil, 870 }, 871 { 872 "abc", 873 "abc", 874 nil, 875 }, 876 { 877 "1%41", 878 "1A", 879 nil, 880 }, 881 { 882 "1%41%42%43", 883 "1ABC", 884 nil, 885 }, 886 { 887 "%4a", 888 "J", 889 nil, 890 }, 891 { 892 "%6F", 893 "o", 894 nil, 895 }, 896 { 897 "%", // not enough characters after % 898 "", 899 EscapeError("%"), 900 }, 901 { 902 "%a", // not enough characters after % 903 "", 904 EscapeError("%a"), 905 }, 906 { 907 "%1", // not enough characters after % 908 "", 909 EscapeError("%1"), 910 }, 911 { 912 "123%45%6", // not enough characters after % 913 "", 914 EscapeError("%6"), 915 }, 916 { 917 "%zzzzz", // invalid hex digits 918 "", 919 EscapeError("%zz"), 920 }, 921 { 922 "a+b", 923 "a b", 924 nil, 925 }, 926 { 927 "a%20b", 928 "a b", 929 nil, 930 }, 931 } 932 933 func TestUnescape(t *testing.T) { 934 for _, tt := range unescapeTests { 935 actual, err := QueryUnescape(tt.in) 936 if actual != tt.out || (err != nil) != (tt.err != nil) { 937 t.Errorf("QueryUnescape(%q) = %q, %s; want %q, %s", tt.in, actual, err, tt.out, tt.err) 938 } 939 940 in := tt.in 941 out := tt.out 942 if strings.Contains(tt.in, "+") { 943 in = strings.ReplaceAll(tt.in, "+", "%20") 944 actual, err := PathUnescape(in) 945 if actual != tt.out || (err != nil) != (tt.err != nil) { 946 t.Errorf("PathUnescape(%q) = %q, %s; want %q, %s", in, actual, err, tt.out, tt.err) 947 } 948 if tt.err == nil { 949 s, err := QueryUnescape(strings.ReplaceAll(tt.in, "+", "XXX")) 950 if err != nil { 951 continue 952 } 953 in = tt.in 954 out = strings.ReplaceAll(s, "XXX", "+") 955 } 956 } 957 958 actual, err = PathUnescape(in) 959 if actual != out || (err != nil) != (tt.err != nil) { 960 t.Errorf("PathUnescape(%q) = %q, %s; want %q, %s", in, actual, err, out, tt.err) 961 } 962 } 963 } 964 965 var queryEscapeTests = []EscapeTest{ 966 { 967 "", 968 "", 969 nil, 970 }, 971 { 972 "abc", 973 "abc", 974 nil, 975 }, 976 { 977 "one two", 978 "one+two", 979 nil, 980 }, 981 { 982 "10%", 983 "10%25", 984 nil, 985 }, 986 { 987 " ?&=#+%!<>#\"{}|\\^[]`☺\t:/@$'()*,;", 988 "+%3F%26%3D%23%2B%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%E2%98%BA%09%3A%2F%40%24%27%28%29%2A%2C%3B", 989 nil, 990 }, 991 } 992 993 func TestQueryEscape(t *testing.T) { 994 for _, tt := range queryEscapeTests { 995 actual := QueryEscape(tt.in) 996 if tt.out != actual { 997 t.Errorf("QueryEscape(%q) = %q, want %q", tt.in, actual, tt.out) 998 } 999 1000 // for bonus points, verify that escape:unescape is an identity. 1001 roundtrip, err := QueryUnescape(actual) 1002 if roundtrip != tt.in || err != nil { 1003 t.Errorf("QueryUnescape(%q) = %q, %s; want %q, %s", actual, roundtrip, err, tt.in, "[no error]") 1004 } 1005 } 1006 } 1007 1008 var pathEscapeTests = []EscapeTest{ 1009 { 1010 "", 1011 "", 1012 nil, 1013 }, 1014 { 1015 "abc", 1016 "abc", 1017 nil, 1018 }, 1019 { 1020 "abc+def", 1021 "abc+def", 1022 nil, 1023 }, 1024 { 1025 "a/b", 1026 "a%2Fb", 1027 nil, 1028 }, 1029 { 1030 "one two", 1031 "one%20two", 1032 nil, 1033 }, 1034 { 1035 "10%", 1036 "10%25", 1037 nil, 1038 }, 1039 { 1040 " ?&=#+%!<>#\"{}|\\^[]`☺\t:/@$'()*,;", 1041 "%20%3F&=%23+%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%E2%98%BA%09:%2F@$%27%28%29%2A%2C%3B", 1042 nil, 1043 }, 1044 } 1045 1046 func TestPathEscape(t *testing.T) { 1047 for _, tt := range pathEscapeTests { 1048 actual := PathEscape(tt.in) 1049 if tt.out != actual { 1050 t.Errorf("PathEscape(%q) = %q, want %q", tt.in, actual, tt.out) 1051 } 1052 1053 // for bonus points, verify that escape:unescape is an identity. 1054 roundtrip, err := PathUnescape(actual) 1055 if roundtrip != tt.in || err != nil { 1056 t.Errorf("PathUnescape(%q) = %q, %s; want %q, %s", actual, roundtrip, err, tt.in, "[no error]") 1057 } 1058 } 1059 } 1060 1061 //var userinfoTests = []UserinfoTest{ 1062 // {"user", "password", "user:password"}, 1063 // {"foo:bar", "~!@#$%^&*()_+{}|[]\\-=`:;'\"<>?,./", 1064 // "foo%3Abar:~!%40%23$%25%5E&*()_+%7B%7D%7C%5B%5D%5C-=%60%3A;'%22%3C%3E?,.%2F"}, 1065 //} 1066 1067 type EncodeQueryTest struct { 1068 m Values 1069 expected string 1070 } 1071 1072 var encodeQueryTests = []EncodeQueryTest{ 1073 {nil, ""}, 1074 {Values{"q": {"puppies"}, "oe": {"utf8"}}, "oe=utf8&q=puppies"}, 1075 {Values{"q": {"dogs", "&", "7"}}, "q=dogs&q=%26&q=7"}, 1076 {Values{ 1077 "a": {"a1", "a2", "a3"}, 1078 "b": {"b1", "b2", "b3"}, 1079 "c": {"c1", "c2", "c3"}, 1080 }, "a=a1&a=a2&a=a3&b=b1&b=b2&b=b3&c=c1&c=c2&c=c3"}, 1081 } 1082 1083 func TestEncodeQuery(t *testing.T) { 1084 for _, tt := range encodeQueryTests { 1085 if q := tt.m.Encode(); q != tt.expected { 1086 t.Errorf(`EncodeQuery(%+v) = %q, want %q`, tt.m, q, tt.expected) 1087 } 1088 } 1089 } 1090 1091 var resolvePathTests = []struct { 1092 base, ref, expected string 1093 }{ 1094 {"a/b", ".", "/a/"}, 1095 {"a/b", "c", "/a/c"}, 1096 {"a/b", "..", "/"}, 1097 {"a/", "..", "/"}, 1098 {"a/", "../..", "/"}, 1099 {"a/b/c", "..", "/a/"}, 1100 {"a/b/c", "../d", "/a/d"}, 1101 {"a/b/c", ".././d", "/a/d"}, 1102 {"a/b", "./..", "/"}, 1103 {"a/./b", ".", "/a/"}, 1104 {"a/../", ".", "/"}, 1105 {"a/.././b", "c", "/c"}, 1106 } 1107 1108 func TestResolvePath(t *testing.T) { 1109 for _, test := range resolvePathTests { 1110 got := resolvePath(test.base, test.ref) 1111 if got != test.expected { 1112 t.Errorf("For %q + %q got %q; expected %q", test.base, test.ref, got, test.expected) 1113 } 1114 } 1115 } 1116 1117 func BenchmarkResolvePath(b *testing.B) { 1118 b.ResetTimer() 1119 b.ReportAllocs() 1120 for i := 0; i < b.N; i++ { 1121 resolvePath("a/b/c", ".././d") 1122 } 1123 } 1124 1125 var resolveReferenceTests = []struct { 1126 base, rel, expected string 1127 }{ 1128 // Absolute URL references 1129 {"http://foo.com?a=b", "https://bar.com/", "https://bar.com/"}, 1130 {"http://foo.com/", "https://bar.com/?a=b", "https://bar.com/?a=b"}, 1131 {"http://foo.com/", "https://bar.com/?", "https://bar.com/?"}, 1132 {"http://foo.com/bar", "mailto:foo@example.com", "mailto:foo@example.com"}, 1133 1134 // Path-absolute references 1135 {"http://foo.com/bar", "/baz", "http://foo.com/baz"}, 1136 {"http://foo.com/bar?a=b#f", "/baz", "http://foo.com/baz"}, 1137 {"http://foo.com/bar?a=b", "/baz?", "http://foo.com/baz?"}, 1138 {"http://foo.com/bar?a=b", "/baz?c=d", "http://foo.com/baz?c=d"}, 1139 1140 // Multiple slashes 1141 {"http://foo.com/bar", "http://foo.com//baz", "http://foo.com//baz"}, 1142 {"http://foo.com/bar", "http://foo.com///baz/quux", "http://foo.com///baz/quux"}, 1143 1144 // Scheme-relative 1145 {"https://foo.com/bar?a=b", "//bar.com/quux", "https://bar.com/quux"}, 1146 1147 // Path-relative references: 1148 1149 // ... current directory 1150 {"http://foo.com", ".", "http://foo.com/"}, 1151 {"http://foo.com/bar", ".", "http://foo.com/"}, 1152 {"http://foo.com/bar/", ".", "http://foo.com/bar/"}, 1153 1154 // ... going down 1155 {"http://foo.com", "bar", "http://foo.com/bar"}, 1156 {"http://foo.com/", "bar", "http://foo.com/bar"}, 1157 {"http://foo.com/bar/baz", "quux", "http://foo.com/bar/quux"}, 1158 1159 // ... going up 1160 {"http://foo.com/bar/baz", "../quux", "http://foo.com/quux"}, 1161 {"http://foo.com/bar/baz", "../../../../../quux", "http://foo.com/quux"}, 1162 {"http://foo.com/bar", "..", "http://foo.com/"}, 1163 {"http://foo.com/bar/baz", "./..", "http://foo.com/"}, 1164 // ".." in the middle (issue 3560) 1165 {"http://foo.com/bar/baz", "quux/dotdot/../tail", "http://foo.com/bar/quux/tail"}, 1166 {"http://foo.com/bar/baz", "quux/./dotdot/../tail", "http://foo.com/bar/quux/tail"}, 1167 {"http://foo.com/bar/baz", "quux/./dotdot/.././tail", "http://foo.com/bar/quux/tail"}, 1168 {"http://foo.com/bar/baz", "quux/./dotdot/./../tail", "http://foo.com/bar/quux/tail"}, 1169 {"http://foo.com/bar/baz", "quux/./dotdot/dotdot/././../../tail", "http://foo.com/bar/quux/tail"}, 1170 {"http://foo.com/bar/baz", "quux/./dotdot/dotdot/./.././../tail", "http://foo.com/bar/quux/tail"}, 1171 {"http://foo.com/bar/baz", "quux/./dotdot/dotdot/dotdot/./../../.././././tail", "http://foo.com/bar/quux/tail"}, 1172 {"http://foo.com/bar/baz", "quux/./dotdot/../dotdot/../dot/./tail/..", "http://foo.com/bar/quux/dot/"}, 1173 1174 // Remove any dot-segments prior to forming the target URI. 1175 // http://tools.ietf.org/html/rfc3986#section-5.2.4 1176 {"http://foo.com/dot/./dotdot/../foo/bar", "../baz", "http://foo.com/dot/baz"}, 1177 1178 // Triple dot isn't special 1179 {"http://foo.com/bar", "...", "http://foo.com/..."}, 1180 1181 // Fragment 1182 {"http://foo.com/bar", ".#frag", "http://foo.com/#frag"}, 1183 {"http://example.org/", "#!$&%27()*+,;=", "http://example.org/#!$&%27()*+,;="}, 1184 1185 // Paths with escaping (issue 16947). 1186 {"http://foo.com/foo%2fbar/", "../baz", "http://foo.com/baz"}, 1187 {"http://foo.com/1/2%2f/3%2f4/5", "../../a/b/c", "http://foo.com/1/a/b/c"}, 1188 {"http://foo.com/1/2/3", "./a%2f../../b/..%2fc", "http://foo.com/1/2/b/..%2fc"}, 1189 {"http://foo.com/1/2%2f/3%2f4/5", "./a%2f../b/../c", "http://foo.com/1/2%2f/3%2f4/a%2f../c"}, 1190 {"http://foo.com/foo%20bar/", "../baz", "http://foo.com/baz"}, 1191 {"http://foo.com/foo", "../bar%2fbaz", "http://foo.com/bar%2fbaz"}, 1192 {"http://foo.com/foo%2dbar/", "./baz-quux", "http://foo.com/foo%2dbar/baz-quux"}, 1193 1194 // RFC 3986: Normal Examples 1195 // http://tools.ietf.org/html/rfc3986#section-5.4.1 1196 {"http://a/b/c/d;p?q", "g:h", "g:h"}, 1197 {"http://a/b/c/d;p?q", "g", "http://a/b/c/g"}, 1198 {"http://a/b/c/d;p?q", "./g", "http://a/b/c/g"}, 1199 {"http://a/b/c/d;p?q", "g/", "http://a/b/c/g/"}, 1200 {"http://a/b/c/d;p?q", "/g", "http://a/g"}, 1201 {"http://a/b/c/d;p?q", "//g", "http://g"}, 1202 {"http://a/b/c/d;p?q", "?y", "http://a/b/c/d;p?y"}, 1203 {"http://a/b/c/d;p?q", "g?y", "http://a/b/c/g?y"}, 1204 {"http://a/b/c/d;p?q", "#s", "http://a/b/c/d;p?q#s"}, 1205 {"http://a/b/c/d;p?q", "g#s", "http://a/b/c/g#s"}, 1206 {"http://a/b/c/d;p?q", "g?y#s", "http://a/b/c/g?y#s"}, 1207 {"http://a/b/c/d;p?q", ";x", "http://a/b/c/;x"}, 1208 {"http://a/b/c/d;p?q", "g;x", "http://a/b/c/g;x"}, 1209 {"http://a/b/c/d;p?q", "g;x?y#s", "http://a/b/c/g;x?y#s"}, 1210 {"http://a/b/c/d;p?q", "", "http://a/b/c/d;p?q"}, 1211 {"http://a/b/c/d;p?q", ".", "http://a/b/c/"}, 1212 {"http://a/b/c/d;p?q", "./", "http://a/b/c/"}, 1213 {"http://a/b/c/d;p?q", "..", "http://a/b/"}, 1214 {"http://a/b/c/d;p?q", "../", "http://a/b/"}, 1215 {"http://a/b/c/d;p?q", "../g", "http://a/b/g"}, 1216 {"http://a/b/c/d;p?q", "../..", "http://a/"}, 1217 {"http://a/b/c/d;p?q", "../../", "http://a/"}, 1218 {"http://a/b/c/d;p?q", "../../g", "http://a/g"}, 1219 1220 // RFC 3986: Abnormal Examples 1221 // http://tools.ietf.org/html/rfc3986#section-5.4.2 1222 {"http://a/b/c/d;p?q", "../../../g", "http://a/g"}, 1223 {"http://a/b/c/d;p?q", "../../../../g", "http://a/g"}, 1224 {"http://a/b/c/d;p?q", "/./g", "http://a/g"}, 1225 {"http://a/b/c/d;p?q", "/../g", "http://a/g"}, 1226 {"http://a/b/c/d;p?q", "g.", "http://a/b/c/g."}, 1227 {"http://a/b/c/d;p?q", ".g", "http://a/b/c/.g"}, 1228 {"http://a/b/c/d;p?q", "g..", "http://a/b/c/g.."}, 1229 {"http://a/b/c/d;p?q", "..g", "http://a/b/c/..g"}, 1230 {"http://a/b/c/d;p?q", "./../g", "http://a/b/g"}, 1231 {"http://a/b/c/d;p?q", "./g/.", "http://a/b/c/g/"}, 1232 {"http://a/b/c/d;p?q", "g/./h", "http://a/b/c/g/h"}, 1233 {"http://a/b/c/d;p?q", "g/../h", "http://a/b/c/h"}, 1234 {"http://a/b/c/d;p?q", "g;x=1/./y", "http://a/b/c/g;x=1/y"}, 1235 {"http://a/b/c/d;p?q", "g;x=1/../y", "http://a/b/c/y"}, 1236 {"http://a/b/c/d;p?q", "g?y/./x", "http://a/b/c/g?y/./x"}, 1237 {"http://a/b/c/d;p?q", "g?y/../x", "http://a/b/c/g?y/../x"}, 1238 {"http://a/b/c/d;p?q", "g#s/./x", "http://a/b/c/g#s/./x"}, 1239 {"http://a/b/c/d;p?q", "g#s/../x", "http://a/b/c/g#s/../x"}, 1240 1241 // Extras. 1242 {"https://a/b/c/d;p?q", "//g?q", "https://g?q"}, 1243 {"https://a/b/c/d;p?q", "//g#s", "https://g#s"}, 1244 {"https://a/b/c/d;p?q", "//g/d/e/f?y#s", "https://g/d/e/f?y#s"}, 1245 {"https://a/b/c/d;p#s", "?y", "https://a/b/c/d;p?y"}, 1246 {"https://a/b/c/d;p?q#s", "?y", "https://a/b/c/d;p?y"}, 1247 } 1248 1249 func TestResolveReference(t *testing.T) { 1250 mustParse := func(url string) *URL { 1251 u, err := Parse(url) 1252 if err != nil { 1253 t.Fatalf("Parse(%q) got err %v", url, err) 1254 } 1255 return u 1256 } 1257 opaque := &URL{Scheme: "scheme", Opaque: "opaque"} 1258 for _, test := range resolveReferenceTests { 1259 base := mustParse(test.base) 1260 rel := mustParse(test.rel) 1261 url := base.ResolveReference(rel) 1262 if got := url.String(); got != test.expected { 1263 t.Errorf("URL(%q).ResolveReference(%q)\ngot %q\nwant %q", test.base, test.rel, got, test.expected) 1264 } 1265 // Ensure that new instances are returned. 1266 if base == url { 1267 t.Errorf("Expected URL.ResolveReference to return new URL instance.") 1268 } 1269 // Test the convenience wrapper too. 1270 url, err := base.Parse(test.rel) 1271 if err != nil { 1272 t.Errorf("URL(%q).Parse(%q) failed: %v", test.base, test.rel, err) 1273 } else if got := url.String(); got != test.expected { 1274 t.Errorf("URL(%q).Parse(%q)\ngot %q\nwant %q", test.base, test.rel, got, test.expected) 1275 } else if base == url { 1276 // Ensure that new instances are returned for the wrapper too. 1277 t.Errorf("Expected URL.Parse to return new URL instance.") 1278 } 1279 // Ensure Opaque resets the URL. 1280 url = base.ResolveReference(opaque) 1281 if *url != *opaque { 1282 t.Errorf("ResolveReference failed to resolve opaque URL:\ngot %#v\nwant %#v", url, opaque) 1283 } 1284 // Test the convenience wrapper with an opaque URL too. 1285 url, err = base.Parse("scheme:opaque") 1286 if err != nil { 1287 t.Errorf(`URL(%q).Parse("scheme:opaque") failed: %v`, test.base, err) 1288 } else if *url != *opaque { 1289 t.Errorf("Parse failed to resolve opaque URL:\ngot %#v\nwant %#v", opaque, url) 1290 } else if base == url { 1291 // Ensure that new instances are returned, again. 1292 t.Errorf("Expected URL.Parse to return new URL instance.") 1293 } 1294 } 1295 } 1296 1297 func TestQueryValues(t *testing.T) { 1298 u, _ := Parse("http://x.com?foo=bar&bar=1&bar=2&baz") 1299 v := u.Query() 1300 if len(v) != 3 { 1301 t.Errorf("got %d keys in Query values, want 3", len(v)) 1302 } 1303 if g, e := v.Get("foo"), "bar"; g != e { 1304 t.Errorf("Get(foo) = %q, want %q", g, e) 1305 } 1306 // Case sensitive: 1307 if g, e := v.Get("Foo"), ""; g != e { 1308 t.Errorf("Get(Foo) = %q, want %q", g, e) 1309 } 1310 if g, e := v.Get("bar"), "1"; g != e { 1311 t.Errorf("Get(bar) = %q, want %q", g, e) 1312 } 1313 if g, e := v.Get("baz"), ""; g != e { 1314 t.Errorf("Get(baz) = %q, want %q", g, e) 1315 } 1316 if h, e := v.Has("foo"), true; h != e { 1317 t.Errorf("Has(foo) = %t, want %t", h, e) 1318 } 1319 if h, e := v.Has("bar"), true; h != e { 1320 t.Errorf("Has(bar) = %t, want %t", h, e) 1321 } 1322 if h, e := v.Has("baz"), true; h != e { 1323 t.Errorf("Has(baz) = %t, want %t", h, e) 1324 } 1325 if h, e := v.Has("noexist"), false; h != e { 1326 t.Errorf("Has(noexist) = %t, want %t", h, e) 1327 } 1328 v.Del("bar") 1329 if g, e := v.Get("bar"), ""; g != e { 1330 t.Errorf("second Get(bar) = %q, want %q", g, e) 1331 } 1332 } 1333 1334 type parseTest struct { 1335 query string 1336 out Values 1337 ok bool 1338 } 1339 1340 var parseTests = []parseTest{ 1341 { 1342 query: "a=1", 1343 out: Values{"a": []string{"1"}}, 1344 ok: true, 1345 }, 1346 { 1347 query: "a=1&b=2", 1348 out: Values{"a": []string{"1"}, "b": []string{"2"}}, 1349 ok: true, 1350 }, 1351 { 1352 query: "a=1&a=2&a=banana", 1353 out: Values{"a": []string{"1", "2", "banana"}}, 1354 ok: true, 1355 }, 1356 { 1357 query: "ascii=%3Ckey%3A+0x90%3E", 1358 out: Values{"ascii": []string{"<key: 0x90>"}}, 1359 ok: true, 1360 }, { 1361 query: "a=1;b=2", 1362 out: Values{}, 1363 ok: false, 1364 }, { 1365 query: "a;b=1", 1366 out: Values{}, 1367 ok: false, 1368 }, { 1369 query: "a=%3B", // hex encoding for semicolon 1370 out: Values{"a": []string{";"}}, 1371 ok: true, 1372 }, 1373 { 1374 query: "a%3Bb=1", 1375 out: Values{"a;b": []string{"1"}}, 1376 ok: true, 1377 }, 1378 { 1379 query: "a=1&a=2;a=banana", 1380 out: Values{"a": []string{"1"}}, 1381 ok: false, 1382 }, 1383 { 1384 query: "a;b&c=1", 1385 out: Values{"c": []string{"1"}}, 1386 ok: false, 1387 }, 1388 { 1389 query: "a=1&b=2;a=3&c=4", 1390 out: Values{"a": []string{"1"}, "c": []string{"4"}}, 1391 ok: false, 1392 }, 1393 { 1394 query: "a=1&b=2;c=3", 1395 out: Values{"a": []string{"1"}}, 1396 ok: false, 1397 }, 1398 { 1399 query: ";", 1400 out: Values{}, 1401 ok: false, 1402 }, 1403 { 1404 query: "a=1;", 1405 out: Values{}, 1406 ok: false, 1407 }, 1408 { 1409 query: "a=1&;", 1410 out: Values{"a": []string{"1"}}, 1411 ok: false, 1412 }, 1413 { 1414 query: ";a=1&b=2", 1415 out: Values{"b": []string{"2"}}, 1416 ok: false, 1417 }, 1418 { 1419 query: "a=1&b=2;", 1420 out: Values{"a": []string{"1"}}, 1421 ok: false, 1422 }, 1423 } 1424 1425 func TestParseQuery(t *testing.T) { 1426 for _, test := range parseTests { 1427 t.Run(test.query, func(t *testing.T) { 1428 form, err := ParseQuery(test.query) 1429 if test.ok != (err == nil) { 1430 want := "<error>" 1431 if test.ok { 1432 want = "<nil>" 1433 } 1434 t.Errorf("Unexpected error: %v, want %v", err, want) 1435 } 1436 if len(form) != len(test.out) { 1437 t.Errorf("len(form) = %d, want %d", len(form), len(test.out)) 1438 } 1439 for k, evs := range test.out { 1440 vs, ok := form[k] 1441 if !ok { 1442 t.Errorf("Missing key %q", k) 1443 continue 1444 } 1445 if len(vs) != len(evs) { 1446 t.Errorf("len(form[%q]) = %d, want %d", k, len(vs), len(evs)) 1447 continue 1448 } 1449 for j, ev := range evs { 1450 if v := vs[j]; v != ev { 1451 t.Errorf("form[%q][%d] = %q, want %q", k, j, v, ev) 1452 } 1453 } 1454 } 1455 }) 1456 } 1457 } 1458 1459 type RequestURITest struct { 1460 url *URL 1461 out string 1462 } 1463 1464 var requritests = []RequestURITest{ 1465 { 1466 &URL{ 1467 Scheme: "http", 1468 Host: "example.com", 1469 Path: "", 1470 }, 1471 "/", 1472 }, 1473 { 1474 &URL{ 1475 Scheme: "http", 1476 Host: "example.com", 1477 Path: "/a b", 1478 }, 1479 "/a%20b", 1480 }, 1481 // golang.org/issue/4860 variant 1 1482 { 1483 &URL{ 1484 Scheme: "http", 1485 Host: "example.com", 1486 Opaque: "/%2F/%2F/", 1487 }, 1488 "/%2F/%2F/", 1489 }, 1490 // golang.org/issue/4860 variant 2 1491 { 1492 &URL{ 1493 Scheme: "http", 1494 Host: "example.com", 1495 Opaque: "//other.example.com/%2F/%2F/", 1496 }, 1497 "http://other.example.com/%2F/%2F/", 1498 }, 1499 // better fix for issue 4860 1500 { 1501 &URL{ 1502 Scheme: "http", 1503 Host: "example.com", 1504 Path: "/////", 1505 RawPath: "/%2F/%2F/", 1506 }, 1507 "/%2F/%2F/", 1508 }, 1509 { 1510 &URL{ 1511 Scheme: "http", 1512 Host: "example.com", 1513 Path: "/////", 1514 RawPath: "/WRONG/", // ignored because doesn't match Path 1515 }, 1516 "/////", 1517 }, 1518 { 1519 &URL{ 1520 Scheme: "http", 1521 Host: "example.com", 1522 Path: "/a b", 1523 RawQuery: "q=go+language", 1524 }, 1525 "/a%20b?q=go+language", 1526 }, 1527 { 1528 &URL{ 1529 Scheme: "http", 1530 Host: "example.com", 1531 Path: "/a b", 1532 RawPath: "/a b", // ignored because invalid 1533 RawQuery: "q=go+language", 1534 }, 1535 "/a%20b?q=go+language", 1536 }, 1537 { 1538 &URL{ 1539 Scheme: "http", 1540 Host: "example.com", 1541 Path: "/a?b", 1542 RawPath: "/a?b", // ignored because invalid 1543 RawQuery: "q=go+language", 1544 }, 1545 "/a%3Fb?q=go+language", 1546 }, 1547 { 1548 &URL{ 1549 Scheme: "myschema", 1550 Opaque: "opaque", 1551 }, 1552 "opaque", 1553 }, 1554 { 1555 &URL{ 1556 Scheme: "myschema", 1557 Opaque: "opaque", 1558 RawQuery: "q=go+language", 1559 }, 1560 "opaque?q=go+language", 1561 }, 1562 { 1563 &URL{ 1564 Scheme: "http", 1565 Host: "example.com", 1566 Path: "//foo", 1567 }, 1568 "//foo", 1569 }, 1570 { 1571 &URL{ 1572 Scheme: "http", 1573 Host: "example.com", 1574 Path: "/foo", 1575 ForceQuery: true, 1576 }, 1577 "/foo?", 1578 }, 1579 } 1580 1581 func TestRequestURI(t *testing.T) { 1582 for _, tt := range requritests { 1583 s := tt.url.RequestURI() 1584 if s != tt.out { 1585 t.Errorf("%#v.RequestURI() == %q (expected %q)", tt.url, s, tt.out) 1586 } 1587 } 1588 } 1589 1590 func TestParseFailure(t *testing.T) { 1591 // Test that the first parse error is returned. 1592 const url = "%gh&%ij" 1593 _, err := ParseQuery(url) 1594 errStr := fmt.Sprint(err) 1595 if !strings.Contains(errStr, "%gh") { 1596 t.Errorf(`ParseQuery(%q) returned error %q, want something containing %q"`, url, errStr, "%gh") 1597 } 1598 } 1599 1600 func TestParseErrors(t *testing.T) { 1601 tests := []struct { 1602 in string 1603 wantErr bool 1604 }{ 1605 {"http://[::1]", false}, 1606 {"http://[::1]:80", false}, 1607 {"http://[::1]:namedport", true}, // rfc3986 3.2.3 1608 {"http://x:namedport", true}, // rfc3986 3.2.3 1609 {"http://[::1]/", false}, 1610 {"http://[::1]a", true}, 1611 {"http://[::1]%23", true}, 1612 {"http://[::1%25en0]", false}, // valid zone id 1613 {"http://[::1]:", false}, // colon, but no port OK 1614 {"http://x:", false}, // colon, but no port OK 1615 {"http://[::1]:%38%30", true}, // not allowed: % encoding only for non-ASCII 1616 {"http://[::1%25%41]", false}, // RFC 6874 allows over-escaping in zone 1617 {"http://[%10::1]", true}, // no %xx escapes in IP address 1618 {"http://[::1]/%48", false}, // %xx in path is fine 1619 {"http://%41:8080/", true}, // not allowed: % encoding only for non-ASCII 1620 {"mysql://x@y(z:123)/foo", true}, // not well-formed per RFC 3986, golang.org/issue/33646 1621 {"mysql://x@y(1.2.3.4:123)/foo", true}, 1622 1623 {" http://foo.com", true}, // invalid character in schema 1624 {"ht tp://foo.com", true}, // invalid character in schema 1625 {"ahttp://foo.com", false}, // valid schema characters 1626 {"1http://foo.com", true}, // invalid character in schema 1627 1628 {"http://[]%20%48%54%54%50%2f%31%2e%31%0a%4d%79%48%65%61%64%65%72%3a%20%31%32%33%0a%0a/", true}, // golang.org/issue/11208 1629 {"http://a b.com/", true}, // no space in host name please 1630 {"cache_object://foo", true}, // scheme cannot have _, relative path cannot have : in first segment 1631 {"cache_object:foo", true}, 1632 {"cache_object:foo/bar", true}, 1633 {"cache_object/:foo/bar", false}, 1634 } 1635 for _, tt := range tests { 1636 u, err := Parse(tt.in) 1637 if tt.wantErr { 1638 if err == nil { 1639 t.Errorf("Parse(%q) = %#v; want an error", tt.in, u) 1640 } 1641 continue 1642 } 1643 if err != nil { 1644 t.Errorf("Parse(%q) = %v; want no error", tt.in, err) 1645 } 1646 } 1647 } 1648 1649 // Issue 11202 1650 func TestStarRequest(t *testing.T) { 1651 u, err := Parse("*") 1652 if err != nil { 1653 t.Fatal(err) 1654 } 1655 if got, want := u.RequestURI(), "*"; got != want { 1656 t.Errorf("RequestURI = %q; want %q", got, want) 1657 } 1658 } 1659 1660 type shouldEscapeTest struct { 1661 in byte 1662 mode encoding 1663 escape bool 1664 } 1665 1666 var shouldEscapeTests = []shouldEscapeTest{ 1667 // Unreserved characters (§2.3) 1668 {'a', encodePath, false}, 1669 {'a', encodeUserPassword, false}, 1670 {'a', encodeQueryComponent, false}, 1671 {'a', encodeFragment, false}, 1672 {'a', encodeHost, false}, 1673 {'z', encodePath, false}, 1674 {'A', encodePath, false}, 1675 {'Z', encodePath, false}, 1676 {'0', encodePath, false}, 1677 {'9', encodePath, false}, 1678 {'-', encodePath, false}, 1679 {'-', encodeUserPassword, false}, 1680 {'-', encodeQueryComponent, false}, 1681 {'-', encodeFragment, false}, 1682 {'.', encodePath, false}, 1683 {'_', encodePath, false}, 1684 {'~', encodePath, false}, 1685 1686 // User information (§3.2.1) 1687 {':', encodeUserPassword, true}, 1688 {'/', encodeUserPassword, true}, 1689 {'?', encodeUserPassword, true}, 1690 {'@', encodeUserPassword, true}, 1691 {'$', encodeUserPassword, false}, 1692 {'&', encodeUserPassword, false}, 1693 {'+', encodeUserPassword, false}, 1694 {',', encodeUserPassword, false}, 1695 {';', encodeUserPassword, false}, 1696 {'=', encodeUserPassword, false}, 1697 1698 // Host (IP address, IPv6 address, registered name, port suffix; §3.2.2) 1699 {'!', encodeHost, false}, 1700 {'$', encodeHost, false}, 1701 {'&', encodeHost, false}, 1702 {'\'', encodeHost, false}, 1703 {'(', encodeHost, false}, 1704 {')', encodeHost, false}, 1705 {'*', encodeHost, false}, 1706 {'+', encodeHost, false}, 1707 {',', encodeHost, false}, 1708 {';', encodeHost, false}, 1709 {'=', encodeHost, false}, 1710 {':', encodeHost, false}, 1711 {'[', encodeHost, false}, 1712 {']', encodeHost, false}, 1713 {'0', encodeHost, false}, 1714 {'9', encodeHost, false}, 1715 {'A', encodeHost, false}, 1716 {'z', encodeHost, false}, 1717 {'_', encodeHost, false}, 1718 {'-', encodeHost, false}, 1719 {'.', encodeHost, false}, 1720 } 1721 1722 func TestShouldEscape(t *testing.T) { 1723 for _, tt := range shouldEscapeTests { 1724 if shouldEscape(tt.in, tt.mode) != tt.escape { 1725 t.Errorf("shouldEscape(%q, %v) returned %v; expected %v", tt.in, tt.mode, !tt.escape, tt.escape) 1726 } 1727 } 1728 } 1729 1730 type timeoutError struct { 1731 timeout bool 1732 } 1733 1734 func (e *timeoutError) Error() string { return "timeout error" } 1735 func (e *timeoutError) Timeout() bool { return e.timeout } 1736 1737 type temporaryError struct { 1738 temporary bool 1739 } 1740 1741 func (e *temporaryError) Error() string { return "temporary error" } 1742 func (e *temporaryError) Temporary() bool { return e.temporary } 1743 1744 type timeoutTemporaryError struct { 1745 timeoutError 1746 temporaryError 1747 } 1748 1749 func (e *timeoutTemporaryError) Error() string { return "timeout/temporary error" } 1750 1751 var netErrorTests = []struct { 1752 err error 1753 timeout bool 1754 temporary bool 1755 }{{ 1756 err: &Error{"Get", "http://google.com/", &timeoutError{timeout: true}}, 1757 timeout: true, 1758 temporary: false, 1759 }, { 1760 err: &Error{"Get", "http://google.com/", &timeoutError{timeout: false}}, 1761 timeout: false, 1762 temporary: false, 1763 }, { 1764 err: &Error{"Get", "http://google.com/", &temporaryError{temporary: true}}, 1765 timeout: false, 1766 temporary: true, 1767 }, { 1768 err: &Error{"Get", "http://google.com/", &temporaryError{temporary: false}}, 1769 timeout: false, 1770 temporary: false, 1771 }, { 1772 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: true}, temporaryError{temporary: true}}}, 1773 timeout: true, 1774 temporary: true, 1775 }, { 1776 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: false}, temporaryError{temporary: true}}}, 1777 timeout: false, 1778 temporary: true, 1779 }, { 1780 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: true}, temporaryError{temporary: false}}}, 1781 timeout: true, 1782 temporary: false, 1783 }, { 1784 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: false}, temporaryError{temporary: false}}}, 1785 timeout: false, 1786 temporary: false, 1787 }, { 1788 err: &Error{"Get", "http://google.com/", io.EOF}, 1789 timeout: false, 1790 temporary: false, 1791 }} 1792 1793 // Test that url.Error implements net.Error and that it forwards 1794 func TestURLErrorImplementsNetError(t *testing.T) { 1795 for i, tt := range netErrorTests { 1796 err, ok := tt.err.(net.Error) 1797 if !ok { 1798 t.Errorf("%d: %T does not implement net.Error", i+1, tt.err) 1799 continue 1800 } 1801 if err.Timeout() != tt.timeout { 1802 t.Errorf("%d: err.Timeout(): got %v, want %v", i+1, err.Timeout(), tt.timeout) 1803 continue 1804 } 1805 if err.Temporary() != tt.temporary { 1806 t.Errorf("%d: err.Temporary(): got %v, want %v", i+1, err.Temporary(), tt.temporary) 1807 } 1808 } 1809 } 1810 1811 func TestURLHostnameAndPort(t *testing.T) { 1812 tests := []struct { 1813 in string // URL.Host field 1814 host string 1815 port string 1816 }{ 1817 {"foo.com:80", "foo.com", "80"}, 1818 {"foo.com", "foo.com", ""}, 1819 {"foo.com:", "foo.com", ""}, 1820 {"FOO.COM", "FOO.COM", ""}, // no canonicalization 1821 {"1.2.3.4", "1.2.3.4", ""}, 1822 {"1.2.3.4:80", "1.2.3.4", "80"}, 1823 {"[1:2:3:4]", "1:2:3:4", ""}, 1824 {"[1:2:3:4]:80", "1:2:3:4", "80"}, 1825 {"[::1]:80", "::1", "80"}, 1826 {"[::1]", "::1", ""}, 1827 {"[::1]:", "::1", ""}, 1828 {"localhost", "localhost", ""}, 1829 {"localhost:443", "localhost", "443"}, 1830 {"some.super.long.domain.example.org:8080", "some.super.long.domain.example.org", "8080"}, 1831 {"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:17000", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "17000"}, 1832 {"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", ""}, 1833 1834 // Ensure that even when not valid, Host is one of "Hostname", 1835 // "Hostname:Port", "[Hostname]" or "[Hostname]:Port". 1836 // See https://golang.org/issue/29098. 1837 {"[google.com]:80", "google.com", "80"}, 1838 {"google.com]:80", "google.com]", "80"}, 1839 {"google.com:80_invalid_port", "google.com:80_invalid_port", ""}, 1840 {"[::1]extra]:80", "::1]extra", "80"}, 1841 {"google.com]extra:extra", "google.com]extra:extra", ""}, 1842 } 1843 for _, tt := range tests { 1844 u := &URL{Host: tt.in} 1845 host, port := u.Hostname(), u.Port() 1846 if host != tt.host { 1847 t.Errorf("Hostname for Host %q = %q; want %q", tt.in, host, tt.host) 1848 } 1849 if port != tt.port { 1850 t.Errorf("Port for Host %q = %q; want %q", tt.in, port, tt.port) 1851 } 1852 } 1853 } 1854 1855 var _ encodingPkg.BinaryMarshaler = (*URL)(nil) 1856 var _ encodingPkg.BinaryUnmarshaler = (*URL)(nil) 1857 1858 func TestJSON(t *testing.T) { 1859 u, err := Parse("https://www.google.com/x?y=z") 1860 if err != nil { 1861 t.Fatal(err) 1862 } 1863 js, err := json.Marshal(u) 1864 if err != nil { 1865 t.Fatal(err) 1866 } 1867 1868 // If only we could implement TextMarshaler/TextUnmarshaler, 1869 // this would work: 1870 // 1871 // if string(js) != strconv.Quote(u.String()) { 1872 // t.Errorf("json encoding: %s\nwant: %s\n", js, strconv.Quote(u.String())) 1873 // } 1874 1875 u1 := new(URL) 1876 err = json.Unmarshal(js, u1) 1877 if err != nil { 1878 t.Fatal(err) 1879 } 1880 if u1.String() != u.String() { 1881 t.Errorf("json decoded to: %s\nwant: %s\n", u1, u) 1882 } 1883 } 1884 1885 func TestGob(t *testing.T) { 1886 u, err := Parse("https://www.google.com/x?y=z") 1887 if err != nil { 1888 t.Fatal(err) 1889 } 1890 var w bytes.Buffer 1891 err = gob.NewEncoder(&w).Encode(u) 1892 if err != nil { 1893 t.Fatal(err) 1894 } 1895 1896 u1 := new(URL) 1897 err = gob.NewDecoder(&w).Decode(u1) 1898 if err != nil { 1899 t.Fatal(err) 1900 } 1901 if u1.String() != u.String() { 1902 t.Errorf("json decoded to: %s\nwant: %s\n", u1, u) 1903 } 1904 } 1905 1906 func TestNilUser(t *testing.T) { 1907 defer func() { 1908 if v := recover(); v != nil { 1909 t.Fatalf("unexpected panic: %v", v) 1910 } 1911 }() 1912 1913 u, err := Parse("http://foo.com/") 1914 1915 if err != nil { 1916 t.Fatalf("parse err: %v", err) 1917 } 1918 1919 if v := u.User.Username(); v != "" { 1920 t.Fatalf("expected empty username, got %s", v) 1921 } 1922 1923 if v, ok := u.User.Password(); v != "" || ok { 1924 t.Fatalf("expected empty password, got %s (%v)", v, ok) 1925 } 1926 1927 if v := u.User.String(); v != "" { 1928 t.Fatalf("expected empty string, got %s", v) 1929 } 1930 } 1931 1932 func TestInvalidUserPassword(t *testing.T) { 1933 _, err := Parse("http://user^:passwo^rd@foo.com/") 1934 if got, wantsub := fmt.Sprint(err), "net/url: invalid userinfo"; !strings.Contains(got, wantsub) { 1935 t.Errorf("error = %q; want substring %q", got, wantsub) 1936 } 1937 } 1938 1939 func TestRejectControlCharacters(t *testing.T) { 1940 tests := []string{ 1941 "http://foo.com/?foo\nbar", 1942 "http\r://foo.com/", 1943 "http://foo\x7f.com/", 1944 } 1945 for _, s := range tests { 1946 _, err := Parse(s) 1947 const wantSub = "net/url: invalid control character in URL" 1948 if got := fmt.Sprint(err); !strings.Contains(got, wantSub) { 1949 t.Errorf("Parse(%q) error = %q; want substring %q", s, got, wantSub) 1950 } 1951 } 1952 1953 // But don't reject non-ASCII CTLs, at least for now: 1954 if _, err := Parse("http://foo.com/ctl\x80"); err != nil { 1955 t.Errorf("error parsing URL with non-ASCII control byte: %v", err) 1956 } 1957 1958 } 1959 1960 var escapeBenchmarks = []struct { 1961 unescaped string 1962 query string 1963 path string 1964 }{ 1965 { 1966 unescaped: "one two", 1967 query: "one+two", 1968 path: "one%20two", 1969 }, 1970 { 1971 unescaped: "Фотки собак", 1972 query: "%D0%A4%D0%BE%D1%82%D0%BA%D0%B8+%D1%81%D0%BE%D0%B1%D0%B0%D0%BA", 1973 path: "%D0%A4%D0%BE%D1%82%D0%BA%D0%B8%20%D1%81%D0%BE%D0%B1%D0%B0%D0%BA", 1974 }, 1975 1976 { 1977 unescaped: "shortrun(break)shortrun", 1978 query: "shortrun%28break%29shortrun", 1979 path: "shortrun%28break%29shortrun", 1980 }, 1981 1982 { 1983 unescaped: "longerrunofcharacters(break)anotherlongerrunofcharacters", 1984 query: "longerrunofcharacters%28break%29anotherlongerrunofcharacters", 1985 path: "longerrunofcharacters%28break%29anotherlongerrunofcharacters", 1986 }, 1987 1988 { 1989 unescaped: strings.Repeat("padded/with+various%characters?that=need$some@escaping+paddedsowebreak/256bytes", 4), 1990 query: strings.Repeat("padded%2Fwith%2Bvarious%25characters%3Fthat%3Dneed%24some%40escaping%2Bpaddedsowebreak%2F256bytes", 4), 1991 path: strings.Repeat("padded%2Fwith+various%25characters%3Fthat=need$some@escaping+paddedsowebreak%2F256bytes", 4), 1992 }, 1993 } 1994 1995 func BenchmarkQueryEscape(b *testing.B) { 1996 for _, tc := range escapeBenchmarks { 1997 b.Run("", func(b *testing.B) { 1998 b.ReportAllocs() 1999 var g string 2000 for i := 0; i < b.N; i++ { 2001 g = QueryEscape(tc.unescaped) 2002 } 2003 b.StopTimer() 2004 if g != tc.query { 2005 b.Errorf("QueryEscape(%q) == %q, want %q", tc.unescaped, g, tc.query) 2006 } 2007 2008 }) 2009 } 2010 } 2011 2012 func BenchmarkPathEscape(b *testing.B) { 2013 for _, tc := range escapeBenchmarks { 2014 b.Run("", func(b *testing.B) { 2015 b.ReportAllocs() 2016 var g string 2017 for i := 0; i < b.N; i++ { 2018 g = PathEscape(tc.unescaped) 2019 } 2020 b.StopTimer() 2021 if g != tc.path { 2022 b.Errorf("PathEscape(%q) == %q, want %q", tc.unescaped, g, tc.path) 2023 } 2024 2025 }) 2026 } 2027 } 2028 2029 func BenchmarkQueryUnescape(b *testing.B) { 2030 for _, tc := range escapeBenchmarks { 2031 b.Run("", func(b *testing.B) { 2032 b.ReportAllocs() 2033 var g string 2034 for i := 0; i < b.N; i++ { 2035 g, _ = QueryUnescape(tc.query) 2036 } 2037 b.StopTimer() 2038 if g != tc.unescaped { 2039 b.Errorf("QueryUnescape(%q) == %q, want %q", tc.query, g, tc.unescaped) 2040 } 2041 2042 }) 2043 } 2044 } 2045 2046 func BenchmarkPathUnescape(b *testing.B) { 2047 for _, tc := range escapeBenchmarks { 2048 b.Run("", func(b *testing.B) { 2049 b.ReportAllocs() 2050 var g string 2051 for i := 0; i < b.N; i++ { 2052 g, _ = PathUnescape(tc.path) 2053 } 2054 b.StopTimer() 2055 if g != tc.unescaped { 2056 b.Errorf("PathUnescape(%q) == %q, want %q", tc.path, g, tc.unescaped) 2057 } 2058 2059 }) 2060 } 2061 } 2062 2063 var sink string 2064 2065 func BenchmarkSplit(b *testing.B) { 2066 url := "http://www.google.com/?q=go+language#foo%26bar" 2067 for i := 0; i < b.N; i++ { 2068 sink, sink = split(url, '#', true) 2069 } 2070 }