1 // Copyright 2010 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.
16 type canonicalHeaderKeyTest struct {
20 var canonicalHeaderKeyTests = []canonicalHeaderKeyTest{
23 {"User-Agent", "User-Agent"},
24 {"uSER-aGENT", "User-Agent"},
25 {"user-agent", "User-Agent"},
26 {"USER-AGENT", "User-Agent"},
27 {"üser-agenT", "üser-Agent"}, // non-ASCII unchanged
30 func TestCanonicalMIMEHeaderKey(t *testing.T) {
31 for _, tt := range canonicalHeaderKeyTests {
32 if s := CanonicalMIMEHeaderKey(tt.in); s != tt.out {
33 t.Errorf("CanonicalMIMEHeaderKey(%q) = %q, want %q", tt.in, s, tt.out)
38 func reader(s string) *Reader {
39 return NewReader(bufio.NewReader(strings.NewReader(s)))
42 func TestReadLine(t *testing.T) {
43 r := reader("line1\nline2\n")
44 s, err := r.ReadLine()
45 if s != "line1" || err != nil {
46 t.Fatalf("Line 1: %s, %v", s, err)
49 if s != "line2" || err != nil {
50 t.Fatalf("Line 2: %s, %v", s, err)
53 if s != "" || err != io.EOF {
54 t.Fatalf("EOF: %s, %v", s, err)
58 func TestReadContinuedLine(t *testing.T) {
59 r := reader("line1\nline\n 2\nline3\n")
60 s, err := r.ReadContinuedLine()
61 if s != "line1" || err != nil {
62 t.Fatalf("Line 1: %s, %v", s, err)
64 s, err = r.ReadContinuedLine()
65 if s != "line 2" || err != nil {
66 t.Fatalf("Line 2: %s, %v", s, err)
68 s, err = r.ReadContinuedLine()
69 if s != "line3" || err != nil {
70 t.Fatalf("Line 3: %s, %v", s, err)
72 s, err = r.ReadContinuedLine()
73 if s != "" || err != io.EOF {
74 t.Fatalf("EOF: %s, %v", s, err)
78 func TestReadCodeLine(t *testing.T) {
79 r := reader("123 hi\n234 bye\n345 no way\n")
80 code, msg, err := r.ReadCodeLine(0)
81 if code != 123 || msg != "hi" || err != nil {
82 t.Fatalf("Line 1: %d, %s, %v", code, msg, err)
84 code, msg, err = r.ReadCodeLine(23)
85 if code != 234 || msg != "bye" || err != nil {
86 t.Fatalf("Line 2: %d, %s, %v", code, msg, err)
88 code, msg, err = r.ReadCodeLine(346)
89 if code != 345 || msg != "no way" || err == nil {
90 t.Fatalf("Line 3: %d, %s, %v", code, msg, err)
92 if e, ok := err.(*Error); !ok || e.Code != code || e.Msg != msg {
93 t.Fatalf("Line 3: wrong error %v\n", err)
95 code, msg, err = r.ReadCodeLine(1)
96 if code != 0 || msg != "" || err != io.EOF {
97 t.Fatalf("EOF: %d, %s, %v", code, msg, err)
101 func TestReadDotLines(t *testing.T) {
102 r := reader("dotlines\r\n.foo\r\n..bar\n...baz\nquux\r\n\r\n.\r\nanother\n")
103 s, err := r.ReadDotLines()
104 want := []string{"dotlines", "foo", ".bar", "..baz", "quux", ""}
105 if !reflect.DeepEqual(s, want) || err != nil {
106 t.Fatalf("ReadDotLines: %v, %v", s, err)
109 s, err = r.ReadDotLines()
110 want = []string{"another"}
111 if !reflect.DeepEqual(s, want) || err != io.ErrUnexpectedEOF {
112 t.Fatalf("ReadDotLines2: %v, %v", s, err)
116 func TestReadDotBytes(t *testing.T) {
117 r := reader("dotlines\r\n.foo\r\n..bar\n...baz\nquux\r\n\r\n.\r\nanot.her\r\n")
118 b, err := r.ReadDotBytes()
119 want := []byte("dotlines\nfoo\n.bar\n..baz\nquux\n\n")
120 if !reflect.DeepEqual(b, want) || err != nil {
121 t.Fatalf("ReadDotBytes: %q, %v", b, err)
124 b, err = r.ReadDotBytes()
125 want = []byte("anot.her\n")
126 if !reflect.DeepEqual(b, want) || err != io.ErrUnexpectedEOF {
127 t.Fatalf("ReadDotBytes2: %q, %v", b, err)
131 func TestReadMIMEHeader(t *testing.T) {
132 r := reader("my-key: Value 1 \r\nLong-key: Even \n Longer Value\r\nmy-Key: Value 2\r\n\n")
133 m, err := r.ReadMIMEHeader()
135 "My-Key": {"Value 1", "Value 2"},
136 "Long-Key": {"Even Longer Value"},
138 if !reflect.DeepEqual(m, want) || err != nil {
139 t.Fatalf("ReadMIMEHeader: %v, %v; want %v", m, err, want)
143 func TestReadMIMEHeaderSingle(t *testing.T) {
144 r := reader("Foo: bar\n\n")
145 m, err := r.ReadMIMEHeader()
146 want := MIMEHeader{"Foo": {"bar"}}
147 if !reflect.DeepEqual(m, want) || err != nil {
148 t.Fatalf("ReadMIMEHeader: %v, %v; want %v", m, err, want)
152 func TestLargeReadMIMEHeader(t *testing.T) {
153 data := make([]byte, 16*1024)
154 for i := 0; i < len(data); i++ {
157 sdata := string(data)
158 r := reader("Cookie: " + sdata + "\r\n\n")
159 m, err := r.ReadMIMEHeader()
161 t.Fatalf("ReadMIMEHeader: %v", err)
163 cookie := m.Get("Cookie")
165 t.Fatalf("ReadMIMEHeader: %v bytes, want %v bytes", len(cookie), len(sdata))
169 // Test that we read slightly-bogus MIME headers seen in the wild,
170 // with spaces before colons, and spaces in keys.
171 func TestReadMIMEHeaderNonCompliant(t *testing.T) {
172 // Invalid HTTP response header as sent by an Axis security
173 // camera: (this is handled by IE, Firefox, Chrome, curl, etc.)
174 r := reader("Foo: bar\r\n" +
175 "Content-Language: en\r\n" +
177 "Audio Mode : None\r\n" +
178 "Privilege : 127\r\n\r\n")
179 m, err := r.ReadMIMEHeader()
182 "Content-Language": {"en"},
184 "Audio-Mode": {"None"},
185 "Privilege": {"127"},
187 if !reflect.DeepEqual(m, want) || err != nil {
188 t.Fatalf("ReadMIMEHeader =\n%v, %v; want:\n%v", m, err, want)
192 type readResponseTest struct {
199 var readResponseTests = []readResponseTest{
200 {"230-Anonymous access granted, restrictions apply\n" +
201 "Read the file README.txt,\n" +
205 "Anonymous access granted, restrictions apply\nRead the file README.txt,\n please",
208 {"230 Anonymous access granted, restrictions apply\n",
211 "Anonymous access granted, restrictions apply",
214 {"400-A\n400-B\n400 C",
220 {"400-A\r\n400-B\r\n400 C\r\n",
227 // See http://www.ietf.org/rfc/rfc959.txt page 36.
228 func TestRFC959Lines(t *testing.T) {
229 for i, tt := range readResponseTests {
230 r := reader(tt.in + "\nFOLLOWING DATA")
231 code, msg, err := r.ReadResponse(tt.inCode)
233 t.Errorf("#%d: ReadResponse: %v", i, err)
236 if code != tt.wantCode {
237 t.Errorf("#%d: code=%d, want %d", i, code, tt.wantCode)
239 if msg != tt.wantMsg {
240 t.Errorf("#%d: msg=%q, want %q", i, msg, tt.wantMsg)
245 func TestCommonHeaders(t *testing.T) {
246 // need to disable the commonHeaders-based optimization
247 // during this check, or we'd not be testing anything
248 oldch := commonHeaders
249 commonHeaders = []string{}
250 defer func() { commonHeaders = oldch }()
253 for _, h := range oldch {
255 t.Errorf("%v is out of order", h)
258 t.Errorf("%v is duplicated", h)
260 if canon := CanonicalMIMEHeaderKey(h); h != canon {
261 t.Errorf("%v is not canonical", h)
267 var clientHeaders = strings.Replace(`Host: golang.org
268 Connection: keep-alive
269 Cache-Control: max-age=0
270 Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
271 User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US) AppleWebKit/534.3 (KHTML, like Gecko) Chrome/6.0.472.63 Safari/534.3
272 Accept-Encoding: gzip,deflate,sdch
273 Accept-Language: en-US,en;q=0.8,fr-CH;q=0.6
274 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
275 COOKIE: __utma=000000000.0000000000.0000000000.0000000000.0000000000.00; __utmb=000000000.0.00.0000000000; __utmc=000000000; __utmz=000000000.0000000000.00.0.utmcsr=code.google.com|utmccn=(referral)|utmcmd=referral|utmcct=/p/go/issues/detail
280 var serverHeaders = strings.Replace(`Content-Type: text/html; charset=utf-8
281 Content-Encoding: gzip
282 Date: Thu, 27 Sep 2012 09:03:33 GMT
283 Server: Google Frontend
284 Cache-Control: private
286 VIA: 1.1 proxy.example.com:80 (XXX/n.n.n-nnn)
292 func BenchmarkReadMIMEHeader(b *testing.B) {
294 br := bufio.NewReader(&buf)
296 for i := 0; i < b.N; i++ {
300 buf.WriteString(clientHeaders)
304 buf.WriteString(serverHeaders)
308 h, err := r.ReadMIMEHeader()
313 b.Fatalf("wrong number of headers: got %d, want %d", len(h), want)
315 if _, ok := h[find]; !ok {
316 b.Fatalf("did not find key %s", find)
321 func BenchmarkUncommon(b *testing.B) {
323 br := bufio.NewReader(&buf)
325 for i := 0; i < b.N; i++ {
326 buf.WriteString("uncommon-header-for-benchmark: foo\r\n\r\n")
327 h, err := r.ReadMIMEHeader()
331 if _, ok := h["Uncommon-Header-For-Benchmark"]; !ok {
332 b.Fatal("Missing result header.")