]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
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 | } |