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         "io"
  10         "os"
  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
  29 func TestCanonicalMIMEHeaderKey(t *testing.T) {
  30         for _, tt := range canonicalHeaderKeyTests {
  31                 if s := CanonicalMIMEHeaderKey(tt.in); s != tt.out {
  32                         t.Errorf("CanonicalMIMEHeaderKey(%q) = %q, want %q", tt.in, s, tt.out)
  33                 }
  34         }
  35 }
  36
  37 func reader(s string) *Reader {
  38         return NewReader(bufio.NewReader(strings.NewReader(s)))
  39 }
  40
  41 func TestReadLine(t *testing.T) {
  42         r := reader("line1\nline2\n")
  43         s, err := r.ReadLine()
  44         if s != "line1" || err != nil {
  45                 t.Fatalf("Line 1: %s, %v", s, err)
  46         }
  47         s, err = r.ReadLine()
  48         if s != "line2" || err != nil {
  49                 t.Fatalf("Line 2: %s, %v", s, err)
  50         }
  51         s, err = r.ReadLine()
  52         if s != "" || err != os.EOF {
  53                 t.Fatalf("EOF: %s, %v", s, err)
  54         }
  55 }
  56
  57 func TestReadContinuedLine(t *testing.T) {
  58         r := reader("line1\nline\n 2\nline3\n")
  59         s, err := r.ReadContinuedLine()
  60         if s != "line1" || err != nil {
  61                 t.Fatalf("Line 1: %s, %v", s, err)
  62         }
  63         s, err = r.ReadContinuedLine()
  64         if s != "line 2" || err != nil {
  65                 t.Fatalf("Line 2: %s, %v", s, err)
  66         }
  67         s, err = r.ReadContinuedLine()
  68         if s != "line3" || err != nil {
  69                 t.Fatalf("Line 3: %s, %v", s, err)
  70         }
  71         s, err = r.ReadContinuedLine()
  72         if s != "" || err != os.EOF {
  73                 t.Fatalf("EOF: %s, %v", s, err)
  74         }
  75 }
  76
  77 func TestReadCodeLine(t *testing.T) {
  78         r := reader("123 hi\n234 bye\n345 no way\n")
  79         code, msg, err := r.ReadCodeLine(0)
  80         if code != 123 || msg != "hi" || err != nil {
  81                 t.Fatalf("Line 1: %d, %s, %v", code, msg, err)
  82         }
  83         code, msg, err = r.ReadCodeLine(23)
  84         if code != 234 || msg != "bye" || err != nil {
  85                 t.Fatalf("Line 2: %d, %s, %v", code, msg, err)
  86         }
  87         code, msg, err = r.ReadCodeLine(346)
  88         if code != 345 || msg != "no way" || err == nil {
  89                 t.Fatalf("Line 3: %d, %s, %v", code, msg, err)
  90         }
  91         if e, ok := err.(*Error); !ok || e.Code != code || e.Msg != msg {
  92                 t.Fatalf("Line 3: wrong error %v\n", err)
  93         }
  94         code, msg, err = r.ReadCodeLine(1)
  95         if code != 0 || msg != "" || err != os.EOF {
  96                 t.Fatalf("EOF: %d, %s, %v", code, msg, err)
  97         }
  98 }
  99
 100 func TestReadDotLines(t *testing.T) {
 101         r := reader("dotlines\r\n.foo\r\n..bar\n...baz\nquux\r\n\r\n.\r\nanother\n")
 102         s, err := r.ReadDotLines()
 103         want := []string{"dotlines", "foo", ".bar", "..baz", "quux", ""}
 104         if !reflect.DeepEqual(s, want) || err != nil {
 105                 t.Fatalf("ReadDotLines: %v, %v", s, err)
 106         }
 107
 108         s, err = r.ReadDotLines()
 109         want = []string{"another"}
 110         if !reflect.DeepEqual(s, want) || err != io.ErrUnexpectedEOF {
 111                 t.Fatalf("ReadDotLines2: %v, %v", s, err)
 112         }
 113 }
 114
 115 func TestReadDotBytes(t *testing.T) {
 116         r := reader("dotlines\r\n.foo\r\n..bar\n...baz\nquux\r\n\r\n.\r\nanot.her\r\n")
 117         b, err := r.ReadDotBytes()
 118         want := []byte("dotlines\nfoo\n.bar\n..baz\nquux\n\n")
 119         if !reflect.DeepEqual(b, want) || err != nil {
 120                 t.Fatalf("ReadDotBytes: %q, %v", b, err)
 121         }
 122
 123         b, err = r.ReadDotBytes()
 124         want = []byte("anot.her\n")
 125         if !reflect.DeepEqual(b, want) || err != io.ErrUnexpectedEOF {
 126                 t.Fatalf("ReadDotBytes2: %q, %v", b, err)
 127         }
 128 }
 129
 130 func TestReadMIMEHeader(t *testing.T) {
 131         r := reader("my-key: Value 1  \r\nLong-key: Even \n Longer Value\r\nmy-Key: Value 2\r\n\n")
 132         m, err := r.ReadMIMEHeader()
 133         want := MIMEHeader{
 134                 "My-Key":   {"Value 1", "Value 2"},
 135                 "Long-Key": {"Even Longer Value"},
 136         }
 137         if !reflect.DeepEqual(m, want) || err != nil {
 138                 t.Fatalf("ReadMIMEHeader: %v, %v; want %v", m, err, want)
 139         }
 140 }
 141
 142 func TestLargeReadMIMEHeader(t *testing.T) {
 143         data := make([]byte, 16*1024)
 144         for i := 0; i < len(data); i++ {
 145                 data[i] = 'x'
 146         }
 147         sdata := string(data)
 148         r := reader("Cookie: " + sdata + "\r\n\n")
 149         m, err := r.ReadMIMEHeader()
 150         if err != nil {
 151                 t.Fatalf("ReadMIMEHeader: %v", err)
 152         }
 153         cookie := m.Get("Cookie")
 154         if cookie != sdata {
 155                 t.Fatalf("ReadMIMEHeader: %v bytes, want %v bytes", len(cookie), len(sdata))
 156         }
 157 }
 158
 159 type readResponseTest struct {
 160         in       string
 161         inCode   int
 162         wantCode int
 163         wantMsg  string
 164 }
 165
 166 var readResponseTests = []readResponseTest{
 167         {"230-Anonymous access granted, restrictions apply\n" +
 168                 "Read the file README.txt,\n" +
 169                 "230  please",
 170                 23,
 171                 230,
 172                 "Anonymous access granted, restrictions apply\nRead the file README.txt,\n please",
 173         },
 174
 175         {"230 Anonymous access granted, restrictions apply\n",
 176                 23,
 177                 230,
 178                 "Anonymous access granted, restrictions apply",
 179         },
 180
 181         {"400-A\n400-B\n400 C",
 182                 4,
 183                 400,
 184                 "A\nB\nC",
 185         },
 186
 187         {"400-A\r\n400-B\r\n400 C\r\n",
 188                 4,
 189                 400,
 190                 "A\nB\nC",
 191         },
 192 }
 193
 194 // See http://www.ietf.org/rfc/rfc959.txt page 36.
 195 func TestRFC959Lines(t *testing.T) {
 196         for i, tt := range readResponseTests {
 197                 r := reader(tt.in + "\nFOLLOWING DATA")
 198                 code, msg, err := r.ReadResponse(tt.inCode)
 199                 if err != nil {
 200                         t.Errorf("#%d: ReadResponse: %v", i, err)
 201                         continue
 202                 }
 203                 if code != tt.wantCode {
 204                         t.Errorf("#%d: code=%d, want %d", i, code, tt.wantCode)
 205                 }
 206                 if msg != tt.wantMsg {
 207                         t.Errorf("%#d: msg=%q, want %q", i, msg, tt.wantMsg)
 208                 }
 209         }
 210 }