ceph/src/jaegertracing/thrift/lib/go/test/tests/protocol_mock.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 // Automatically generated by MockGen. DO NOT EDIT!
  21 // Source: thrift (interfaces: TProtocol)
  22
  23 package tests
  24
  25 import (
  26         "context"
  27         thrift "thrift"
  28
  29         gomock "github.com/golang/mock/gomock"
  30 )
  31
  32 // Mock of TProtocol interface
  33 type MockTProtocol struct {
  34         ctrl     *gomock.Controller
  35         recorder *_MockTProtocolRecorder
  36 }
  37
  38 // Recorder for MockTProtocol (not exported)
  39 type _MockTProtocolRecorder struct {
  40         mock *MockTProtocol
  41 }
  42
  43 func NewMockTProtocol(ctrl *gomock.Controller) *MockTProtocol {
  44         mock := &MockTProtocol{ctrl: ctrl}
  45         mock.recorder = &_MockTProtocolRecorder{mock}
  46         return mock
  47 }
  48
  49 func (_m *MockTProtocol) EXPECT() *_MockTProtocolRecorder {
  50         return _m.recorder
  51 }
  52
  53 func (_m *MockTProtocol) Flush(ctx context.Context) error {
  54         ret := _m.ctrl.Call(_m, "Flush")
  55         ret0, _ := ret[0].(error)
  56         return ret0
  57 }
  58
  59 func (_mr *_MockTProtocolRecorder) Flush(ctx context.Context) *gomock.Call {
  60         return _mr.mock.ctrl.RecordCall(_mr.mock, "Flush")
  61 }
  62
  63 func (_m *MockTProtocol) ReadBinary() ([]byte, error) {
  64         ret := _m.ctrl.Call(_m, "ReadBinary")
  65         ret0, _ := ret[0].([]byte)
  66         ret1, _ := ret[1].(error)
  67         return ret0, ret1
  68 }
  69
  70 func (_mr *_MockTProtocolRecorder) ReadBinary() *gomock.Call {
  71         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadBinary")
  72 }
  73
  74 func (_m *MockTProtocol) ReadBool() (bool, error) {
  75         ret := _m.ctrl.Call(_m, "ReadBool")
  76         ret0, _ := ret[0].(bool)
  77         ret1, _ := ret[1].(error)
  78         return ret0, ret1
  79 }
  80
  81 func (_mr *_MockTProtocolRecorder) ReadBool() *gomock.Call {
  82         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadBool")
  83 }
  84
  85 func (_m *MockTProtocol) ReadByte() (int8, error) {
  86         ret := _m.ctrl.Call(_m, "ReadByte")
  87         ret0, _ := ret[0].(int8)
  88         ret1, _ := ret[1].(error)
  89         return ret0, ret1
  90 }
  91
  92 func (_mr *_MockTProtocolRecorder) ReadByte() *gomock.Call {
  93         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadByte")
  94 }
  95
  96 func (_m *MockTProtocol) ReadDouble() (float64, error) {
  97         ret := _m.ctrl.Call(_m, "ReadDouble")
  98         ret0, _ := ret[0].(float64)
  99         ret1, _ := ret[1].(error)
 100         return ret0, ret1
 101 }
 102
 103 func (_mr *_MockTProtocolRecorder) ReadDouble() *gomock.Call {
 104         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadDouble")
 105 }
 106
 107 func (_m *MockTProtocol) ReadFieldBegin() (string, thrift.TType, int16, error) {
 108         ret := _m.ctrl.Call(_m, "ReadFieldBegin")
 109         ret0, _ := ret[0].(string)
 110         ret1, _ := ret[1].(thrift.TType)
 111         ret2, _ := ret[2].(int16)
 112         ret3, _ := ret[3].(error)
 113         return ret0, ret1, ret2, ret3
 114 }
 115
 116 func (_mr *_MockTProtocolRecorder) ReadFieldBegin() *gomock.Call {
 117         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadFieldBegin")
 118 }
 119
 120 func (_m *MockTProtocol) ReadFieldEnd() error {
 121         ret := _m.ctrl.Call(_m, "ReadFieldEnd")
 122         ret0, _ := ret[0].(error)
 123         return ret0
 124 }
 125
 126 func (_mr *_MockTProtocolRecorder) ReadFieldEnd() *gomock.Call {
 127         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadFieldEnd")
 128 }
 129
 130 func (_m *MockTProtocol) ReadI16() (int16, error) {
 131         ret := _m.ctrl.Call(_m, "ReadI16")
 132         ret0, _ := ret[0].(int16)
 133         ret1, _ := ret[1].(error)
 134         return ret0, ret1
 135 }
 136
 137 func (_mr *_MockTProtocolRecorder) ReadI16() *gomock.Call {
 138         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI16")
 139 }
 140
 141 func (_m *MockTProtocol) ReadI32() (int32, error) {
 142         ret := _m.ctrl.Call(_m, "ReadI32")
 143         ret0, _ := ret[0].(int32)
 144         ret1, _ := ret[1].(error)
 145         return ret0, ret1
 146 }
 147
 148 func (_mr *_MockTProtocolRecorder) ReadI32() *gomock.Call {
 149         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI32")
 150 }
 151
 152 func (_m *MockTProtocol) ReadI64() (int64, error) {
 153         ret := _m.ctrl.Call(_m, "ReadI64")
 154         ret0, _ := ret[0].(int64)
 155         ret1, _ := ret[1].(error)
 156         return ret0, ret1
 157 }
 158
 159 func (_mr *_MockTProtocolRecorder) ReadI64() *gomock.Call {
 160         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI64")
 161 }
 162
 163 func (_m *MockTProtocol) ReadListBegin() (thrift.TType, int, error) {
 164         ret := _m.ctrl.Call(_m, "ReadListBegin")
 165         ret0, _ := ret[0].(thrift.TType)
 166         ret1, _ := ret[1].(int)
 167         ret2, _ := ret[2].(error)
 168         return ret0, ret1, ret2
 169 }
 170
 171 func (_mr *_MockTProtocolRecorder) ReadListBegin() *gomock.Call {
 172         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadListBegin")
 173 }
 174
 175 func (_m *MockTProtocol) ReadListEnd() error {
 176         ret := _m.ctrl.Call(_m, "ReadListEnd")
 177         ret0, _ := ret[0].(error)
 178         return ret0
 179 }
 180
 181 func (_mr *_MockTProtocolRecorder) ReadListEnd() *gomock.Call {
 182         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadListEnd")
 183 }
 184
 185 func (_m *MockTProtocol) ReadMapBegin() (thrift.TType, thrift.TType, int, error) {
 186         ret := _m.ctrl.Call(_m, "ReadMapBegin")
 187         ret0, _ := ret[0].(thrift.TType)
 188         ret1, _ := ret[1].(thrift.TType)
 189         ret2, _ := ret[2].(int)
 190         ret3, _ := ret[3].(error)
 191         return ret0, ret1, ret2, ret3
 192 }
 193
 194 func (_mr *_MockTProtocolRecorder) ReadMapBegin() *gomock.Call {
 195         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMapBegin")
 196 }
 197
 198 func (_m *MockTProtocol) ReadMapEnd() error {
 199         ret := _m.ctrl.Call(_m, "ReadMapEnd")
 200         ret0, _ := ret[0].(error)
 201         return ret0
 202 }
 203
 204 func (_mr *_MockTProtocolRecorder) ReadMapEnd() *gomock.Call {
 205         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMapEnd")
 206 }
 207
 208 func (_m *MockTProtocol) ReadMessageBegin() (string, thrift.TMessageType, int32, error) {
 209         ret := _m.ctrl.Call(_m, "ReadMessageBegin")
 210         ret0, _ := ret[0].(string)
 211         ret1, _ := ret[1].(thrift.TMessageType)
 212         ret2, _ := ret[2].(int32)
 213         ret3, _ := ret[3].(error)
 214         return ret0, ret1, ret2, ret3
 215 }
 216
 217 func (_mr *_MockTProtocolRecorder) ReadMessageBegin() *gomock.Call {
 218         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessageBegin")
 219 }
 220
 221 func (_m *MockTProtocol) ReadMessageEnd() error {
 222         ret := _m.ctrl.Call(_m, "ReadMessageEnd")
 223         ret0, _ := ret[0].(error)
 224         return ret0
 225 }
 226
 227 func (_mr *_MockTProtocolRecorder) ReadMessageEnd() *gomock.Call {
 228         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessageEnd")
 229 }
 230
 231 func (_m *MockTProtocol) ReadSetBegin() (thrift.TType, int, error) {
 232         ret := _m.ctrl.Call(_m, "ReadSetBegin")
 233         ret0, _ := ret[0].(thrift.TType)
 234         ret1, _ := ret[1].(int)
 235         ret2, _ := ret[2].(error)
 236         return ret0, ret1, ret2
 237 }
 238
 239 func (_mr *_MockTProtocolRecorder) ReadSetBegin() *gomock.Call {
 240         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadSetBegin")
 241 }
 242
 243 func (_m *MockTProtocol) ReadSetEnd() error {
 244         ret := _m.ctrl.Call(_m, "ReadSetEnd")
 245         ret0, _ := ret[0].(error)
 246         return ret0
 247 }
 248
 249 func (_mr *_MockTProtocolRecorder) ReadSetEnd() *gomock.Call {
 250         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadSetEnd")
 251 }
 252
 253 func (_m *MockTProtocol) ReadString() (string, error) {
 254         ret := _m.ctrl.Call(_m, "ReadString")
 255         ret0, _ := ret[0].(string)
 256         ret1, _ := ret[1].(error)
 257         return ret0, ret1
 258 }
 259
 260 func (_mr *_MockTProtocolRecorder) ReadString() *gomock.Call {
 261         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadString")
 262 }
 263
 264 func (_m *MockTProtocol) ReadStructBegin() (string, error) {
 265         ret := _m.ctrl.Call(_m, "ReadStructBegin")
 266         ret0, _ := ret[0].(string)
 267         ret1, _ := ret[1].(error)
 268         return ret0, ret1
 269 }
 270
 271 func (_mr *_MockTProtocolRecorder) ReadStructBegin() *gomock.Call {
 272         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadStructBegin")
 273 }
 274
 275 func (_m *MockTProtocol) ReadStructEnd() error {
 276         ret := _m.ctrl.Call(_m, "ReadStructEnd")
 277         ret0, _ := ret[0].(error)
 278         return ret0
 279 }
 280
 281 func (_mr *_MockTProtocolRecorder) ReadStructEnd() *gomock.Call {
 282         return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadStructEnd")
 283 }
 284
 285 func (_m *MockTProtocol) Skip(_param0 thrift.TType) error {
 286         ret := _m.ctrl.Call(_m, "Skip", _param0)
 287         ret0, _ := ret[0].(error)
 288         return ret0
 289 }
 290
 291 func (_mr *_MockTProtocolRecorder) Skip(arg0 interface{}) *gomock.Call {
 292         return _mr.mock.ctrl.RecordCall(_mr.mock, "Skip", arg0)
 293 }
 294
 295 func (_m *MockTProtocol) Transport() thrift.TTransport {
 296         ret := _m.ctrl.Call(_m, "Transport")
 297         ret0, _ := ret[0].(thrift.TTransport)
 298         return ret0
 299 }
 300
 301 func (_mr *_MockTProtocolRecorder) Transport() *gomock.Call {
 302         return _mr.mock.ctrl.RecordCall(_mr.mock, "Transport")
 303 }
 304
 305 func (_m *MockTProtocol) WriteBinary(_param0 []byte) error {
 306         ret := _m.ctrl.Call(_m, "WriteBinary", _param0)
 307         ret0, _ := ret[0].(error)
 308         return ret0
 309 }
 310
 311 func (_mr *_MockTProtocolRecorder) WriteBinary(arg0 interface{}) *gomock.Call {
 312         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteBinary", arg0)
 313 }
 314
 315 func (_m *MockTProtocol) WriteBool(_param0 bool) error {
 316         ret := _m.ctrl.Call(_m, "WriteBool", _param0)
 317         ret0, _ := ret[0].(error)
 318         return ret0
 319 }
 320
 321 func (_mr *_MockTProtocolRecorder) WriteBool(arg0 interface{}) *gomock.Call {
 322         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteBool", arg0)
 323 }
 324
 325 func (_m *MockTProtocol) WriteByte(_param0 int8) error {
 326         ret := _m.ctrl.Call(_m, "WriteByte", _param0)
 327         ret0, _ := ret[0].(error)
 328         return ret0
 329 }
 330
 331 func (_mr *_MockTProtocolRecorder) WriteByte(arg0 interface{}) *gomock.Call {
 332         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteByte", arg0)
 333 }
 334
 335 func (_m *MockTProtocol) WriteDouble(_param0 float64) error {
 336         ret := _m.ctrl.Call(_m, "WriteDouble", _param0)
 337         ret0, _ := ret[0].(error)
 338         return ret0
 339 }
 340
 341 func (_mr *_MockTProtocolRecorder) WriteDouble(arg0 interface{}) *gomock.Call {
 342         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteDouble", arg0)
 343 }
 344
 345 func (_m *MockTProtocol) WriteFieldBegin(_param0 string, _param1 thrift.TType, _param2 int16) error {
 346         ret := _m.ctrl.Call(_m, "WriteFieldBegin", _param0, _param1, _param2)
 347         ret0, _ := ret[0].(error)
 348         return ret0
 349 }
 350
 351 func (_mr *_MockTProtocolRecorder) WriteFieldBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
 352         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldBegin", arg0, arg1, arg2)
 353 }
 354
 355 func (_m *MockTProtocol) WriteFieldEnd() error {
 356         ret := _m.ctrl.Call(_m, "WriteFieldEnd")
 357         ret0, _ := ret[0].(error)
 358         return ret0
 359 }
 360
 361 func (_mr *_MockTProtocolRecorder) WriteFieldEnd() *gomock.Call {
 362         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldEnd")
 363 }
 364
 365 func (_m *MockTProtocol) WriteFieldStop() error {
 366         ret := _m.ctrl.Call(_m, "WriteFieldStop")
 367         ret0, _ := ret[0].(error)
 368         return ret0
 369 }
 370
 371 func (_mr *_MockTProtocolRecorder) WriteFieldStop() *gomock.Call {
 372         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldStop")
 373 }
 374
 375 func (_m *MockTProtocol) WriteI16(_param0 int16) error {
 376         ret := _m.ctrl.Call(_m, "WriteI16", _param0)
 377         ret0, _ := ret[0].(error)
 378         return ret0
 379 }
 380
 381 func (_mr *_MockTProtocolRecorder) WriteI16(arg0 interface{}) *gomock.Call {
 382         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI16", arg0)
 383 }
 384
 385 func (_m *MockTProtocol) WriteI32(_param0 int32) error {
 386         ret := _m.ctrl.Call(_m, "WriteI32", _param0)
 387         ret0, _ := ret[0].(error)
 388         return ret0
 389 }
 390
 391 func (_mr *_MockTProtocolRecorder) WriteI32(arg0 interface{}) *gomock.Call {
 392         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI32", arg0)
 393 }
 394
 395 func (_m *MockTProtocol) WriteI64(_param0 int64) error {
 396         ret := _m.ctrl.Call(_m, "WriteI64", _param0)
 397         ret0, _ := ret[0].(error)
 398         return ret0
 399 }
 400
 401 func (_mr *_MockTProtocolRecorder) WriteI64(arg0 interface{}) *gomock.Call {
 402         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI64", arg0)
 403 }
 404
 405 func (_m *MockTProtocol) WriteListBegin(_param0 thrift.TType, _param1 int) error {
 406         ret := _m.ctrl.Call(_m, "WriteListBegin", _param0, _param1)
 407         ret0, _ := ret[0].(error)
 408         return ret0
 409 }
 410
 411 func (_mr *_MockTProtocolRecorder) WriteListBegin(arg0, arg1 interface{}) *gomock.Call {
 412         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteListBegin", arg0, arg1)
 413 }
 414
 415 func (_m *MockTProtocol) WriteListEnd() error {
 416         ret := _m.ctrl.Call(_m, "WriteListEnd")
 417         ret0, _ := ret[0].(error)
 418         return ret0
 419 }
 420
 421 func (_mr *_MockTProtocolRecorder) WriteListEnd() *gomock.Call {
 422         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteListEnd")
 423 }
 424
 425 func (_m *MockTProtocol) WriteMapBegin(_param0 thrift.TType, _param1 thrift.TType, _param2 int) error {
 426         ret := _m.ctrl.Call(_m, "WriteMapBegin", _param0, _param1, _param2)
 427         ret0, _ := ret[0].(error)
 428         return ret0
 429 }
 430
 431 func (_mr *_MockTProtocolRecorder) WriteMapBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
 432         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMapBegin", arg0, arg1, arg2)
 433 }
 434
 435 func (_m *MockTProtocol) WriteMapEnd() error {
 436         ret := _m.ctrl.Call(_m, "WriteMapEnd")
 437         ret0, _ := ret[0].(error)
 438         return ret0
 439 }
 440
 441 func (_mr *_MockTProtocolRecorder) WriteMapEnd() *gomock.Call {
 442         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMapEnd")
 443 }
 444
 445 func (_m *MockTProtocol) WriteMessageBegin(_param0 string, _param1 thrift.TMessageType, _param2 int32) error {
 446         ret := _m.ctrl.Call(_m, "WriteMessageBegin", _param0, _param1, _param2)
 447         ret0, _ := ret[0].(error)
 448         return ret0
 449 }
 450
 451 func (_mr *_MockTProtocolRecorder) WriteMessageBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
 452         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessageBegin", arg0, arg1, arg2)
 453 }
 454
 455 func (_m *MockTProtocol) WriteMessageEnd() error {
 456         ret := _m.ctrl.Call(_m, "WriteMessageEnd")
 457         ret0, _ := ret[0].(error)
 458         return ret0
 459 }
 460
 461 func (_mr *_MockTProtocolRecorder) WriteMessageEnd() *gomock.Call {
 462         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessageEnd")
 463 }
 464
 465 func (_m *MockTProtocol) WriteSetBegin(_param0 thrift.TType, _param1 int) error {
 466         ret := _m.ctrl.Call(_m, "WriteSetBegin", _param0, _param1)
 467         ret0, _ := ret[0].(error)
 468         return ret0
 469 }
 470
 471 func (_mr *_MockTProtocolRecorder) WriteSetBegin(arg0, arg1 interface{}) *gomock.Call {
 472         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteSetBegin", arg0, arg1)
 473 }
 474
 475 func (_m *MockTProtocol) WriteSetEnd() error {
 476         ret := _m.ctrl.Call(_m, "WriteSetEnd")
 477         ret0, _ := ret[0].(error)
 478         return ret0
 479 }
 480
 481 func (_mr *_MockTProtocolRecorder) WriteSetEnd() *gomock.Call {
 482         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteSetEnd")
 483 }
 484
 485 func (_m *MockTProtocol) WriteString(_param0 string) error {
 486         ret := _m.ctrl.Call(_m, "WriteString", _param0)
 487         ret0, _ := ret[0].(error)
 488         return ret0
 489 }
 490
 491 func (_mr *_MockTProtocolRecorder) WriteString(arg0 interface{}) *gomock.Call {
 492         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteString", arg0)
 493 }
 494
 495 func (_m *MockTProtocol) WriteStructBegin(_param0 string) error {
 496         ret := _m.ctrl.Call(_m, "WriteStructBegin", _param0)
 497         ret0, _ := ret[0].(error)
 498         return ret0
 499 }
 500
 501 func (_mr *_MockTProtocolRecorder) WriteStructBegin(arg0 interface{}) *gomock.Call {
 502         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteStructBegin", arg0)
 503 }
 504
 505 func (_m *MockTProtocol) WriteStructEnd() error {
 506         ret := _m.ctrl.Call(_m, "WriteStructEnd")
 507         ret0, _ := ret[0].(error)
 508         return ret0
 509 }
 510
 511 func (_mr *_MockTProtocolRecorder) WriteStructEnd() *gomock.Call {
 512         return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteStructEnd")
 513 }