Merge pull request #201 from Bytom/v0.1

[bytom/vapor.git] / vendor / github.com / go-logfmt / logfmt / decode_test.go

diff --git a/vendor/github.com/go-logfmt/logfmt/decode_test.go b/vendor/github.com/go-logfmt/logfmt/decode_test.go
deleted file mode 100644 (file)
index 363152d..0000000
--- a/vendor/github.com/go-logfmt/logfmt/decode_test.go
+++ /dev/null
@@ -1,184 +0,0 @@
-package logfmt
-
-import (
-       "bytes"
-       "fmt"
-       "reflect"
-       "strings"
-       "testing"
-)
-
-type kv struct {
-       k, v []byte
-}
-
-func (s kv) String() string {
-       return fmt.Sprintf("{k:%q v:%q}", s.k, s.v)
-}
-
-func TestDecoder_scan(t *testing.T) {
-       tests := []struct {
-               data string
-               want [][]kv
-       }{
-               {"", nil},
-               {"\n\n", [][]kv{nil, nil}},
-               {`x= `, [][]kv{{{[]byte("x"), nil}}}},
-               {`y=`, [][]kv{{{[]byte("y"), nil}}}},
-               {`y`, [][]kv{{{[]byte("y"), nil}}}},
-               {`y=f`, [][]kv{{{[]byte("y"), []byte("f")}}}},
-               {"y=\"\\tf\"", [][]kv{{{[]byte("y"), []byte("\tf")}}}},
-               {"a=1\n", [][]kv{{{[]byte("a"), []byte("1")}}}},
-               {
-                       `a=1 b="bar" ƒ=2h3s r="esc\t" d x=sf   `,
-                       [][]kv{{
-                               {[]byte("a"), []byte("1")},
-                               {[]byte("b"), []byte("bar")},
-                               {[]byte("ƒ"), []byte("2h3s")},
-                               {[]byte("r"), []byte("esc\t")},
-                               {[]byte("d"), nil},
-                               {[]byte("x"), []byte("sf")},
-                       }},
-               },
-               {
-                       "y=f\ny=g",
-                       [][]kv{
-                               {{[]byte("y"), []byte("f")}},
-                               {{[]byte("y"), []byte("g")}},
-                       },
-               },
-               {
-                       "y=f  \n\x1e y=g",
-                       [][]kv{
-                               {{[]byte("y"), []byte("f")}},
-                               {{[]byte("y"), []byte("g")}},
-                       },
-               },
-               {
-                       "y= d y=g",
-                       [][]kv{{
-                               {[]byte("y"), nil},
-                               {[]byte("d"), nil},
-                               {[]byte("y"), []byte("g")},
-                       }},
-               },
-               {
-                       "y=\"f\"\ny=g",
-                       [][]kv{
-                               {{[]byte("y"), []byte("f")}},
-                               {{[]byte("y"), []byte("g")}},
-                       },
-               },
-               {
-                       "y=\"f\\n\"y=g",
-                       [][]kv{{
-                               {[]byte("y"), []byte("f\n")},
-                               {[]byte("y"), []byte("g")},
-                       }},
-               },
-       }
-
-       for _, test := range tests {
-               var got [][]kv
-               dec := NewDecoder(strings.NewReader(test.data))
-
-               for dec.ScanRecord() {
-                       var kvs []kv
-                       for dec.ScanKeyval() {
-                               k := dec.Key()
-                               v := dec.Value()
-                               if k != nil {
-                                       kvs = append(kvs, kv{k, v})
-                               }
-                       }
-                       got = append(got, kvs)
-               }
-               if err := dec.Err(); err != nil {
-                       t.Errorf("got err: %v", err)
-               }
-               if !reflect.DeepEqual(got, test.want) {
-                       t.Errorf("\n  in: %q\n got: %+v\nwant: %+v", test.data, got, test.want)
-               }
-       }
-}
-
-func TestDecoder_errors(t *testing.T) {
-       tests := []struct {
-               data string
-               want error
-       }{
-               {"a=1\n=bar", &SyntaxError{Msg: "unexpected '='", Line: 2, Pos: 1}},
-               {"a=1\n\"k\"=bar", &SyntaxError{Msg: "unexpected '\"'", Line: 2, Pos: 1}},
-               {"a=1\nk\"ey=bar", &SyntaxError{Msg: "unexpected '\"'", Line: 2, Pos: 2}},
-               {"a=1\nk=b\"ar", &SyntaxError{Msg: "unexpected '\"'", Line: 2, Pos: 4}},
-               {"a=1\nk=b =ar", &SyntaxError{Msg: "unexpected '='", Line: 2, Pos: 5}},
-               {"a==", &SyntaxError{Msg: "unexpected '='", Line: 1, Pos: 3}},
-               {"a=1\nk=b=ar", &SyntaxError{Msg: "unexpected '='", Line: 2, Pos: 4}},
-               {"a=\"1", &SyntaxError{Msg: "unterminated quoted value", Line: 1, Pos: 5}},
-               {"a=\"1\\", &SyntaxError{Msg: "unterminated quoted value", Line: 1, Pos: 6}},
-               {"a=\"\\t1", &SyntaxError{Msg: "unterminated quoted value", Line: 1, Pos: 7}},
-               {"a=\"\\u1\"", &SyntaxError{Msg: "invalid quoted value", Line: 1, Pos: 8}},
-               {"a\ufffd=bar", &SyntaxError{Msg: "invalid key", Line: 1, Pos: 5}},
-               {"\x80=bar", &SyntaxError{Msg: "invalid key", Line: 1, Pos: 2}},
-               {"\x80", &SyntaxError{Msg: "invalid key", Line: 1, Pos: 2}},
-       }
-
-       for _, test := range tests {
-               dec := NewDecoder(strings.NewReader(test.data))
-
-               for dec.ScanRecord() {
-                       for dec.ScanKeyval() {
-                       }
-               }
-               if got, want := dec.Err(), test.want; !reflect.DeepEqual(got, want) {
-                       t.Errorf("got: %v, want: %v", got, want)
-               }
-       }
-}
-
-func TestDecoder_decode_encode(t *testing.T) {
-       tests := []struct {
-               in, out string
-       }{
-               {"", ""},
-               {"\n", "\n"},
-               {"\n  \n", "\n\n"},
-               {
-                       "a=1\nb=2\n",
-                       "a=1\nb=2\n",
-               },
-               {
-                       "a=1 b=\"bar\" ƒ=2h3s r=\"esc\\t\" d x=sf   ",
-                       "a=1 b=bar ƒ=2h3s r=\"esc\\t\" d= x=sf\n",
-               },
-       }
-
-       for _, test := range tests {
-               dec := NewDecoder(strings.NewReader(test.in))
-               buf := bytes.Buffer{}
-               enc := NewEncoder(&buf)
-
-               var err error
-       loop:
-               for dec.ScanRecord() && err == nil {
-                       for dec.ScanKeyval() {
-                               if dec.Key() == nil {
-                                       continue
-                               }
-                               if err = enc.EncodeKeyval(dec.Key(), dec.Value()); err != nil {
-                                       break loop
-                               }
-                       }
-                       enc.EndRecord()
-               }
-               if err == nil {
-                       err = dec.Err()
-               }
-               if err != nil {
-                       t.Errorf("got err: %v", err)
-               }
-               if got, want := buf.String(), test.out; got != want {
-                       t.Errorf("\n got: %q\nwant: %q", got, want)
-               }
-       }
-}