vendor/github.com/go-logfmt/logfmt/encode_internal_test.go

   1 package logfmt
   2
   3 import (
   4         "bytes"
   5         "errors"
   6         "fmt"
   7         "reflect"
   8         "testing"
   9 )
  10
  11 func TestSafeString(t *testing.T) {
  12         _, ok := safeString((*stringStringer)(nil))
  13         if got, want := ok, false; got != want {
  14                 t.Errorf(" got %v, want %v", got, want)
  15         }
  16 }
  17
  18 func TestSafeMarshal(t *testing.T) {
  19         kb, err := safeMarshal((*stringMarshaler)(nil))
  20         if got := kb; got != nil {
  21                 t.Errorf(" got %v, want nil", got)
  22         }
  23         if got, want := err, error(nil); got != want {
  24                 t.Errorf(" got %v, want %v", got, want)
  25         }
  26 }
  27
  28 func TestWriteKeyStrings(t *testing.T) {
  29         keygen := []func(string) interface{}{
  30                 func(s string) interface{} { return s },
  31                 func(s string) interface{} { return stringData(s) },
  32                 func(s string) interface{} { return stringStringer(s) },
  33                 func(s string) interface{} { return stringMarshaler(s) },
  34         }
  35
  36         data := []struct {
  37                 key  string
  38                 want string
  39                 err  error
  40         }{
  41                 {key: "k", want: "k"},
  42                 {key: `\`, want: `\`},
  43                 {key: "\n", err: ErrInvalidKey},
  44                 {key: "\x00", err: ErrInvalidKey},
  45                 {key: "\x10", err: ErrInvalidKey},
  46                 {key: "\x1F", err: ErrInvalidKey},
  47                 {key: "", err: ErrInvalidKey},
  48                 {key: " ", err: ErrInvalidKey},
  49                 {key: "=", err: ErrInvalidKey},
  50                 {key: `"`, err: ErrInvalidKey},
  51         }
  52
  53         for _, g := range keygen {
  54                 for _, d := range data {
  55                         w := &bytes.Buffer{}
  56                         key := g(d.key)
  57                         err := writeKey(w, key)
  58                         if err != d.err {
  59                                 t.Errorf("%#v (%[1]T): got error: %v, want error: %v", key, err, d.err)
  60                         }
  61                         if err != nil {
  62                                 continue
  63                         }
  64                         if got, want := w.String(), d.want; got != want {
  65                                 t.Errorf("%#v (%[1]T): got '%s', want '%s'", key, got, want)
  66                         }
  67                 }
  68         }
  69 }
  70
  71 func TestWriteKey(t *testing.T) {
  72         var (
  73                 nilPtr *int
  74                 one    = 1
  75                 ptr    = &one
  76         )
  77
  78         data := []struct {
  79                 key  interface{}
  80                 want string
  81                 err  error
  82         }{
  83                 {key: nil, err: ErrNilKey},
  84                 {key: nilPtr, err: ErrNilKey},
  85                 {key: (*stringStringer)(nil), err: ErrNilKey},
  86                 {key: (*stringMarshaler)(nil), err: ErrNilKey},
  87                 {key: (*stringerMarshaler)(nil), err: ErrNilKey},
  88                 {key: ptr, want: "1"},
  89
  90                 {key: errorMarshaler{}, err: &MarshalerError{Type: reflect.TypeOf(errorMarshaler{}), Err: errMarshaling}},
  91                 {key: make(chan int), err: ErrUnsupportedKeyType},
  92                 {key: []int{}, err: ErrUnsupportedKeyType},
  93                 {key: map[int]int{}, err: ErrUnsupportedKeyType},
  94                 {key: [2]int{}, err: ErrUnsupportedKeyType},
  95                 {key: struct{}{}, err: ErrUnsupportedKeyType},
  96                 {key: fmt.Sprint, err: ErrUnsupportedKeyType},
  97         }
  98
  99         for _, d := range data {
 100                 w := &bytes.Buffer{}
 101                 err := writeKey(w, d.key)
 102                 if !reflect.DeepEqual(err, d.err) {
 103                         t.Errorf("%#v: got error: %v, want error: %v", d.key, err, d.err)
 104                 }
 105                 if err != nil {
 106                         continue
 107                 }
 108                 if got, want := w.String(), d.want; got != want {
 109                         t.Errorf("%#v: got '%s', want '%s'", d.key, got, want)
 110                 }
 111         }
 112 }
 113
 114 func TestWriteValueStrings(t *testing.T) {
 115         keygen := []func(string) interface{}{
 116                 func(s string) interface{} { return s },
 117                 func(s string) interface{} { return errors.New(s) },
 118                 func(s string) interface{} { return stringData(s) },
 119                 func(s string) interface{} { return stringStringer(s) },
 120                 func(s string) interface{} { return stringMarshaler(s) },
 121         }
 122
 123         data := []struct {
 124                 value string
 125                 want  string
 126                 err   error
 127         }{
 128                 {value: "", want: ""},
 129                 {value: "v", want: "v"},
 130                 {value: " ", want: `" "`},
 131                 {value: "=", want: `"="`},
 132                 {value: `\`, want: `\`},
 133                 {value: `"`, want: `"\""`},
 134                 {value: `\"`, want: `"\\\""`},
 135                 {value: "\n", want: `"\n"`},
 136                 {value: "\x00", want: `"\u0000"`},
 137                 {value: "\x10", want: `"\u0010"`},
 138                 {value: "\x1F", want: `"\u001f"`},
 139                 {value: "µ", want: `µ`},
 140         }
 141
 142         for _, g := range keygen {
 143                 for _, d := range data {
 144                         w := &bytes.Buffer{}
 145                         value := g(d.value)
 146                         err := writeValue(w, value)
 147                         if err != d.err {
 148                                 t.Errorf("%#v (%[1]T): got error: %v, want error: %v", value, err, d.err)
 149                         }
 150                         if err != nil {
 151                                 continue
 152                         }
 153                         if got, want := w.String(), d.want; got != want {
 154                                 t.Errorf("%#v (%[1]T): got '%s', want '%s'", value, got, want)
 155                         }
 156                 }
 157         }
 158 }
 159
 160 func TestWriteValue(t *testing.T) {
 161         var (
 162                 nilPtr *int
 163                 one    = 1
 164                 ptr    = &one
 165         )
 166
 167         data := []struct {
 168                 value interface{}
 169                 want  string
 170                 err   error
 171         }{
 172                 {value: nil, want: "null"},
 173                 {value: nilPtr, want: "null"},
 174                 {value: (*stringStringer)(nil), want: "null"},
 175                 {value: (*stringMarshaler)(nil), want: "null"},
 176                 {value: (*stringerMarshaler)(nil), want: "null"},
 177                 {value: ptr, want: "1"},
 178
 179                 {value: errorMarshaler{}, err: &MarshalerError{Type: reflect.TypeOf(errorMarshaler{}), Err: errMarshaling}},
 180                 {value: make(chan int), err: ErrUnsupportedValueType},
 181                 {value: []int{}, err: ErrUnsupportedValueType},
 182                 {value: map[int]int{}, err: ErrUnsupportedValueType},
 183                 {value: [2]int{}, err: ErrUnsupportedValueType},
 184                 {value: struct{}{}, err: ErrUnsupportedValueType},
 185                 {value: fmt.Sprint, err: ErrUnsupportedValueType},
 186         }
 187
 188         for _, d := range data {
 189                 w := &bytes.Buffer{}
 190                 err := writeValue(w, d.value)
 191                 if !reflect.DeepEqual(err, d.err) {
 192                         t.Errorf("%#v: got error: %v, want error: %v", d.value, err, d.err)
 193                 }
 194                 if err != nil {
 195                         continue
 196                 }
 197                 if got, want := w.String(), d.want; got != want {
 198                         t.Errorf("%#v: got '%s', want '%s'", d.value, got, want)
 199                 }
 200         }
 201 }
 202
 203 type stringData string
 204
 205 type stringStringer string
 206
 207 func (s stringStringer) String() string {
 208         return string(s)
 209 }
 210
 211 type stringMarshaler string
 212
 213 func (s stringMarshaler) MarshalText() ([]byte, error) {
 214         return []byte(s), nil
 215 }
 216
 217 type stringerMarshaler string
 218
 219 func (s stringerMarshaler) String() string {
 220         return "String() called"
 221 }
 222
 223 func (s stringerMarshaler) MarshalText() ([]byte, error) {
 224         return []byte(s), nil
 225 }
 226
 227 var errMarshaling = errors.New("marshal error")
 228
 229 type errorMarshaler struct{}
 230
 231 func (errorMarshaler) MarshalText() ([]byte, error) {
 232         return nil, errMarshaling
 233 }