Source file
src/net/url/url_test.go
Documentation: net/url
1
2
3
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
23 roundtrip string
24 }
25
26 var urltests = []URLTest{
27
28 {
29 "http://www.google.com",
30 &URL{
31 Scheme: "http",
32 Host: "www.google.com",
33 },
34 "",
35 },
36
37 {
38 "http://www.google.com/",
39 &URL{
40 Scheme: "http",
41 Host: "www.google.com",
42 Path: "/",
43 },
44 "",
45 },
46
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
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
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
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
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
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
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
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
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
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
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
167 {
168 "mailto:/webmaster@golang.org",
169 &URL{
170 Scheme: "mailto",
171 Path: "/webmaster@golang.org",
172 },
173 "mailto:///webmaster@golang.org",
174 },
175
176 {
177 "mailto:webmaster@golang.org",
178 &URL{
179 Scheme: "mailto",
180 Opaque: "webmaster@golang.org",
181 },
182 "",
183 },
184
185 {
186 "/foo?query=http://bad",
187 &URL{
188 Path: "/foo",
189 RawQuery: "query=http://bad",
190 },
191 "",
192 },
193
194 {
195 "//foo",
196 &URL{
197 Host: "foo",
198 },
199 "",
200 },
201
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
213
214
215
216
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
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
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
308
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
319 {
320 "MaIlTo:webmaster@golang.org",
321 &URL{
322 Scheme: "mailto",
323 Opaque: "webmaster@golang.org",
324 },
325 "mailto:webmaster@golang.org",
326 },
327
328 {
329 "a/b/c",
330 &URL{
331 Path: "a/b/c",
332 },
333 "a/b/c",
334 },
335
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
346 {
347 "http://192.168.0.1/",
348 &URL{
349 Scheme: "http",
350 Host: "192.168.0.1",
351 Path: "/",
352 },
353 "",
354 },
355
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
366 {
367 "http://[fe80::1]/",
368 &URL{
369 Scheme: "http",
370 Host: "[fe80::1]",
371 Path: "/",
372 },
373 "",
374 },
375
376 {
377 "http://[fe80::1]:8080/",
378 &URL{
379 Scheme: "http",
380 Host: "[fe80::1]:8080",
381 Path: "/",
382 },
383 "",
384 },
385
386 {
387 "http://[fe80::1%25en0]/",
388 &URL{
389 Scheme: "http",
390 Host: "[fe80::1%en0]",
391 Path: "/",
392 },
393 "",
394 },
395
396 {
397 "http://[fe80::1%25en0]:8080/",
398 &URL{
399 Scheme: "http",
400 Host: "[fe80::1%en0]:8080",
401 Path: "/",
402 },
403 "",
404 },
405
406 {
407 "http://[fe80::1%25%65%6e%301-._~]/",
408 &URL{
409 Scheme: "http",
410 Host: "[fe80::1%en01-._~]",
411 Path: "/",
412 },
413 "http://[fe80::1%25en01-._~]/",
414 },
415
416 {
417 "http://[fe80::1%25%65%6e%301-._~]:8080/",
418 &URL{
419 Scheme: "http",
420 Host: "[fe80::1%en01-._~]:8080",
421 Path: "/",
422 },
423 "http://[fe80::1%25en01-._~]:8080/",
424 },
425
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
438 {
439 "mysql://a,b,c/bar",
440 &URL{
441 Scheme: "mysql",
442 Host: "a,b,c",
443 Path: "/bar",
444 },
445 "",
446 },
447
448 {
449 "scheme://!$&'()*+,;=hello!:1/path",
450 &URL{
451 Scheme: "scheme",
452 Host: "!$&'()*+,;=hello!:1",
453 Path: "/path",
454 },
455 "",
456 },
457
458 {
459 "http://host/!$&'()*+,;=:@[hello]",
460 &URL{
461 Scheme: "http",
462 Host: "host",
463 Path: "/!$&'()*+,;=:@[hello]",
464 RawPath: "/!$&'()*+,;=:@[hello]",
465 },
466 "",
467 },
468
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
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
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
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
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
565 {
566 "http://example.com//foo",
567 &URL{
568 Scheme: "http",
569 Host: "example.com",
570 Path: "//foo",
571 },
572 "",
573 },
574
575 {
576 "myscheme://authority<\"hi\">/foo",
577 &URL{
578 Scheme: "myscheme",
579 Host: "authority<\"hi\">",
580 Path: "/foo",
581 },
582 "",
583 },
584
585
586
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
596
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
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
688 {"http://[fe80::1%25en0]/", true},
689 {"http://[fe80::1%25en0]:8080/", true},
690 {"http://[fe80::1%25%65%6e%301-._~]/", true},
691 {"http://[fe80::1%25%65%6e%301-._~]:8080/", true},
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
704
705
706
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
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
744 {
745 url: URL{
746 Path: "this:that",
747 },
748 want: "./this:that",
749 },
750
751 {
752 url: URL{
753 Path: "here/this:that",
754 },
755 want: "here/this:that",
756 },
757
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 "%",
898 "",
899 EscapeError("%"),
900 },
901 {
902 "%a",
903 "",
904 EscapeError("%a"),
905 },
906 {
907 "%1",
908 "",
909 EscapeError("%1"),
910 },
911 {
912 "123%45%6",
913 "",
914 EscapeError("%6"),
915 },
916 {
917 "%zzzzz",
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
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
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
1062
1063
1064
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
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
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
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
1145 {"https://foo.com/bar?a=b", "//bar.com/quux", "https://bar.com/quux"},
1146
1147
1148
1149
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
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
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
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
1175
1176 {"http://foo.com/dot/./dotdot/../foo/bar", "../baz", "http://foo.com/dot/baz"},
1177
1178
1179 {"http://foo.com/bar", "...", "http://foo.com/..."},
1180
1181
1182 {"http://foo.com/bar", ".#frag", "http://foo.com/#frag"},
1183 {"http://example.org/", "#!$&%27()*+,;=", "http://example.org/#!$&%27()*+,;="},
1184
1185
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
1195
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
1221
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
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
1266 if base == url {
1267 t.Errorf("Expected URL.ResolveReference to return new URL instance.")
1268 }
1269
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
1277 t.Errorf("Expected URL.Parse to return new URL instance.")
1278 }
1279
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
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
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")
1299 v := u.Query()
1300 if len(v) != 2 {
1301 t.Errorf("got %d keys in Query values, want 2", 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
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 v.Del("bar")
1317 if g, e := v.Get("bar"), ""; g != e {
1318 t.Errorf("second Get(bar) = %q, want %q", g, e)
1319 }
1320 }
1321
1322 type parseTest struct {
1323 query string
1324 out Values
1325 }
1326
1327 var parseTests = []parseTest{
1328 {
1329 query: "a=1&b=2",
1330 out: Values{"a": []string{"1"}, "b": []string{"2"}},
1331 },
1332 {
1333 query: "a=1&a=2&a=banana",
1334 out: Values{"a": []string{"1", "2", "banana"}},
1335 },
1336 {
1337 query: "ascii=%3Ckey%3A+0x90%3E",
1338 out: Values{"ascii": []string{"<key: 0x90>"}},
1339 },
1340 {
1341 query: "a=1;b=2",
1342 out: Values{"a": []string{"1"}, "b": []string{"2"}},
1343 },
1344 {
1345 query: "a=1&a=2;a=banana",
1346 out: Values{"a": []string{"1", "2", "banana"}},
1347 },
1348 }
1349
1350 func TestParseQuery(t *testing.T) {
1351 for i, test := range parseTests {
1352 form, err := ParseQuery(test.query)
1353 if err != nil {
1354 t.Errorf("test %d: Unexpected error: %v", i, err)
1355 continue
1356 }
1357 if len(form) != len(test.out) {
1358 t.Errorf("test %d: len(form) = %d, want %d", i, len(form), len(test.out))
1359 }
1360 for k, evs := range test.out {
1361 vs, ok := form[k]
1362 if !ok {
1363 t.Errorf("test %d: Missing key %q", i, k)
1364 continue
1365 }
1366 if len(vs) != len(evs) {
1367 t.Errorf("test %d: len(form[%q]) = %d, want %d", i, k, len(vs), len(evs))
1368 continue
1369 }
1370 for j, ev := range evs {
1371 if v := vs[j]; v != ev {
1372 t.Errorf("test %d: form[%q][%d] = %q, want %q", i, k, j, v, ev)
1373 }
1374 }
1375 }
1376 }
1377 }
1378
1379 type RequestURITest struct {
1380 url *URL
1381 out string
1382 }
1383
1384 var requritests = []RequestURITest{
1385 {
1386 &URL{
1387 Scheme: "http",
1388 Host: "example.com",
1389 Path: "",
1390 },
1391 "/",
1392 },
1393 {
1394 &URL{
1395 Scheme: "http",
1396 Host: "example.com",
1397 Path: "/a b",
1398 },
1399 "/a%20b",
1400 },
1401
1402 {
1403 &URL{
1404 Scheme: "http",
1405 Host: "example.com",
1406 Opaque: "/%2F/%2F/",
1407 },
1408 "/%2F/%2F/",
1409 },
1410
1411 {
1412 &URL{
1413 Scheme: "http",
1414 Host: "example.com",
1415 Opaque: "//other.example.com/%2F/%2F/",
1416 },
1417 "http://other.example.com/%2F/%2F/",
1418 },
1419
1420 {
1421 &URL{
1422 Scheme: "http",
1423 Host: "example.com",
1424 Path: "/////",
1425 RawPath: "/%2F/%2F/",
1426 },
1427 "/%2F/%2F/",
1428 },
1429 {
1430 &URL{
1431 Scheme: "http",
1432 Host: "example.com",
1433 Path: "/////",
1434 RawPath: "/WRONG/",
1435 },
1436 "/////",
1437 },
1438 {
1439 &URL{
1440 Scheme: "http",
1441 Host: "example.com",
1442 Path: "/a b",
1443 RawQuery: "q=go+language",
1444 },
1445 "/a%20b?q=go+language",
1446 },
1447 {
1448 &URL{
1449 Scheme: "http",
1450 Host: "example.com",
1451 Path: "/a b",
1452 RawPath: "/a b",
1453 RawQuery: "q=go+language",
1454 },
1455 "/a%20b?q=go+language",
1456 },
1457 {
1458 &URL{
1459 Scheme: "http",
1460 Host: "example.com",
1461 Path: "/a?b",
1462 RawPath: "/a?b",
1463 RawQuery: "q=go+language",
1464 },
1465 "/a%3Fb?q=go+language",
1466 },
1467 {
1468 &URL{
1469 Scheme: "myschema",
1470 Opaque: "opaque",
1471 },
1472 "opaque",
1473 },
1474 {
1475 &URL{
1476 Scheme: "myschema",
1477 Opaque: "opaque",
1478 RawQuery: "q=go+language",
1479 },
1480 "opaque?q=go+language",
1481 },
1482 {
1483 &URL{
1484 Scheme: "http",
1485 Host: "example.com",
1486 Path: "//foo",
1487 },
1488 "//foo",
1489 },
1490 {
1491 &URL{
1492 Scheme: "http",
1493 Host: "example.com",
1494 Path: "/foo",
1495 ForceQuery: true,
1496 },
1497 "/foo?",
1498 },
1499 }
1500
1501 func TestRequestURI(t *testing.T) {
1502 for _, tt := range requritests {
1503 s := tt.url.RequestURI()
1504 if s != tt.out {
1505 t.Errorf("%#v.RequestURI() == %q (expected %q)", tt.url, s, tt.out)
1506 }
1507 }
1508 }
1509
1510 func TestParseFailure(t *testing.T) {
1511
1512 const url = "%gh&%ij"
1513 _, err := ParseQuery(url)
1514 errStr := fmt.Sprint(err)
1515 if !strings.Contains(errStr, "%gh") {
1516 t.Errorf(`ParseQuery(%q) returned error %q, want something containing %q"`, url, errStr, "%gh")
1517 }
1518 }
1519
1520 func TestParseErrors(t *testing.T) {
1521 tests := []struct {
1522 in string
1523 wantErr bool
1524 }{
1525 {"http://[::1]", false},
1526 {"http://[::1]:80", false},
1527 {"http://[::1]:namedport", true},
1528 {"http://x:namedport", true},
1529 {"http://[::1]/", false},
1530 {"http://[::1]a", true},
1531 {"http://[::1]%23", true},
1532 {"http://[::1%25en0]", false},
1533 {"http://[::1]:", false},
1534 {"http://x:", false},
1535 {"http://[::1]:%38%30", true},
1536 {"http://[::1%25%41]", false},
1537 {"http://[%10::1]", true},
1538 {"http://[::1]/%48", false},
1539 {"http://%41:8080/", true},
1540 {"mysql://x@y(z:123)/foo", true},
1541 {"mysql://x@y(1.2.3.4:123)/foo", true},
1542
1543 {" http://foo.com", true},
1544 {"ht tp://foo.com", true},
1545 {"ahttp://foo.com", false},
1546 {"1http://foo.com", true},
1547
1548 {"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},
1549 {"http://a b.com/", true},
1550 {"cache_object://foo", true},
1551 {"cache_object:foo", true},
1552 {"cache_object:foo/bar", true},
1553 {"cache_object/:foo/bar", false},
1554 }
1555 for _, tt := range tests {
1556 u, err := Parse(tt.in)
1557 if tt.wantErr {
1558 if err == nil {
1559 t.Errorf("Parse(%q) = %#v; want an error", tt.in, u)
1560 }
1561 continue
1562 }
1563 if err != nil {
1564 t.Errorf("Parse(%q) = %v; want no error", tt.in, err)
1565 }
1566 }
1567 }
1568
1569
1570 func TestStarRequest(t *testing.T) {
1571 u, err := Parse("*")
1572 if err != nil {
1573 t.Fatal(err)
1574 }
1575 if got, want := u.RequestURI(), "*"; got != want {
1576 t.Errorf("RequestURI = %q; want %q", got, want)
1577 }
1578 }
1579
1580 type shouldEscapeTest struct {
1581 in byte
1582 mode encoding
1583 escape bool
1584 }
1585
1586 var shouldEscapeTests = []shouldEscapeTest{
1587
1588 {'a', encodePath, false},
1589 {'a', encodeUserPassword, false},
1590 {'a', encodeQueryComponent, false},
1591 {'a', encodeFragment, false},
1592 {'a', encodeHost, false},
1593 {'z', encodePath, false},
1594 {'A', encodePath, false},
1595 {'Z', encodePath, false},
1596 {'0', encodePath, false},
1597 {'9', encodePath, false},
1598 {'-', encodePath, false},
1599 {'-', encodeUserPassword, false},
1600 {'-', encodeQueryComponent, false},
1601 {'-', encodeFragment, false},
1602 {'.', encodePath, false},
1603 {'_', encodePath, false},
1604 {'~', encodePath, false},
1605
1606
1607 {':', encodeUserPassword, true},
1608 {'/', encodeUserPassword, true},
1609 {'?', encodeUserPassword, true},
1610 {'@', encodeUserPassword, true},
1611 {'$', encodeUserPassword, false},
1612 {'&', encodeUserPassword, false},
1613 {'+', encodeUserPassword, false},
1614 {',', encodeUserPassword, false},
1615 {';', encodeUserPassword, false},
1616 {'=', encodeUserPassword, false},
1617
1618
1619 {'!', encodeHost, false},
1620 {'$', encodeHost, false},
1621 {'&', encodeHost, false},
1622 {'\'', encodeHost, false},
1623 {'(', encodeHost, false},
1624 {')', encodeHost, false},
1625 {'*', encodeHost, false},
1626 {'+', encodeHost, false},
1627 {',', encodeHost, false},
1628 {';', encodeHost, false},
1629 {'=', encodeHost, false},
1630 {':', encodeHost, false},
1631 {'[', encodeHost, false},
1632 {']', encodeHost, false},
1633 {'0', encodeHost, false},
1634 {'9', encodeHost, false},
1635 {'A', encodeHost, false},
1636 {'z', encodeHost, false},
1637 {'_', encodeHost, false},
1638 {'-', encodeHost, false},
1639 {'.', encodeHost, false},
1640 }
1641
1642 func TestShouldEscape(t *testing.T) {
1643 for _, tt := range shouldEscapeTests {
1644 if shouldEscape(tt.in, tt.mode) != tt.escape {
1645 t.Errorf("shouldEscape(%q, %v) returned %v; expected %v", tt.in, tt.mode, !tt.escape, tt.escape)
1646 }
1647 }
1648 }
1649
1650 type timeoutError struct {
1651 timeout bool
1652 }
1653
1654 func (e *timeoutError) Error() string { return "timeout error" }
1655 func (e *timeoutError) Timeout() bool { return e.timeout }
1656
1657 type temporaryError struct {
1658 temporary bool
1659 }
1660
1661 func (e *temporaryError) Error() string { return "temporary error" }
1662 func (e *temporaryError) Temporary() bool { return e.temporary }
1663
1664 type timeoutTemporaryError struct {
1665 timeoutError
1666 temporaryError
1667 }
1668
1669 func (e *timeoutTemporaryError) Error() string { return "timeout/temporary error" }
1670
1671 var netErrorTests = []struct {
1672 err error
1673 timeout bool
1674 temporary bool
1675 }{{
1676 err: &Error{"Get", "http://google.com/", &timeoutError{timeout: true}},
1677 timeout: true,
1678 temporary: false,
1679 }, {
1680 err: &Error{"Get", "http://google.com/", &timeoutError{timeout: false}},
1681 timeout: false,
1682 temporary: false,
1683 }, {
1684 err: &Error{"Get", "http://google.com/", &temporaryError{temporary: true}},
1685 timeout: false,
1686 temporary: true,
1687 }, {
1688 err: &Error{"Get", "http://google.com/", &temporaryError{temporary: false}},
1689 timeout: false,
1690 temporary: false,
1691 }, {
1692 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: true}, temporaryError{temporary: true}}},
1693 timeout: true,
1694 temporary: true,
1695 }, {
1696 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: false}, temporaryError{temporary: true}}},
1697 timeout: false,
1698 temporary: true,
1699 }, {
1700 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: true}, temporaryError{temporary: false}}},
1701 timeout: true,
1702 temporary: false,
1703 }, {
1704 err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: false}, temporaryError{temporary: false}}},
1705 timeout: false,
1706 temporary: false,
1707 }, {
1708 err: &Error{"Get", "http://google.com/", io.EOF},
1709 timeout: false,
1710 temporary: false,
1711 }}
1712
1713
1714 func TestURLErrorImplementsNetError(t *testing.T) {
1715 for i, tt := range netErrorTests {
1716 err, ok := tt.err.(net.Error)
1717 if !ok {
1718 t.Errorf("%d: %T does not implement net.Error", i+1, tt.err)
1719 continue
1720 }
1721 if err.Timeout() != tt.timeout {
1722 t.Errorf("%d: err.Timeout(): got %v, want %v", i+1, err.Timeout(), tt.timeout)
1723 continue
1724 }
1725 if err.Temporary() != tt.temporary {
1726 t.Errorf("%d: err.Temporary(): got %v, want %v", i+1, err.Temporary(), tt.temporary)
1727 }
1728 }
1729 }
1730
1731 func TestURLHostnameAndPort(t *testing.T) {
1732 tests := []struct {
1733 in string
1734 host string
1735 port string
1736 }{
1737 {"foo.com:80", "foo.com", "80"},
1738 {"foo.com", "foo.com", ""},
1739 {"foo.com:", "foo.com", ""},
1740 {"FOO.COM", "FOO.COM", ""},
1741 {"1.2.3.4", "1.2.3.4", ""},
1742 {"1.2.3.4:80", "1.2.3.4", "80"},
1743 {"[1:2:3:4]", "1:2:3:4", ""},
1744 {"[1:2:3:4]:80", "1:2:3:4", "80"},
1745 {"[::1]:80", "::1", "80"},
1746 {"[::1]", "::1", ""},
1747 {"[::1]:", "::1", ""},
1748 {"localhost", "localhost", ""},
1749 {"localhost:443", "localhost", "443"},
1750 {"some.super.long.domain.example.org:8080", "some.super.long.domain.example.org", "8080"},
1751 {"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:17000", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "17000"},
1752 {"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", ""},
1753
1754
1755
1756
1757 {"[google.com]:80", "google.com", "80"},
1758 {"google.com]:80", "google.com]", "80"},
1759 {"google.com:80_invalid_port", "google.com:80_invalid_port", ""},
1760 {"[::1]extra]:80", "::1]extra", "80"},
1761 {"google.com]extra:extra", "google.com]extra:extra", ""},
1762 }
1763 for _, tt := range tests {
1764 u := &URL{Host: tt.in}
1765 host, port := u.Hostname(), u.Port()
1766 if host != tt.host {
1767 t.Errorf("Hostname for Host %q = %q; want %q", tt.in, host, tt.host)
1768 }
1769 if port != tt.port {
1770 t.Errorf("Port for Host %q = %q; want %q", tt.in, port, tt.port)
1771 }
1772 }
1773 }
1774
1775 var _ encodingPkg.BinaryMarshaler = (*URL)(nil)
1776 var _ encodingPkg.BinaryUnmarshaler = (*URL)(nil)
1777
1778 func TestJSON(t *testing.T) {
1779 u, err := Parse("https://www.google.com/x?y=z")
1780 if err != nil {
1781 t.Fatal(err)
1782 }
1783 js, err := json.Marshal(u)
1784 if err != nil {
1785 t.Fatal(err)
1786 }
1787
1788
1789
1790
1791
1792
1793
1794
1795 u1 := new(URL)
1796 err = json.Unmarshal(js, u1)
1797 if err != nil {
1798 t.Fatal(err)
1799 }
1800 if u1.String() != u.String() {
1801 t.Errorf("json decoded to: %s\nwant: %s\n", u1, u)
1802 }
1803 }
1804
1805 func TestGob(t *testing.T) {
1806 u, err := Parse("https://www.google.com/x?y=z")
1807 if err != nil {
1808 t.Fatal(err)
1809 }
1810 var w bytes.Buffer
1811 err = gob.NewEncoder(&w).Encode(u)
1812 if err != nil {
1813 t.Fatal(err)
1814 }
1815
1816 u1 := new(URL)
1817 err = gob.NewDecoder(&w).Decode(u1)
1818 if err != nil {
1819 t.Fatal(err)
1820 }
1821 if u1.String() != u.String() {
1822 t.Errorf("json decoded to: %s\nwant: %s\n", u1, u)
1823 }
1824 }
1825
1826 func TestNilUser(t *testing.T) {
1827 defer func() {
1828 if v := recover(); v != nil {
1829 t.Fatalf("unexpected panic: %v", v)
1830 }
1831 }()
1832
1833 u, err := Parse("http://foo.com/")
1834
1835 if err != nil {
1836 t.Fatalf("parse err: %v", err)
1837 }
1838
1839 if v := u.User.Username(); v != "" {
1840 t.Fatalf("expected empty username, got %s", v)
1841 }
1842
1843 if v, ok := u.User.Password(); v != "" || ok {
1844 t.Fatalf("expected empty password, got %s (%v)", v, ok)
1845 }
1846
1847 if v := u.User.String(); v != "" {
1848 t.Fatalf("expected empty string, got %s", v)
1849 }
1850 }
1851
1852 func TestInvalidUserPassword(t *testing.T) {
1853 _, err := Parse("http://user^:passwo^rd@foo.com/")
1854 if got, wantsub := fmt.Sprint(err), "net/url: invalid userinfo"; !strings.Contains(got, wantsub) {
1855 t.Errorf("error = %q; want substring %q", got, wantsub)
1856 }
1857 }
1858
1859 func TestRejectControlCharacters(t *testing.T) {
1860 tests := []string{
1861 "http://foo.com/?foo\nbar",
1862 "http\r://foo.com/",
1863 "http://foo\x7f.com/",
1864 }
1865 for _, s := range tests {
1866 _, err := Parse(s)
1867 const wantSub = "net/url: invalid control character in URL"
1868 if got := fmt.Sprint(err); !strings.Contains(got, wantSub) {
1869 t.Errorf("Parse(%q) error = %q; want substring %q", s, got, wantSub)
1870 }
1871 }
1872
1873
1874 if _, err := Parse("http://foo.com/ctl\x80"); err != nil {
1875 t.Errorf("error parsing URL with non-ASCII control byte: %v", err)
1876 }
1877
1878 }
1879
1880 var escapeBenchmarks = []struct {
1881 unescaped string
1882 query string
1883 path string
1884 }{
1885 {
1886 unescaped: "one two",
1887 query: "one+two",
1888 path: "one%20two",
1889 },
1890 {
1891 unescaped: "Фотки собак",
1892 query: "%D0%A4%D0%BE%D1%82%D0%BA%D0%B8+%D1%81%D0%BE%D0%B1%D0%B0%D0%BA",
1893 path: "%D0%A4%D0%BE%D1%82%D0%BA%D0%B8%20%D1%81%D0%BE%D0%B1%D0%B0%D0%BA",
1894 },
1895
1896 {
1897 unescaped: "shortrun(break)shortrun",
1898 query: "shortrun%28break%29shortrun",
1899 path: "shortrun%28break%29shortrun",
1900 },
1901
1902 {
1903 unescaped: "longerrunofcharacters(break)anotherlongerrunofcharacters",
1904 query: "longerrunofcharacters%28break%29anotherlongerrunofcharacters",
1905 path: "longerrunofcharacters%28break%29anotherlongerrunofcharacters",
1906 },
1907
1908 {
1909 unescaped: strings.Repeat("padded/with+various%characters?that=need$some@escaping+paddedsowebreak/256bytes", 4),
1910 query: strings.Repeat("padded%2Fwith%2Bvarious%25characters%3Fthat%3Dneed%24some%40escaping%2Bpaddedsowebreak%2F256bytes", 4),
1911 path: strings.Repeat("padded%2Fwith+various%25characters%3Fthat=need$some@escaping+paddedsowebreak%2F256bytes", 4),
1912 },
1913 }
1914
1915 func BenchmarkQueryEscape(b *testing.B) {
1916 for _, tc := range escapeBenchmarks {
1917 b.Run("", func(b *testing.B) {
1918 b.ReportAllocs()
1919 var g string
1920 for i := 0; i < b.N; i++ {
1921 g = QueryEscape(tc.unescaped)
1922 }
1923 b.StopTimer()
1924 if g != tc.query {
1925 b.Errorf("QueryEscape(%q) == %q, want %q", tc.unescaped, g, tc.query)
1926 }
1927
1928 })
1929 }
1930 }
1931
1932 func BenchmarkPathEscape(b *testing.B) {
1933 for _, tc := range escapeBenchmarks {
1934 b.Run("", func(b *testing.B) {
1935 b.ReportAllocs()
1936 var g string
1937 for i := 0; i < b.N; i++ {
1938 g = PathEscape(tc.unescaped)
1939 }
1940 b.StopTimer()
1941 if g != tc.path {
1942 b.Errorf("PathEscape(%q) == %q, want %q", tc.unescaped, g, tc.path)
1943 }
1944
1945 })
1946 }
1947 }
1948
1949 func BenchmarkQueryUnescape(b *testing.B) {
1950 for _, tc := range escapeBenchmarks {
1951 b.Run("", func(b *testing.B) {
1952 b.ReportAllocs()
1953 var g string
1954 for i := 0; i < b.N; i++ {
1955 g, _ = QueryUnescape(tc.query)
1956 }
1957 b.StopTimer()
1958 if g != tc.unescaped {
1959 b.Errorf("QueryUnescape(%q) == %q, want %q", tc.query, g, tc.unescaped)
1960 }
1961
1962 })
1963 }
1964 }
1965
1966 func BenchmarkPathUnescape(b *testing.B) {
1967 for _, tc := range escapeBenchmarks {
1968 b.Run("", func(b *testing.B) {
1969 b.ReportAllocs()
1970 var g string
1971 for i := 0; i < b.N; i++ {
1972 g, _ = PathUnescape(tc.path)
1973 }
1974 b.StopTimer()
1975 if g != tc.unescaped {
1976 b.Errorf("PathUnescape(%q) == %q, want %q", tc.path, g, tc.unescaped)
1977 }
1978
1979 })
1980 }
1981 }
1982
1983 var sink string
1984
1985 func BenchmarkSplit(b *testing.B) {
1986 url := "http://www.google.com/?q=go+language#foo%26bar"
1987 for i := 0; i < b.N; i++ {
1988 sink, sink = split(url, '#', true)
1989 }
1990 }
1991
View as plain text