github.com/roboticscm/goman@v0.0.0-20210203095141-87c07b4a0a55/src/net/textproto/reader_test.go (about) 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. 4 5 package textproto 6 7 import ( 8 "bufio" 9 "bytes" 10 "io" 11 "reflect" 12 "strings" 13 "testing" 14 ) 15 16 type canonicalHeaderKeyTest struct { 17 in, out string 18 } 19 20 var canonicalHeaderKeyTests = []canonicalHeaderKeyTest{ 21 {"a-b-c", "A-B-C"}, 22 {"a-1-c", "A-1-C"}, 23 {"User-Agent", "User-Agent"}, 24 {"uSER-aGENT", "User-Agent"}, 25 {"user-agent", "User-Agent"}, 26 {"USER-AGENT", "User-Agent"}, 27 28 // Non-ASCII or anything with spaces or non-token chars is unchanged: 29 {"üser-agenT", "üser-agenT"}, 30 {"a B", "a B"}, 31 32 // This caused a panic due to mishandling of a space: 33 {"C Ontent-Transfer-Encoding", "C Ontent-Transfer-Encoding"}, 34 {"foo bar", "foo bar"}, 35 } 36 37 func TestCanonicalMIMEHeaderKey(t *testing.T) { 38 for _, tt := range canonicalHeaderKeyTests { 39 if s := CanonicalMIMEHeaderKey(tt.in); s != tt.out { 40 t.Errorf("CanonicalMIMEHeaderKey(%q) = %q, want %q", tt.in, s, tt.out) 41 } 42 } 43 } 44 45 func reader(s string) *Reader { 46 return NewReader(bufio.NewReader(strings.NewReader(s))) 47 } 48 49 func TestReadLine(t *testing.T) { 50 r := reader("line1\nline2\n") 51 s, err := r.ReadLine() 52 if s != "line1" || err != nil { 53 t.Fatalf("Line 1: %s, %v", s, err) 54 } 55 s, err = r.ReadLine() 56 if s != "line2" || err != nil { 57 t.Fatalf("Line 2: %s, %v", s, err) 58 } 59 s, err = r.ReadLine() 60 if s != "" || err != io.EOF { 61 t.Fatalf("EOF: %s, %v", s, err) 62 } 63 } 64 65 func TestReadContinuedLine(t *testing.T) { 66 r := reader("line1\nline\n 2\nline3\n") 67 s, err := r.ReadContinuedLine() 68 if s != "line1" || err != nil { 69 t.Fatalf("Line 1: %s, %v", s, err) 70 } 71 s, err = r.ReadContinuedLine() 72 if s != "line 2" || err != nil { 73 t.Fatalf("Line 2: %s, %v", s, err) 74 } 75 s, err = r.ReadContinuedLine() 76 if s != "line3" || err != nil { 77 t.Fatalf("Line 3: %s, %v", s, err) 78 } 79 s, err = r.ReadContinuedLine() 80 if s != "" || err != io.EOF { 81 t.Fatalf("EOF: %s, %v", s, err) 82 } 83 } 84 85 func TestReadCodeLine(t *testing.T) { 86 r := reader("123 hi\n234 bye\n345 no way\n") 87 code, msg, err := r.ReadCodeLine(0) 88 if code != 123 || msg != "hi" || err != nil { 89 t.Fatalf("Line 1: %d, %s, %v", code, msg, err) 90 } 91 code, msg, err = r.ReadCodeLine(23) 92 if code != 234 || msg != "bye" || err != nil { 93 t.Fatalf("Line 2: %d, %s, %v", code, msg, err) 94 } 95 code, msg, err = r.ReadCodeLine(346) 96 if code != 345 || msg != "no way" || err == nil { 97 t.Fatalf("Line 3: %d, %s, %v", code, msg, err) 98 } 99 if e, ok := err.(*Error); !ok || e.Code != code || e.Msg != msg { 100 t.Fatalf("Line 3: wrong error %v\n", err) 101 } 102 code, msg, err = r.ReadCodeLine(1) 103 if code != 0 || msg != "" || err != io.EOF { 104 t.Fatalf("EOF: %d, %s, %v", code, msg, err) 105 } 106 } 107 108 func TestReadDotLines(t *testing.T) { 109 r := reader("dotlines\r\n.foo\r\n..bar\n...baz\nquux\r\n\r\n.\r\nanother\n") 110 s, err := r.ReadDotLines() 111 want := []string{"dotlines", "foo", ".bar", "..baz", "quux", ""} 112 if !reflect.DeepEqual(s, want) || err != nil { 113 t.Fatalf("ReadDotLines: %v, %v", s, err) 114 } 115 116 s, err = r.ReadDotLines() 117 want = []string{"another"} 118 if !reflect.DeepEqual(s, want) || err != io.ErrUnexpectedEOF { 119 t.Fatalf("ReadDotLines2: %v, %v", s, err) 120 } 121 } 122 123 func TestReadDotBytes(t *testing.T) { 124 r := reader("dotlines\r\n.foo\r\n..bar\n...baz\nquux\r\n\r\n.\r\nanot.her\r\n") 125 b, err := r.ReadDotBytes() 126 want := []byte("dotlines\nfoo\n.bar\n..baz\nquux\n\n") 127 if !reflect.DeepEqual(b, want) || err != nil { 128 t.Fatalf("ReadDotBytes: %q, %v", b, err) 129 } 130 131 b, err = r.ReadDotBytes() 132 want = []byte("anot.her\n") 133 if !reflect.DeepEqual(b, want) || err != io.ErrUnexpectedEOF { 134 t.Fatalf("ReadDotBytes2: %q, %v", b, err) 135 } 136 } 137 138 func TestReadMIMEHeader(t *testing.T) { 139 r := reader("my-key: Value 1 \r\nLong-key: Even \n Longer Value\r\nmy-Key: Value 2\r\n\n") 140 m, err := r.ReadMIMEHeader() 141 want := MIMEHeader{ 142 "My-Key": {"Value 1", "Value 2"}, 143 "Long-Key": {"Even Longer Value"}, 144 } 145 if !reflect.DeepEqual(m, want) || err != nil { 146 t.Fatalf("ReadMIMEHeader: %v, %v; want %v", m, err, want) 147 } 148 } 149 150 func TestReadMIMEHeaderSingle(t *testing.T) { 151 r := reader("Foo: bar\n\n") 152 m, err := r.ReadMIMEHeader() 153 want := MIMEHeader{"Foo": {"bar"}} 154 if !reflect.DeepEqual(m, want) || err != nil { 155 t.Fatalf("ReadMIMEHeader: %v, %v; want %v", m, err, want) 156 } 157 } 158 159 func TestLargeReadMIMEHeader(t *testing.T) { 160 data := make([]byte, 16*1024) 161 for i := 0; i < len(data); i++ { 162 data[i] = 'x' 163 } 164 sdata := string(data) 165 r := reader("Cookie: " + sdata + "\r\n\n") 166 m, err := r.ReadMIMEHeader() 167 if err != nil { 168 t.Fatalf("ReadMIMEHeader: %v", err) 169 } 170 cookie := m.Get("Cookie") 171 if cookie != sdata { 172 t.Fatalf("ReadMIMEHeader: %v bytes, want %v bytes", len(cookie), len(sdata)) 173 } 174 } 175 176 // Test that we read slightly-bogus MIME headers seen in the wild, 177 // with spaces before colons, and spaces in keys. 178 func TestReadMIMEHeaderNonCompliant(t *testing.T) { 179 // Invalid HTTP response header as sent by an Axis security 180 // camera: (this is handled by IE, Firefox, Chrome, curl, etc.) 181 r := reader("Foo: bar\r\n" + 182 "Content-Language: en\r\n" + 183 "SID : 0\r\n" + 184 "Audio Mode : None\r\n" + 185 "Privilege : 127\r\n\r\n") 186 m, err := r.ReadMIMEHeader() 187 want := MIMEHeader{ 188 "Foo": {"bar"}, 189 "Content-Language": {"en"}, 190 "Sid": {"0"}, 191 "Audio Mode": {"None"}, 192 "Privilege": {"127"}, 193 } 194 if !reflect.DeepEqual(m, want) || err != nil { 195 t.Fatalf("ReadMIMEHeader =\n%v, %v; want:\n%v", m, err, want) 196 } 197 } 198 199 type readResponseTest struct { 200 in string 201 inCode int 202 wantCode int 203 wantMsg string 204 } 205 206 var readResponseTests = []readResponseTest{ 207 {"230-Anonymous access granted, restrictions apply\n" + 208 "Read the file README.txt,\n" + 209 "230 please", 210 23, 211 230, 212 "Anonymous access granted, restrictions apply\nRead the file README.txt,\n please", 213 }, 214 215 {"230 Anonymous access granted, restrictions apply\n", 216 23, 217 230, 218 "Anonymous access granted, restrictions apply", 219 }, 220 221 {"400-A\n400-B\n400 C", 222 4, 223 400, 224 "A\nB\nC", 225 }, 226 227 {"400-A\r\n400-B\r\n400 C\r\n", 228 4, 229 400, 230 "A\nB\nC", 231 }, 232 } 233 234 // See http://www.ietf.org/rfc/rfc959.txt page 36. 235 func TestRFC959Lines(t *testing.T) { 236 for i, tt := range readResponseTests { 237 r := reader(tt.in + "\nFOLLOWING DATA") 238 code, msg, err := r.ReadResponse(tt.inCode) 239 if err != nil { 240 t.Errorf("#%d: ReadResponse: %v", i, err) 241 continue 242 } 243 if code != tt.wantCode { 244 t.Errorf("#%d: code=%d, want %d", i, code, tt.wantCode) 245 } 246 if msg != tt.wantMsg { 247 t.Errorf("#%d: msg=%q, want %q", i, msg, tt.wantMsg) 248 } 249 } 250 } 251 252 func TestCommonHeaders(t *testing.T) { 253 for h := range commonHeader { 254 if h != CanonicalMIMEHeaderKey(h) { 255 t.Errorf("Non-canonical header %q in commonHeader", h) 256 } 257 } 258 b := []byte("content-Length") 259 want := "Content-Length" 260 n := testing.AllocsPerRun(200, func() { 261 if x := canonicalMIMEHeaderKey(b); x != want { 262 t.Fatalf("canonicalMIMEHeaderKey(%q) = %q; want %q", b, x, want) 263 } 264 }) 265 if n > 0 { 266 t.Errorf("canonicalMIMEHeaderKey allocs = %v; want 0", n) 267 } 268 } 269 270 var clientHeaders = strings.Replace(`Host: golang.org 271 Connection: keep-alive 272 Cache-Control: max-age=0 273 Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5 274 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 275 Accept-Encoding: gzip,deflate,sdch 276 Accept-Language: en-US,en;q=0.8,fr-CH;q=0.6 277 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3 278 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 279 Non-Interned: test 280 281 `, "\n", "\r\n", -1) 282 283 var serverHeaders = strings.Replace(`Content-Type: text/html; charset=utf-8 284 Content-Encoding: gzip 285 Date: Thu, 27 Sep 2012 09:03:33 GMT 286 Server: Google Frontend 287 Cache-Control: private 288 Content-Length: 2298 289 VIA: 1.1 proxy.example.com:80 (XXX/n.n.n-nnn) 290 Connection: Close 291 Non-Interned: test 292 293 `, "\n", "\r\n", -1) 294 295 func BenchmarkReadMIMEHeader(b *testing.B) { 296 b.ReportAllocs() 297 var buf bytes.Buffer 298 br := bufio.NewReader(&buf) 299 r := NewReader(br) 300 for i := 0; i < b.N; i++ { 301 var want int 302 var find string 303 if (i & 1) == 1 { 304 buf.WriteString(clientHeaders) 305 want = 10 306 find = "Cookie" 307 } else { 308 buf.WriteString(serverHeaders) 309 want = 9 310 find = "Via" 311 } 312 h, err := r.ReadMIMEHeader() 313 if err != nil { 314 b.Fatal(err) 315 } 316 if len(h) != want { 317 b.Fatalf("wrong number of headers: got %d, want %d", len(h), want) 318 } 319 if _, ok := h[find]; !ok { 320 b.Fatalf("did not find key %s", find) 321 } 322 } 323 } 324 325 func BenchmarkUncommon(b *testing.B) { 326 b.ReportAllocs() 327 var buf bytes.Buffer 328 br := bufio.NewReader(&buf) 329 r := NewReader(br) 330 for i := 0; i < b.N; i++ { 331 buf.WriteString("uncommon-header-for-benchmark: foo\r\n\r\n") 332 h, err := r.ReadMIMEHeader() 333 if err != nil { 334 b.Fatal(err) 335 } 336 if _, ok := h["Uncommon-Header-For-Benchmark"]; !ok { 337 b.Fatal("Missing result header.") 338 } 339 } 340 }