You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

798 lines
19 KiB

  1. // Code generated by mockery v2.5.1. DO NOT EDIT.
  2. package mocks
  3. import (
  4. context "context"
  5. abcicli "github.com/tendermint/tendermint/abci/client"
  6. log "github.com/tendermint/tendermint/libs/log"
  7. mock "github.com/stretchr/testify/mock"
  8. types "github.com/tendermint/tendermint/abci/types"
  9. )
  10. // Client is an autogenerated mock type for the Client type
  11. type Client struct {
  12. mock.Mock
  13. }
  14. // ApplySnapshotChunkAsync provides a mock function with given fields: _a0, _a1
  15. func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abcicli.ReqRes, error) {
  16. ret := _m.Called(_a0, _a1)
  17. var r0 *abcicli.ReqRes
  18. if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *abcicli.ReqRes); ok {
  19. r0 = rf(_a0, _a1)
  20. } else {
  21. if ret.Get(0) != nil {
  22. r0 = ret.Get(0).(*abcicli.ReqRes)
  23. }
  24. }
  25. var r1 error
  26. if rf, ok := ret.Get(1).(func(context.Context, types.RequestApplySnapshotChunk) error); ok {
  27. r1 = rf(_a0, _a1)
  28. } else {
  29. r1 = ret.Error(1)
  30. }
  31. return r0, r1
  32. }
  33. // ApplySnapshotChunkSync provides a mock function with given fields: _a0, _a1
  34. func (_m *Client) ApplySnapshotChunkSync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
  35. ret := _m.Called(_a0, _a1)
  36. var r0 *types.ResponseApplySnapshotChunk
  37. if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok {
  38. r0 = rf(_a0, _a1)
  39. } else {
  40. if ret.Get(0) != nil {
  41. r0 = ret.Get(0).(*types.ResponseApplySnapshotChunk)
  42. }
  43. }
  44. var r1 error
  45. if rf, ok := ret.Get(1).(func(context.Context, types.RequestApplySnapshotChunk) error); ok {
  46. r1 = rf(_a0, _a1)
  47. } else {
  48. r1 = ret.Error(1)
  49. }
  50. return r0, r1
  51. }
  52. // BeginBlockAsync provides a mock function with given fields: _a0, _a1
  53. func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abcicli.ReqRes, error) {
  54. ret := _m.Called(_a0, _a1)
  55. var r0 *abcicli.ReqRes
  56. if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *abcicli.ReqRes); ok {
  57. r0 = rf(_a0, _a1)
  58. } else {
  59. if ret.Get(0) != nil {
  60. r0 = ret.Get(0).(*abcicli.ReqRes)
  61. }
  62. }
  63. var r1 error
  64. if rf, ok := ret.Get(1).(func(context.Context, types.RequestBeginBlock) error); ok {
  65. r1 = rf(_a0, _a1)
  66. } else {
  67. r1 = ret.Error(1)
  68. }
  69. return r0, r1
  70. }
  71. // BeginBlockSync provides a mock function with given fields: _a0, _a1
  72. func (_m *Client) BeginBlockSync(_a0 context.Context, _a1 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
  73. ret := _m.Called(_a0, _a1)
  74. var r0 *types.ResponseBeginBlock
  75. if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *types.ResponseBeginBlock); ok {
  76. r0 = rf(_a0, _a1)
  77. } else {
  78. if ret.Get(0) != nil {
  79. r0 = ret.Get(0).(*types.ResponseBeginBlock)
  80. }
  81. }
  82. var r1 error
  83. if rf, ok := ret.Get(1).(func(context.Context, types.RequestBeginBlock) error); ok {
  84. r1 = rf(_a0, _a1)
  85. } else {
  86. r1 = ret.Error(1)
  87. }
  88. return r0, r1
  89. }
  90. // CheckTxAsync provides a mock function with given fields: _a0, _a1
  91. func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abcicli.ReqRes, error) {
  92. ret := _m.Called(_a0, _a1)
  93. var r0 *abcicli.ReqRes
  94. if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abcicli.ReqRes); ok {
  95. r0 = rf(_a0, _a1)
  96. } else {
  97. if ret.Get(0) != nil {
  98. r0 = ret.Get(0).(*abcicli.ReqRes)
  99. }
  100. }
  101. var r1 error
  102. if rf, ok := ret.Get(1).(func(context.Context, types.RequestCheckTx) error); ok {
  103. r1 = rf(_a0, _a1)
  104. } else {
  105. r1 = ret.Error(1)
  106. }
  107. return r0, r1
  108. }
  109. // CheckTxSync provides a mock function with given fields: _a0, _a1
  110. func (_m *Client) CheckTxSync(_a0 context.Context, _a1 types.RequestCheckTx) (*types.ResponseCheckTx, error) {
  111. ret := _m.Called(_a0, _a1)
  112. var r0 *types.ResponseCheckTx
  113. if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *types.ResponseCheckTx); ok {
  114. r0 = rf(_a0, _a1)
  115. } else {
  116. if ret.Get(0) != nil {
  117. r0 = ret.Get(0).(*types.ResponseCheckTx)
  118. }
  119. }
  120. var r1 error
  121. if rf, ok := ret.Get(1).(func(context.Context, types.RequestCheckTx) error); ok {
  122. r1 = rf(_a0, _a1)
  123. } else {
  124. r1 = ret.Error(1)
  125. }
  126. return r0, r1
  127. }
  128. // CommitAsync provides a mock function with given fields: _a0
  129. func (_m *Client) CommitAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
  130. ret := _m.Called(_a0)
  131. var r0 *abcicli.ReqRes
  132. if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
  133. r0 = rf(_a0)
  134. } else {
  135. if ret.Get(0) != nil {
  136. r0 = ret.Get(0).(*abcicli.ReqRes)
  137. }
  138. }
  139. var r1 error
  140. if rf, ok := ret.Get(1).(func(context.Context) error); ok {
  141. r1 = rf(_a0)
  142. } else {
  143. r1 = ret.Error(1)
  144. }
  145. return r0, r1
  146. }
  147. // CommitSync provides a mock function with given fields: _a0
  148. func (_m *Client) CommitSync(_a0 context.Context) (*types.ResponseCommit, error) {
  149. ret := _m.Called(_a0)
  150. var r0 *types.ResponseCommit
  151. if rf, ok := ret.Get(0).(func(context.Context) *types.ResponseCommit); ok {
  152. r0 = rf(_a0)
  153. } else {
  154. if ret.Get(0) != nil {
  155. r0 = ret.Get(0).(*types.ResponseCommit)
  156. }
  157. }
  158. var r1 error
  159. if rf, ok := ret.Get(1).(func(context.Context) error); ok {
  160. r1 = rf(_a0)
  161. } else {
  162. r1 = ret.Error(1)
  163. }
  164. return r0, r1
  165. }
  166. // DeliverTxAsync provides a mock function with given fields: _a0, _a1
  167. func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abcicli.ReqRes, error) {
  168. ret := _m.Called(_a0, _a1)
  169. var r0 *abcicli.ReqRes
  170. if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abcicli.ReqRes); ok {
  171. r0 = rf(_a0, _a1)
  172. } else {
  173. if ret.Get(0) != nil {
  174. r0 = ret.Get(0).(*abcicli.ReqRes)
  175. }
  176. }
  177. var r1 error
  178. if rf, ok := ret.Get(1).(func(context.Context, types.RequestDeliverTx) error); ok {
  179. r1 = rf(_a0, _a1)
  180. } else {
  181. r1 = ret.Error(1)
  182. }
  183. return r0, r1
  184. }
  185. // DeliverTxSync provides a mock function with given fields: _a0, _a1
  186. func (_m *Client) DeliverTxSync(_a0 context.Context, _a1 types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
  187. ret := _m.Called(_a0, _a1)
  188. var r0 *types.ResponseDeliverTx
  189. if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *types.ResponseDeliverTx); ok {
  190. r0 = rf(_a0, _a1)
  191. } else {
  192. if ret.Get(0) != nil {
  193. r0 = ret.Get(0).(*types.ResponseDeliverTx)
  194. }
  195. }
  196. var r1 error
  197. if rf, ok := ret.Get(1).(func(context.Context, types.RequestDeliverTx) error); ok {
  198. r1 = rf(_a0, _a1)
  199. } else {
  200. r1 = ret.Error(1)
  201. }
  202. return r0, r1
  203. }
  204. // EchoAsync provides a mock function with given fields: ctx, msg
  205. func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abcicli.ReqRes, error) {
  206. ret := _m.Called(ctx, msg)
  207. var r0 *abcicli.ReqRes
  208. if rf, ok := ret.Get(0).(func(context.Context, string) *abcicli.ReqRes); ok {
  209. r0 = rf(ctx, msg)
  210. } else {
  211. if ret.Get(0) != nil {
  212. r0 = ret.Get(0).(*abcicli.ReqRes)
  213. }
  214. }
  215. var r1 error
  216. if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
  217. r1 = rf(ctx, msg)
  218. } else {
  219. r1 = ret.Error(1)
  220. }
  221. return r0, r1
  222. }
  223. // EchoSync provides a mock function with given fields: ctx, msg
  224. func (_m *Client) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
  225. ret := _m.Called(ctx, msg)
  226. var r0 *types.ResponseEcho
  227. if rf, ok := ret.Get(0).(func(context.Context, string) *types.ResponseEcho); ok {
  228. r0 = rf(ctx, msg)
  229. } else {
  230. if ret.Get(0) != nil {
  231. r0 = ret.Get(0).(*types.ResponseEcho)
  232. }
  233. }
  234. var r1 error
  235. if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
  236. r1 = rf(ctx, msg)
  237. } else {
  238. r1 = ret.Error(1)
  239. }
  240. return r0, r1
  241. }
  242. // EndBlockAsync provides a mock function with given fields: _a0, _a1
  243. func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abcicli.ReqRes, error) {
  244. ret := _m.Called(_a0, _a1)
  245. var r0 *abcicli.ReqRes
  246. if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *abcicli.ReqRes); ok {
  247. r0 = rf(_a0, _a1)
  248. } else {
  249. if ret.Get(0) != nil {
  250. r0 = ret.Get(0).(*abcicli.ReqRes)
  251. }
  252. }
  253. var r1 error
  254. if rf, ok := ret.Get(1).(func(context.Context, types.RequestEndBlock) error); ok {
  255. r1 = rf(_a0, _a1)
  256. } else {
  257. r1 = ret.Error(1)
  258. }
  259. return r0, r1
  260. }
  261. // EndBlockSync provides a mock function with given fields: _a0, _a1
  262. func (_m *Client) EndBlockSync(_a0 context.Context, _a1 types.RequestEndBlock) (*types.ResponseEndBlock, error) {
  263. ret := _m.Called(_a0, _a1)
  264. var r0 *types.ResponseEndBlock
  265. if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *types.ResponseEndBlock); ok {
  266. r0 = rf(_a0, _a1)
  267. } else {
  268. if ret.Get(0) != nil {
  269. r0 = ret.Get(0).(*types.ResponseEndBlock)
  270. }
  271. }
  272. var r1 error
  273. if rf, ok := ret.Get(1).(func(context.Context, types.RequestEndBlock) error); ok {
  274. r1 = rf(_a0, _a1)
  275. } else {
  276. r1 = ret.Error(1)
  277. }
  278. return r0, r1
  279. }
  280. // Error provides a mock function with given fields:
  281. func (_m *Client) Error() error {
  282. ret := _m.Called()
  283. var r0 error
  284. if rf, ok := ret.Get(0).(func() error); ok {
  285. r0 = rf()
  286. } else {
  287. r0 = ret.Error(0)
  288. }
  289. return r0
  290. }
  291. // FlushAsync provides a mock function with given fields: _a0
  292. func (_m *Client) FlushAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
  293. ret := _m.Called(_a0)
  294. var r0 *abcicli.ReqRes
  295. if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
  296. r0 = rf(_a0)
  297. } else {
  298. if ret.Get(0) != nil {
  299. r0 = ret.Get(0).(*abcicli.ReqRes)
  300. }
  301. }
  302. var r1 error
  303. if rf, ok := ret.Get(1).(func(context.Context) error); ok {
  304. r1 = rf(_a0)
  305. } else {
  306. r1 = ret.Error(1)
  307. }
  308. return r0, r1
  309. }
  310. // FlushSync provides a mock function with given fields: _a0
  311. func (_m *Client) FlushSync(_a0 context.Context) error {
  312. ret := _m.Called(_a0)
  313. var r0 error
  314. if rf, ok := ret.Get(0).(func(context.Context) error); ok {
  315. r0 = rf(_a0)
  316. } else {
  317. r0 = ret.Error(0)
  318. }
  319. return r0
  320. }
  321. // InfoAsync provides a mock function with given fields: _a0, _a1
  322. func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abcicli.ReqRes, error) {
  323. ret := _m.Called(_a0, _a1)
  324. var r0 *abcicli.ReqRes
  325. if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *abcicli.ReqRes); ok {
  326. r0 = rf(_a0, _a1)
  327. } else {
  328. if ret.Get(0) != nil {
  329. r0 = ret.Get(0).(*abcicli.ReqRes)
  330. }
  331. }
  332. var r1 error
  333. if rf, ok := ret.Get(1).(func(context.Context, types.RequestInfo) error); ok {
  334. r1 = rf(_a0, _a1)
  335. } else {
  336. r1 = ret.Error(1)
  337. }
  338. return r0, r1
  339. }
  340. // InfoSync provides a mock function with given fields: _a0, _a1
  341. func (_m *Client) InfoSync(_a0 context.Context, _a1 types.RequestInfo) (*types.ResponseInfo, error) {
  342. ret := _m.Called(_a0, _a1)
  343. var r0 *types.ResponseInfo
  344. if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *types.ResponseInfo); ok {
  345. r0 = rf(_a0, _a1)
  346. } else {
  347. if ret.Get(0) != nil {
  348. r0 = ret.Get(0).(*types.ResponseInfo)
  349. }
  350. }
  351. var r1 error
  352. if rf, ok := ret.Get(1).(func(context.Context, types.RequestInfo) error); ok {
  353. r1 = rf(_a0, _a1)
  354. } else {
  355. r1 = ret.Error(1)
  356. }
  357. return r0, r1
  358. }
  359. // InitChainAsync provides a mock function with given fields: _a0, _a1
  360. func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abcicli.ReqRes, error) {
  361. ret := _m.Called(_a0, _a1)
  362. var r0 *abcicli.ReqRes
  363. if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *abcicli.ReqRes); ok {
  364. r0 = rf(_a0, _a1)
  365. } else {
  366. if ret.Get(0) != nil {
  367. r0 = ret.Get(0).(*abcicli.ReqRes)
  368. }
  369. }
  370. var r1 error
  371. if rf, ok := ret.Get(1).(func(context.Context, types.RequestInitChain) error); ok {
  372. r1 = rf(_a0, _a1)
  373. } else {
  374. r1 = ret.Error(1)
  375. }
  376. return r0, r1
  377. }
  378. // InitChainSync provides a mock function with given fields: _a0, _a1
  379. func (_m *Client) InitChainSync(_a0 context.Context, _a1 types.RequestInitChain) (*types.ResponseInitChain, error) {
  380. ret := _m.Called(_a0, _a1)
  381. var r0 *types.ResponseInitChain
  382. if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *types.ResponseInitChain); ok {
  383. r0 = rf(_a0, _a1)
  384. } else {
  385. if ret.Get(0) != nil {
  386. r0 = ret.Get(0).(*types.ResponseInitChain)
  387. }
  388. }
  389. var r1 error
  390. if rf, ok := ret.Get(1).(func(context.Context, types.RequestInitChain) error); ok {
  391. r1 = rf(_a0, _a1)
  392. } else {
  393. r1 = ret.Error(1)
  394. }
  395. return r0, r1
  396. }
  397. // IsRunning provides a mock function with given fields:
  398. func (_m *Client) IsRunning() bool {
  399. ret := _m.Called()
  400. var r0 bool
  401. if rf, ok := ret.Get(0).(func() bool); ok {
  402. r0 = rf()
  403. } else {
  404. r0 = ret.Get(0).(bool)
  405. }
  406. return r0
  407. }
  408. // ListSnapshotsAsync provides a mock function with given fields: _a0, _a1
  409. func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abcicli.ReqRes, error) {
  410. ret := _m.Called(_a0, _a1)
  411. var r0 *abcicli.ReqRes
  412. if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *abcicli.ReqRes); ok {
  413. r0 = rf(_a0, _a1)
  414. } else {
  415. if ret.Get(0) != nil {
  416. r0 = ret.Get(0).(*abcicli.ReqRes)
  417. }
  418. }
  419. var r1 error
  420. if rf, ok := ret.Get(1).(func(context.Context, types.RequestListSnapshots) error); ok {
  421. r1 = rf(_a0, _a1)
  422. } else {
  423. r1 = ret.Error(1)
  424. }
  425. return r0, r1
  426. }
  427. // ListSnapshotsSync provides a mock function with given fields: _a0, _a1
  428. func (_m *Client) ListSnapshotsSync(_a0 context.Context, _a1 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
  429. ret := _m.Called(_a0, _a1)
  430. var r0 *types.ResponseListSnapshots
  431. if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *types.ResponseListSnapshots); ok {
  432. r0 = rf(_a0, _a1)
  433. } else {
  434. if ret.Get(0) != nil {
  435. r0 = ret.Get(0).(*types.ResponseListSnapshots)
  436. }
  437. }
  438. var r1 error
  439. if rf, ok := ret.Get(1).(func(context.Context, types.RequestListSnapshots) error); ok {
  440. r1 = rf(_a0, _a1)
  441. } else {
  442. r1 = ret.Error(1)
  443. }
  444. return r0, r1
  445. }
  446. // LoadSnapshotChunkAsync provides a mock function with given fields: _a0, _a1
  447. func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abcicli.ReqRes, error) {
  448. ret := _m.Called(_a0, _a1)
  449. var r0 *abcicli.ReqRes
  450. if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *abcicli.ReqRes); ok {
  451. r0 = rf(_a0, _a1)
  452. } else {
  453. if ret.Get(0) != nil {
  454. r0 = ret.Get(0).(*abcicli.ReqRes)
  455. }
  456. }
  457. var r1 error
  458. if rf, ok := ret.Get(1).(func(context.Context, types.RequestLoadSnapshotChunk) error); ok {
  459. r1 = rf(_a0, _a1)
  460. } else {
  461. r1 = ret.Error(1)
  462. }
  463. return r0, r1
  464. }
  465. // LoadSnapshotChunkSync provides a mock function with given fields: _a0, _a1
  466. func (_m *Client) LoadSnapshotChunkSync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
  467. ret := _m.Called(_a0, _a1)
  468. var r0 *types.ResponseLoadSnapshotChunk
  469. if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok {
  470. r0 = rf(_a0, _a1)
  471. } else {
  472. if ret.Get(0) != nil {
  473. r0 = ret.Get(0).(*types.ResponseLoadSnapshotChunk)
  474. }
  475. }
  476. var r1 error
  477. if rf, ok := ret.Get(1).(func(context.Context, types.RequestLoadSnapshotChunk) error); ok {
  478. r1 = rf(_a0, _a1)
  479. } else {
  480. r1 = ret.Error(1)
  481. }
  482. return r0, r1
  483. }
  484. // OfferSnapshotAsync provides a mock function with given fields: _a0, _a1
  485. func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abcicli.ReqRes, error) {
  486. ret := _m.Called(_a0, _a1)
  487. var r0 *abcicli.ReqRes
  488. if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *abcicli.ReqRes); ok {
  489. r0 = rf(_a0, _a1)
  490. } else {
  491. if ret.Get(0) != nil {
  492. r0 = ret.Get(0).(*abcicli.ReqRes)
  493. }
  494. }
  495. var r1 error
  496. if rf, ok := ret.Get(1).(func(context.Context, types.RequestOfferSnapshot) error); ok {
  497. r1 = rf(_a0, _a1)
  498. } else {
  499. r1 = ret.Error(1)
  500. }
  501. return r0, r1
  502. }
  503. // OfferSnapshotSync provides a mock function with given fields: _a0, _a1
  504. func (_m *Client) OfferSnapshotSync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
  505. ret := _m.Called(_a0, _a1)
  506. var r0 *types.ResponseOfferSnapshot
  507. if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok {
  508. r0 = rf(_a0, _a1)
  509. } else {
  510. if ret.Get(0) != nil {
  511. r0 = ret.Get(0).(*types.ResponseOfferSnapshot)
  512. }
  513. }
  514. var r1 error
  515. if rf, ok := ret.Get(1).(func(context.Context, types.RequestOfferSnapshot) error); ok {
  516. r1 = rf(_a0, _a1)
  517. } else {
  518. r1 = ret.Error(1)
  519. }
  520. return r0, r1
  521. }
  522. // OnReset provides a mock function with given fields:
  523. func (_m *Client) OnReset() error {
  524. ret := _m.Called()
  525. var r0 error
  526. if rf, ok := ret.Get(0).(func() error); ok {
  527. r0 = rf()
  528. } else {
  529. r0 = ret.Error(0)
  530. }
  531. return r0
  532. }
  533. // OnStart provides a mock function with given fields:
  534. func (_m *Client) OnStart() error {
  535. ret := _m.Called()
  536. var r0 error
  537. if rf, ok := ret.Get(0).(func() error); ok {
  538. r0 = rf()
  539. } else {
  540. r0 = ret.Error(0)
  541. }
  542. return r0
  543. }
  544. // OnStop provides a mock function with given fields:
  545. func (_m *Client) OnStop() {
  546. _m.Called()
  547. }
  548. // QueryAsync provides a mock function with given fields: _a0, _a1
  549. func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abcicli.ReqRes, error) {
  550. ret := _m.Called(_a0, _a1)
  551. var r0 *abcicli.ReqRes
  552. if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *abcicli.ReqRes); ok {
  553. r0 = rf(_a0, _a1)
  554. } else {
  555. if ret.Get(0) != nil {
  556. r0 = ret.Get(0).(*abcicli.ReqRes)
  557. }
  558. }
  559. var r1 error
  560. if rf, ok := ret.Get(1).(func(context.Context, types.RequestQuery) error); ok {
  561. r1 = rf(_a0, _a1)
  562. } else {
  563. r1 = ret.Error(1)
  564. }
  565. return r0, r1
  566. }
  567. // QuerySync provides a mock function with given fields: _a0, _a1
  568. func (_m *Client) QuerySync(_a0 context.Context, _a1 types.RequestQuery) (*types.ResponseQuery, error) {
  569. ret := _m.Called(_a0, _a1)
  570. var r0 *types.ResponseQuery
  571. if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *types.ResponseQuery); ok {
  572. r0 = rf(_a0, _a1)
  573. } else {
  574. if ret.Get(0) != nil {
  575. r0 = ret.Get(0).(*types.ResponseQuery)
  576. }
  577. }
  578. var r1 error
  579. if rf, ok := ret.Get(1).(func(context.Context, types.RequestQuery) error); ok {
  580. r1 = rf(_a0, _a1)
  581. } else {
  582. r1 = ret.Error(1)
  583. }
  584. return r0, r1
  585. }
  586. // Quit provides a mock function with given fields:
  587. func (_m *Client) Quit() <-chan struct{} {
  588. ret := _m.Called()
  589. var r0 <-chan struct{}
  590. if rf, ok := ret.Get(0).(func() <-chan struct{}); ok {
  591. r0 = rf()
  592. } else {
  593. if ret.Get(0) != nil {
  594. r0 = ret.Get(0).(<-chan struct{})
  595. }
  596. }
  597. return r0
  598. }
  599. // Reset provides a mock function with given fields:
  600. func (_m *Client) Reset() error {
  601. ret := _m.Called()
  602. var r0 error
  603. if rf, ok := ret.Get(0).(func() error); ok {
  604. r0 = rf()
  605. } else {
  606. r0 = ret.Error(0)
  607. }
  608. return r0
  609. }
  610. // SetLogger provides a mock function with given fields: _a0
  611. func (_m *Client) SetLogger(_a0 log.Logger) {
  612. _m.Called(_a0)
  613. }
  614. // SetResponseCallback provides a mock function with given fields: _a0
  615. func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) {
  616. _m.Called(_a0)
  617. }
  618. // Start provides a mock function with given fields:
  619. func (_m *Client) Start() error {
  620. ret := _m.Called()
  621. var r0 error
  622. if rf, ok := ret.Get(0).(func() error); ok {
  623. r0 = rf()
  624. } else {
  625. r0 = ret.Error(0)
  626. }
  627. return r0
  628. }
  629. // Stop provides a mock function with given fields:
  630. func (_m *Client) Stop() error {
  631. ret := _m.Called()
  632. var r0 error
  633. if rf, ok := ret.Get(0).(func() error); ok {
  634. r0 = rf()
  635. } else {
  636. r0 = ret.Error(0)
  637. }
  638. return r0
  639. }
  640. // String provides a mock function with given fields:
  641. func (_m *Client) String() string {
  642. ret := _m.Called()
  643. var r0 string
  644. if rf, ok := ret.Get(0).(func() string); ok {
  645. r0 = rf()
  646. } else {
  647. r0 = ret.Get(0).(string)
  648. }
  649. return r0
  650. }