libgo/go/net/textproto/reader_test.go

   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         {"üser-agenT", "üser-Agent"}, // non-ASCII unchanged
  28 }
  29
  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)
  34                 }
  35         }
  36 }
  37
  38 func reader(s string) *Reader {
  39         return NewReader(bufio.NewReader(strings.NewReader(s)))
  40 }
  41
  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)
  47         }
  48         s, err = r.ReadLine()
  49         if s != "line2" || err != nil {
  50                 t.Fatalf("Line 2: %s, %v", s, err)
  51         }
  52         s, err = r.ReadLine()
  53         if s != "" || err != io.EOF {
  54                 t.Fatalf("EOF: %s, %v", s, err)
  55         }
  56 }
  57
  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)
  63         }
  64         s, err = r.ReadContinuedLine()
  65         if s != "line 2" || err != nil {
  66                 t.Fatalf("Line 2: %s, %v", s, err)
  67         }
  68         s, err = r.ReadContinuedLine()
  69         if s != "line3" || err != nil {
  70                 t.Fatalf("Line 3: %s, %v", s, err)
  71         }
  72         s, err = r.ReadContinuedLine()
  73         if s != "" || err != io.EOF {
  74                 t.Fatalf("EOF: %s, %v", s, err)
  75         }
  76 }
  77
  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)
  83         }
  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)
  87         }
  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)
  91         }
  92         if e, ok := err.(*Error); !ok || e.Code != code || e.Msg != msg {
  93                 t.Fatalf("Line 3: wrong error %v\n", err)
  94         }
  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)
  98         }
  99 }
 100
 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)
 107         }
 108
 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)
 113         }
 114 }
 115
 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)
 122         }
 123
 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)
 128         }
 129 }
 130
 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()
 134         want := MIMEHeader{
 135                 "My-Key":   {"Value 1", "Value 2"},
 136                 "Long-Key": {"Even Longer Value"},
 137         }
 138         if !reflect.DeepEqual(m, want) || err != nil {
 139                 t.Fatalf("ReadMIMEHeader: %v, %v; want %v", m, err, want)
 140         }
 141 }
 142
 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)
 149         }
 150 }
 151
 152 func TestLargeReadMIMEHeader(t *testing.T) {
 153         data := make([]byte, 16*1024)
 154         for i := 0; i < len(data); i++ {
 155                 data[i] = 'x'
 156         }
 157         sdata := string(data)
 158         r := reader("Cookie: " + sdata + "\r\n\n")
 159         m, err := r.ReadMIMEHeader()
 160         if err != nil {
 161                 t.Fatalf("ReadMIMEHeader: %v", err)
 162         }
 163         cookie := m.Get("Cookie")
 164         if cookie != sdata {
 165                 t.Fatalf("ReadMIMEHeader: %v bytes, want %v bytes", len(cookie), len(sdata))
 166         }
 167 }
 168
 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" +
 176                 "SID : 0\r\n" +
 177                 "Audio Mode : None\r\n" +
 178                 "Privilege : 127\r\n\r\n")
 179         m, err := r.ReadMIMEHeader()
 180         want := MIMEHeader{
 181                 "Foo":              {"bar"},
 182                 "Content-Language": {"en"},
 183                 "Sid":              {"0"},
 184                 "Audio-Mode":       {"None"},
 185                 "Privilege":        {"127"},
 186         }
 187         if !reflect.DeepEqual(m, want) || err != nil {
 188                 t.Fatalf("ReadMIMEHeader =\n%v, %v; want:\n%v", m, err, want)
 189         }
 190 }
 191
 192 type readResponseTest struct {
 193         in       string
 194         inCode   int
 195         wantCode int
 196         wantMsg  string
 197 }
 198
 199 var readResponseTests = []readResponseTest{
 200         {"230-Anonymous access granted, restrictions apply\n" +
 201                 "Read the file README.txt,\n" +
 202                 "230  please",
 203                 23,
 204                 230,
 205                 "Anonymous access granted, restrictions apply\nRead the file README.txt,\n please",
 206         },
 207
 208         {"230 Anonymous access granted, restrictions apply\n",
 209                 23,
 210                 230,
 211                 "Anonymous access granted, restrictions apply",
 212         },
 213
 214         {"400-A\n400-B\n400 C",
 215                 4,
 216                 400,
 217                 "A\nB\nC",
 218         },
 219
 220         {"400-A\r\n400-B\r\n400 C\r\n",
 221                 4,
 222                 400,
 223                 "A\nB\nC",
 224         },
 225 }
 226
 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)
 232                 if err != nil {
 233                         t.Errorf("#%d: ReadResponse: %v", i, err)
 234                         continue
 235                 }
 236                 if code != tt.wantCode {
 237                         t.Errorf("#%d: code=%d, want %d", i, code, tt.wantCode)
 238                 }
 239                 if msg != tt.wantMsg {
 240                         t.Errorf("#%d: msg=%q, want %q", i, msg, tt.wantMsg)
 241                 }
 242         }
 243 }
 244
 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 }()
 251
 252         last := ""
 253         for _, h := range oldch {
 254                 if last > h {
 255                         t.Errorf("%v is out of order", h)
 256                 }
 257                 if last == h {
 258                         t.Errorf("%v is duplicated", h)
 259                 }
 260                 if canon := CanonicalMIMEHeaderKey(h); h != canon {
 261                         t.Errorf("%v is not canonical", h)
 262                 }
 263                 last = h
 264         }
 265 }
 266
 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
 276 Non-Interned: test
 277
 278 `, "\n", "\r\n", -1)
 279
 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
 285 Content-Length: 2298
 286 VIA: 1.1 proxy.example.com:80 (XXX/n.n.n-nnn)
 287 Connection: Close
 288 Non-Interned: test
 289
 290 `, "\n", "\r\n", -1)
 291
 292 func BenchmarkReadMIMEHeader(b *testing.B) {
 293         b.ReportAllocs()
 294         var buf bytes.Buffer
 295         br := bufio.NewReader(&buf)
 296         r := NewReader(br)
 297         for i := 0; i < b.N; i++ {
 298                 var want int
 299                 var find string
 300                 if (i & 1) == 1 {
 301                         buf.WriteString(clientHeaders)
 302                         want = 10
 303                         find = "Cookie"
 304                 } else {
 305                         buf.WriteString(serverHeaders)
 306                         want = 9
 307                         find = "Via"
 308                 }
 309                 h, err := r.ReadMIMEHeader()
 310                 if err != nil {
 311                         b.Fatal(err)
 312                 }
 313                 if len(h) != want {
 314                         b.Fatalf("wrong number of headers: got %d, want %d", len(h), want)
 315                 }
 316                 if _, ok := h[find]; !ok {
 317                         b.Fatalf("did not find key %s", find)
 318                 }
 319         }
 320 }
 321
 322 func BenchmarkUncommon(b *testing.B) {
 323         b.ReportAllocs()
 324         var buf bytes.Buffer
 325         br := bufio.NewReader(&buf)
 326         r := NewReader(br)
 327         for i := 0; i < b.N; i++ {
 328                 buf.WriteString("uncommon-header-for-benchmark: foo\r\n\r\n")
 329                 h, err := r.ReadMIMEHeader()
 330                 if err != nil {
 331                         b.Fatal(err)
 332                 }
 333                 if _, ok := h["Uncommon-Header-For-Benchmark"]; !ok {
 334                         b.Fatal("Missing result header.")
 335                 }
 336         }
 337 }