Source file src/net/url/url_test.go

Documentation: net/url

		 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://[email protected]/",
		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%[email protected]/",
		83  		&URL{
		84  			Scheme: "ftp",
		85  			User:	 User("john doe"),
		86  			Host:	 "www.google.com",
		87  			Path:	 "/",
		88  		},
		89  		"ftp://john%[email protected]/",
		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:/[email protected]",
	 169  		&URL{
	 170  			Scheme: "mailto",
	 171  			Path:	 "/[email protected]",
	 172  		},
	 173  		"mailto:///[email protected]", // unfortunate compromise
	 174  	},
	 175  	// non-authority
	 176  	{
	 177  		"mailto:[email protected]",
	 178  		&URL{
	 179  			Scheme: "mailto",
	 180  			Opaque: "[email protected]",
	 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:[email protected]",
	 226  		&URL{
	 227  			Scheme: "http",
	 228  			User:	 UserPassword("user", "password"),
	 229  			Host:	 "google.com",
	 230  		},
	 231  		"http://user:[email protected]",
	 232  	},
	 233  	// unescaped @ in username should not confuse host
	 234  	{
	 235  		"http://j@ne:[email protected]",
	 236  		&URL{
	 237  			Scheme: "http",
	 238  			User:	 UserPassword("j@ne", "password"),
	 239  			Host:	 "google.com",
	 240  		},
	 241  		"http://j%40ne:[email protected]",
	 242  	},
	 243  	// unescaped @ in password should not confuse host
	 244  	{
	 245  		"http://jane:p@[email protected]",
	 246  		&URL{
	 247  			Scheme: "http",
	 248  			User:	 UserPassword("jane", "p@ssword"),
	 249  			Host:	 "google.com",
	 250  		},
	 251  		"http://jane:p%[email protected]",
	 252  	},
	 253  	{
	 254  		"http://j@ne:[email protected]/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:[email protected]/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:[email protected]",
	 321  		&URL{
	 322  			Scheme: "mailto",
	 323  			Opaque: "[email protected]",
	 324  		},
	 325  		"mailto:[email protected]",
	 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%[email protected]",
	 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 = "//[email protected]/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:[email protected]/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://[email protected]/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://:[email protected]/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:[email protected]", "mailto:[email protected]"},
	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^[email protected]/")
	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  }
	2071  

View as plain text