ceph/src/jaegertracing/thrift/lib/go/thrift/protocol_test.go

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements. See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership. The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License. You may obtain a copy of the License at
   9  *
  10  *   http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing,
  13  * software distributed under the License is distributed on an
  14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15  * KIND, either express or implied. See the License for the
  16  * specific language governing permissions and limitations
  17  * under the License.
  18  */
  19
  20 package thrift
  21
  22 import (
  23         "bytes"
  24         "context"
  25         "io/ioutil"
  26         "math"
  27         "net"
  28         "net/http"
  29         "testing"
  30 )
  31
  32 const PROTOCOL_BINARY_DATA_SIZE = 155
  33
  34 var (
  35         protocol_bdata []byte // test data for writing; same as data
  36         BOOL_VALUES    []bool
  37         BYTE_VALUES    []int8
  38         INT16_VALUES   []int16
  39         INT32_VALUES   []int32
  40         INT64_VALUES   []int64
  41         DOUBLE_VALUES  []float64
  42         STRING_VALUES  []string
  43 )
  44
  45 func init() {
  46         protocol_bdata = make([]byte, PROTOCOL_BINARY_DATA_SIZE)
  47         for i := 0; i < PROTOCOL_BINARY_DATA_SIZE; i++ {
  48                 protocol_bdata[i] = byte((i + 'a') % 255)
  49         }
  50         BOOL_VALUES = []bool{false, true, false, false, true}
  51         BYTE_VALUES = []int8{117, 0, 1, 32, 127, -128, -1}
  52         INT16_VALUES = []int16{459, 0, 1, -1, -128, 127, 32767, -32768}
  53         INT32_VALUES = []int32{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535}
  54         INT64_VALUES = []int64{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535, 34359738481, -35184372088719, -9223372036854775808, 9223372036854775807}
  55         DOUBLE_VALUES = []float64{459.3, 0.0, -1.0, 1.0, 0.5, 0.3333, 3.14159, 1.537e-38, 1.673e25, 6.02214179e23, -6.02214179e23, INFINITY.Float64(), NEGATIVE_INFINITY.Float64(), NAN.Float64()}
  56         STRING_VALUES = []string{"", "a", "st[uf]f", "st,u:ff with spaces", "stuff\twith\nescape\\characters'...\"lots{of}fun</xml>"}
  57 }
  58
  59 type HTTPEchoServer struct{}
  60 type HTTPHeaderEchoServer struct{}
  61
  62 func (p *HTTPEchoServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
  63         buf, err := ioutil.ReadAll(req.Body)
  64         if err != nil {
  65                 w.WriteHeader(http.StatusBadRequest)
  66                 w.Write(buf)
  67         } else {
  68                 w.WriteHeader(http.StatusOK)
  69                 w.Write(buf)
  70         }
  71 }
  72
  73 func (p *HTTPHeaderEchoServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
  74         buf, err := ioutil.ReadAll(req.Body)
  75         if err != nil {
  76                 w.WriteHeader(http.StatusBadRequest)
  77                 w.Write(buf)
  78         } else {
  79                 w.WriteHeader(http.StatusOK)
  80                 w.Write(buf)
  81         }
  82 }
  83
  84 func HttpClientSetupForTest(t *testing.T) (net.Listener, net.Addr) {
  85         addr, err := FindAvailableTCPServerPort(40000)
  86         if err != nil {
  87                 t.Fatalf("Unable to find available tcp port addr: %s", err)
  88                 return nil, addr
  89         }
  90         l, err := net.Listen(addr.Network(), addr.String())
  91         if err != nil {
  92                 t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err)
  93                 return l, addr
  94         }
  95         go http.Serve(l, &HTTPEchoServer{})
  96         return l, addr
  97 }
  98
  99 func HttpClientSetupForHeaderTest(t *testing.T) (net.Listener, net.Addr) {
 100         addr, err := FindAvailableTCPServerPort(40000)
 101         if err != nil {
 102                 t.Fatalf("Unable to find available tcp port addr: %s", err)
 103                 return nil, addr
 104         }
 105         l, err := net.Listen(addr.Network(), addr.String())
 106         if err != nil {
 107                 t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err)
 108                 return l, addr
 109         }
 110         go http.Serve(l, &HTTPHeaderEchoServer{})
 111         return l, addr
 112 }
 113
 114 func ReadWriteProtocolTest(t *testing.T, protocolFactory TProtocolFactory) {
 115         buf := bytes.NewBuffer(make([]byte, 0, 1024))
 116         l, addr := HttpClientSetupForTest(t)
 117         defer l.Close()
 118         transports := []TTransportFactory{
 119                 NewTMemoryBufferTransportFactory(1024),
 120                 NewStreamTransportFactory(buf, buf, true),
 121                 NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024)),
 122                 NewTZlibTransportFactoryWithFactory(0, NewTMemoryBufferTransportFactory(1024)),
 123                 NewTZlibTransportFactoryWithFactory(6, NewTMemoryBufferTransportFactory(1024)),
 124                 NewTZlibTransportFactoryWithFactory(9, NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024))),
 125                 NewTHttpPostClientTransportFactory("http://" + addr.String()),
 126         }
 127         for _, tf := range transports {
 128                 trans, err := tf.GetTransport(nil)
 129                 if err != nil {
 130                         t.Error(err)
 131                         continue
 132                 }
 133                 p := protocolFactory.GetProtocol(trans)
 134                 ReadWriteBool(t, p, trans)
 135                 trans.Close()
 136         }
 137         for _, tf := range transports {
 138                 trans, err := tf.GetTransport(nil)
 139                 if err != nil {
 140                         t.Error(err)
 141                         continue
 142                 }
 143                 p := protocolFactory.GetProtocol(trans)
 144                 ReadWriteByte(t, p, trans)
 145                 trans.Close()
 146         }
 147         for _, tf := range transports {
 148                 trans, err := tf.GetTransport(nil)
 149                 if err != nil {
 150                         t.Error(err)
 151                         continue
 152                 }
 153                 p := protocolFactory.GetProtocol(trans)
 154                 ReadWriteI16(t, p, trans)
 155                 trans.Close()
 156         }
 157         for _, tf := range transports {
 158                 trans, err := tf.GetTransport(nil)
 159                 if err != nil {
 160                         t.Error(err)
 161                         continue
 162                 }
 163                 p := protocolFactory.GetProtocol(trans)
 164                 ReadWriteI32(t, p, trans)
 165                 trans.Close()
 166         }
 167         for _, tf := range transports {
 168                 trans, err := tf.GetTransport(nil)
 169                 if err != nil {
 170                         t.Error(err)
 171                         continue
 172                 }
 173                 p := protocolFactory.GetProtocol(trans)
 174                 ReadWriteI64(t, p, trans)
 175                 trans.Close()
 176         }
 177         for _, tf := range transports {
 178                 trans, err := tf.GetTransport(nil)
 179                 if err != nil {
 180                         t.Error(err)
 181                         continue
 182                 }
 183                 p := protocolFactory.GetProtocol(trans)
 184                 ReadWriteDouble(t, p, trans)
 185                 trans.Close()
 186         }
 187         for _, tf := range transports {
 188                 trans, err := tf.GetTransport(nil)
 189                 if err != nil {
 190                         t.Error(err)
 191                         continue
 192                 }
 193                 p := protocolFactory.GetProtocol(trans)
 194                 ReadWriteString(t, p, trans)
 195                 trans.Close()
 196         }
 197         for _, tf := range transports {
 198                 trans, err := tf.GetTransport(nil)
 199                 if err != nil {
 200                         t.Error(err)
 201                         continue
 202                 }
 203                 p := protocolFactory.GetProtocol(trans)
 204                 ReadWriteBinary(t, p, trans)
 205                 trans.Close()
 206         }
 207         for _, tf := range transports {
 208                 trans, err := tf.GetTransport(nil)
 209                 if err != nil {
 210                         t.Error(err)
 211                         continue
 212                 }
 213                 p := protocolFactory.GetProtocol(trans)
 214                 ReadWriteI64(t, p, trans)
 215                 ReadWriteDouble(t, p, trans)
 216                 ReadWriteBinary(t, p, trans)
 217                 ReadWriteByte(t, p, trans)
 218                 trans.Close()
 219         }
 220 }
 221
 222 func ReadWriteBool(t testing.TB, p TProtocol, trans TTransport) {
 223         thetype := TType(BOOL)
 224         thelen := len(BOOL_VALUES)
 225         err := p.WriteListBegin(thetype, thelen)
 226         if err != nil {
 227                 t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteBool", p, trans, err, thetype)
 228         }
 229         for k, v := range BOOL_VALUES {
 230                 err = p.WriteBool(v)
 231                 if err != nil {
 232                         t.Errorf("%s: %T %T %v Error writing bool in list at index %v: %v", "ReadWriteBool", p, trans, err, k, v)
 233                 }
 234         }
 235         p.WriteListEnd()
 236         if err != nil {
 237                 t.Errorf("%s: %T %T %v Error writing list end: %v", "ReadWriteBool", p, trans, err, BOOL_VALUES)
 238         }
 239         p.Flush(context.Background())
 240         thetype2, thelen2, err := p.ReadListBegin()
 241         if err != nil {
 242                 t.Errorf("%s: %T %T %v Error reading list: %v", "ReadWriteBool", p, trans, err, BOOL_VALUES)
 243         }
 244         _, ok := p.(*TSimpleJSONProtocol)
 245         if !ok {
 246                 if thetype != thetype2 {
 247                         t.Errorf("%s: %T %T type %s != type %s", "ReadWriteBool", p, trans, thetype, thetype2)
 248                 }
 249                 if thelen != thelen2 {
 250                         t.Errorf("%s: %T %T len %v != len %v", "ReadWriteBool", p, trans, thelen, thelen2)
 251                 }
 252         }
 253         for k, v := range BOOL_VALUES {
 254                 value, err := p.ReadBool()
 255                 if err != nil {
 256                         t.Errorf("%s: %T %T %v Error reading bool at index %v: %v", "ReadWriteBool", p, trans, err, k, v)
 257                 }
 258                 if v != value {
 259                         t.Errorf("%s: index %v %v %v %v != %v", "ReadWriteBool", k, p, trans, v, value)
 260                 }
 261         }
 262         err = p.ReadListEnd()
 263         if err != nil {
 264                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteBool", p, trans, err)
 265         }
 266 }
 267
 268 func ReadWriteByte(t testing.TB, p TProtocol, trans TTransport) {
 269         thetype := TType(BYTE)
 270         thelen := len(BYTE_VALUES)
 271         err := p.WriteListBegin(thetype, thelen)
 272         if err != nil {
 273                 t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteByte", p, trans, err, thetype)
 274         }
 275         for k, v := range BYTE_VALUES {
 276                 err = p.WriteByte(v)
 277                 if err != nil {
 278                         t.Errorf("%s: %T %T %q Error writing byte in list at index %d: %q", "ReadWriteByte", p, trans, err, k, v)
 279                 }
 280         }
 281         err = p.WriteListEnd()
 282         if err != nil {
 283                 t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
 284         }
 285         err = p.Flush(context.Background())
 286         if err != nil {
 287                 t.Errorf("%s: %T %T %q Error flushing list of bytes: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
 288         }
 289         thetype2, thelen2, err := p.ReadListBegin()
 290         if err != nil {
 291                 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
 292         }
 293         _, ok := p.(*TSimpleJSONProtocol)
 294         if !ok {
 295                 if thetype != thetype2 {
 296                         t.Errorf("%s: %T %T type %s != type %s", "ReadWriteByte", p, trans, thetype, thetype2)
 297                 }
 298                 if thelen != thelen2 {
 299                         t.Errorf("%s: %T %T len %v != len %v", "ReadWriteByte", p, trans, thelen, thelen2)
 300                 }
 301         }
 302         for k, v := range BYTE_VALUES {
 303                 value, err := p.ReadByte()
 304                 if err != nil {
 305                         t.Errorf("%s: %T %T %q Error reading byte at index %d: %q", "ReadWriteByte", p, trans, err, k, v)
 306                 }
 307                 if v != value {
 308                         t.Errorf("%s: %T %T %d != %d", "ReadWriteByte", p, trans, v, value)
 309                 }
 310         }
 311         err = p.ReadListEnd()
 312         if err != nil {
 313                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteByte", p, trans, err)
 314         }
 315 }
 316
 317 func ReadWriteI16(t testing.TB, p TProtocol, trans TTransport) {
 318         thetype := TType(I16)
 319         thelen := len(INT16_VALUES)
 320         p.WriteListBegin(thetype, thelen)
 321         for _, v := range INT16_VALUES {
 322                 p.WriteI16(v)
 323         }
 324         p.WriteListEnd()
 325         p.Flush(context.Background())
 326         thetype2, thelen2, err := p.ReadListBegin()
 327         if err != nil {
 328                 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI16", p, trans, err, INT16_VALUES)
 329         }
 330         _, ok := p.(*TSimpleJSONProtocol)
 331         if !ok {
 332                 if thetype != thetype2 {
 333                         t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI16", p, trans, thetype, thetype2)
 334                 }
 335                 if thelen != thelen2 {
 336                         t.Errorf("%s: %T %T len %v != len %v", "ReadWriteI16", p, trans, thelen, thelen2)
 337                 }
 338         }
 339         for k, v := range INT16_VALUES {
 340                 value, err := p.ReadI16()
 341                 if err != nil {
 342                         t.Errorf("%s: %T %T %q Error reading int16 at index %d: %q", "ReadWriteI16", p, trans, err, k, v)
 343                 }
 344                 if v != value {
 345                         t.Errorf("%s: %T %T %d != %d", "ReadWriteI16", p, trans, v, value)
 346                 }
 347         }
 348         err = p.ReadListEnd()
 349         if err != nil {
 350                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI16", p, trans, err)
 351         }
 352 }
 353
 354 func ReadWriteI32(t testing.TB, p TProtocol, trans TTransport) {
 355         thetype := TType(I32)
 356         thelen := len(INT32_VALUES)
 357         p.WriteListBegin(thetype, thelen)
 358         for _, v := range INT32_VALUES {
 359                 p.WriteI32(v)
 360         }
 361         p.WriteListEnd()
 362         p.Flush(context.Background())
 363         thetype2, thelen2, err := p.ReadListBegin()
 364         if err != nil {
 365                 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI32", p, trans, err, INT32_VALUES)
 366         }
 367         _, ok := p.(*TSimpleJSONProtocol)
 368         if !ok {
 369                 if thetype != thetype2 {
 370                         t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI32", p, trans, thetype, thetype2)
 371                 }
 372                 if thelen != thelen2 {
 373                         t.Errorf("%s: %T %T len %v != len %v", "ReadWriteI32", p, trans, thelen, thelen2)
 374                 }
 375         }
 376         for k, v := range INT32_VALUES {
 377                 value, err := p.ReadI32()
 378                 if err != nil {
 379                         t.Errorf("%s: %T %T %q Error reading int32 at index %d: %q", "ReadWriteI32", p, trans, err, k, v)
 380                 }
 381                 if v != value {
 382                         t.Errorf("%s: %T %T %d != %d", "ReadWriteI32", p, trans, v, value)
 383                 }
 384         }
 385         if err != nil {
 386                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI32", p, trans, err)
 387         }
 388 }
 389
 390 func ReadWriteI64(t testing.TB, p TProtocol, trans TTransport) {
 391         thetype := TType(I64)
 392         thelen := len(INT64_VALUES)
 393         p.WriteListBegin(thetype, thelen)
 394         for _, v := range INT64_VALUES {
 395                 p.WriteI64(v)
 396         }
 397         p.WriteListEnd()
 398         p.Flush(context.Background())
 399         thetype2, thelen2, err := p.ReadListBegin()
 400         if err != nil {
 401                 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI64", p, trans, err, INT64_VALUES)
 402         }
 403         _, ok := p.(*TSimpleJSONProtocol)
 404         if !ok {
 405                 if thetype != thetype2 {
 406                         t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI64", p, trans, thetype, thetype2)
 407                 }
 408                 if thelen != thelen2 {
 409                         t.Errorf("%s: %T %T len %v != len %v", "ReadWriteI64", p, trans, thelen, thelen2)
 410                 }
 411         }
 412         for k, v := range INT64_VALUES {
 413                 value, err := p.ReadI64()
 414                 if err != nil {
 415                         t.Errorf("%s: %T %T %q Error reading int64 at index %d: %q", "ReadWriteI64", p, trans, err, k, v)
 416                 }
 417                 if v != value {
 418                         t.Errorf("%s: %T %T %q != %q", "ReadWriteI64", p, trans, v, value)
 419                 }
 420         }
 421         if err != nil {
 422                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI64", p, trans, err)
 423         }
 424 }
 425
 426 func ReadWriteDouble(t testing.TB, p TProtocol, trans TTransport) {
 427         thetype := TType(DOUBLE)
 428         thelen := len(DOUBLE_VALUES)
 429         p.WriteListBegin(thetype, thelen)
 430         for _, v := range DOUBLE_VALUES {
 431                 p.WriteDouble(v)
 432         }
 433         p.WriteListEnd()
 434         p.Flush(context.Background())
 435         thetype2, thelen2, err := p.ReadListBegin()
 436         if err != nil {
 437                 t.Errorf("%s: %T %T %v Error reading list: %v", "ReadWriteDouble", p, trans, err, DOUBLE_VALUES)
 438         }
 439         if thetype != thetype2 {
 440                 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteDouble", p, trans, thetype, thetype2)
 441         }
 442         if thelen != thelen2 {
 443                 t.Errorf("%s: %T %T len %v != len %v", "ReadWriteDouble", p, trans, thelen, thelen2)
 444         }
 445         for k, v := range DOUBLE_VALUES {
 446                 value, err := p.ReadDouble()
 447                 if err != nil {
 448                         t.Errorf("%s: %T %T %q Error reading double at index %d: %v", "ReadWriteDouble", p, trans, err, k, v)
 449                 }
 450                 if math.IsNaN(v) {
 451                         if !math.IsNaN(value) {
 452                                 t.Errorf("%s: %T %T math.IsNaN(%v) != math.IsNaN(%v)", "ReadWriteDouble", p, trans, v, value)
 453                         }
 454                 } else if v != value {
 455                         t.Errorf("%s: %T %T %v != %v", "ReadWriteDouble", p, trans, v, value)
 456                 }
 457         }
 458         err = p.ReadListEnd()
 459         if err != nil {
 460                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteDouble", p, trans, err)
 461         }
 462 }
 463
 464 func ReadWriteString(t testing.TB, p TProtocol, trans TTransport) {
 465         thetype := TType(STRING)
 466         thelen := len(STRING_VALUES)
 467         p.WriteListBegin(thetype, thelen)
 468         for _, v := range STRING_VALUES {
 469                 p.WriteString(v)
 470         }
 471         p.WriteListEnd()
 472         p.Flush(context.Background())
 473         thetype2, thelen2, err := p.ReadListBegin()
 474         if err != nil {
 475                 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteString", p, trans, err, STRING_VALUES)
 476         }
 477         _, ok := p.(*TSimpleJSONProtocol)
 478         if !ok {
 479                 if thetype != thetype2 {
 480                         t.Errorf("%s: %T %T type %s != type %s", "ReadWriteString", p, trans, thetype, thetype2)
 481                 }
 482                 if thelen != thelen2 {
 483                         t.Errorf("%s: %T %T len %v != len %v", "ReadWriteString", p, trans, thelen, thelen2)
 484                 }
 485         }
 486         for k, v := range STRING_VALUES {
 487                 value, err := p.ReadString()
 488                 if err != nil {
 489                         t.Errorf("%s: %T %T %q Error reading string at index %d: %q", "ReadWriteString", p, trans, err, k, v)
 490                 }
 491                 if v != value {
 492                         t.Errorf("%s: %T %T %v != %v", "ReadWriteString", p, trans, v, value)
 493                 }
 494         }
 495         if err != nil {
 496                 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteString", p, trans, err)
 497         }
 498 }
 499
 500 func ReadWriteBinary(t testing.TB, p TProtocol, trans TTransport) {
 501         v := protocol_bdata
 502         p.WriteBinary(v)
 503         p.Flush(context.Background())
 504         value, err := p.ReadBinary()
 505         if err != nil {
 506                 t.Errorf("%s: %T %T Unable to read binary: %s", "ReadWriteBinary", p, trans, err.Error())
 507         }
 508         if len(v) != len(value) {
 509                 t.Errorf("%s: %T %T len(v) != len(value)... %d != %d", "ReadWriteBinary", p, trans, len(v), len(value))
 510         } else {
 511                 for i := 0; i < len(v); i++ {
 512                         if v[i] != value[i] {
 513                                 t.Errorf("%s: %T %T %s != %s", "ReadWriteBinary", p, trans, v, value)
 514                         }
 515                 }
 516         }
 517 }