github.com/artyom/thrift@v0.0.0-20130902103359-388840a05deb/protocol_test.go (about) 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 "io/ioutil" 25 "math" 26 "net" 27 "net/http" 28 "testing" 29 ) 30 31 const PROTOCOL_BINARY_DATA_SIZE = 155 32 33 var ( 34 data string // test data for writing 35 protocol_bdata []byte // test data for writing; same as data 36 BOOL_VALUES []bool 37 BYTE_VALUES []byte 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 data = string(protocol_bdata) 51 BOOL_VALUES = []bool{false, true, false, false, true} 52 BYTE_VALUES = []byte{117, 0, 1, 32, 127, 128, 255} 53 INT16_VALUES = []int16{459, 0, 1, -1, -128, 127, 32767, -32768} 54 INT32_VALUES = []int32{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535} 55 INT64_VALUES = []int64{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535, 34359738481, -35184372088719, -9223372036854775808, 9223372036854775807} 56 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()} 57 STRING_VALUES = []string{"", "a", "st[uf]f", "st,u:ff with spaces", "stuff\twith\nescape\\characters'...\"lots{of}fun</xml>"} 58 } 59 60 type HTTPEchoServer 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 HttpClientSetupForTest(t *testing.T) (net.Listener, net.Addr) { 74 addr, err := FindAvailableTCPServerPort(40000) 75 if err != nil { 76 t.Fatalf("Unable to find available tcp port addr: %s", err) 77 return nil, addr 78 } 79 l, err := net.Listen(addr.Network(), addr.String()) 80 if err != nil { 81 t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err) 82 return l, addr 83 } 84 go http.Serve(l, &HTTPEchoServer{}) 85 return l, addr 86 } 87 88 func ReadWriteProtocolTest(t *testing.T, protocolFactory TProtocolFactory) { 89 buf := bytes.NewBuffer(make([]byte, 0, 1024)) 90 l, addr := HttpClientSetupForTest(t) 91 defer l.Close() 92 transports := []TTransportFactory{ 93 NewTMemoryBufferTransportFactory(1024), 94 NewStreamTransportFactory(buf, buf, true), 95 NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024)), 96 NewTHttpPostClientTransportFactory("http://" + addr.String()), 97 } 98 for _, tf := range transports { 99 trans := tf.GetTransport(nil) 100 p := protocolFactory.GetProtocol(trans) 101 ReadWriteBool(t, p, trans) 102 trans.Close() 103 } 104 for _, tf := range transports { 105 trans := tf.GetTransport(nil) 106 p := protocolFactory.GetProtocol(trans) 107 ReadWriteByte(t, p, trans) 108 trans.Close() 109 } 110 for _, tf := range transports { 111 trans := tf.GetTransport(nil) 112 p := protocolFactory.GetProtocol(trans) 113 ReadWriteI16(t, p, trans) 114 trans.Close() 115 } 116 for _, tf := range transports { 117 trans := tf.GetTransport(nil) 118 p := protocolFactory.GetProtocol(trans) 119 ReadWriteI32(t, p, trans) 120 trans.Close() 121 } 122 for _, tf := range transports { 123 trans := tf.GetTransport(nil) 124 p := protocolFactory.GetProtocol(trans) 125 ReadWriteI64(t, p, trans) 126 trans.Close() 127 } 128 for _, tf := range transports { 129 trans := tf.GetTransport(nil) 130 p := protocolFactory.GetProtocol(trans) 131 ReadWriteDouble(t, p, trans) 132 trans.Close() 133 } 134 for _, tf := range transports { 135 trans := tf.GetTransport(nil) 136 p := protocolFactory.GetProtocol(trans) 137 ReadWriteString(t, p, trans) 138 trans.Close() 139 } 140 for _, tf := range transports { 141 trans := tf.GetTransport(nil) 142 p := protocolFactory.GetProtocol(trans) 143 ReadWriteBinary(t, p, trans) 144 trans.Close() 145 } 146 147 for _, tf := range transports { 148 trans := tf.GetTransport(nil) 149 p := protocolFactory.GetProtocol(trans); 150 ReadWriteI64(t, p, trans); 151 ReadWriteDouble(t, p, trans); 152 ReadWriteBinary(t, p, trans); 153 ReadWriteByte(t, p, trans); 154 trans.Close() 155 } 156 157 } 158 159 func ReadWriteBool(t *testing.T, p TProtocol, trans TTransport) { 160 thetype := TType(BOOL) 161 thelen := len(BOOL_VALUES) 162 err := p.WriteListBegin(thetype, thelen) 163 if err != nil { 164 t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteBool", p, trans, err, thetype) 165 } 166 for k, v := range BOOL_VALUES { 167 err = p.WriteBool(v) 168 if err != nil { 169 t.Errorf("%s: %T %T %q Error writing bool in list at index %d: %q", "ReadWriteBool", p, trans, err, k, v) 170 } 171 } 172 p.WriteListEnd() 173 if err != nil { 174 t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteBool", p, trans, err, BOOL_VALUES) 175 } 176 p.Flush() 177 thetype2, thelen2, err := p.ReadListBegin() 178 if err != nil { 179 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteBool", p, trans, err, BOOL_VALUES) 180 } 181 _, ok := p.(*TSimpleJSONProtocol) 182 if !ok { 183 if thetype != thetype2 { 184 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteBool", p, trans, thetype, thetype2) 185 } 186 if thelen != thelen2 { 187 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteBool", p, trans, thelen, thelen2) 188 } 189 } 190 for k, v := range BOOL_VALUES { 191 value, err := p.ReadBool() 192 if err != nil { 193 t.Errorf("%s: %T %T %q Error reading bool at index %d: %q", "ReadWriteBool", p, trans, err, k, v) 194 } 195 if v != value { 196 t.Errorf("%s: index %d %q %q %q != %q", "ReadWriteBool", k, p, trans, v, value) 197 } 198 } 199 err = p.ReadListEnd() 200 if err != nil { 201 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteBool", p, trans, err) 202 } 203 } 204 205 func ReadWriteByte(t *testing.T, p TProtocol, trans TTransport) { 206 thetype := TType(BYTE) 207 thelen := len(BYTE_VALUES) 208 err := p.WriteListBegin(thetype, thelen) 209 if err != nil { 210 t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteByte", p, trans, err, thetype) 211 } 212 for k, v := range BYTE_VALUES { 213 err = p.WriteByte(v) 214 if err != nil { 215 t.Errorf("%s: %T %T %q Error writing byte in list at index %d: %q", "ReadWriteByte", p, trans, err, k, v) 216 } 217 } 218 err = p.WriteListEnd() 219 if err != nil { 220 t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES) 221 } 222 err = p.Flush() 223 if err != nil { 224 t.Errorf("%s: %T %T %q Error flushing list of bytes: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES) 225 } 226 thetype2, thelen2, err := p.ReadListBegin() 227 if err != nil { 228 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES) 229 } 230 _, ok := p.(*TSimpleJSONProtocol) 231 if !ok { 232 if thetype != thetype2 { 233 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteByte", p, trans, thetype, thetype2) 234 } 235 if thelen != thelen2 { 236 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteByte", p, trans, thelen, thelen2) 237 } 238 } 239 for k, v := range BYTE_VALUES { 240 value, err := p.ReadByte() 241 if err != nil { 242 t.Errorf("%s: %T %T %q Error reading byte at index %d: %q", "ReadWriteByte", p, trans, err, k, v) 243 } 244 if v != value { 245 t.Errorf("%s: %T %T %d != %d", "ReadWriteByte", p, trans, v, value) 246 } 247 } 248 err = p.ReadListEnd() 249 if err != nil { 250 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteByte", p, trans, err) 251 } 252 } 253 254 func ReadWriteI16(t *testing.T, p TProtocol, trans TTransport) { 255 thetype := TType(I16) 256 thelen := len(INT16_VALUES) 257 p.WriteListBegin(thetype, thelen) 258 for _, v := range INT16_VALUES { 259 p.WriteI16(v) 260 } 261 p.WriteListEnd() 262 p.Flush() 263 thetype2, thelen2, err := p.ReadListBegin() 264 if err != nil { 265 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI16", p, trans, err, INT16_VALUES) 266 } 267 _, ok := p.(*TSimpleJSONProtocol) 268 if !ok { 269 if thetype != thetype2 { 270 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI16", p, trans, thetype, thetype2) 271 } 272 if thelen != thelen2 { 273 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteI16", p, trans, thelen, thelen2) 274 } 275 } 276 for k, v := range INT16_VALUES { 277 value, err := p.ReadI16() 278 if err != nil { 279 t.Errorf("%s: %T %T %q Error reading int16 at index %d: %q", "ReadWriteI16", p, trans, err, k, v) 280 } 281 if v != value { 282 t.Errorf("%s: %T %T %d != %d", "ReadWriteI16", p, trans, v, value) 283 } 284 } 285 err = p.ReadListEnd() 286 if err != nil { 287 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI16", p, trans, err) 288 } 289 } 290 291 func ReadWriteI32(t *testing.T, p TProtocol, trans TTransport) { 292 thetype := TType(I32) 293 thelen := len(INT32_VALUES) 294 p.WriteListBegin(thetype, thelen) 295 for _, v := range INT32_VALUES { 296 p.WriteI32(v) 297 } 298 p.WriteListEnd() 299 p.Flush() 300 thetype2, thelen2, err := p.ReadListBegin() 301 if err != nil { 302 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI32", p, trans, err, INT32_VALUES) 303 } 304 _, ok := p.(*TSimpleJSONProtocol) 305 if !ok { 306 if thetype != thetype2 { 307 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI32", p, trans, thetype, thetype2) 308 } 309 if thelen != thelen2 { 310 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteI32", p, trans, thelen, thelen2) 311 } 312 } 313 for k, v := range INT32_VALUES { 314 value, err := p.ReadI32() 315 if err != nil { 316 t.Errorf("%s: %T %T %q Error reading int32 at index %d: %q", "ReadWriteI32", p, trans, err, k, v) 317 } 318 if v != value { 319 t.Errorf("%s: %T %T %d != %d", "ReadWriteI32", p, trans, v, value) 320 } 321 } 322 if err != nil { 323 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI32", p, trans, err) 324 } 325 } 326 327 func ReadWriteI64(t *testing.T, p TProtocol, trans TTransport) { 328 thetype := TType(I64) 329 thelen := len(INT64_VALUES) 330 p.WriteListBegin(thetype, thelen) 331 for _, v := range INT64_VALUES { 332 p.WriteI64(v) 333 } 334 p.WriteListEnd() 335 p.Flush() 336 thetype2, thelen2, err := p.ReadListBegin() 337 if err != nil { 338 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI64", p, trans, err, INT64_VALUES) 339 } 340 _, ok := p.(*TSimpleJSONProtocol) 341 if !ok { 342 if thetype != thetype2 { 343 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI64", p, trans, thetype, thetype2) 344 } 345 if thelen != thelen2 { 346 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteI64", p, trans, thelen, thelen2) 347 } 348 } 349 for k, v := range INT64_VALUES { 350 value, err := p.ReadI64() 351 if err != nil { 352 t.Errorf("%s: %T %T %q Error reading int64 at index %d: %q", "ReadWriteI64", p, trans, err, k, v) 353 } 354 if v != value { 355 t.Errorf("%s: %T %T %q != %q", "ReadWriteI64", p, trans, v, value) 356 } 357 } 358 if err != nil { 359 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI64", p, trans, err) 360 } 361 } 362 363 func ReadWriteDouble(t *testing.T, p TProtocol, trans TTransport) { 364 thetype := TType(DOUBLE) 365 thelen := len(DOUBLE_VALUES) 366 p.WriteListBegin(thetype, thelen) 367 for _, v := range DOUBLE_VALUES { 368 p.WriteDouble(v) 369 } 370 p.WriteListEnd() 371 p.Flush() 372 wrotebuffer := "" 373 if memtrans, ok := trans.(*TMemoryBuffer); ok { 374 wrotebuffer = memtrans.String() 375 } 376 thetype2, thelen2, err := p.ReadListBegin() 377 if err != nil { 378 t.Errorf("%s: %T %T %q Error reading list: %q, wrote: %v", "ReadWriteDouble", p, trans, err, DOUBLE_VALUES, wrotebuffer) 379 } 380 if thetype != thetype2 { 381 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteDouble", p, trans, thetype, thetype2) 382 } 383 if thelen != thelen2 { 384 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteDouble", p, trans, thelen, thelen2) 385 } 386 for k, v := range DOUBLE_VALUES { 387 value, err := p.ReadDouble() 388 if err != nil { 389 t.Errorf("%s: %T %T %q Error reading double at index %d: %q", "ReadWriteDouble", p, trans, err, k, v) 390 } 391 if math.IsNaN(v) { 392 if !math.IsNaN(value) { 393 t.Errorf("%s: %T %T math.IsNaN(%q) != math.IsNaN(%q)", "ReadWriteDouble", p, trans, v, value) 394 } 395 } else if v != value { 396 t.Errorf("%s: %T %T %v != %q", "ReadWriteDouble", p, trans, v, value) 397 } 398 } 399 err = p.ReadListEnd() 400 if err != nil { 401 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteDouble", p, trans, err) 402 } 403 } 404 405 func ReadWriteString(t *testing.T, p TProtocol, trans TTransport) { 406 thetype := TType(STRING) 407 thelen := len(STRING_VALUES) 408 p.WriteListBegin(thetype, thelen) 409 for _, v := range STRING_VALUES { 410 p.WriteString(v) 411 } 412 p.WriteListEnd() 413 p.Flush() 414 thetype2, thelen2, err := p.ReadListBegin() 415 if err != nil { 416 t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteString", p, trans, err, STRING_VALUES) 417 } 418 _, ok := p.(*TSimpleJSONProtocol) 419 if !ok { 420 if thetype != thetype2 { 421 t.Errorf("%s: %T %T type %s != type %s", "ReadWriteString", p, trans, thetype, thetype2) 422 } 423 if thelen != thelen2 { 424 t.Errorf("%s: %T %T len %s != len %s", "ReadWriteString", p, trans, thelen, thelen2) 425 } 426 } 427 for k, v := range STRING_VALUES { 428 value, err := p.ReadString() 429 if err != nil { 430 t.Errorf("%s: %T %T %q Error reading string at index %d: %q", "ReadWriteString", p, trans, err, k, v) 431 } 432 if v != value { 433 t.Errorf("%s: %T %T %d != %d", "ReadWriteString", p, trans, v, value) 434 } 435 } 436 if err != nil { 437 t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteString", p, trans, err) 438 } 439 } 440 441 func ReadWriteBinary(t *testing.T, p TProtocol, trans TTransport) { 442 v := protocol_bdata 443 p.WriteBinary(v) 444 p.Flush() 445 value, err := p.ReadBinary() 446 if err != nil { 447 t.Errorf("%s: %T %T Unable to read binary: %s", "ReadWriteBinary", p, trans, err.Error()) 448 } 449 if len(v) != len(value) { 450 t.Errorf("%s: %T %T len(v) != len(value)... %d != %d", "ReadWriteBinary", p, trans, len(v), len(value)) 451 } else { 452 for i := 0; i < len(v); i++ { 453 if v[i] != value[i] { 454 t.Errorf("%s: %T %T %s != %s", "ReadWriteBinary", p, trans, v, value) 455 } 456 } 457 } 458 }