github.com/wata727/tflint@v0.12.2-0.20191013070026-96dd0d36f385/client/aws_elasticache_mock.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: ../vendor/github.com/aws/aws-sdk-go/service/elasticache/elasticacheiface/interface.go 3 4 // Package client is a generated GoMock package. 5 package client 6 7 import ( 8 aws "github.com/aws/aws-sdk-go/aws" 9 request "github.com/aws/aws-sdk-go/aws/request" 10 elasticache "github.com/aws/aws-sdk-go/service/elasticache" 11 gomock "github.com/golang/mock/gomock" 12 reflect "reflect" 13 ) 14 15 // MockElastiCacheAPI is a mock of ElastiCacheAPI interface 16 type MockElastiCacheAPI struct { 17 ctrl *gomock.Controller 18 recorder *MockElastiCacheAPIMockRecorder 19 } 20 21 // MockElastiCacheAPIMockRecorder is the mock recorder for MockElastiCacheAPI 22 type MockElastiCacheAPIMockRecorder struct { 23 mock *MockElastiCacheAPI 24 } 25 26 // NewMockElastiCacheAPI creates a new mock instance 27 func NewMockElastiCacheAPI(ctrl *gomock.Controller) *MockElastiCacheAPI { 28 mock := &MockElastiCacheAPI{ctrl: ctrl} 29 mock.recorder = &MockElastiCacheAPIMockRecorder{mock} 30 return mock 31 } 32 33 // EXPECT returns an object that allows the caller to indicate expected use 34 func (m *MockElastiCacheAPI) EXPECT() *MockElastiCacheAPIMockRecorder { 35 return m.recorder 36 } 37 38 // AddTagsToResource mocks base method 39 func (m *MockElastiCacheAPI) AddTagsToResource(arg0 *elasticache.AddTagsToResourceInput) (*elasticache.TagListMessage, error) { 40 m.ctrl.T.Helper() 41 ret := m.ctrl.Call(m, "AddTagsToResource", arg0) 42 ret0, _ := ret[0].(*elasticache.TagListMessage) 43 ret1, _ := ret[1].(error) 44 return ret0, ret1 45 } 46 47 // AddTagsToResource indicates an expected call of AddTagsToResource 48 func (mr *MockElastiCacheAPIMockRecorder) AddTagsToResource(arg0 interface{}) *gomock.Call { 49 mr.mock.ctrl.T.Helper() 50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResource", reflect.TypeOf((*MockElastiCacheAPI)(nil).AddTagsToResource), arg0) 51 } 52 53 // AddTagsToResourceWithContext mocks base method 54 func (m *MockElastiCacheAPI) AddTagsToResourceWithContext(arg0 aws.Context, arg1 *elasticache.AddTagsToResourceInput, arg2 ...request.Option) (*elasticache.TagListMessage, error) { 55 m.ctrl.T.Helper() 56 varargs := []interface{}{arg0, arg1} 57 for _, a := range arg2 { 58 varargs = append(varargs, a) 59 } 60 ret := m.ctrl.Call(m, "AddTagsToResourceWithContext", varargs...) 61 ret0, _ := ret[0].(*elasticache.TagListMessage) 62 ret1, _ := ret[1].(error) 63 return ret0, ret1 64 } 65 66 // AddTagsToResourceWithContext indicates an expected call of AddTagsToResourceWithContext 67 func (mr *MockElastiCacheAPIMockRecorder) AddTagsToResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 68 mr.mock.ctrl.T.Helper() 69 varargs := append([]interface{}{arg0, arg1}, arg2...) 70 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).AddTagsToResourceWithContext), varargs...) 71 } 72 73 // AddTagsToResourceRequest mocks base method 74 func (m *MockElastiCacheAPI) AddTagsToResourceRequest(arg0 *elasticache.AddTagsToResourceInput) (*request.Request, *elasticache.TagListMessage) { 75 m.ctrl.T.Helper() 76 ret := m.ctrl.Call(m, "AddTagsToResourceRequest", arg0) 77 ret0, _ := ret[0].(*request.Request) 78 ret1, _ := ret[1].(*elasticache.TagListMessage) 79 return ret0, ret1 80 } 81 82 // AddTagsToResourceRequest indicates an expected call of AddTagsToResourceRequest 83 func (mr *MockElastiCacheAPIMockRecorder) AddTagsToResourceRequest(arg0 interface{}) *gomock.Call { 84 mr.mock.ctrl.T.Helper() 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).AddTagsToResourceRequest), arg0) 86 } 87 88 // AuthorizeCacheSecurityGroupIngress mocks base method 89 func (m *MockElastiCacheAPI) AuthorizeCacheSecurityGroupIngress(arg0 *elasticache.AuthorizeCacheSecurityGroupIngressInput) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "AuthorizeCacheSecurityGroupIngress", arg0) 92 ret0, _ := ret[0].(*elasticache.AuthorizeCacheSecurityGroupIngressOutput) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // AuthorizeCacheSecurityGroupIngress indicates an expected call of AuthorizeCacheSecurityGroupIngress 98 func (mr *MockElastiCacheAPIMockRecorder) AuthorizeCacheSecurityGroupIngress(arg0 interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCacheSecurityGroupIngress", reflect.TypeOf((*MockElastiCacheAPI)(nil).AuthorizeCacheSecurityGroupIngress), arg0) 101 } 102 103 // AuthorizeCacheSecurityGroupIngressWithContext mocks base method 104 func (m *MockElastiCacheAPI) AuthorizeCacheSecurityGroupIngressWithContext(arg0 aws.Context, arg1 *elasticache.AuthorizeCacheSecurityGroupIngressInput, arg2 ...request.Option) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, error) { 105 m.ctrl.T.Helper() 106 varargs := []interface{}{arg0, arg1} 107 for _, a := range arg2 { 108 varargs = append(varargs, a) 109 } 110 ret := m.ctrl.Call(m, "AuthorizeCacheSecurityGroupIngressWithContext", varargs...) 111 ret0, _ := ret[0].(*elasticache.AuthorizeCacheSecurityGroupIngressOutput) 112 ret1, _ := ret[1].(error) 113 return ret0, ret1 114 } 115 116 // AuthorizeCacheSecurityGroupIngressWithContext indicates an expected call of AuthorizeCacheSecurityGroupIngressWithContext 117 func (mr *MockElastiCacheAPIMockRecorder) AuthorizeCacheSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 118 mr.mock.ctrl.T.Helper() 119 varargs := append([]interface{}{arg0, arg1}, arg2...) 120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCacheSecurityGroupIngressWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).AuthorizeCacheSecurityGroupIngressWithContext), varargs...) 121 } 122 123 // AuthorizeCacheSecurityGroupIngressRequest mocks base method 124 func (m *MockElastiCacheAPI) AuthorizeCacheSecurityGroupIngressRequest(arg0 *elasticache.AuthorizeCacheSecurityGroupIngressInput) (*request.Request, *elasticache.AuthorizeCacheSecurityGroupIngressOutput) { 125 m.ctrl.T.Helper() 126 ret := m.ctrl.Call(m, "AuthorizeCacheSecurityGroupIngressRequest", arg0) 127 ret0, _ := ret[0].(*request.Request) 128 ret1, _ := ret[1].(*elasticache.AuthorizeCacheSecurityGroupIngressOutput) 129 return ret0, ret1 130 } 131 132 // AuthorizeCacheSecurityGroupIngressRequest indicates an expected call of AuthorizeCacheSecurityGroupIngressRequest 133 func (mr *MockElastiCacheAPIMockRecorder) AuthorizeCacheSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { 134 mr.mock.ctrl.T.Helper() 135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCacheSecurityGroupIngressRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).AuthorizeCacheSecurityGroupIngressRequest), arg0) 136 } 137 138 // BatchApplyUpdateAction mocks base method 139 func (m *MockElastiCacheAPI) BatchApplyUpdateAction(arg0 *elasticache.BatchApplyUpdateActionInput) (*elasticache.BatchApplyUpdateActionOutput, error) { 140 m.ctrl.T.Helper() 141 ret := m.ctrl.Call(m, "BatchApplyUpdateAction", arg0) 142 ret0, _ := ret[0].(*elasticache.BatchApplyUpdateActionOutput) 143 ret1, _ := ret[1].(error) 144 return ret0, ret1 145 } 146 147 // BatchApplyUpdateAction indicates an expected call of BatchApplyUpdateAction 148 func (mr *MockElastiCacheAPIMockRecorder) BatchApplyUpdateAction(arg0 interface{}) *gomock.Call { 149 mr.mock.ctrl.T.Helper() 150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchApplyUpdateAction", reflect.TypeOf((*MockElastiCacheAPI)(nil).BatchApplyUpdateAction), arg0) 151 } 152 153 // BatchApplyUpdateActionWithContext mocks base method 154 func (m *MockElastiCacheAPI) BatchApplyUpdateActionWithContext(arg0 aws.Context, arg1 *elasticache.BatchApplyUpdateActionInput, arg2 ...request.Option) (*elasticache.BatchApplyUpdateActionOutput, error) { 155 m.ctrl.T.Helper() 156 varargs := []interface{}{arg0, arg1} 157 for _, a := range arg2 { 158 varargs = append(varargs, a) 159 } 160 ret := m.ctrl.Call(m, "BatchApplyUpdateActionWithContext", varargs...) 161 ret0, _ := ret[0].(*elasticache.BatchApplyUpdateActionOutput) 162 ret1, _ := ret[1].(error) 163 return ret0, ret1 164 } 165 166 // BatchApplyUpdateActionWithContext indicates an expected call of BatchApplyUpdateActionWithContext 167 func (mr *MockElastiCacheAPIMockRecorder) BatchApplyUpdateActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 168 mr.mock.ctrl.T.Helper() 169 varargs := append([]interface{}{arg0, arg1}, arg2...) 170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchApplyUpdateActionWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).BatchApplyUpdateActionWithContext), varargs...) 171 } 172 173 // BatchApplyUpdateActionRequest mocks base method 174 func (m *MockElastiCacheAPI) BatchApplyUpdateActionRequest(arg0 *elasticache.BatchApplyUpdateActionInput) (*request.Request, *elasticache.BatchApplyUpdateActionOutput) { 175 m.ctrl.T.Helper() 176 ret := m.ctrl.Call(m, "BatchApplyUpdateActionRequest", arg0) 177 ret0, _ := ret[0].(*request.Request) 178 ret1, _ := ret[1].(*elasticache.BatchApplyUpdateActionOutput) 179 return ret0, ret1 180 } 181 182 // BatchApplyUpdateActionRequest indicates an expected call of BatchApplyUpdateActionRequest 183 func (mr *MockElastiCacheAPIMockRecorder) BatchApplyUpdateActionRequest(arg0 interface{}) *gomock.Call { 184 mr.mock.ctrl.T.Helper() 185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchApplyUpdateActionRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).BatchApplyUpdateActionRequest), arg0) 186 } 187 188 // BatchStopUpdateAction mocks base method 189 func (m *MockElastiCacheAPI) BatchStopUpdateAction(arg0 *elasticache.BatchStopUpdateActionInput) (*elasticache.BatchStopUpdateActionOutput, error) { 190 m.ctrl.T.Helper() 191 ret := m.ctrl.Call(m, "BatchStopUpdateAction", arg0) 192 ret0, _ := ret[0].(*elasticache.BatchStopUpdateActionOutput) 193 ret1, _ := ret[1].(error) 194 return ret0, ret1 195 } 196 197 // BatchStopUpdateAction indicates an expected call of BatchStopUpdateAction 198 func (mr *MockElastiCacheAPIMockRecorder) BatchStopUpdateAction(arg0 interface{}) *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchStopUpdateAction", reflect.TypeOf((*MockElastiCacheAPI)(nil).BatchStopUpdateAction), arg0) 201 } 202 203 // BatchStopUpdateActionWithContext mocks base method 204 func (m *MockElastiCacheAPI) BatchStopUpdateActionWithContext(arg0 aws.Context, arg1 *elasticache.BatchStopUpdateActionInput, arg2 ...request.Option) (*elasticache.BatchStopUpdateActionOutput, error) { 205 m.ctrl.T.Helper() 206 varargs := []interface{}{arg0, arg1} 207 for _, a := range arg2 { 208 varargs = append(varargs, a) 209 } 210 ret := m.ctrl.Call(m, "BatchStopUpdateActionWithContext", varargs...) 211 ret0, _ := ret[0].(*elasticache.BatchStopUpdateActionOutput) 212 ret1, _ := ret[1].(error) 213 return ret0, ret1 214 } 215 216 // BatchStopUpdateActionWithContext indicates an expected call of BatchStopUpdateActionWithContext 217 func (mr *MockElastiCacheAPIMockRecorder) BatchStopUpdateActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 218 mr.mock.ctrl.T.Helper() 219 varargs := append([]interface{}{arg0, arg1}, arg2...) 220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchStopUpdateActionWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).BatchStopUpdateActionWithContext), varargs...) 221 } 222 223 // BatchStopUpdateActionRequest mocks base method 224 func (m *MockElastiCacheAPI) BatchStopUpdateActionRequest(arg0 *elasticache.BatchStopUpdateActionInput) (*request.Request, *elasticache.BatchStopUpdateActionOutput) { 225 m.ctrl.T.Helper() 226 ret := m.ctrl.Call(m, "BatchStopUpdateActionRequest", arg0) 227 ret0, _ := ret[0].(*request.Request) 228 ret1, _ := ret[1].(*elasticache.BatchStopUpdateActionOutput) 229 return ret0, ret1 230 } 231 232 // BatchStopUpdateActionRequest indicates an expected call of BatchStopUpdateActionRequest 233 func (mr *MockElastiCacheAPIMockRecorder) BatchStopUpdateActionRequest(arg0 interface{}) *gomock.Call { 234 mr.mock.ctrl.T.Helper() 235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchStopUpdateActionRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).BatchStopUpdateActionRequest), arg0) 236 } 237 238 // CopySnapshot mocks base method 239 func (m *MockElastiCacheAPI) CopySnapshot(arg0 *elasticache.CopySnapshotInput) (*elasticache.CopySnapshotOutput, error) { 240 m.ctrl.T.Helper() 241 ret := m.ctrl.Call(m, "CopySnapshot", arg0) 242 ret0, _ := ret[0].(*elasticache.CopySnapshotOutput) 243 ret1, _ := ret[1].(error) 244 return ret0, ret1 245 } 246 247 // CopySnapshot indicates an expected call of CopySnapshot 248 func (mr *MockElastiCacheAPIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call { 249 mr.mock.ctrl.T.Helper() 250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockElastiCacheAPI)(nil).CopySnapshot), arg0) 251 } 252 253 // CopySnapshotWithContext mocks base method 254 func (m *MockElastiCacheAPI) CopySnapshotWithContext(arg0 aws.Context, arg1 *elasticache.CopySnapshotInput, arg2 ...request.Option) (*elasticache.CopySnapshotOutput, error) { 255 m.ctrl.T.Helper() 256 varargs := []interface{}{arg0, arg1} 257 for _, a := range arg2 { 258 varargs = append(varargs, a) 259 } 260 ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...) 261 ret0, _ := ret[0].(*elasticache.CopySnapshotOutput) 262 ret1, _ := ret[1].(error) 263 return ret0, ret1 264 } 265 266 // CopySnapshotWithContext indicates an expected call of CopySnapshotWithContext 267 func (mr *MockElastiCacheAPIMockRecorder) CopySnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 268 mr.mock.ctrl.T.Helper() 269 varargs := append([]interface{}{arg0, arg1}, arg2...) 270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CopySnapshotWithContext), varargs...) 271 } 272 273 // CopySnapshotRequest mocks base method 274 func (m *MockElastiCacheAPI) CopySnapshotRequest(arg0 *elasticache.CopySnapshotInput) (*request.Request, *elasticache.CopySnapshotOutput) { 275 m.ctrl.T.Helper() 276 ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0) 277 ret0, _ := ret[0].(*request.Request) 278 ret1, _ := ret[1].(*elasticache.CopySnapshotOutput) 279 return ret0, ret1 280 } 281 282 // CopySnapshotRequest indicates an expected call of CopySnapshotRequest 283 func (mr *MockElastiCacheAPIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call { 284 mr.mock.ctrl.T.Helper() 285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CopySnapshotRequest), arg0) 286 } 287 288 // CreateCacheCluster mocks base method 289 func (m *MockElastiCacheAPI) CreateCacheCluster(arg0 *elasticache.CreateCacheClusterInput) (*elasticache.CreateCacheClusterOutput, error) { 290 m.ctrl.T.Helper() 291 ret := m.ctrl.Call(m, "CreateCacheCluster", arg0) 292 ret0, _ := ret[0].(*elasticache.CreateCacheClusterOutput) 293 ret1, _ := ret[1].(error) 294 return ret0, ret1 295 } 296 297 // CreateCacheCluster indicates an expected call of CreateCacheCluster 298 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheCluster(arg0 interface{}) *gomock.Call { 299 mr.mock.ctrl.T.Helper() 300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheCluster), arg0) 301 } 302 303 // CreateCacheClusterWithContext mocks base method 304 func (m *MockElastiCacheAPI) CreateCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheClusterInput, arg2 ...request.Option) (*elasticache.CreateCacheClusterOutput, error) { 305 m.ctrl.T.Helper() 306 varargs := []interface{}{arg0, arg1} 307 for _, a := range arg2 { 308 varargs = append(varargs, a) 309 } 310 ret := m.ctrl.Call(m, "CreateCacheClusterWithContext", varargs...) 311 ret0, _ := ret[0].(*elasticache.CreateCacheClusterOutput) 312 ret1, _ := ret[1].(error) 313 return ret0, ret1 314 } 315 316 // CreateCacheClusterWithContext indicates an expected call of CreateCacheClusterWithContext 317 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 318 mr.mock.ctrl.T.Helper() 319 varargs := append([]interface{}{arg0, arg1}, arg2...) 320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheClusterWithContext), varargs...) 321 } 322 323 // CreateCacheClusterRequest mocks base method 324 func (m *MockElastiCacheAPI) CreateCacheClusterRequest(arg0 *elasticache.CreateCacheClusterInput) (*request.Request, *elasticache.CreateCacheClusterOutput) { 325 m.ctrl.T.Helper() 326 ret := m.ctrl.Call(m, "CreateCacheClusterRequest", arg0) 327 ret0, _ := ret[0].(*request.Request) 328 ret1, _ := ret[1].(*elasticache.CreateCacheClusterOutput) 329 return ret0, ret1 330 } 331 332 // CreateCacheClusterRequest indicates an expected call of CreateCacheClusterRequest 333 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheClusterRequest(arg0 interface{}) *gomock.Call { 334 mr.mock.ctrl.T.Helper() 335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheClusterRequest), arg0) 336 } 337 338 // CreateCacheParameterGroup mocks base method 339 func (m *MockElastiCacheAPI) CreateCacheParameterGroup(arg0 *elasticache.CreateCacheParameterGroupInput) (*elasticache.CreateCacheParameterGroupOutput, error) { 340 m.ctrl.T.Helper() 341 ret := m.ctrl.Call(m, "CreateCacheParameterGroup", arg0) 342 ret0, _ := ret[0].(*elasticache.CreateCacheParameterGroupOutput) 343 ret1, _ := ret[1].(error) 344 return ret0, ret1 345 } 346 347 // CreateCacheParameterGroup indicates an expected call of CreateCacheParameterGroup 348 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheParameterGroup(arg0 interface{}) *gomock.Call { 349 mr.mock.ctrl.T.Helper() 350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheParameterGroup), arg0) 351 } 352 353 // CreateCacheParameterGroupWithContext mocks base method 354 func (m *MockElastiCacheAPI) CreateCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.CreateCacheParameterGroupOutput, error) { 355 m.ctrl.T.Helper() 356 varargs := []interface{}{arg0, arg1} 357 for _, a := range arg2 { 358 varargs = append(varargs, a) 359 } 360 ret := m.ctrl.Call(m, "CreateCacheParameterGroupWithContext", varargs...) 361 ret0, _ := ret[0].(*elasticache.CreateCacheParameterGroupOutput) 362 ret1, _ := ret[1].(error) 363 return ret0, ret1 364 } 365 366 // CreateCacheParameterGroupWithContext indicates an expected call of CreateCacheParameterGroupWithContext 367 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 368 mr.mock.ctrl.T.Helper() 369 varargs := append([]interface{}{arg0, arg1}, arg2...) 370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheParameterGroupWithContext), varargs...) 371 } 372 373 // CreateCacheParameterGroupRequest mocks base method 374 func (m *MockElastiCacheAPI) CreateCacheParameterGroupRequest(arg0 *elasticache.CreateCacheParameterGroupInput) (*request.Request, *elasticache.CreateCacheParameterGroupOutput) { 375 m.ctrl.T.Helper() 376 ret := m.ctrl.Call(m, "CreateCacheParameterGroupRequest", arg0) 377 ret0, _ := ret[0].(*request.Request) 378 ret1, _ := ret[1].(*elasticache.CreateCacheParameterGroupOutput) 379 return ret0, ret1 380 } 381 382 // CreateCacheParameterGroupRequest indicates an expected call of CreateCacheParameterGroupRequest 383 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheParameterGroupRequest(arg0 interface{}) *gomock.Call { 384 mr.mock.ctrl.T.Helper() 385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheParameterGroupRequest), arg0) 386 } 387 388 // CreateCacheSecurityGroup mocks base method 389 func (m *MockElastiCacheAPI) CreateCacheSecurityGroup(arg0 *elasticache.CreateCacheSecurityGroupInput) (*elasticache.CreateCacheSecurityGroupOutput, error) { 390 m.ctrl.T.Helper() 391 ret := m.ctrl.Call(m, "CreateCacheSecurityGroup", arg0) 392 ret0, _ := ret[0].(*elasticache.CreateCacheSecurityGroupOutput) 393 ret1, _ := ret[1].(error) 394 return ret0, ret1 395 } 396 397 // CreateCacheSecurityGroup indicates an expected call of CreateCacheSecurityGroup 398 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSecurityGroup(arg0 interface{}) *gomock.Call { 399 mr.mock.ctrl.T.Helper() 400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSecurityGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSecurityGroup), arg0) 401 } 402 403 // CreateCacheSecurityGroupWithContext mocks base method 404 func (m *MockElastiCacheAPI) CreateCacheSecurityGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheSecurityGroupInput, arg2 ...request.Option) (*elasticache.CreateCacheSecurityGroupOutput, error) { 405 m.ctrl.T.Helper() 406 varargs := []interface{}{arg0, arg1} 407 for _, a := range arg2 { 408 varargs = append(varargs, a) 409 } 410 ret := m.ctrl.Call(m, "CreateCacheSecurityGroupWithContext", varargs...) 411 ret0, _ := ret[0].(*elasticache.CreateCacheSecurityGroupOutput) 412 ret1, _ := ret[1].(error) 413 return ret0, ret1 414 } 415 416 // CreateCacheSecurityGroupWithContext indicates an expected call of CreateCacheSecurityGroupWithContext 417 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 418 mr.mock.ctrl.T.Helper() 419 varargs := append([]interface{}{arg0, arg1}, arg2...) 420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSecurityGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSecurityGroupWithContext), varargs...) 421 } 422 423 // CreateCacheSecurityGroupRequest mocks base method 424 func (m *MockElastiCacheAPI) CreateCacheSecurityGroupRequest(arg0 *elasticache.CreateCacheSecurityGroupInput) (*request.Request, *elasticache.CreateCacheSecurityGroupOutput) { 425 m.ctrl.T.Helper() 426 ret := m.ctrl.Call(m, "CreateCacheSecurityGroupRequest", arg0) 427 ret0, _ := ret[0].(*request.Request) 428 ret1, _ := ret[1].(*elasticache.CreateCacheSecurityGroupOutput) 429 return ret0, ret1 430 } 431 432 // CreateCacheSecurityGroupRequest indicates an expected call of CreateCacheSecurityGroupRequest 433 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSecurityGroupRequest(arg0 interface{}) *gomock.Call { 434 mr.mock.ctrl.T.Helper() 435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSecurityGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSecurityGroupRequest), arg0) 436 } 437 438 // CreateCacheSubnetGroup mocks base method 439 func (m *MockElastiCacheAPI) CreateCacheSubnetGroup(arg0 *elasticache.CreateCacheSubnetGroupInput) (*elasticache.CreateCacheSubnetGroupOutput, error) { 440 m.ctrl.T.Helper() 441 ret := m.ctrl.Call(m, "CreateCacheSubnetGroup", arg0) 442 ret0, _ := ret[0].(*elasticache.CreateCacheSubnetGroupOutput) 443 ret1, _ := ret[1].(error) 444 return ret0, ret1 445 } 446 447 // CreateCacheSubnetGroup indicates an expected call of CreateCacheSubnetGroup 448 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSubnetGroup(arg0 interface{}) *gomock.Call { 449 mr.mock.ctrl.T.Helper() 450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSubnetGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSubnetGroup), arg0) 451 } 452 453 // CreateCacheSubnetGroupWithContext mocks base method 454 func (m *MockElastiCacheAPI) CreateCacheSubnetGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheSubnetGroupInput, arg2 ...request.Option) (*elasticache.CreateCacheSubnetGroupOutput, error) { 455 m.ctrl.T.Helper() 456 varargs := []interface{}{arg0, arg1} 457 for _, a := range arg2 { 458 varargs = append(varargs, a) 459 } 460 ret := m.ctrl.Call(m, "CreateCacheSubnetGroupWithContext", varargs...) 461 ret0, _ := ret[0].(*elasticache.CreateCacheSubnetGroupOutput) 462 ret1, _ := ret[1].(error) 463 return ret0, ret1 464 } 465 466 // CreateCacheSubnetGroupWithContext indicates an expected call of CreateCacheSubnetGroupWithContext 467 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 468 mr.mock.ctrl.T.Helper() 469 varargs := append([]interface{}{arg0, arg1}, arg2...) 470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSubnetGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSubnetGroupWithContext), varargs...) 471 } 472 473 // CreateCacheSubnetGroupRequest mocks base method 474 func (m *MockElastiCacheAPI) CreateCacheSubnetGroupRequest(arg0 *elasticache.CreateCacheSubnetGroupInput) (*request.Request, *elasticache.CreateCacheSubnetGroupOutput) { 475 m.ctrl.T.Helper() 476 ret := m.ctrl.Call(m, "CreateCacheSubnetGroupRequest", arg0) 477 ret0, _ := ret[0].(*request.Request) 478 ret1, _ := ret[1].(*elasticache.CreateCacheSubnetGroupOutput) 479 return ret0, ret1 480 } 481 482 // CreateCacheSubnetGroupRequest indicates an expected call of CreateCacheSubnetGroupRequest 483 func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSubnetGroupRequest(arg0 interface{}) *gomock.Call { 484 mr.mock.ctrl.T.Helper() 485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSubnetGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSubnetGroupRequest), arg0) 486 } 487 488 // CreateReplicationGroup mocks base method 489 func (m *MockElastiCacheAPI) CreateReplicationGroup(arg0 *elasticache.CreateReplicationGroupInput) (*elasticache.CreateReplicationGroupOutput, error) { 490 m.ctrl.T.Helper() 491 ret := m.ctrl.Call(m, "CreateReplicationGroup", arg0) 492 ret0, _ := ret[0].(*elasticache.CreateReplicationGroupOutput) 493 ret1, _ := ret[1].(error) 494 return ret0, ret1 495 } 496 497 // CreateReplicationGroup indicates an expected call of CreateReplicationGroup 498 func (mr *MockElastiCacheAPIMockRecorder) CreateReplicationGroup(arg0 interface{}) *gomock.Call { 499 mr.mock.ctrl.T.Helper() 500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateReplicationGroup), arg0) 501 } 502 503 // CreateReplicationGroupWithContext mocks base method 504 func (m *MockElastiCacheAPI) CreateReplicationGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateReplicationGroupInput, arg2 ...request.Option) (*elasticache.CreateReplicationGroupOutput, error) { 505 m.ctrl.T.Helper() 506 varargs := []interface{}{arg0, arg1} 507 for _, a := range arg2 { 508 varargs = append(varargs, a) 509 } 510 ret := m.ctrl.Call(m, "CreateReplicationGroupWithContext", varargs...) 511 ret0, _ := ret[0].(*elasticache.CreateReplicationGroupOutput) 512 ret1, _ := ret[1].(error) 513 return ret0, ret1 514 } 515 516 // CreateReplicationGroupWithContext indicates an expected call of CreateReplicationGroupWithContext 517 func (mr *MockElastiCacheAPIMockRecorder) CreateReplicationGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 518 mr.mock.ctrl.T.Helper() 519 varargs := append([]interface{}{arg0, arg1}, arg2...) 520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateReplicationGroupWithContext), varargs...) 521 } 522 523 // CreateReplicationGroupRequest mocks base method 524 func (m *MockElastiCacheAPI) CreateReplicationGroupRequest(arg0 *elasticache.CreateReplicationGroupInput) (*request.Request, *elasticache.CreateReplicationGroupOutput) { 525 m.ctrl.T.Helper() 526 ret := m.ctrl.Call(m, "CreateReplicationGroupRequest", arg0) 527 ret0, _ := ret[0].(*request.Request) 528 ret1, _ := ret[1].(*elasticache.CreateReplicationGroupOutput) 529 return ret0, ret1 530 } 531 532 // CreateReplicationGroupRequest indicates an expected call of CreateReplicationGroupRequest 533 func (mr *MockElastiCacheAPIMockRecorder) CreateReplicationGroupRequest(arg0 interface{}) *gomock.Call { 534 mr.mock.ctrl.T.Helper() 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateReplicationGroupRequest), arg0) 536 } 537 538 // CreateSnapshot mocks base method 539 func (m *MockElastiCacheAPI) CreateSnapshot(arg0 *elasticache.CreateSnapshotInput) (*elasticache.CreateSnapshotOutput, error) { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "CreateSnapshot", arg0) 542 ret0, _ := ret[0].(*elasticache.CreateSnapshotOutput) 543 ret1, _ := ret[1].(error) 544 return ret0, ret1 545 } 546 547 // CreateSnapshot indicates an expected call of CreateSnapshot 548 func (mr *MockElastiCacheAPIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call { 549 mr.mock.ctrl.T.Helper() 550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateSnapshot), arg0) 551 } 552 553 // CreateSnapshotWithContext mocks base method 554 func (m *MockElastiCacheAPI) CreateSnapshotWithContext(arg0 aws.Context, arg1 *elasticache.CreateSnapshotInput, arg2 ...request.Option) (*elasticache.CreateSnapshotOutput, error) { 555 m.ctrl.T.Helper() 556 varargs := []interface{}{arg0, arg1} 557 for _, a := range arg2 { 558 varargs = append(varargs, a) 559 } 560 ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...) 561 ret0, _ := ret[0].(*elasticache.CreateSnapshotOutput) 562 ret1, _ := ret[1].(error) 563 return ret0, ret1 564 } 565 566 // CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext 567 func (mr *MockElastiCacheAPIMockRecorder) CreateSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 568 mr.mock.ctrl.T.Helper() 569 varargs := append([]interface{}{arg0, arg1}, arg2...) 570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateSnapshotWithContext), varargs...) 571 } 572 573 // CreateSnapshotRequest mocks base method 574 func (m *MockElastiCacheAPI) CreateSnapshotRequest(arg0 *elasticache.CreateSnapshotInput) (*request.Request, *elasticache.CreateSnapshotOutput) { 575 m.ctrl.T.Helper() 576 ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0) 577 ret0, _ := ret[0].(*request.Request) 578 ret1, _ := ret[1].(*elasticache.CreateSnapshotOutput) 579 return ret0, ret1 580 } 581 582 // CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest 583 func (mr *MockElastiCacheAPIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call { 584 mr.mock.ctrl.T.Helper() 585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateSnapshotRequest), arg0) 586 } 587 588 // DecreaseReplicaCount mocks base method 589 func (m *MockElastiCacheAPI) DecreaseReplicaCount(arg0 *elasticache.DecreaseReplicaCountInput) (*elasticache.DecreaseReplicaCountOutput, error) { 590 m.ctrl.T.Helper() 591 ret := m.ctrl.Call(m, "DecreaseReplicaCount", arg0) 592 ret0, _ := ret[0].(*elasticache.DecreaseReplicaCountOutput) 593 ret1, _ := ret[1].(error) 594 return ret0, ret1 595 } 596 597 // DecreaseReplicaCount indicates an expected call of DecreaseReplicaCount 598 func (mr *MockElastiCacheAPIMockRecorder) DecreaseReplicaCount(arg0 interface{}) *gomock.Call { 599 mr.mock.ctrl.T.Helper() 600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecreaseReplicaCount", reflect.TypeOf((*MockElastiCacheAPI)(nil).DecreaseReplicaCount), arg0) 601 } 602 603 // DecreaseReplicaCountWithContext mocks base method 604 func (m *MockElastiCacheAPI) DecreaseReplicaCountWithContext(arg0 aws.Context, arg1 *elasticache.DecreaseReplicaCountInput, arg2 ...request.Option) (*elasticache.DecreaseReplicaCountOutput, error) { 605 m.ctrl.T.Helper() 606 varargs := []interface{}{arg0, arg1} 607 for _, a := range arg2 { 608 varargs = append(varargs, a) 609 } 610 ret := m.ctrl.Call(m, "DecreaseReplicaCountWithContext", varargs...) 611 ret0, _ := ret[0].(*elasticache.DecreaseReplicaCountOutput) 612 ret1, _ := ret[1].(error) 613 return ret0, ret1 614 } 615 616 // DecreaseReplicaCountWithContext indicates an expected call of DecreaseReplicaCountWithContext 617 func (mr *MockElastiCacheAPIMockRecorder) DecreaseReplicaCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 618 mr.mock.ctrl.T.Helper() 619 varargs := append([]interface{}{arg0, arg1}, arg2...) 620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecreaseReplicaCountWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DecreaseReplicaCountWithContext), varargs...) 621 } 622 623 // DecreaseReplicaCountRequest mocks base method 624 func (m *MockElastiCacheAPI) DecreaseReplicaCountRequest(arg0 *elasticache.DecreaseReplicaCountInput) (*request.Request, *elasticache.DecreaseReplicaCountOutput) { 625 m.ctrl.T.Helper() 626 ret := m.ctrl.Call(m, "DecreaseReplicaCountRequest", arg0) 627 ret0, _ := ret[0].(*request.Request) 628 ret1, _ := ret[1].(*elasticache.DecreaseReplicaCountOutput) 629 return ret0, ret1 630 } 631 632 // DecreaseReplicaCountRequest indicates an expected call of DecreaseReplicaCountRequest 633 func (mr *MockElastiCacheAPIMockRecorder) DecreaseReplicaCountRequest(arg0 interface{}) *gomock.Call { 634 mr.mock.ctrl.T.Helper() 635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecreaseReplicaCountRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DecreaseReplicaCountRequest), arg0) 636 } 637 638 // DeleteCacheCluster mocks base method 639 func (m *MockElastiCacheAPI) DeleteCacheCluster(arg0 *elasticache.DeleteCacheClusterInput) (*elasticache.DeleteCacheClusterOutput, error) { 640 m.ctrl.T.Helper() 641 ret := m.ctrl.Call(m, "DeleteCacheCluster", arg0) 642 ret0, _ := ret[0].(*elasticache.DeleteCacheClusterOutput) 643 ret1, _ := ret[1].(error) 644 return ret0, ret1 645 } 646 647 // DeleteCacheCluster indicates an expected call of DeleteCacheCluster 648 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheCluster(arg0 interface{}) *gomock.Call { 649 mr.mock.ctrl.T.Helper() 650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheCluster), arg0) 651 } 652 653 // DeleteCacheClusterWithContext mocks base method 654 func (m *MockElastiCacheAPI) DeleteCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheClusterInput, arg2 ...request.Option) (*elasticache.DeleteCacheClusterOutput, error) { 655 m.ctrl.T.Helper() 656 varargs := []interface{}{arg0, arg1} 657 for _, a := range arg2 { 658 varargs = append(varargs, a) 659 } 660 ret := m.ctrl.Call(m, "DeleteCacheClusterWithContext", varargs...) 661 ret0, _ := ret[0].(*elasticache.DeleteCacheClusterOutput) 662 ret1, _ := ret[1].(error) 663 return ret0, ret1 664 } 665 666 // DeleteCacheClusterWithContext indicates an expected call of DeleteCacheClusterWithContext 667 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 668 mr.mock.ctrl.T.Helper() 669 varargs := append([]interface{}{arg0, arg1}, arg2...) 670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheClusterWithContext), varargs...) 671 } 672 673 // DeleteCacheClusterRequest mocks base method 674 func (m *MockElastiCacheAPI) DeleteCacheClusterRequest(arg0 *elasticache.DeleteCacheClusterInput) (*request.Request, *elasticache.DeleteCacheClusterOutput) { 675 m.ctrl.T.Helper() 676 ret := m.ctrl.Call(m, "DeleteCacheClusterRequest", arg0) 677 ret0, _ := ret[0].(*request.Request) 678 ret1, _ := ret[1].(*elasticache.DeleteCacheClusterOutput) 679 return ret0, ret1 680 } 681 682 // DeleteCacheClusterRequest indicates an expected call of DeleteCacheClusterRequest 683 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheClusterRequest(arg0 interface{}) *gomock.Call { 684 mr.mock.ctrl.T.Helper() 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheClusterRequest), arg0) 686 } 687 688 // DeleteCacheParameterGroup mocks base method 689 func (m *MockElastiCacheAPI) DeleteCacheParameterGroup(arg0 *elasticache.DeleteCacheParameterGroupInput) (*elasticache.DeleteCacheParameterGroupOutput, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "DeleteCacheParameterGroup", arg0) 692 ret0, _ := ret[0].(*elasticache.DeleteCacheParameterGroupOutput) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // DeleteCacheParameterGroup indicates an expected call of DeleteCacheParameterGroup 698 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheParameterGroup(arg0 interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheParameterGroup), arg0) 701 } 702 703 // DeleteCacheParameterGroupWithContext mocks base method 704 func (m *MockElastiCacheAPI) DeleteCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.DeleteCacheParameterGroupOutput, error) { 705 m.ctrl.T.Helper() 706 varargs := []interface{}{arg0, arg1} 707 for _, a := range arg2 { 708 varargs = append(varargs, a) 709 } 710 ret := m.ctrl.Call(m, "DeleteCacheParameterGroupWithContext", varargs...) 711 ret0, _ := ret[0].(*elasticache.DeleteCacheParameterGroupOutput) 712 ret1, _ := ret[1].(error) 713 return ret0, ret1 714 } 715 716 // DeleteCacheParameterGroupWithContext indicates an expected call of DeleteCacheParameterGroupWithContext 717 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 718 mr.mock.ctrl.T.Helper() 719 varargs := append([]interface{}{arg0, arg1}, arg2...) 720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheParameterGroupWithContext), varargs...) 721 } 722 723 // DeleteCacheParameterGroupRequest mocks base method 724 func (m *MockElastiCacheAPI) DeleteCacheParameterGroupRequest(arg0 *elasticache.DeleteCacheParameterGroupInput) (*request.Request, *elasticache.DeleteCacheParameterGroupOutput) { 725 m.ctrl.T.Helper() 726 ret := m.ctrl.Call(m, "DeleteCacheParameterGroupRequest", arg0) 727 ret0, _ := ret[0].(*request.Request) 728 ret1, _ := ret[1].(*elasticache.DeleteCacheParameterGroupOutput) 729 return ret0, ret1 730 } 731 732 // DeleteCacheParameterGroupRequest indicates an expected call of DeleteCacheParameterGroupRequest 733 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheParameterGroupRequest(arg0 interface{}) *gomock.Call { 734 mr.mock.ctrl.T.Helper() 735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheParameterGroupRequest), arg0) 736 } 737 738 // DeleteCacheSecurityGroup mocks base method 739 func (m *MockElastiCacheAPI) DeleteCacheSecurityGroup(arg0 *elasticache.DeleteCacheSecurityGroupInput) (*elasticache.DeleteCacheSecurityGroupOutput, error) { 740 m.ctrl.T.Helper() 741 ret := m.ctrl.Call(m, "DeleteCacheSecurityGroup", arg0) 742 ret0, _ := ret[0].(*elasticache.DeleteCacheSecurityGroupOutput) 743 ret1, _ := ret[1].(error) 744 return ret0, ret1 745 } 746 747 // DeleteCacheSecurityGroup indicates an expected call of DeleteCacheSecurityGroup 748 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSecurityGroup(arg0 interface{}) *gomock.Call { 749 mr.mock.ctrl.T.Helper() 750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSecurityGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSecurityGroup), arg0) 751 } 752 753 // DeleteCacheSecurityGroupWithContext mocks base method 754 func (m *MockElastiCacheAPI) DeleteCacheSecurityGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheSecurityGroupInput, arg2 ...request.Option) (*elasticache.DeleteCacheSecurityGroupOutput, error) { 755 m.ctrl.T.Helper() 756 varargs := []interface{}{arg0, arg1} 757 for _, a := range arg2 { 758 varargs = append(varargs, a) 759 } 760 ret := m.ctrl.Call(m, "DeleteCacheSecurityGroupWithContext", varargs...) 761 ret0, _ := ret[0].(*elasticache.DeleteCacheSecurityGroupOutput) 762 ret1, _ := ret[1].(error) 763 return ret0, ret1 764 } 765 766 // DeleteCacheSecurityGroupWithContext indicates an expected call of DeleteCacheSecurityGroupWithContext 767 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 768 mr.mock.ctrl.T.Helper() 769 varargs := append([]interface{}{arg0, arg1}, arg2...) 770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSecurityGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSecurityGroupWithContext), varargs...) 771 } 772 773 // DeleteCacheSecurityGroupRequest mocks base method 774 func (m *MockElastiCacheAPI) DeleteCacheSecurityGroupRequest(arg0 *elasticache.DeleteCacheSecurityGroupInput) (*request.Request, *elasticache.DeleteCacheSecurityGroupOutput) { 775 m.ctrl.T.Helper() 776 ret := m.ctrl.Call(m, "DeleteCacheSecurityGroupRequest", arg0) 777 ret0, _ := ret[0].(*request.Request) 778 ret1, _ := ret[1].(*elasticache.DeleteCacheSecurityGroupOutput) 779 return ret0, ret1 780 } 781 782 // DeleteCacheSecurityGroupRequest indicates an expected call of DeleteCacheSecurityGroupRequest 783 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSecurityGroupRequest(arg0 interface{}) *gomock.Call { 784 mr.mock.ctrl.T.Helper() 785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSecurityGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSecurityGroupRequest), arg0) 786 } 787 788 // DeleteCacheSubnetGroup mocks base method 789 func (m *MockElastiCacheAPI) DeleteCacheSubnetGroup(arg0 *elasticache.DeleteCacheSubnetGroupInput) (*elasticache.DeleteCacheSubnetGroupOutput, error) { 790 m.ctrl.T.Helper() 791 ret := m.ctrl.Call(m, "DeleteCacheSubnetGroup", arg0) 792 ret0, _ := ret[0].(*elasticache.DeleteCacheSubnetGroupOutput) 793 ret1, _ := ret[1].(error) 794 return ret0, ret1 795 } 796 797 // DeleteCacheSubnetGroup indicates an expected call of DeleteCacheSubnetGroup 798 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSubnetGroup(arg0 interface{}) *gomock.Call { 799 mr.mock.ctrl.T.Helper() 800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSubnetGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSubnetGroup), arg0) 801 } 802 803 // DeleteCacheSubnetGroupWithContext mocks base method 804 func (m *MockElastiCacheAPI) DeleteCacheSubnetGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheSubnetGroupInput, arg2 ...request.Option) (*elasticache.DeleteCacheSubnetGroupOutput, error) { 805 m.ctrl.T.Helper() 806 varargs := []interface{}{arg0, arg1} 807 for _, a := range arg2 { 808 varargs = append(varargs, a) 809 } 810 ret := m.ctrl.Call(m, "DeleteCacheSubnetGroupWithContext", varargs...) 811 ret0, _ := ret[0].(*elasticache.DeleteCacheSubnetGroupOutput) 812 ret1, _ := ret[1].(error) 813 return ret0, ret1 814 } 815 816 // DeleteCacheSubnetGroupWithContext indicates an expected call of DeleteCacheSubnetGroupWithContext 817 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 818 mr.mock.ctrl.T.Helper() 819 varargs := append([]interface{}{arg0, arg1}, arg2...) 820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSubnetGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSubnetGroupWithContext), varargs...) 821 } 822 823 // DeleteCacheSubnetGroupRequest mocks base method 824 func (m *MockElastiCacheAPI) DeleteCacheSubnetGroupRequest(arg0 *elasticache.DeleteCacheSubnetGroupInput) (*request.Request, *elasticache.DeleteCacheSubnetGroupOutput) { 825 m.ctrl.T.Helper() 826 ret := m.ctrl.Call(m, "DeleteCacheSubnetGroupRequest", arg0) 827 ret0, _ := ret[0].(*request.Request) 828 ret1, _ := ret[1].(*elasticache.DeleteCacheSubnetGroupOutput) 829 return ret0, ret1 830 } 831 832 // DeleteCacheSubnetGroupRequest indicates an expected call of DeleteCacheSubnetGroupRequest 833 func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSubnetGroupRequest(arg0 interface{}) *gomock.Call { 834 mr.mock.ctrl.T.Helper() 835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSubnetGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSubnetGroupRequest), arg0) 836 } 837 838 // DeleteReplicationGroup mocks base method 839 func (m *MockElastiCacheAPI) DeleteReplicationGroup(arg0 *elasticache.DeleteReplicationGroupInput) (*elasticache.DeleteReplicationGroupOutput, error) { 840 m.ctrl.T.Helper() 841 ret := m.ctrl.Call(m, "DeleteReplicationGroup", arg0) 842 ret0, _ := ret[0].(*elasticache.DeleteReplicationGroupOutput) 843 ret1, _ := ret[1].(error) 844 return ret0, ret1 845 } 846 847 // DeleteReplicationGroup indicates an expected call of DeleteReplicationGroup 848 func (mr *MockElastiCacheAPIMockRecorder) DeleteReplicationGroup(arg0 interface{}) *gomock.Call { 849 mr.mock.ctrl.T.Helper() 850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteReplicationGroup), arg0) 851 } 852 853 // DeleteReplicationGroupWithContext mocks base method 854 func (m *MockElastiCacheAPI) DeleteReplicationGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteReplicationGroupInput, arg2 ...request.Option) (*elasticache.DeleteReplicationGroupOutput, error) { 855 m.ctrl.T.Helper() 856 varargs := []interface{}{arg0, arg1} 857 for _, a := range arg2 { 858 varargs = append(varargs, a) 859 } 860 ret := m.ctrl.Call(m, "DeleteReplicationGroupWithContext", varargs...) 861 ret0, _ := ret[0].(*elasticache.DeleteReplicationGroupOutput) 862 ret1, _ := ret[1].(error) 863 return ret0, ret1 864 } 865 866 // DeleteReplicationGroupWithContext indicates an expected call of DeleteReplicationGroupWithContext 867 func (mr *MockElastiCacheAPIMockRecorder) DeleteReplicationGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 868 mr.mock.ctrl.T.Helper() 869 varargs := append([]interface{}{arg0, arg1}, arg2...) 870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteReplicationGroupWithContext), varargs...) 871 } 872 873 // DeleteReplicationGroupRequest mocks base method 874 func (m *MockElastiCacheAPI) DeleteReplicationGroupRequest(arg0 *elasticache.DeleteReplicationGroupInput) (*request.Request, *elasticache.DeleteReplicationGroupOutput) { 875 m.ctrl.T.Helper() 876 ret := m.ctrl.Call(m, "DeleteReplicationGroupRequest", arg0) 877 ret0, _ := ret[0].(*request.Request) 878 ret1, _ := ret[1].(*elasticache.DeleteReplicationGroupOutput) 879 return ret0, ret1 880 } 881 882 // DeleteReplicationGroupRequest indicates an expected call of DeleteReplicationGroupRequest 883 func (mr *MockElastiCacheAPIMockRecorder) DeleteReplicationGroupRequest(arg0 interface{}) *gomock.Call { 884 mr.mock.ctrl.T.Helper() 885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteReplicationGroupRequest), arg0) 886 } 887 888 // DeleteSnapshot mocks base method 889 func (m *MockElastiCacheAPI) DeleteSnapshot(arg0 *elasticache.DeleteSnapshotInput) (*elasticache.DeleteSnapshotOutput, error) { 890 m.ctrl.T.Helper() 891 ret := m.ctrl.Call(m, "DeleteSnapshot", arg0) 892 ret0, _ := ret[0].(*elasticache.DeleteSnapshotOutput) 893 ret1, _ := ret[1].(error) 894 return ret0, ret1 895 } 896 897 // DeleteSnapshot indicates an expected call of DeleteSnapshot 898 func (mr *MockElastiCacheAPIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call { 899 mr.mock.ctrl.T.Helper() 900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteSnapshot), arg0) 901 } 902 903 // DeleteSnapshotWithContext mocks base method 904 func (m *MockElastiCacheAPI) DeleteSnapshotWithContext(arg0 aws.Context, arg1 *elasticache.DeleteSnapshotInput, arg2 ...request.Option) (*elasticache.DeleteSnapshotOutput, error) { 905 m.ctrl.T.Helper() 906 varargs := []interface{}{arg0, arg1} 907 for _, a := range arg2 { 908 varargs = append(varargs, a) 909 } 910 ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...) 911 ret0, _ := ret[0].(*elasticache.DeleteSnapshotOutput) 912 ret1, _ := ret[1].(error) 913 return ret0, ret1 914 } 915 916 // DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext 917 func (mr *MockElastiCacheAPIMockRecorder) DeleteSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 918 mr.mock.ctrl.T.Helper() 919 varargs := append([]interface{}{arg0, arg1}, arg2...) 920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteSnapshotWithContext), varargs...) 921 } 922 923 // DeleteSnapshotRequest mocks base method 924 func (m *MockElastiCacheAPI) DeleteSnapshotRequest(arg0 *elasticache.DeleteSnapshotInput) (*request.Request, *elasticache.DeleteSnapshotOutput) { 925 m.ctrl.T.Helper() 926 ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0) 927 ret0, _ := ret[0].(*request.Request) 928 ret1, _ := ret[1].(*elasticache.DeleteSnapshotOutput) 929 return ret0, ret1 930 } 931 932 // DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest 933 func (mr *MockElastiCacheAPIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call { 934 mr.mock.ctrl.T.Helper() 935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteSnapshotRequest), arg0) 936 } 937 938 // DescribeCacheClusters mocks base method 939 func (m *MockElastiCacheAPI) DescribeCacheClusters(arg0 *elasticache.DescribeCacheClustersInput) (*elasticache.DescribeCacheClustersOutput, error) { 940 m.ctrl.T.Helper() 941 ret := m.ctrl.Call(m, "DescribeCacheClusters", arg0) 942 ret0, _ := ret[0].(*elasticache.DescribeCacheClustersOutput) 943 ret1, _ := ret[1].(error) 944 return ret0, ret1 945 } 946 947 // DescribeCacheClusters indicates an expected call of DescribeCacheClusters 948 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClusters(arg0 interface{}) *gomock.Call { 949 mr.mock.ctrl.T.Helper() 950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClusters", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClusters), arg0) 951 } 952 953 // DescribeCacheClustersWithContext mocks base method 954 func (m *MockElastiCacheAPI) DescribeCacheClustersWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 ...request.Option) (*elasticache.DescribeCacheClustersOutput, error) { 955 m.ctrl.T.Helper() 956 varargs := []interface{}{arg0, arg1} 957 for _, a := range arg2 { 958 varargs = append(varargs, a) 959 } 960 ret := m.ctrl.Call(m, "DescribeCacheClustersWithContext", varargs...) 961 ret0, _ := ret[0].(*elasticache.DescribeCacheClustersOutput) 962 ret1, _ := ret[1].(error) 963 return ret0, ret1 964 } 965 966 // DescribeCacheClustersWithContext indicates an expected call of DescribeCacheClustersWithContext 967 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 968 mr.mock.ctrl.T.Helper() 969 varargs := append([]interface{}{arg0, arg1}, arg2...) 970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersWithContext), varargs...) 971 } 972 973 // DescribeCacheClustersRequest mocks base method 974 func (m *MockElastiCacheAPI) DescribeCacheClustersRequest(arg0 *elasticache.DescribeCacheClustersInput) (*request.Request, *elasticache.DescribeCacheClustersOutput) { 975 m.ctrl.T.Helper() 976 ret := m.ctrl.Call(m, "DescribeCacheClustersRequest", arg0) 977 ret0, _ := ret[0].(*request.Request) 978 ret1, _ := ret[1].(*elasticache.DescribeCacheClustersOutput) 979 return ret0, ret1 980 } 981 982 // DescribeCacheClustersRequest indicates an expected call of DescribeCacheClustersRequest 983 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersRequest(arg0 interface{}) *gomock.Call { 984 mr.mock.ctrl.T.Helper() 985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersRequest), arg0) 986 } 987 988 // DescribeCacheClustersPages mocks base method 989 func (m *MockElastiCacheAPI) DescribeCacheClustersPages(arg0 *elasticache.DescribeCacheClustersInput, arg1 func(*elasticache.DescribeCacheClustersOutput, bool) bool) error { 990 m.ctrl.T.Helper() 991 ret := m.ctrl.Call(m, "DescribeCacheClustersPages", arg0, arg1) 992 ret0, _ := ret[0].(error) 993 return ret0 994 } 995 996 // DescribeCacheClustersPages indicates an expected call of DescribeCacheClustersPages 997 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersPages(arg0, arg1 interface{}) *gomock.Call { 998 mr.mock.ctrl.T.Helper() 999 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersPages), arg0, arg1) 1000 } 1001 1002 // DescribeCacheClustersPagesWithContext mocks base method 1003 func (m *MockElastiCacheAPI) DescribeCacheClustersPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 func(*elasticache.DescribeCacheClustersOutput, bool) bool, arg3 ...request.Option) error { 1004 m.ctrl.T.Helper() 1005 varargs := []interface{}{arg0, arg1, arg2} 1006 for _, a := range arg3 { 1007 varargs = append(varargs, a) 1008 } 1009 ret := m.ctrl.Call(m, "DescribeCacheClustersPagesWithContext", varargs...) 1010 ret0, _ := ret[0].(error) 1011 return ret0 1012 } 1013 1014 // DescribeCacheClustersPagesWithContext indicates an expected call of DescribeCacheClustersPagesWithContext 1015 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1016 mr.mock.ctrl.T.Helper() 1017 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1018 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersPagesWithContext), varargs...) 1019 } 1020 1021 // DescribeCacheEngineVersions mocks base method 1022 func (m *MockElastiCacheAPI) DescribeCacheEngineVersions(arg0 *elasticache.DescribeCacheEngineVersionsInput) (*elasticache.DescribeCacheEngineVersionsOutput, error) { 1023 m.ctrl.T.Helper() 1024 ret := m.ctrl.Call(m, "DescribeCacheEngineVersions", arg0) 1025 ret0, _ := ret[0].(*elasticache.DescribeCacheEngineVersionsOutput) 1026 ret1, _ := ret[1].(error) 1027 return ret0, ret1 1028 } 1029 1030 // DescribeCacheEngineVersions indicates an expected call of DescribeCacheEngineVersions 1031 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersions(arg0 interface{}) *gomock.Call { 1032 mr.mock.ctrl.T.Helper() 1033 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersions", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersions), arg0) 1034 } 1035 1036 // DescribeCacheEngineVersionsWithContext mocks base method 1037 func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheEngineVersionsInput, arg2 ...request.Option) (*elasticache.DescribeCacheEngineVersionsOutput, error) { 1038 m.ctrl.T.Helper() 1039 varargs := []interface{}{arg0, arg1} 1040 for _, a := range arg2 { 1041 varargs = append(varargs, a) 1042 } 1043 ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsWithContext", varargs...) 1044 ret0, _ := ret[0].(*elasticache.DescribeCacheEngineVersionsOutput) 1045 ret1, _ := ret[1].(error) 1046 return ret0, ret1 1047 } 1048 1049 // DescribeCacheEngineVersionsWithContext indicates an expected call of DescribeCacheEngineVersionsWithContext 1050 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1051 mr.mock.ctrl.T.Helper() 1052 varargs := append([]interface{}{arg0, arg1}, arg2...) 1053 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsWithContext), varargs...) 1054 } 1055 1056 // DescribeCacheEngineVersionsRequest mocks base method 1057 func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsRequest(arg0 *elasticache.DescribeCacheEngineVersionsInput) (*request.Request, *elasticache.DescribeCacheEngineVersionsOutput) { 1058 m.ctrl.T.Helper() 1059 ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsRequest", arg0) 1060 ret0, _ := ret[0].(*request.Request) 1061 ret1, _ := ret[1].(*elasticache.DescribeCacheEngineVersionsOutput) 1062 return ret0, ret1 1063 } 1064 1065 // DescribeCacheEngineVersionsRequest indicates an expected call of DescribeCacheEngineVersionsRequest 1066 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsRequest(arg0 interface{}) *gomock.Call { 1067 mr.mock.ctrl.T.Helper() 1068 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsRequest), arg0) 1069 } 1070 1071 // DescribeCacheEngineVersionsPages mocks base method 1072 func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsPages(arg0 *elasticache.DescribeCacheEngineVersionsInput, arg1 func(*elasticache.DescribeCacheEngineVersionsOutput, bool) bool) error { 1073 m.ctrl.T.Helper() 1074 ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsPages", arg0, arg1) 1075 ret0, _ := ret[0].(error) 1076 return ret0 1077 } 1078 1079 // DescribeCacheEngineVersionsPages indicates an expected call of DescribeCacheEngineVersionsPages 1080 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsPages(arg0, arg1 interface{}) *gomock.Call { 1081 mr.mock.ctrl.T.Helper() 1082 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsPages), arg0, arg1) 1083 } 1084 1085 // DescribeCacheEngineVersionsPagesWithContext mocks base method 1086 func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheEngineVersionsInput, arg2 func(*elasticache.DescribeCacheEngineVersionsOutput, bool) bool, arg3 ...request.Option) error { 1087 m.ctrl.T.Helper() 1088 varargs := []interface{}{arg0, arg1, arg2} 1089 for _, a := range arg3 { 1090 varargs = append(varargs, a) 1091 } 1092 ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsPagesWithContext", varargs...) 1093 ret0, _ := ret[0].(error) 1094 return ret0 1095 } 1096 1097 // DescribeCacheEngineVersionsPagesWithContext indicates an expected call of DescribeCacheEngineVersionsPagesWithContext 1098 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1099 mr.mock.ctrl.T.Helper() 1100 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1101 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsPagesWithContext), varargs...) 1102 } 1103 1104 // DescribeCacheParameterGroups mocks base method 1105 func (m *MockElastiCacheAPI) DescribeCacheParameterGroups(arg0 *elasticache.DescribeCacheParameterGroupsInput) (*elasticache.DescribeCacheParameterGroupsOutput, error) { 1106 m.ctrl.T.Helper() 1107 ret := m.ctrl.Call(m, "DescribeCacheParameterGroups", arg0) 1108 ret0, _ := ret[0].(*elasticache.DescribeCacheParameterGroupsOutput) 1109 ret1, _ := ret[1].(error) 1110 return ret0, ret1 1111 } 1112 1113 // DescribeCacheParameterGroups indicates an expected call of DescribeCacheParameterGroups 1114 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroups(arg0 interface{}) *gomock.Call { 1115 mr.mock.ctrl.T.Helper() 1116 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroups), arg0) 1117 } 1118 1119 // DescribeCacheParameterGroupsWithContext mocks base method 1120 func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParameterGroupsInput, arg2 ...request.Option) (*elasticache.DescribeCacheParameterGroupsOutput, error) { 1121 m.ctrl.T.Helper() 1122 varargs := []interface{}{arg0, arg1} 1123 for _, a := range arg2 { 1124 varargs = append(varargs, a) 1125 } 1126 ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsWithContext", varargs...) 1127 ret0, _ := ret[0].(*elasticache.DescribeCacheParameterGroupsOutput) 1128 ret1, _ := ret[1].(error) 1129 return ret0, ret1 1130 } 1131 1132 // DescribeCacheParameterGroupsWithContext indicates an expected call of DescribeCacheParameterGroupsWithContext 1133 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1134 mr.mock.ctrl.T.Helper() 1135 varargs := append([]interface{}{arg0, arg1}, arg2...) 1136 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsWithContext), varargs...) 1137 } 1138 1139 // DescribeCacheParameterGroupsRequest mocks base method 1140 func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsRequest(arg0 *elasticache.DescribeCacheParameterGroupsInput) (*request.Request, *elasticache.DescribeCacheParameterGroupsOutput) { 1141 m.ctrl.T.Helper() 1142 ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsRequest", arg0) 1143 ret0, _ := ret[0].(*request.Request) 1144 ret1, _ := ret[1].(*elasticache.DescribeCacheParameterGroupsOutput) 1145 return ret0, ret1 1146 } 1147 1148 // DescribeCacheParameterGroupsRequest indicates an expected call of DescribeCacheParameterGroupsRequest 1149 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsRequest(arg0 interface{}) *gomock.Call { 1150 mr.mock.ctrl.T.Helper() 1151 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsRequest), arg0) 1152 } 1153 1154 // DescribeCacheParameterGroupsPages mocks base method 1155 func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsPages(arg0 *elasticache.DescribeCacheParameterGroupsInput, arg1 func(*elasticache.DescribeCacheParameterGroupsOutput, bool) bool) error { 1156 m.ctrl.T.Helper() 1157 ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsPages", arg0, arg1) 1158 ret0, _ := ret[0].(error) 1159 return ret0 1160 } 1161 1162 // DescribeCacheParameterGroupsPages indicates an expected call of DescribeCacheParameterGroupsPages 1163 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsPages(arg0, arg1 interface{}) *gomock.Call { 1164 mr.mock.ctrl.T.Helper() 1165 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsPages), arg0, arg1) 1166 } 1167 1168 // DescribeCacheParameterGroupsPagesWithContext mocks base method 1169 func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParameterGroupsInput, arg2 func(*elasticache.DescribeCacheParameterGroupsOutput, bool) bool, arg3 ...request.Option) error { 1170 m.ctrl.T.Helper() 1171 varargs := []interface{}{arg0, arg1, arg2} 1172 for _, a := range arg3 { 1173 varargs = append(varargs, a) 1174 } 1175 ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsPagesWithContext", varargs...) 1176 ret0, _ := ret[0].(error) 1177 return ret0 1178 } 1179 1180 // DescribeCacheParameterGroupsPagesWithContext indicates an expected call of DescribeCacheParameterGroupsPagesWithContext 1181 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1182 mr.mock.ctrl.T.Helper() 1183 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1184 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsPagesWithContext), varargs...) 1185 } 1186 1187 // DescribeCacheParameters mocks base method 1188 func (m *MockElastiCacheAPI) DescribeCacheParameters(arg0 *elasticache.DescribeCacheParametersInput) (*elasticache.DescribeCacheParametersOutput, error) { 1189 m.ctrl.T.Helper() 1190 ret := m.ctrl.Call(m, "DescribeCacheParameters", arg0) 1191 ret0, _ := ret[0].(*elasticache.DescribeCacheParametersOutput) 1192 ret1, _ := ret[1].(error) 1193 return ret0, ret1 1194 } 1195 1196 // DescribeCacheParameters indicates an expected call of DescribeCacheParameters 1197 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameters(arg0 interface{}) *gomock.Call { 1198 mr.mock.ctrl.T.Helper() 1199 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameters", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameters), arg0) 1200 } 1201 1202 // DescribeCacheParametersWithContext mocks base method 1203 func (m *MockElastiCacheAPI) DescribeCacheParametersWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParametersInput, arg2 ...request.Option) (*elasticache.DescribeCacheParametersOutput, error) { 1204 m.ctrl.T.Helper() 1205 varargs := []interface{}{arg0, arg1} 1206 for _, a := range arg2 { 1207 varargs = append(varargs, a) 1208 } 1209 ret := m.ctrl.Call(m, "DescribeCacheParametersWithContext", varargs...) 1210 ret0, _ := ret[0].(*elasticache.DescribeCacheParametersOutput) 1211 ret1, _ := ret[1].(error) 1212 return ret0, ret1 1213 } 1214 1215 // DescribeCacheParametersWithContext indicates an expected call of DescribeCacheParametersWithContext 1216 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1217 mr.mock.ctrl.T.Helper() 1218 varargs := append([]interface{}{arg0, arg1}, arg2...) 1219 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersWithContext), varargs...) 1220 } 1221 1222 // DescribeCacheParametersRequest mocks base method 1223 func (m *MockElastiCacheAPI) DescribeCacheParametersRequest(arg0 *elasticache.DescribeCacheParametersInput) (*request.Request, *elasticache.DescribeCacheParametersOutput) { 1224 m.ctrl.T.Helper() 1225 ret := m.ctrl.Call(m, "DescribeCacheParametersRequest", arg0) 1226 ret0, _ := ret[0].(*request.Request) 1227 ret1, _ := ret[1].(*elasticache.DescribeCacheParametersOutput) 1228 return ret0, ret1 1229 } 1230 1231 // DescribeCacheParametersRequest indicates an expected call of DescribeCacheParametersRequest 1232 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersRequest(arg0 interface{}) *gomock.Call { 1233 mr.mock.ctrl.T.Helper() 1234 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersRequest), arg0) 1235 } 1236 1237 // DescribeCacheParametersPages mocks base method 1238 func (m *MockElastiCacheAPI) DescribeCacheParametersPages(arg0 *elasticache.DescribeCacheParametersInput, arg1 func(*elasticache.DescribeCacheParametersOutput, bool) bool) error { 1239 m.ctrl.T.Helper() 1240 ret := m.ctrl.Call(m, "DescribeCacheParametersPages", arg0, arg1) 1241 ret0, _ := ret[0].(error) 1242 return ret0 1243 } 1244 1245 // DescribeCacheParametersPages indicates an expected call of DescribeCacheParametersPages 1246 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersPages(arg0, arg1 interface{}) *gomock.Call { 1247 mr.mock.ctrl.T.Helper() 1248 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersPages), arg0, arg1) 1249 } 1250 1251 // DescribeCacheParametersPagesWithContext mocks base method 1252 func (m *MockElastiCacheAPI) DescribeCacheParametersPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParametersInput, arg2 func(*elasticache.DescribeCacheParametersOutput, bool) bool, arg3 ...request.Option) error { 1253 m.ctrl.T.Helper() 1254 varargs := []interface{}{arg0, arg1, arg2} 1255 for _, a := range arg3 { 1256 varargs = append(varargs, a) 1257 } 1258 ret := m.ctrl.Call(m, "DescribeCacheParametersPagesWithContext", varargs...) 1259 ret0, _ := ret[0].(error) 1260 return ret0 1261 } 1262 1263 // DescribeCacheParametersPagesWithContext indicates an expected call of DescribeCacheParametersPagesWithContext 1264 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1265 mr.mock.ctrl.T.Helper() 1266 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1267 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersPagesWithContext), varargs...) 1268 } 1269 1270 // DescribeCacheSecurityGroups mocks base method 1271 func (m *MockElastiCacheAPI) DescribeCacheSecurityGroups(arg0 *elasticache.DescribeCacheSecurityGroupsInput) (*elasticache.DescribeCacheSecurityGroupsOutput, error) { 1272 m.ctrl.T.Helper() 1273 ret := m.ctrl.Call(m, "DescribeCacheSecurityGroups", arg0) 1274 ret0, _ := ret[0].(*elasticache.DescribeCacheSecurityGroupsOutput) 1275 ret1, _ := ret[1].(error) 1276 return ret0, ret1 1277 } 1278 1279 // DescribeCacheSecurityGroups indicates an expected call of DescribeCacheSecurityGroups 1280 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroups(arg0 interface{}) *gomock.Call { 1281 mr.mock.ctrl.T.Helper() 1282 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroups), arg0) 1283 } 1284 1285 // DescribeCacheSecurityGroupsWithContext mocks base method 1286 func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSecurityGroupsInput, arg2 ...request.Option) (*elasticache.DescribeCacheSecurityGroupsOutput, error) { 1287 m.ctrl.T.Helper() 1288 varargs := []interface{}{arg0, arg1} 1289 for _, a := range arg2 { 1290 varargs = append(varargs, a) 1291 } 1292 ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsWithContext", varargs...) 1293 ret0, _ := ret[0].(*elasticache.DescribeCacheSecurityGroupsOutput) 1294 ret1, _ := ret[1].(error) 1295 return ret0, ret1 1296 } 1297 1298 // DescribeCacheSecurityGroupsWithContext indicates an expected call of DescribeCacheSecurityGroupsWithContext 1299 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1300 mr.mock.ctrl.T.Helper() 1301 varargs := append([]interface{}{arg0, arg1}, arg2...) 1302 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsWithContext), varargs...) 1303 } 1304 1305 // DescribeCacheSecurityGroupsRequest mocks base method 1306 func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsRequest(arg0 *elasticache.DescribeCacheSecurityGroupsInput) (*request.Request, *elasticache.DescribeCacheSecurityGroupsOutput) { 1307 m.ctrl.T.Helper() 1308 ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsRequest", arg0) 1309 ret0, _ := ret[0].(*request.Request) 1310 ret1, _ := ret[1].(*elasticache.DescribeCacheSecurityGroupsOutput) 1311 return ret0, ret1 1312 } 1313 1314 // DescribeCacheSecurityGroupsRequest indicates an expected call of DescribeCacheSecurityGroupsRequest 1315 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsRequest(arg0 interface{}) *gomock.Call { 1316 mr.mock.ctrl.T.Helper() 1317 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsRequest), arg0) 1318 } 1319 1320 // DescribeCacheSecurityGroupsPages mocks base method 1321 func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsPages(arg0 *elasticache.DescribeCacheSecurityGroupsInput, arg1 func(*elasticache.DescribeCacheSecurityGroupsOutput, bool) bool) error { 1322 m.ctrl.T.Helper() 1323 ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsPages", arg0, arg1) 1324 ret0, _ := ret[0].(error) 1325 return ret0 1326 } 1327 1328 // DescribeCacheSecurityGroupsPages indicates an expected call of DescribeCacheSecurityGroupsPages 1329 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { 1330 mr.mock.ctrl.T.Helper() 1331 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsPages), arg0, arg1) 1332 } 1333 1334 // DescribeCacheSecurityGroupsPagesWithContext mocks base method 1335 func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSecurityGroupsInput, arg2 func(*elasticache.DescribeCacheSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error { 1336 m.ctrl.T.Helper() 1337 varargs := []interface{}{arg0, arg1, arg2} 1338 for _, a := range arg3 { 1339 varargs = append(varargs, a) 1340 } 1341 ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsPagesWithContext", varargs...) 1342 ret0, _ := ret[0].(error) 1343 return ret0 1344 } 1345 1346 // DescribeCacheSecurityGroupsPagesWithContext indicates an expected call of DescribeCacheSecurityGroupsPagesWithContext 1347 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1348 mr.mock.ctrl.T.Helper() 1349 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsPagesWithContext), varargs...) 1351 } 1352 1353 // DescribeCacheSubnetGroups mocks base method 1354 func (m *MockElastiCacheAPI) DescribeCacheSubnetGroups(arg0 *elasticache.DescribeCacheSubnetGroupsInput) (*elasticache.DescribeCacheSubnetGroupsOutput, error) { 1355 m.ctrl.T.Helper() 1356 ret := m.ctrl.Call(m, "DescribeCacheSubnetGroups", arg0) 1357 ret0, _ := ret[0].(*elasticache.DescribeCacheSubnetGroupsOutput) 1358 ret1, _ := ret[1].(error) 1359 return ret0, ret1 1360 } 1361 1362 // DescribeCacheSubnetGroups indicates an expected call of DescribeCacheSubnetGroups 1363 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroups(arg0 interface{}) *gomock.Call { 1364 mr.mock.ctrl.T.Helper() 1365 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroups), arg0) 1366 } 1367 1368 // DescribeCacheSubnetGroupsWithContext mocks base method 1369 func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSubnetGroupsInput, arg2 ...request.Option) (*elasticache.DescribeCacheSubnetGroupsOutput, error) { 1370 m.ctrl.T.Helper() 1371 varargs := []interface{}{arg0, arg1} 1372 for _, a := range arg2 { 1373 varargs = append(varargs, a) 1374 } 1375 ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsWithContext", varargs...) 1376 ret0, _ := ret[0].(*elasticache.DescribeCacheSubnetGroupsOutput) 1377 ret1, _ := ret[1].(error) 1378 return ret0, ret1 1379 } 1380 1381 // DescribeCacheSubnetGroupsWithContext indicates an expected call of DescribeCacheSubnetGroupsWithContext 1382 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1383 mr.mock.ctrl.T.Helper() 1384 varargs := append([]interface{}{arg0, arg1}, arg2...) 1385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsWithContext), varargs...) 1386 } 1387 1388 // DescribeCacheSubnetGroupsRequest mocks base method 1389 func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsRequest(arg0 *elasticache.DescribeCacheSubnetGroupsInput) (*request.Request, *elasticache.DescribeCacheSubnetGroupsOutput) { 1390 m.ctrl.T.Helper() 1391 ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsRequest", arg0) 1392 ret0, _ := ret[0].(*request.Request) 1393 ret1, _ := ret[1].(*elasticache.DescribeCacheSubnetGroupsOutput) 1394 return ret0, ret1 1395 } 1396 1397 // DescribeCacheSubnetGroupsRequest indicates an expected call of DescribeCacheSubnetGroupsRequest 1398 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsRequest(arg0 interface{}) *gomock.Call { 1399 mr.mock.ctrl.T.Helper() 1400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsRequest), arg0) 1401 } 1402 1403 // DescribeCacheSubnetGroupsPages mocks base method 1404 func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsPages(arg0 *elasticache.DescribeCacheSubnetGroupsInput, arg1 func(*elasticache.DescribeCacheSubnetGroupsOutput, bool) bool) error { 1405 m.ctrl.T.Helper() 1406 ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsPages", arg0, arg1) 1407 ret0, _ := ret[0].(error) 1408 return ret0 1409 } 1410 1411 // DescribeCacheSubnetGroupsPages indicates an expected call of DescribeCacheSubnetGroupsPages 1412 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsPages(arg0, arg1 interface{}) *gomock.Call { 1413 mr.mock.ctrl.T.Helper() 1414 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsPages), arg0, arg1) 1415 } 1416 1417 // DescribeCacheSubnetGroupsPagesWithContext mocks base method 1418 func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSubnetGroupsInput, arg2 func(*elasticache.DescribeCacheSubnetGroupsOutput, bool) bool, arg3 ...request.Option) error { 1419 m.ctrl.T.Helper() 1420 varargs := []interface{}{arg0, arg1, arg2} 1421 for _, a := range arg3 { 1422 varargs = append(varargs, a) 1423 } 1424 ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsPagesWithContext", varargs...) 1425 ret0, _ := ret[0].(error) 1426 return ret0 1427 } 1428 1429 // DescribeCacheSubnetGroupsPagesWithContext indicates an expected call of DescribeCacheSubnetGroupsPagesWithContext 1430 func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1431 mr.mock.ctrl.T.Helper() 1432 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1433 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsPagesWithContext), varargs...) 1434 } 1435 1436 // DescribeEngineDefaultParameters mocks base method 1437 func (m *MockElastiCacheAPI) DescribeEngineDefaultParameters(arg0 *elasticache.DescribeEngineDefaultParametersInput) (*elasticache.DescribeEngineDefaultParametersOutput, error) { 1438 m.ctrl.T.Helper() 1439 ret := m.ctrl.Call(m, "DescribeEngineDefaultParameters", arg0) 1440 ret0, _ := ret[0].(*elasticache.DescribeEngineDefaultParametersOutput) 1441 ret1, _ := ret[1].(error) 1442 return ret0, ret1 1443 } 1444 1445 // DescribeEngineDefaultParameters indicates an expected call of DescribeEngineDefaultParameters 1446 func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParameters(arg0 interface{}) *gomock.Call { 1447 mr.mock.ctrl.T.Helper() 1448 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParameters", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParameters), arg0) 1449 } 1450 1451 // DescribeEngineDefaultParametersWithContext mocks base method 1452 func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEngineDefaultParametersInput, arg2 ...request.Option) (*elasticache.DescribeEngineDefaultParametersOutput, error) { 1453 m.ctrl.T.Helper() 1454 varargs := []interface{}{arg0, arg1} 1455 for _, a := range arg2 { 1456 varargs = append(varargs, a) 1457 } 1458 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersWithContext", varargs...) 1459 ret0, _ := ret[0].(*elasticache.DescribeEngineDefaultParametersOutput) 1460 ret1, _ := ret[1].(error) 1461 return ret0, ret1 1462 } 1463 1464 // DescribeEngineDefaultParametersWithContext indicates an expected call of DescribeEngineDefaultParametersWithContext 1465 func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1466 mr.mock.ctrl.T.Helper() 1467 varargs := append([]interface{}{arg0, arg1}, arg2...) 1468 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersWithContext), varargs...) 1469 } 1470 1471 // DescribeEngineDefaultParametersRequest mocks base method 1472 func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersRequest(arg0 *elasticache.DescribeEngineDefaultParametersInput) (*request.Request, *elasticache.DescribeEngineDefaultParametersOutput) { 1473 m.ctrl.T.Helper() 1474 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersRequest", arg0) 1475 ret0, _ := ret[0].(*request.Request) 1476 ret1, _ := ret[1].(*elasticache.DescribeEngineDefaultParametersOutput) 1477 return ret0, ret1 1478 } 1479 1480 // DescribeEngineDefaultParametersRequest indicates an expected call of DescribeEngineDefaultParametersRequest 1481 func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersRequest(arg0 interface{}) *gomock.Call { 1482 mr.mock.ctrl.T.Helper() 1483 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersRequest), arg0) 1484 } 1485 1486 // DescribeEngineDefaultParametersPages mocks base method 1487 func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersPages(arg0 *elasticache.DescribeEngineDefaultParametersInput, arg1 func(*elasticache.DescribeEngineDefaultParametersOutput, bool) bool) error { 1488 m.ctrl.T.Helper() 1489 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersPages", arg0, arg1) 1490 ret0, _ := ret[0].(error) 1491 return ret0 1492 } 1493 1494 // DescribeEngineDefaultParametersPages indicates an expected call of DescribeEngineDefaultParametersPages 1495 func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersPages(arg0, arg1 interface{}) *gomock.Call { 1496 mr.mock.ctrl.T.Helper() 1497 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersPages), arg0, arg1) 1498 } 1499 1500 // DescribeEngineDefaultParametersPagesWithContext mocks base method 1501 func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEngineDefaultParametersInput, arg2 func(*elasticache.DescribeEngineDefaultParametersOutput, bool) bool, arg3 ...request.Option) error { 1502 m.ctrl.T.Helper() 1503 varargs := []interface{}{arg0, arg1, arg2} 1504 for _, a := range arg3 { 1505 varargs = append(varargs, a) 1506 } 1507 ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersPagesWithContext", varargs...) 1508 ret0, _ := ret[0].(error) 1509 return ret0 1510 } 1511 1512 // DescribeEngineDefaultParametersPagesWithContext indicates an expected call of DescribeEngineDefaultParametersPagesWithContext 1513 func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1514 mr.mock.ctrl.T.Helper() 1515 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1516 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersPagesWithContext), varargs...) 1517 } 1518 1519 // DescribeEvents mocks base method 1520 func (m *MockElastiCacheAPI) DescribeEvents(arg0 *elasticache.DescribeEventsInput) (*elasticache.DescribeEventsOutput, error) { 1521 m.ctrl.T.Helper() 1522 ret := m.ctrl.Call(m, "DescribeEvents", arg0) 1523 ret0, _ := ret[0].(*elasticache.DescribeEventsOutput) 1524 ret1, _ := ret[1].(error) 1525 return ret0, ret1 1526 } 1527 1528 // DescribeEvents indicates an expected call of DescribeEvents 1529 func (mr *MockElastiCacheAPIMockRecorder) DescribeEvents(arg0 interface{}) *gomock.Call { 1530 mr.mock.ctrl.T.Helper() 1531 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEvents", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEvents), arg0) 1532 } 1533 1534 // DescribeEventsWithContext mocks base method 1535 func (m *MockElastiCacheAPI) DescribeEventsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEventsInput, arg2 ...request.Option) (*elasticache.DescribeEventsOutput, error) { 1536 m.ctrl.T.Helper() 1537 varargs := []interface{}{arg0, arg1} 1538 for _, a := range arg2 { 1539 varargs = append(varargs, a) 1540 } 1541 ret := m.ctrl.Call(m, "DescribeEventsWithContext", varargs...) 1542 ret0, _ := ret[0].(*elasticache.DescribeEventsOutput) 1543 ret1, _ := ret[1].(error) 1544 return ret0, ret1 1545 } 1546 1547 // DescribeEventsWithContext indicates an expected call of DescribeEventsWithContext 1548 func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1549 mr.mock.ctrl.T.Helper() 1550 varargs := append([]interface{}{arg0, arg1}, arg2...) 1551 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsWithContext), varargs...) 1552 } 1553 1554 // DescribeEventsRequest mocks base method 1555 func (m *MockElastiCacheAPI) DescribeEventsRequest(arg0 *elasticache.DescribeEventsInput) (*request.Request, *elasticache.DescribeEventsOutput) { 1556 m.ctrl.T.Helper() 1557 ret := m.ctrl.Call(m, "DescribeEventsRequest", arg0) 1558 ret0, _ := ret[0].(*request.Request) 1559 ret1, _ := ret[1].(*elasticache.DescribeEventsOutput) 1560 return ret0, ret1 1561 } 1562 1563 // DescribeEventsRequest indicates an expected call of DescribeEventsRequest 1564 func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsRequest(arg0 interface{}) *gomock.Call { 1565 mr.mock.ctrl.T.Helper() 1566 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsRequest), arg0) 1567 } 1568 1569 // DescribeEventsPages mocks base method 1570 func (m *MockElastiCacheAPI) DescribeEventsPages(arg0 *elasticache.DescribeEventsInput, arg1 func(*elasticache.DescribeEventsOutput, bool) bool) error { 1571 m.ctrl.T.Helper() 1572 ret := m.ctrl.Call(m, "DescribeEventsPages", arg0, arg1) 1573 ret0, _ := ret[0].(error) 1574 return ret0 1575 } 1576 1577 // DescribeEventsPages indicates an expected call of DescribeEventsPages 1578 func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsPages(arg0, arg1 interface{}) *gomock.Call { 1579 mr.mock.ctrl.T.Helper() 1580 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsPages), arg0, arg1) 1581 } 1582 1583 // DescribeEventsPagesWithContext mocks base method 1584 func (m *MockElastiCacheAPI) DescribeEventsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEventsInput, arg2 func(*elasticache.DescribeEventsOutput, bool) bool, arg3 ...request.Option) error { 1585 m.ctrl.T.Helper() 1586 varargs := []interface{}{arg0, arg1, arg2} 1587 for _, a := range arg3 { 1588 varargs = append(varargs, a) 1589 } 1590 ret := m.ctrl.Call(m, "DescribeEventsPagesWithContext", varargs...) 1591 ret0, _ := ret[0].(error) 1592 return ret0 1593 } 1594 1595 // DescribeEventsPagesWithContext indicates an expected call of DescribeEventsPagesWithContext 1596 func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1597 mr.mock.ctrl.T.Helper() 1598 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1599 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsPagesWithContext), varargs...) 1600 } 1601 1602 // DescribeReplicationGroups mocks base method 1603 func (m *MockElastiCacheAPI) DescribeReplicationGroups(arg0 *elasticache.DescribeReplicationGroupsInput) (*elasticache.DescribeReplicationGroupsOutput, error) { 1604 m.ctrl.T.Helper() 1605 ret := m.ctrl.Call(m, "DescribeReplicationGroups", arg0) 1606 ret0, _ := ret[0].(*elasticache.DescribeReplicationGroupsOutput) 1607 ret1, _ := ret[1].(error) 1608 return ret0, ret1 1609 } 1610 1611 // DescribeReplicationGroups indicates an expected call of DescribeReplicationGroups 1612 func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroups(arg0 interface{}) *gomock.Call { 1613 mr.mock.ctrl.T.Helper() 1614 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroups), arg0) 1615 } 1616 1617 // DescribeReplicationGroupsWithContext mocks base method 1618 func (m *MockElastiCacheAPI) DescribeReplicationGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 ...request.Option) (*elasticache.DescribeReplicationGroupsOutput, error) { 1619 m.ctrl.T.Helper() 1620 varargs := []interface{}{arg0, arg1} 1621 for _, a := range arg2 { 1622 varargs = append(varargs, a) 1623 } 1624 ret := m.ctrl.Call(m, "DescribeReplicationGroupsWithContext", varargs...) 1625 ret0, _ := ret[0].(*elasticache.DescribeReplicationGroupsOutput) 1626 ret1, _ := ret[1].(error) 1627 return ret0, ret1 1628 } 1629 1630 // DescribeReplicationGroupsWithContext indicates an expected call of DescribeReplicationGroupsWithContext 1631 func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1632 mr.mock.ctrl.T.Helper() 1633 varargs := append([]interface{}{arg0, arg1}, arg2...) 1634 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsWithContext), varargs...) 1635 } 1636 1637 // DescribeReplicationGroupsRequest mocks base method 1638 func (m *MockElastiCacheAPI) DescribeReplicationGroupsRequest(arg0 *elasticache.DescribeReplicationGroupsInput) (*request.Request, *elasticache.DescribeReplicationGroupsOutput) { 1639 m.ctrl.T.Helper() 1640 ret := m.ctrl.Call(m, "DescribeReplicationGroupsRequest", arg0) 1641 ret0, _ := ret[0].(*request.Request) 1642 ret1, _ := ret[1].(*elasticache.DescribeReplicationGroupsOutput) 1643 return ret0, ret1 1644 } 1645 1646 // DescribeReplicationGroupsRequest indicates an expected call of DescribeReplicationGroupsRequest 1647 func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsRequest(arg0 interface{}) *gomock.Call { 1648 mr.mock.ctrl.T.Helper() 1649 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsRequest), arg0) 1650 } 1651 1652 // DescribeReplicationGroupsPages mocks base method 1653 func (m *MockElastiCacheAPI) DescribeReplicationGroupsPages(arg0 *elasticache.DescribeReplicationGroupsInput, arg1 func(*elasticache.DescribeReplicationGroupsOutput, bool) bool) error { 1654 m.ctrl.T.Helper() 1655 ret := m.ctrl.Call(m, "DescribeReplicationGroupsPages", arg0, arg1) 1656 ret0, _ := ret[0].(error) 1657 return ret0 1658 } 1659 1660 // DescribeReplicationGroupsPages indicates an expected call of DescribeReplicationGroupsPages 1661 func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsPages(arg0, arg1 interface{}) *gomock.Call { 1662 mr.mock.ctrl.T.Helper() 1663 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsPages), arg0, arg1) 1664 } 1665 1666 // DescribeReplicationGroupsPagesWithContext mocks base method 1667 func (m *MockElastiCacheAPI) DescribeReplicationGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 func(*elasticache.DescribeReplicationGroupsOutput, bool) bool, arg3 ...request.Option) error { 1668 m.ctrl.T.Helper() 1669 varargs := []interface{}{arg0, arg1, arg2} 1670 for _, a := range arg3 { 1671 varargs = append(varargs, a) 1672 } 1673 ret := m.ctrl.Call(m, "DescribeReplicationGroupsPagesWithContext", varargs...) 1674 ret0, _ := ret[0].(error) 1675 return ret0 1676 } 1677 1678 // DescribeReplicationGroupsPagesWithContext indicates an expected call of DescribeReplicationGroupsPagesWithContext 1679 func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1680 mr.mock.ctrl.T.Helper() 1681 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1682 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsPagesWithContext), varargs...) 1683 } 1684 1685 // DescribeReservedCacheNodes mocks base method 1686 func (m *MockElastiCacheAPI) DescribeReservedCacheNodes(arg0 *elasticache.DescribeReservedCacheNodesInput) (*elasticache.DescribeReservedCacheNodesOutput, error) { 1687 m.ctrl.T.Helper() 1688 ret := m.ctrl.Call(m, "DescribeReservedCacheNodes", arg0) 1689 ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOutput) 1690 ret1, _ := ret[1].(error) 1691 return ret0, ret1 1692 } 1693 1694 // DescribeReservedCacheNodes indicates an expected call of DescribeReservedCacheNodes 1695 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodes(arg0 interface{}) *gomock.Call { 1696 mr.mock.ctrl.T.Helper() 1697 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodes", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodes), arg0) 1698 } 1699 1700 // DescribeReservedCacheNodesWithContext mocks base method 1701 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesInput, arg2 ...request.Option) (*elasticache.DescribeReservedCacheNodesOutput, error) { 1702 m.ctrl.T.Helper() 1703 varargs := []interface{}{arg0, arg1} 1704 for _, a := range arg2 { 1705 varargs = append(varargs, a) 1706 } 1707 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesWithContext", varargs...) 1708 ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOutput) 1709 ret1, _ := ret[1].(error) 1710 return ret0, ret1 1711 } 1712 1713 // DescribeReservedCacheNodesWithContext indicates an expected call of DescribeReservedCacheNodesWithContext 1714 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1715 mr.mock.ctrl.T.Helper() 1716 varargs := append([]interface{}{arg0, arg1}, arg2...) 1717 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesWithContext), varargs...) 1718 } 1719 1720 // DescribeReservedCacheNodesRequest mocks base method 1721 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesRequest(arg0 *elasticache.DescribeReservedCacheNodesInput) (*request.Request, *elasticache.DescribeReservedCacheNodesOutput) { 1722 m.ctrl.T.Helper() 1723 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesRequest", arg0) 1724 ret0, _ := ret[0].(*request.Request) 1725 ret1, _ := ret[1].(*elasticache.DescribeReservedCacheNodesOutput) 1726 return ret0, ret1 1727 } 1728 1729 // DescribeReservedCacheNodesRequest indicates an expected call of DescribeReservedCacheNodesRequest 1730 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesRequest(arg0 interface{}) *gomock.Call { 1731 mr.mock.ctrl.T.Helper() 1732 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesRequest), arg0) 1733 } 1734 1735 // DescribeReservedCacheNodesPages mocks base method 1736 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesPages(arg0 *elasticache.DescribeReservedCacheNodesInput, arg1 func(*elasticache.DescribeReservedCacheNodesOutput, bool) bool) error { 1737 m.ctrl.T.Helper() 1738 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesPages", arg0, arg1) 1739 ret0, _ := ret[0].(error) 1740 return ret0 1741 } 1742 1743 // DescribeReservedCacheNodesPages indicates an expected call of DescribeReservedCacheNodesPages 1744 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesPages(arg0, arg1 interface{}) *gomock.Call { 1745 mr.mock.ctrl.T.Helper() 1746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesPages), arg0, arg1) 1747 } 1748 1749 // DescribeReservedCacheNodesPagesWithContext mocks base method 1750 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesInput, arg2 func(*elasticache.DescribeReservedCacheNodesOutput, bool) bool, arg3 ...request.Option) error { 1751 m.ctrl.T.Helper() 1752 varargs := []interface{}{arg0, arg1, arg2} 1753 for _, a := range arg3 { 1754 varargs = append(varargs, a) 1755 } 1756 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesPagesWithContext", varargs...) 1757 ret0, _ := ret[0].(error) 1758 return ret0 1759 } 1760 1761 // DescribeReservedCacheNodesPagesWithContext indicates an expected call of DescribeReservedCacheNodesPagesWithContext 1762 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1763 mr.mock.ctrl.T.Helper() 1764 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1765 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesPagesWithContext), varargs...) 1766 } 1767 1768 // DescribeReservedCacheNodesOfferings mocks base method 1769 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferings(arg0 *elasticache.DescribeReservedCacheNodesOfferingsInput) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, error) { 1770 m.ctrl.T.Helper() 1771 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferings", arg0) 1772 ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOfferingsOutput) 1773 ret1, _ := ret[1].(error) 1774 return ret0, ret1 1775 } 1776 1777 // DescribeReservedCacheNodesOfferings indicates an expected call of DescribeReservedCacheNodesOfferings 1778 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferings(arg0 interface{}) *gomock.Call { 1779 mr.mock.ctrl.T.Helper() 1780 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferings", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferings), arg0) 1781 } 1782 1783 // DescribeReservedCacheNodesOfferingsWithContext mocks base method 1784 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesOfferingsInput, arg2 ...request.Option) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, error) { 1785 m.ctrl.T.Helper() 1786 varargs := []interface{}{arg0, arg1} 1787 for _, a := range arg2 { 1788 varargs = append(varargs, a) 1789 } 1790 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsWithContext", varargs...) 1791 ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOfferingsOutput) 1792 ret1, _ := ret[1].(error) 1793 return ret0, ret1 1794 } 1795 1796 // DescribeReservedCacheNodesOfferingsWithContext indicates an expected call of DescribeReservedCacheNodesOfferingsWithContext 1797 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1798 mr.mock.ctrl.T.Helper() 1799 varargs := append([]interface{}{arg0, arg1}, arg2...) 1800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsWithContext), varargs...) 1801 } 1802 1803 // DescribeReservedCacheNodesOfferingsRequest mocks base method 1804 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsRequest(arg0 *elasticache.DescribeReservedCacheNodesOfferingsInput) (*request.Request, *elasticache.DescribeReservedCacheNodesOfferingsOutput) { 1805 m.ctrl.T.Helper() 1806 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsRequest", arg0) 1807 ret0, _ := ret[0].(*request.Request) 1808 ret1, _ := ret[1].(*elasticache.DescribeReservedCacheNodesOfferingsOutput) 1809 return ret0, ret1 1810 } 1811 1812 // DescribeReservedCacheNodesOfferingsRequest indicates an expected call of DescribeReservedCacheNodesOfferingsRequest 1813 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsRequest(arg0 interface{}) *gomock.Call { 1814 mr.mock.ctrl.T.Helper() 1815 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsRequest), arg0) 1816 } 1817 1818 // DescribeReservedCacheNodesOfferingsPages mocks base method 1819 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsPages(arg0 *elasticache.DescribeReservedCacheNodesOfferingsInput, arg1 func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, bool) bool) error { 1820 m.ctrl.T.Helper() 1821 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsPages", arg0, arg1) 1822 ret0, _ := ret[0].(error) 1823 return ret0 1824 } 1825 1826 // DescribeReservedCacheNodesOfferingsPages indicates an expected call of DescribeReservedCacheNodesOfferingsPages 1827 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsPages(arg0, arg1 interface{}) *gomock.Call { 1828 mr.mock.ctrl.T.Helper() 1829 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsPages), arg0, arg1) 1830 } 1831 1832 // DescribeReservedCacheNodesOfferingsPagesWithContext mocks base method 1833 func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesOfferingsInput, arg2 func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, bool) bool, arg3 ...request.Option) error { 1834 m.ctrl.T.Helper() 1835 varargs := []interface{}{arg0, arg1, arg2} 1836 for _, a := range arg3 { 1837 varargs = append(varargs, a) 1838 } 1839 ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsPagesWithContext", varargs...) 1840 ret0, _ := ret[0].(error) 1841 return ret0 1842 } 1843 1844 // DescribeReservedCacheNodesOfferingsPagesWithContext indicates an expected call of DescribeReservedCacheNodesOfferingsPagesWithContext 1845 func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1846 mr.mock.ctrl.T.Helper() 1847 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1848 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsPagesWithContext), varargs...) 1849 } 1850 1851 // DescribeServiceUpdates mocks base method 1852 func (m *MockElastiCacheAPI) DescribeServiceUpdates(arg0 *elasticache.DescribeServiceUpdatesInput) (*elasticache.DescribeServiceUpdatesOutput, error) { 1853 m.ctrl.T.Helper() 1854 ret := m.ctrl.Call(m, "DescribeServiceUpdates", arg0) 1855 ret0, _ := ret[0].(*elasticache.DescribeServiceUpdatesOutput) 1856 ret1, _ := ret[1].(error) 1857 return ret0, ret1 1858 } 1859 1860 // DescribeServiceUpdates indicates an expected call of DescribeServiceUpdates 1861 func (mr *MockElastiCacheAPIMockRecorder) DescribeServiceUpdates(arg0 interface{}) *gomock.Call { 1862 mr.mock.ctrl.T.Helper() 1863 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServiceUpdates", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeServiceUpdates), arg0) 1864 } 1865 1866 // DescribeServiceUpdatesWithContext mocks base method 1867 func (m *MockElastiCacheAPI) DescribeServiceUpdatesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeServiceUpdatesInput, arg2 ...request.Option) (*elasticache.DescribeServiceUpdatesOutput, error) { 1868 m.ctrl.T.Helper() 1869 varargs := []interface{}{arg0, arg1} 1870 for _, a := range arg2 { 1871 varargs = append(varargs, a) 1872 } 1873 ret := m.ctrl.Call(m, "DescribeServiceUpdatesWithContext", varargs...) 1874 ret0, _ := ret[0].(*elasticache.DescribeServiceUpdatesOutput) 1875 ret1, _ := ret[1].(error) 1876 return ret0, ret1 1877 } 1878 1879 // DescribeServiceUpdatesWithContext indicates an expected call of DescribeServiceUpdatesWithContext 1880 func (mr *MockElastiCacheAPIMockRecorder) DescribeServiceUpdatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1881 mr.mock.ctrl.T.Helper() 1882 varargs := append([]interface{}{arg0, arg1}, arg2...) 1883 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServiceUpdatesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeServiceUpdatesWithContext), varargs...) 1884 } 1885 1886 // DescribeServiceUpdatesRequest mocks base method 1887 func (m *MockElastiCacheAPI) DescribeServiceUpdatesRequest(arg0 *elasticache.DescribeServiceUpdatesInput) (*request.Request, *elasticache.DescribeServiceUpdatesOutput) { 1888 m.ctrl.T.Helper() 1889 ret := m.ctrl.Call(m, "DescribeServiceUpdatesRequest", arg0) 1890 ret0, _ := ret[0].(*request.Request) 1891 ret1, _ := ret[1].(*elasticache.DescribeServiceUpdatesOutput) 1892 return ret0, ret1 1893 } 1894 1895 // DescribeServiceUpdatesRequest indicates an expected call of DescribeServiceUpdatesRequest 1896 func (mr *MockElastiCacheAPIMockRecorder) DescribeServiceUpdatesRequest(arg0 interface{}) *gomock.Call { 1897 mr.mock.ctrl.T.Helper() 1898 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServiceUpdatesRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeServiceUpdatesRequest), arg0) 1899 } 1900 1901 // DescribeServiceUpdatesPages mocks base method 1902 func (m *MockElastiCacheAPI) DescribeServiceUpdatesPages(arg0 *elasticache.DescribeServiceUpdatesInput, arg1 func(*elasticache.DescribeServiceUpdatesOutput, bool) bool) error { 1903 m.ctrl.T.Helper() 1904 ret := m.ctrl.Call(m, "DescribeServiceUpdatesPages", arg0, arg1) 1905 ret0, _ := ret[0].(error) 1906 return ret0 1907 } 1908 1909 // DescribeServiceUpdatesPages indicates an expected call of DescribeServiceUpdatesPages 1910 func (mr *MockElastiCacheAPIMockRecorder) DescribeServiceUpdatesPages(arg0, arg1 interface{}) *gomock.Call { 1911 mr.mock.ctrl.T.Helper() 1912 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServiceUpdatesPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeServiceUpdatesPages), arg0, arg1) 1913 } 1914 1915 // DescribeServiceUpdatesPagesWithContext mocks base method 1916 func (m *MockElastiCacheAPI) DescribeServiceUpdatesPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeServiceUpdatesInput, arg2 func(*elasticache.DescribeServiceUpdatesOutput, bool) bool, arg3 ...request.Option) error { 1917 m.ctrl.T.Helper() 1918 varargs := []interface{}{arg0, arg1, arg2} 1919 for _, a := range arg3 { 1920 varargs = append(varargs, a) 1921 } 1922 ret := m.ctrl.Call(m, "DescribeServiceUpdatesPagesWithContext", varargs...) 1923 ret0, _ := ret[0].(error) 1924 return ret0 1925 } 1926 1927 // DescribeServiceUpdatesPagesWithContext indicates an expected call of DescribeServiceUpdatesPagesWithContext 1928 func (mr *MockElastiCacheAPIMockRecorder) DescribeServiceUpdatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1929 mr.mock.ctrl.T.Helper() 1930 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServiceUpdatesPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeServiceUpdatesPagesWithContext), varargs...) 1932 } 1933 1934 // DescribeSnapshots mocks base method 1935 func (m *MockElastiCacheAPI) DescribeSnapshots(arg0 *elasticache.DescribeSnapshotsInput) (*elasticache.DescribeSnapshotsOutput, error) { 1936 m.ctrl.T.Helper() 1937 ret := m.ctrl.Call(m, "DescribeSnapshots", arg0) 1938 ret0, _ := ret[0].(*elasticache.DescribeSnapshotsOutput) 1939 ret1, _ := ret[1].(error) 1940 return ret0, ret1 1941 } 1942 1943 // DescribeSnapshots indicates an expected call of DescribeSnapshots 1944 func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call { 1945 mr.mock.ctrl.T.Helper() 1946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshots), arg0) 1947 } 1948 1949 // DescribeSnapshotsWithContext mocks base method 1950 func (m *MockElastiCacheAPI) DescribeSnapshotsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeSnapshotsInput, arg2 ...request.Option) (*elasticache.DescribeSnapshotsOutput, error) { 1951 m.ctrl.T.Helper() 1952 varargs := []interface{}{arg0, arg1} 1953 for _, a := range arg2 { 1954 varargs = append(varargs, a) 1955 } 1956 ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...) 1957 ret0, _ := ret[0].(*elasticache.DescribeSnapshotsOutput) 1958 ret1, _ := ret[1].(error) 1959 return ret0, ret1 1960 } 1961 1962 // DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext 1963 func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1964 mr.mock.ctrl.T.Helper() 1965 varargs := append([]interface{}{arg0, arg1}, arg2...) 1966 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsWithContext), varargs...) 1967 } 1968 1969 // DescribeSnapshotsRequest mocks base method 1970 func (m *MockElastiCacheAPI) DescribeSnapshotsRequest(arg0 *elasticache.DescribeSnapshotsInput) (*request.Request, *elasticache.DescribeSnapshotsOutput) { 1971 m.ctrl.T.Helper() 1972 ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0) 1973 ret0, _ := ret[0].(*request.Request) 1974 ret1, _ := ret[1].(*elasticache.DescribeSnapshotsOutput) 1975 return ret0, ret1 1976 } 1977 1978 // DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest 1979 func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call { 1980 mr.mock.ctrl.T.Helper() 1981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsRequest), arg0) 1982 } 1983 1984 // DescribeSnapshotsPages mocks base method 1985 func (m *MockElastiCacheAPI) DescribeSnapshotsPages(arg0 *elasticache.DescribeSnapshotsInput, arg1 func(*elasticache.DescribeSnapshotsOutput, bool) bool) error { 1986 m.ctrl.T.Helper() 1987 ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1) 1988 ret0, _ := ret[0].(error) 1989 return ret0 1990 } 1991 1992 // DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages 1993 func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { 1994 mr.mock.ctrl.T.Helper() 1995 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsPages), arg0, arg1) 1996 } 1997 1998 // DescribeSnapshotsPagesWithContext mocks base method 1999 func (m *MockElastiCacheAPI) DescribeSnapshotsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeSnapshotsInput, arg2 func(*elasticache.DescribeSnapshotsOutput, bool) bool, arg3 ...request.Option) error { 2000 m.ctrl.T.Helper() 2001 varargs := []interface{}{arg0, arg1, arg2} 2002 for _, a := range arg3 { 2003 varargs = append(varargs, a) 2004 } 2005 ret := m.ctrl.Call(m, "DescribeSnapshotsPagesWithContext", varargs...) 2006 ret0, _ := ret[0].(error) 2007 return ret0 2008 } 2009 2010 // DescribeSnapshotsPagesWithContext indicates an expected call of DescribeSnapshotsPagesWithContext 2011 func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2012 mr.mock.ctrl.T.Helper() 2013 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2014 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsPagesWithContext), varargs...) 2015 } 2016 2017 // DescribeUpdateActions mocks base method 2018 func (m *MockElastiCacheAPI) DescribeUpdateActions(arg0 *elasticache.DescribeUpdateActionsInput) (*elasticache.DescribeUpdateActionsOutput, error) { 2019 m.ctrl.T.Helper() 2020 ret := m.ctrl.Call(m, "DescribeUpdateActions", arg0) 2021 ret0, _ := ret[0].(*elasticache.DescribeUpdateActionsOutput) 2022 ret1, _ := ret[1].(error) 2023 return ret0, ret1 2024 } 2025 2026 // DescribeUpdateActions indicates an expected call of DescribeUpdateActions 2027 func (mr *MockElastiCacheAPIMockRecorder) DescribeUpdateActions(arg0 interface{}) *gomock.Call { 2028 mr.mock.ctrl.T.Helper() 2029 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUpdateActions", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeUpdateActions), arg0) 2030 } 2031 2032 // DescribeUpdateActionsWithContext mocks base method 2033 func (m *MockElastiCacheAPI) DescribeUpdateActionsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeUpdateActionsInput, arg2 ...request.Option) (*elasticache.DescribeUpdateActionsOutput, error) { 2034 m.ctrl.T.Helper() 2035 varargs := []interface{}{arg0, arg1} 2036 for _, a := range arg2 { 2037 varargs = append(varargs, a) 2038 } 2039 ret := m.ctrl.Call(m, "DescribeUpdateActionsWithContext", varargs...) 2040 ret0, _ := ret[0].(*elasticache.DescribeUpdateActionsOutput) 2041 ret1, _ := ret[1].(error) 2042 return ret0, ret1 2043 } 2044 2045 // DescribeUpdateActionsWithContext indicates an expected call of DescribeUpdateActionsWithContext 2046 func (mr *MockElastiCacheAPIMockRecorder) DescribeUpdateActionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2047 mr.mock.ctrl.T.Helper() 2048 varargs := append([]interface{}{arg0, arg1}, arg2...) 2049 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUpdateActionsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeUpdateActionsWithContext), varargs...) 2050 } 2051 2052 // DescribeUpdateActionsRequest mocks base method 2053 func (m *MockElastiCacheAPI) DescribeUpdateActionsRequest(arg0 *elasticache.DescribeUpdateActionsInput) (*request.Request, *elasticache.DescribeUpdateActionsOutput) { 2054 m.ctrl.T.Helper() 2055 ret := m.ctrl.Call(m, "DescribeUpdateActionsRequest", arg0) 2056 ret0, _ := ret[0].(*request.Request) 2057 ret1, _ := ret[1].(*elasticache.DescribeUpdateActionsOutput) 2058 return ret0, ret1 2059 } 2060 2061 // DescribeUpdateActionsRequest indicates an expected call of DescribeUpdateActionsRequest 2062 func (mr *MockElastiCacheAPIMockRecorder) DescribeUpdateActionsRequest(arg0 interface{}) *gomock.Call { 2063 mr.mock.ctrl.T.Helper() 2064 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUpdateActionsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeUpdateActionsRequest), arg0) 2065 } 2066 2067 // DescribeUpdateActionsPages mocks base method 2068 func (m *MockElastiCacheAPI) DescribeUpdateActionsPages(arg0 *elasticache.DescribeUpdateActionsInput, arg1 func(*elasticache.DescribeUpdateActionsOutput, bool) bool) error { 2069 m.ctrl.T.Helper() 2070 ret := m.ctrl.Call(m, "DescribeUpdateActionsPages", arg0, arg1) 2071 ret0, _ := ret[0].(error) 2072 return ret0 2073 } 2074 2075 // DescribeUpdateActionsPages indicates an expected call of DescribeUpdateActionsPages 2076 func (mr *MockElastiCacheAPIMockRecorder) DescribeUpdateActionsPages(arg0, arg1 interface{}) *gomock.Call { 2077 mr.mock.ctrl.T.Helper() 2078 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUpdateActionsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeUpdateActionsPages), arg0, arg1) 2079 } 2080 2081 // DescribeUpdateActionsPagesWithContext mocks base method 2082 func (m *MockElastiCacheAPI) DescribeUpdateActionsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeUpdateActionsInput, arg2 func(*elasticache.DescribeUpdateActionsOutput, bool) bool, arg3 ...request.Option) error { 2083 m.ctrl.T.Helper() 2084 varargs := []interface{}{arg0, arg1, arg2} 2085 for _, a := range arg3 { 2086 varargs = append(varargs, a) 2087 } 2088 ret := m.ctrl.Call(m, "DescribeUpdateActionsPagesWithContext", varargs...) 2089 ret0, _ := ret[0].(error) 2090 return ret0 2091 } 2092 2093 // DescribeUpdateActionsPagesWithContext indicates an expected call of DescribeUpdateActionsPagesWithContext 2094 func (mr *MockElastiCacheAPIMockRecorder) DescribeUpdateActionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 2095 mr.mock.ctrl.T.Helper() 2096 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 2097 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUpdateActionsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeUpdateActionsPagesWithContext), varargs...) 2098 } 2099 2100 // IncreaseReplicaCount mocks base method 2101 func (m *MockElastiCacheAPI) IncreaseReplicaCount(arg0 *elasticache.IncreaseReplicaCountInput) (*elasticache.IncreaseReplicaCountOutput, error) { 2102 m.ctrl.T.Helper() 2103 ret := m.ctrl.Call(m, "IncreaseReplicaCount", arg0) 2104 ret0, _ := ret[0].(*elasticache.IncreaseReplicaCountOutput) 2105 ret1, _ := ret[1].(error) 2106 return ret0, ret1 2107 } 2108 2109 // IncreaseReplicaCount indicates an expected call of IncreaseReplicaCount 2110 func (mr *MockElastiCacheAPIMockRecorder) IncreaseReplicaCount(arg0 interface{}) *gomock.Call { 2111 mr.mock.ctrl.T.Helper() 2112 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseReplicaCount", reflect.TypeOf((*MockElastiCacheAPI)(nil).IncreaseReplicaCount), arg0) 2113 } 2114 2115 // IncreaseReplicaCountWithContext mocks base method 2116 func (m *MockElastiCacheAPI) IncreaseReplicaCountWithContext(arg0 aws.Context, arg1 *elasticache.IncreaseReplicaCountInput, arg2 ...request.Option) (*elasticache.IncreaseReplicaCountOutput, error) { 2117 m.ctrl.T.Helper() 2118 varargs := []interface{}{arg0, arg1} 2119 for _, a := range arg2 { 2120 varargs = append(varargs, a) 2121 } 2122 ret := m.ctrl.Call(m, "IncreaseReplicaCountWithContext", varargs...) 2123 ret0, _ := ret[0].(*elasticache.IncreaseReplicaCountOutput) 2124 ret1, _ := ret[1].(error) 2125 return ret0, ret1 2126 } 2127 2128 // IncreaseReplicaCountWithContext indicates an expected call of IncreaseReplicaCountWithContext 2129 func (mr *MockElastiCacheAPIMockRecorder) IncreaseReplicaCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2130 mr.mock.ctrl.T.Helper() 2131 varargs := append([]interface{}{arg0, arg1}, arg2...) 2132 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseReplicaCountWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).IncreaseReplicaCountWithContext), varargs...) 2133 } 2134 2135 // IncreaseReplicaCountRequest mocks base method 2136 func (m *MockElastiCacheAPI) IncreaseReplicaCountRequest(arg0 *elasticache.IncreaseReplicaCountInput) (*request.Request, *elasticache.IncreaseReplicaCountOutput) { 2137 m.ctrl.T.Helper() 2138 ret := m.ctrl.Call(m, "IncreaseReplicaCountRequest", arg0) 2139 ret0, _ := ret[0].(*request.Request) 2140 ret1, _ := ret[1].(*elasticache.IncreaseReplicaCountOutput) 2141 return ret0, ret1 2142 } 2143 2144 // IncreaseReplicaCountRequest indicates an expected call of IncreaseReplicaCountRequest 2145 func (mr *MockElastiCacheAPIMockRecorder) IncreaseReplicaCountRequest(arg0 interface{}) *gomock.Call { 2146 mr.mock.ctrl.T.Helper() 2147 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseReplicaCountRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).IncreaseReplicaCountRequest), arg0) 2148 } 2149 2150 // ListAllowedNodeTypeModifications mocks base method 2151 func (m *MockElastiCacheAPI) ListAllowedNodeTypeModifications(arg0 *elasticache.ListAllowedNodeTypeModificationsInput) (*elasticache.ListAllowedNodeTypeModificationsOutput, error) { 2152 m.ctrl.T.Helper() 2153 ret := m.ctrl.Call(m, "ListAllowedNodeTypeModifications", arg0) 2154 ret0, _ := ret[0].(*elasticache.ListAllowedNodeTypeModificationsOutput) 2155 ret1, _ := ret[1].(error) 2156 return ret0, ret1 2157 } 2158 2159 // ListAllowedNodeTypeModifications indicates an expected call of ListAllowedNodeTypeModifications 2160 func (mr *MockElastiCacheAPIMockRecorder) ListAllowedNodeTypeModifications(arg0 interface{}) *gomock.Call { 2161 mr.mock.ctrl.T.Helper() 2162 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllowedNodeTypeModifications", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListAllowedNodeTypeModifications), arg0) 2163 } 2164 2165 // ListAllowedNodeTypeModificationsWithContext mocks base method 2166 func (m *MockElastiCacheAPI) ListAllowedNodeTypeModificationsWithContext(arg0 aws.Context, arg1 *elasticache.ListAllowedNodeTypeModificationsInput, arg2 ...request.Option) (*elasticache.ListAllowedNodeTypeModificationsOutput, error) { 2167 m.ctrl.T.Helper() 2168 varargs := []interface{}{arg0, arg1} 2169 for _, a := range arg2 { 2170 varargs = append(varargs, a) 2171 } 2172 ret := m.ctrl.Call(m, "ListAllowedNodeTypeModificationsWithContext", varargs...) 2173 ret0, _ := ret[0].(*elasticache.ListAllowedNodeTypeModificationsOutput) 2174 ret1, _ := ret[1].(error) 2175 return ret0, ret1 2176 } 2177 2178 // ListAllowedNodeTypeModificationsWithContext indicates an expected call of ListAllowedNodeTypeModificationsWithContext 2179 func (mr *MockElastiCacheAPIMockRecorder) ListAllowedNodeTypeModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2180 mr.mock.ctrl.T.Helper() 2181 varargs := append([]interface{}{arg0, arg1}, arg2...) 2182 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllowedNodeTypeModificationsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListAllowedNodeTypeModificationsWithContext), varargs...) 2183 } 2184 2185 // ListAllowedNodeTypeModificationsRequest mocks base method 2186 func (m *MockElastiCacheAPI) ListAllowedNodeTypeModificationsRequest(arg0 *elasticache.ListAllowedNodeTypeModificationsInput) (*request.Request, *elasticache.ListAllowedNodeTypeModificationsOutput) { 2187 m.ctrl.T.Helper() 2188 ret := m.ctrl.Call(m, "ListAllowedNodeTypeModificationsRequest", arg0) 2189 ret0, _ := ret[0].(*request.Request) 2190 ret1, _ := ret[1].(*elasticache.ListAllowedNodeTypeModificationsOutput) 2191 return ret0, ret1 2192 } 2193 2194 // ListAllowedNodeTypeModificationsRequest indicates an expected call of ListAllowedNodeTypeModificationsRequest 2195 func (mr *MockElastiCacheAPIMockRecorder) ListAllowedNodeTypeModificationsRequest(arg0 interface{}) *gomock.Call { 2196 mr.mock.ctrl.T.Helper() 2197 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllowedNodeTypeModificationsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListAllowedNodeTypeModificationsRequest), arg0) 2198 } 2199 2200 // ListTagsForResource mocks base method 2201 func (m *MockElastiCacheAPI) ListTagsForResource(arg0 *elasticache.ListTagsForResourceInput) (*elasticache.TagListMessage, error) { 2202 m.ctrl.T.Helper() 2203 ret := m.ctrl.Call(m, "ListTagsForResource", arg0) 2204 ret0, _ := ret[0].(*elasticache.TagListMessage) 2205 ret1, _ := ret[1].(error) 2206 return ret0, ret1 2207 } 2208 2209 // ListTagsForResource indicates an expected call of ListTagsForResource 2210 func (mr *MockElastiCacheAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { 2211 mr.mock.ctrl.T.Helper() 2212 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListTagsForResource), arg0) 2213 } 2214 2215 // ListTagsForResourceWithContext mocks base method 2216 func (m *MockElastiCacheAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *elasticache.ListTagsForResourceInput, arg2 ...request.Option) (*elasticache.TagListMessage, error) { 2217 m.ctrl.T.Helper() 2218 varargs := []interface{}{arg0, arg1} 2219 for _, a := range arg2 { 2220 varargs = append(varargs, a) 2221 } 2222 ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) 2223 ret0, _ := ret[0].(*elasticache.TagListMessage) 2224 ret1, _ := ret[1].(error) 2225 return ret0, ret1 2226 } 2227 2228 // ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext 2229 func (mr *MockElastiCacheAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2230 mr.mock.ctrl.T.Helper() 2231 varargs := append([]interface{}{arg0, arg1}, arg2...) 2232 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListTagsForResourceWithContext), varargs...) 2233 } 2234 2235 // ListTagsForResourceRequest mocks base method 2236 func (m *MockElastiCacheAPI) ListTagsForResourceRequest(arg0 *elasticache.ListTagsForResourceInput) (*request.Request, *elasticache.TagListMessage) { 2237 m.ctrl.T.Helper() 2238 ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) 2239 ret0, _ := ret[0].(*request.Request) 2240 ret1, _ := ret[1].(*elasticache.TagListMessage) 2241 return ret0, ret1 2242 } 2243 2244 // ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest 2245 func (mr *MockElastiCacheAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { 2246 mr.mock.ctrl.T.Helper() 2247 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListTagsForResourceRequest), arg0) 2248 } 2249 2250 // ModifyCacheCluster mocks base method 2251 func (m *MockElastiCacheAPI) ModifyCacheCluster(arg0 *elasticache.ModifyCacheClusterInput) (*elasticache.ModifyCacheClusterOutput, error) { 2252 m.ctrl.T.Helper() 2253 ret := m.ctrl.Call(m, "ModifyCacheCluster", arg0) 2254 ret0, _ := ret[0].(*elasticache.ModifyCacheClusterOutput) 2255 ret1, _ := ret[1].(error) 2256 return ret0, ret1 2257 } 2258 2259 // ModifyCacheCluster indicates an expected call of ModifyCacheCluster 2260 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheCluster(arg0 interface{}) *gomock.Call { 2261 mr.mock.ctrl.T.Helper() 2262 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheCluster), arg0) 2263 } 2264 2265 // ModifyCacheClusterWithContext mocks base method 2266 func (m *MockElastiCacheAPI) ModifyCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.ModifyCacheClusterInput, arg2 ...request.Option) (*elasticache.ModifyCacheClusterOutput, error) { 2267 m.ctrl.T.Helper() 2268 varargs := []interface{}{arg0, arg1} 2269 for _, a := range arg2 { 2270 varargs = append(varargs, a) 2271 } 2272 ret := m.ctrl.Call(m, "ModifyCacheClusterWithContext", varargs...) 2273 ret0, _ := ret[0].(*elasticache.ModifyCacheClusterOutput) 2274 ret1, _ := ret[1].(error) 2275 return ret0, ret1 2276 } 2277 2278 // ModifyCacheClusterWithContext indicates an expected call of ModifyCacheClusterWithContext 2279 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2280 mr.mock.ctrl.T.Helper() 2281 varargs := append([]interface{}{arg0, arg1}, arg2...) 2282 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheClusterWithContext), varargs...) 2283 } 2284 2285 // ModifyCacheClusterRequest mocks base method 2286 func (m *MockElastiCacheAPI) ModifyCacheClusterRequest(arg0 *elasticache.ModifyCacheClusterInput) (*request.Request, *elasticache.ModifyCacheClusterOutput) { 2287 m.ctrl.T.Helper() 2288 ret := m.ctrl.Call(m, "ModifyCacheClusterRequest", arg0) 2289 ret0, _ := ret[0].(*request.Request) 2290 ret1, _ := ret[1].(*elasticache.ModifyCacheClusterOutput) 2291 return ret0, ret1 2292 } 2293 2294 // ModifyCacheClusterRequest indicates an expected call of ModifyCacheClusterRequest 2295 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheClusterRequest(arg0 interface{}) *gomock.Call { 2296 mr.mock.ctrl.T.Helper() 2297 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheClusterRequest), arg0) 2298 } 2299 2300 // ModifyCacheParameterGroup mocks base method 2301 func (m *MockElastiCacheAPI) ModifyCacheParameterGroup(arg0 *elasticache.ModifyCacheParameterGroupInput) (*elasticache.CacheParameterGroupNameMessage, error) { 2302 m.ctrl.T.Helper() 2303 ret := m.ctrl.Call(m, "ModifyCacheParameterGroup", arg0) 2304 ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage) 2305 ret1, _ := ret[1].(error) 2306 return ret0, ret1 2307 } 2308 2309 // ModifyCacheParameterGroup indicates an expected call of ModifyCacheParameterGroup 2310 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheParameterGroup(arg0 interface{}) *gomock.Call { 2311 mr.mock.ctrl.T.Helper() 2312 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheParameterGroup), arg0) 2313 } 2314 2315 // ModifyCacheParameterGroupWithContext mocks base method 2316 func (m *MockElastiCacheAPI) ModifyCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.ModifyCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.CacheParameterGroupNameMessage, error) { 2317 m.ctrl.T.Helper() 2318 varargs := []interface{}{arg0, arg1} 2319 for _, a := range arg2 { 2320 varargs = append(varargs, a) 2321 } 2322 ret := m.ctrl.Call(m, "ModifyCacheParameterGroupWithContext", varargs...) 2323 ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage) 2324 ret1, _ := ret[1].(error) 2325 return ret0, ret1 2326 } 2327 2328 // ModifyCacheParameterGroupWithContext indicates an expected call of ModifyCacheParameterGroupWithContext 2329 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2330 mr.mock.ctrl.T.Helper() 2331 varargs := append([]interface{}{arg0, arg1}, arg2...) 2332 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheParameterGroupWithContext), varargs...) 2333 } 2334 2335 // ModifyCacheParameterGroupRequest mocks base method 2336 func (m *MockElastiCacheAPI) ModifyCacheParameterGroupRequest(arg0 *elasticache.ModifyCacheParameterGroupInput) (*request.Request, *elasticache.CacheParameterGroupNameMessage) { 2337 m.ctrl.T.Helper() 2338 ret := m.ctrl.Call(m, "ModifyCacheParameterGroupRequest", arg0) 2339 ret0, _ := ret[0].(*request.Request) 2340 ret1, _ := ret[1].(*elasticache.CacheParameterGroupNameMessage) 2341 return ret0, ret1 2342 } 2343 2344 // ModifyCacheParameterGroupRequest indicates an expected call of ModifyCacheParameterGroupRequest 2345 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheParameterGroupRequest(arg0 interface{}) *gomock.Call { 2346 mr.mock.ctrl.T.Helper() 2347 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheParameterGroupRequest), arg0) 2348 } 2349 2350 // ModifyCacheSubnetGroup mocks base method 2351 func (m *MockElastiCacheAPI) ModifyCacheSubnetGroup(arg0 *elasticache.ModifyCacheSubnetGroupInput) (*elasticache.ModifyCacheSubnetGroupOutput, error) { 2352 m.ctrl.T.Helper() 2353 ret := m.ctrl.Call(m, "ModifyCacheSubnetGroup", arg0) 2354 ret0, _ := ret[0].(*elasticache.ModifyCacheSubnetGroupOutput) 2355 ret1, _ := ret[1].(error) 2356 return ret0, ret1 2357 } 2358 2359 // ModifyCacheSubnetGroup indicates an expected call of ModifyCacheSubnetGroup 2360 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheSubnetGroup(arg0 interface{}) *gomock.Call { 2361 mr.mock.ctrl.T.Helper() 2362 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheSubnetGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheSubnetGroup), arg0) 2363 } 2364 2365 // ModifyCacheSubnetGroupWithContext mocks base method 2366 func (m *MockElastiCacheAPI) ModifyCacheSubnetGroupWithContext(arg0 aws.Context, arg1 *elasticache.ModifyCacheSubnetGroupInput, arg2 ...request.Option) (*elasticache.ModifyCacheSubnetGroupOutput, error) { 2367 m.ctrl.T.Helper() 2368 varargs := []interface{}{arg0, arg1} 2369 for _, a := range arg2 { 2370 varargs = append(varargs, a) 2371 } 2372 ret := m.ctrl.Call(m, "ModifyCacheSubnetGroupWithContext", varargs...) 2373 ret0, _ := ret[0].(*elasticache.ModifyCacheSubnetGroupOutput) 2374 ret1, _ := ret[1].(error) 2375 return ret0, ret1 2376 } 2377 2378 // ModifyCacheSubnetGroupWithContext indicates an expected call of ModifyCacheSubnetGroupWithContext 2379 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2380 mr.mock.ctrl.T.Helper() 2381 varargs := append([]interface{}{arg0, arg1}, arg2...) 2382 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheSubnetGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheSubnetGroupWithContext), varargs...) 2383 } 2384 2385 // ModifyCacheSubnetGroupRequest mocks base method 2386 func (m *MockElastiCacheAPI) ModifyCacheSubnetGroupRequest(arg0 *elasticache.ModifyCacheSubnetGroupInput) (*request.Request, *elasticache.ModifyCacheSubnetGroupOutput) { 2387 m.ctrl.T.Helper() 2388 ret := m.ctrl.Call(m, "ModifyCacheSubnetGroupRequest", arg0) 2389 ret0, _ := ret[0].(*request.Request) 2390 ret1, _ := ret[1].(*elasticache.ModifyCacheSubnetGroupOutput) 2391 return ret0, ret1 2392 } 2393 2394 // ModifyCacheSubnetGroupRequest indicates an expected call of ModifyCacheSubnetGroupRequest 2395 func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheSubnetGroupRequest(arg0 interface{}) *gomock.Call { 2396 mr.mock.ctrl.T.Helper() 2397 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheSubnetGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheSubnetGroupRequest), arg0) 2398 } 2399 2400 // ModifyReplicationGroup mocks base method 2401 func (m *MockElastiCacheAPI) ModifyReplicationGroup(arg0 *elasticache.ModifyReplicationGroupInput) (*elasticache.ModifyReplicationGroupOutput, error) { 2402 m.ctrl.T.Helper() 2403 ret := m.ctrl.Call(m, "ModifyReplicationGroup", arg0) 2404 ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupOutput) 2405 ret1, _ := ret[1].(error) 2406 return ret0, ret1 2407 } 2408 2409 // ModifyReplicationGroup indicates an expected call of ModifyReplicationGroup 2410 func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroup(arg0 interface{}) *gomock.Call { 2411 mr.mock.ctrl.T.Helper() 2412 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroup), arg0) 2413 } 2414 2415 // ModifyReplicationGroupWithContext mocks base method 2416 func (m *MockElastiCacheAPI) ModifyReplicationGroupWithContext(arg0 aws.Context, arg1 *elasticache.ModifyReplicationGroupInput, arg2 ...request.Option) (*elasticache.ModifyReplicationGroupOutput, error) { 2417 m.ctrl.T.Helper() 2418 varargs := []interface{}{arg0, arg1} 2419 for _, a := range arg2 { 2420 varargs = append(varargs, a) 2421 } 2422 ret := m.ctrl.Call(m, "ModifyReplicationGroupWithContext", varargs...) 2423 ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupOutput) 2424 ret1, _ := ret[1].(error) 2425 return ret0, ret1 2426 } 2427 2428 // ModifyReplicationGroupWithContext indicates an expected call of ModifyReplicationGroupWithContext 2429 func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2430 mr.mock.ctrl.T.Helper() 2431 varargs := append([]interface{}{arg0, arg1}, arg2...) 2432 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupWithContext), varargs...) 2433 } 2434 2435 // ModifyReplicationGroupRequest mocks base method 2436 func (m *MockElastiCacheAPI) ModifyReplicationGroupRequest(arg0 *elasticache.ModifyReplicationGroupInput) (*request.Request, *elasticache.ModifyReplicationGroupOutput) { 2437 m.ctrl.T.Helper() 2438 ret := m.ctrl.Call(m, "ModifyReplicationGroupRequest", arg0) 2439 ret0, _ := ret[0].(*request.Request) 2440 ret1, _ := ret[1].(*elasticache.ModifyReplicationGroupOutput) 2441 return ret0, ret1 2442 } 2443 2444 // ModifyReplicationGroupRequest indicates an expected call of ModifyReplicationGroupRequest 2445 func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupRequest(arg0 interface{}) *gomock.Call { 2446 mr.mock.ctrl.T.Helper() 2447 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupRequest), arg0) 2448 } 2449 2450 // ModifyReplicationGroupShardConfiguration mocks base method 2451 func (m *MockElastiCacheAPI) ModifyReplicationGroupShardConfiguration(arg0 *elasticache.ModifyReplicationGroupShardConfigurationInput) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, error) { 2452 m.ctrl.T.Helper() 2453 ret := m.ctrl.Call(m, "ModifyReplicationGroupShardConfiguration", arg0) 2454 ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupShardConfigurationOutput) 2455 ret1, _ := ret[1].(error) 2456 return ret0, ret1 2457 } 2458 2459 // ModifyReplicationGroupShardConfiguration indicates an expected call of ModifyReplicationGroupShardConfiguration 2460 func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupShardConfiguration(arg0 interface{}) *gomock.Call { 2461 mr.mock.ctrl.T.Helper() 2462 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupShardConfiguration", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupShardConfiguration), arg0) 2463 } 2464 2465 // ModifyReplicationGroupShardConfigurationWithContext mocks base method 2466 func (m *MockElastiCacheAPI) ModifyReplicationGroupShardConfigurationWithContext(arg0 aws.Context, arg1 *elasticache.ModifyReplicationGroupShardConfigurationInput, arg2 ...request.Option) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, error) { 2467 m.ctrl.T.Helper() 2468 varargs := []interface{}{arg0, arg1} 2469 for _, a := range arg2 { 2470 varargs = append(varargs, a) 2471 } 2472 ret := m.ctrl.Call(m, "ModifyReplicationGroupShardConfigurationWithContext", varargs...) 2473 ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupShardConfigurationOutput) 2474 ret1, _ := ret[1].(error) 2475 return ret0, ret1 2476 } 2477 2478 // ModifyReplicationGroupShardConfigurationWithContext indicates an expected call of ModifyReplicationGroupShardConfigurationWithContext 2479 func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupShardConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2480 mr.mock.ctrl.T.Helper() 2481 varargs := append([]interface{}{arg0, arg1}, arg2...) 2482 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupShardConfigurationWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupShardConfigurationWithContext), varargs...) 2483 } 2484 2485 // ModifyReplicationGroupShardConfigurationRequest mocks base method 2486 func (m *MockElastiCacheAPI) ModifyReplicationGroupShardConfigurationRequest(arg0 *elasticache.ModifyReplicationGroupShardConfigurationInput) (*request.Request, *elasticache.ModifyReplicationGroupShardConfigurationOutput) { 2487 m.ctrl.T.Helper() 2488 ret := m.ctrl.Call(m, "ModifyReplicationGroupShardConfigurationRequest", arg0) 2489 ret0, _ := ret[0].(*request.Request) 2490 ret1, _ := ret[1].(*elasticache.ModifyReplicationGroupShardConfigurationOutput) 2491 return ret0, ret1 2492 } 2493 2494 // ModifyReplicationGroupShardConfigurationRequest indicates an expected call of ModifyReplicationGroupShardConfigurationRequest 2495 func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupShardConfigurationRequest(arg0 interface{}) *gomock.Call { 2496 mr.mock.ctrl.T.Helper() 2497 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupShardConfigurationRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupShardConfigurationRequest), arg0) 2498 } 2499 2500 // PurchaseReservedCacheNodesOffering mocks base method 2501 func (m *MockElastiCacheAPI) PurchaseReservedCacheNodesOffering(arg0 *elasticache.PurchaseReservedCacheNodesOfferingInput) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, error) { 2502 m.ctrl.T.Helper() 2503 ret := m.ctrl.Call(m, "PurchaseReservedCacheNodesOffering", arg0) 2504 ret0, _ := ret[0].(*elasticache.PurchaseReservedCacheNodesOfferingOutput) 2505 ret1, _ := ret[1].(error) 2506 return ret0, ret1 2507 } 2508 2509 // PurchaseReservedCacheNodesOffering indicates an expected call of PurchaseReservedCacheNodesOffering 2510 func (mr *MockElastiCacheAPIMockRecorder) PurchaseReservedCacheNodesOffering(arg0 interface{}) *gomock.Call { 2511 mr.mock.ctrl.T.Helper() 2512 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedCacheNodesOffering", reflect.TypeOf((*MockElastiCacheAPI)(nil).PurchaseReservedCacheNodesOffering), arg0) 2513 } 2514 2515 // PurchaseReservedCacheNodesOfferingWithContext mocks base method 2516 func (m *MockElastiCacheAPI) PurchaseReservedCacheNodesOfferingWithContext(arg0 aws.Context, arg1 *elasticache.PurchaseReservedCacheNodesOfferingInput, arg2 ...request.Option) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, error) { 2517 m.ctrl.T.Helper() 2518 varargs := []interface{}{arg0, arg1} 2519 for _, a := range arg2 { 2520 varargs = append(varargs, a) 2521 } 2522 ret := m.ctrl.Call(m, "PurchaseReservedCacheNodesOfferingWithContext", varargs...) 2523 ret0, _ := ret[0].(*elasticache.PurchaseReservedCacheNodesOfferingOutput) 2524 ret1, _ := ret[1].(error) 2525 return ret0, ret1 2526 } 2527 2528 // PurchaseReservedCacheNodesOfferingWithContext indicates an expected call of PurchaseReservedCacheNodesOfferingWithContext 2529 func (mr *MockElastiCacheAPIMockRecorder) PurchaseReservedCacheNodesOfferingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2530 mr.mock.ctrl.T.Helper() 2531 varargs := append([]interface{}{arg0, arg1}, arg2...) 2532 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedCacheNodesOfferingWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).PurchaseReservedCacheNodesOfferingWithContext), varargs...) 2533 } 2534 2535 // PurchaseReservedCacheNodesOfferingRequest mocks base method 2536 func (m *MockElastiCacheAPI) PurchaseReservedCacheNodesOfferingRequest(arg0 *elasticache.PurchaseReservedCacheNodesOfferingInput) (*request.Request, *elasticache.PurchaseReservedCacheNodesOfferingOutput) { 2537 m.ctrl.T.Helper() 2538 ret := m.ctrl.Call(m, "PurchaseReservedCacheNodesOfferingRequest", arg0) 2539 ret0, _ := ret[0].(*request.Request) 2540 ret1, _ := ret[1].(*elasticache.PurchaseReservedCacheNodesOfferingOutput) 2541 return ret0, ret1 2542 } 2543 2544 // PurchaseReservedCacheNodesOfferingRequest indicates an expected call of PurchaseReservedCacheNodesOfferingRequest 2545 func (mr *MockElastiCacheAPIMockRecorder) PurchaseReservedCacheNodesOfferingRequest(arg0 interface{}) *gomock.Call { 2546 mr.mock.ctrl.T.Helper() 2547 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedCacheNodesOfferingRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).PurchaseReservedCacheNodesOfferingRequest), arg0) 2548 } 2549 2550 // RebootCacheCluster mocks base method 2551 func (m *MockElastiCacheAPI) RebootCacheCluster(arg0 *elasticache.RebootCacheClusterInput) (*elasticache.RebootCacheClusterOutput, error) { 2552 m.ctrl.T.Helper() 2553 ret := m.ctrl.Call(m, "RebootCacheCluster", arg0) 2554 ret0, _ := ret[0].(*elasticache.RebootCacheClusterOutput) 2555 ret1, _ := ret[1].(error) 2556 return ret0, ret1 2557 } 2558 2559 // RebootCacheCluster indicates an expected call of RebootCacheCluster 2560 func (mr *MockElastiCacheAPIMockRecorder) RebootCacheCluster(arg0 interface{}) *gomock.Call { 2561 mr.mock.ctrl.T.Helper() 2562 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).RebootCacheCluster), arg0) 2563 } 2564 2565 // RebootCacheClusterWithContext mocks base method 2566 func (m *MockElastiCacheAPI) RebootCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.RebootCacheClusterInput, arg2 ...request.Option) (*elasticache.RebootCacheClusterOutput, error) { 2567 m.ctrl.T.Helper() 2568 varargs := []interface{}{arg0, arg1} 2569 for _, a := range arg2 { 2570 varargs = append(varargs, a) 2571 } 2572 ret := m.ctrl.Call(m, "RebootCacheClusterWithContext", varargs...) 2573 ret0, _ := ret[0].(*elasticache.RebootCacheClusterOutput) 2574 ret1, _ := ret[1].(error) 2575 return ret0, ret1 2576 } 2577 2578 // RebootCacheClusterWithContext indicates an expected call of RebootCacheClusterWithContext 2579 func (mr *MockElastiCacheAPIMockRecorder) RebootCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2580 mr.mock.ctrl.T.Helper() 2581 varargs := append([]interface{}{arg0, arg1}, arg2...) 2582 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).RebootCacheClusterWithContext), varargs...) 2583 } 2584 2585 // RebootCacheClusterRequest mocks base method 2586 func (m *MockElastiCacheAPI) RebootCacheClusterRequest(arg0 *elasticache.RebootCacheClusterInput) (*request.Request, *elasticache.RebootCacheClusterOutput) { 2587 m.ctrl.T.Helper() 2588 ret := m.ctrl.Call(m, "RebootCacheClusterRequest", arg0) 2589 ret0, _ := ret[0].(*request.Request) 2590 ret1, _ := ret[1].(*elasticache.RebootCacheClusterOutput) 2591 return ret0, ret1 2592 } 2593 2594 // RebootCacheClusterRequest indicates an expected call of RebootCacheClusterRequest 2595 func (mr *MockElastiCacheAPIMockRecorder) RebootCacheClusterRequest(arg0 interface{}) *gomock.Call { 2596 mr.mock.ctrl.T.Helper() 2597 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).RebootCacheClusterRequest), arg0) 2598 } 2599 2600 // RemoveTagsFromResource mocks base method 2601 func (m *MockElastiCacheAPI) RemoveTagsFromResource(arg0 *elasticache.RemoveTagsFromResourceInput) (*elasticache.TagListMessage, error) { 2602 m.ctrl.T.Helper() 2603 ret := m.ctrl.Call(m, "RemoveTagsFromResource", arg0) 2604 ret0, _ := ret[0].(*elasticache.TagListMessage) 2605 ret1, _ := ret[1].(error) 2606 return ret0, ret1 2607 } 2608 2609 // RemoveTagsFromResource indicates an expected call of RemoveTagsFromResource 2610 func (mr *MockElastiCacheAPIMockRecorder) RemoveTagsFromResource(arg0 interface{}) *gomock.Call { 2611 mr.mock.ctrl.T.Helper() 2612 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResource", reflect.TypeOf((*MockElastiCacheAPI)(nil).RemoveTagsFromResource), arg0) 2613 } 2614 2615 // RemoveTagsFromResourceWithContext mocks base method 2616 func (m *MockElastiCacheAPI) RemoveTagsFromResourceWithContext(arg0 aws.Context, arg1 *elasticache.RemoveTagsFromResourceInput, arg2 ...request.Option) (*elasticache.TagListMessage, error) { 2617 m.ctrl.T.Helper() 2618 varargs := []interface{}{arg0, arg1} 2619 for _, a := range arg2 { 2620 varargs = append(varargs, a) 2621 } 2622 ret := m.ctrl.Call(m, "RemoveTagsFromResourceWithContext", varargs...) 2623 ret0, _ := ret[0].(*elasticache.TagListMessage) 2624 ret1, _ := ret[1].(error) 2625 return ret0, ret1 2626 } 2627 2628 // RemoveTagsFromResourceWithContext indicates an expected call of RemoveTagsFromResourceWithContext 2629 func (mr *MockElastiCacheAPIMockRecorder) RemoveTagsFromResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2630 mr.mock.ctrl.T.Helper() 2631 varargs := append([]interface{}{arg0, arg1}, arg2...) 2632 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).RemoveTagsFromResourceWithContext), varargs...) 2633 } 2634 2635 // RemoveTagsFromResourceRequest mocks base method 2636 func (m *MockElastiCacheAPI) RemoveTagsFromResourceRequest(arg0 *elasticache.RemoveTagsFromResourceInput) (*request.Request, *elasticache.TagListMessage) { 2637 m.ctrl.T.Helper() 2638 ret := m.ctrl.Call(m, "RemoveTagsFromResourceRequest", arg0) 2639 ret0, _ := ret[0].(*request.Request) 2640 ret1, _ := ret[1].(*elasticache.TagListMessage) 2641 return ret0, ret1 2642 } 2643 2644 // RemoveTagsFromResourceRequest indicates an expected call of RemoveTagsFromResourceRequest 2645 func (mr *MockElastiCacheAPIMockRecorder) RemoveTagsFromResourceRequest(arg0 interface{}) *gomock.Call { 2646 mr.mock.ctrl.T.Helper() 2647 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).RemoveTagsFromResourceRequest), arg0) 2648 } 2649 2650 // ResetCacheParameterGroup mocks base method 2651 func (m *MockElastiCacheAPI) ResetCacheParameterGroup(arg0 *elasticache.ResetCacheParameterGroupInput) (*elasticache.CacheParameterGroupNameMessage, error) { 2652 m.ctrl.T.Helper() 2653 ret := m.ctrl.Call(m, "ResetCacheParameterGroup", arg0) 2654 ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage) 2655 ret1, _ := ret[1].(error) 2656 return ret0, ret1 2657 } 2658 2659 // ResetCacheParameterGroup indicates an expected call of ResetCacheParameterGroup 2660 func (mr *MockElastiCacheAPIMockRecorder) ResetCacheParameterGroup(arg0 interface{}) *gomock.Call { 2661 mr.mock.ctrl.T.Helper() 2662 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ResetCacheParameterGroup), arg0) 2663 } 2664 2665 // ResetCacheParameterGroupWithContext mocks base method 2666 func (m *MockElastiCacheAPI) ResetCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.ResetCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.CacheParameterGroupNameMessage, error) { 2667 m.ctrl.T.Helper() 2668 varargs := []interface{}{arg0, arg1} 2669 for _, a := range arg2 { 2670 varargs = append(varargs, a) 2671 } 2672 ret := m.ctrl.Call(m, "ResetCacheParameterGroupWithContext", varargs...) 2673 ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage) 2674 ret1, _ := ret[1].(error) 2675 return ret0, ret1 2676 } 2677 2678 // ResetCacheParameterGroupWithContext indicates an expected call of ResetCacheParameterGroupWithContext 2679 func (mr *MockElastiCacheAPIMockRecorder) ResetCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2680 mr.mock.ctrl.T.Helper() 2681 varargs := append([]interface{}{arg0, arg1}, arg2...) 2682 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ResetCacheParameterGroupWithContext), varargs...) 2683 } 2684 2685 // ResetCacheParameterGroupRequest mocks base method 2686 func (m *MockElastiCacheAPI) ResetCacheParameterGroupRequest(arg0 *elasticache.ResetCacheParameterGroupInput) (*request.Request, *elasticache.CacheParameterGroupNameMessage) { 2687 m.ctrl.T.Helper() 2688 ret := m.ctrl.Call(m, "ResetCacheParameterGroupRequest", arg0) 2689 ret0, _ := ret[0].(*request.Request) 2690 ret1, _ := ret[1].(*elasticache.CacheParameterGroupNameMessage) 2691 return ret0, ret1 2692 } 2693 2694 // ResetCacheParameterGroupRequest indicates an expected call of ResetCacheParameterGroupRequest 2695 func (mr *MockElastiCacheAPIMockRecorder) ResetCacheParameterGroupRequest(arg0 interface{}) *gomock.Call { 2696 mr.mock.ctrl.T.Helper() 2697 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ResetCacheParameterGroupRequest), arg0) 2698 } 2699 2700 // RevokeCacheSecurityGroupIngress mocks base method 2701 func (m *MockElastiCacheAPI) RevokeCacheSecurityGroupIngress(arg0 *elasticache.RevokeCacheSecurityGroupIngressInput) (*elasticache.RevokeCacheSecurityGroupIngressOutput, error) { 2702 m.ctrl.T.Helper() 2703 ret := m.ctrl.Call(m, "RevokeCacheSecurityGroupIngress", arg0) 2704 ret0, _ := ret[0].(*elasticache.RevokeCacheSecurityGroupIngressOutput) 2705 ret1, _ := ret[1].(error) 2706 return ret0, ret1 2707 } 2708 2709 // RevokeCacheSecurityGroupIngress indicates an expected call of RevokeCacheSecurityGroupIngress 2710 func (mr *MockElastiCacheAPIMockRecorder) RevokeCacheSecurityGroupIngress(arg0 interface{}) *gomock.Call { 2711 mr.mock.ctrl.T.Helper() 2712 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeCacheSecurityGroupIngress", reflect.TypeOf((*MockElastiCacheAPI)(nil).RevokeCacheSecurityGroupIngress), arg0) 2713 } 2714 2715 // RevokeCacheSecurityGroupIngressWithContext mocks base method 2716 func (m *MockElastiCacheAPI) RevokeCacheSecurityGroupIngressWithContext(arg0 aws.Context, arg1 *elasticache.RevokeCacheSecurityGroupIngressInput, arg2 ...request.Option) (*elasticache.RevokeCacheSecurityGroupIngressOutput, error) { 2717 m.ctrl.T.Helper() 2718 varargs := []interface{}{arg0, arg1} 2719 for _, a := range arg2 { 2720 varargs = append(varargs, a) 2721 } 2722 ret := m.ctrl.Call(m, "RevokeCacheSecurityGroupIngressWithContext", varargs...) 2723 ret0, _ := ret[0].(*elasticache.RevokeCacheSecurityGroupIngressOutput) 2724 ret1, _ := ret[1].(error) 2725 return ret0, ret1 2726 } 2727 2728 // RevokeCacheSecurityGroupIngressWithContext indicates an expected call of RevokeCacheSecurityGroupIngressWithContext 2729 func (mr *MockElastiCacheAPIMockRecorder) RevokeCacheSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2730 mr.mock.ctrl.T.Helper() 2731 varargs := append([]interface{}{arg0, arg1}, arg2...) 2732 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeCacheSecurityGroupIngressWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).RevokeCacheSecurityGroupIngressWithContext), varargs...) 2733 } 2734 2735 // RevokeCacheSecurityGroupIngressRequest mocks base method 2736 func (m *MockElastiCacheAPI) RevokeCacheSecurityGroupIngressRequest(arg0 *elasticache.RevokeCacheSecurityGroupIngressInput) (*request.Request, *elasticache.RevokeCacheSecurityGroupIngressOutput) { 2737 m.ctrl.T.Helper() 2738 ret := m.ctrl.Call(m, "RevokeCacheSecurityGroupIngressRequest", arg0) 2739 ret0, _ := ret[0].(*request.Request) 2740 ret1, _ := ret[1].(*elasticache.RevokeCacheSecurityGroupIngressOutput) 2741 return ret0, ret1 2742 } 2743 2744 // RevokeCacheSecurityGroupIngressRequest indicates an expected call of RevokeCacheSecurityGroupIngressRequest 2745 func (mr *MockElastiCacheAPIMockRecorder) RevokeCacheSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { 2746 mr.mock.ctrl.T.Helper() 2747 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeCacheSecurityGroupIngressRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).RevokeCacheSecurityGroupIngressRequest), arg0) 2748 } 2749 2750 // TestFailover mocks base method 2751 func (m *MockElastiCacheAPI) TestFailover(arg0 *elasticache.TestFailoverInput) (*elasticache.TestFailoverOutput, error) { 2752 m.ctrl.T.Helper() 2753 ret := m.ctrl.Call(m, "TestFailover", arg0) 2754 ret0, _ := ret[0].(*elasticache.TestFailoverOutput) 2755 ret1, _ := ret[1].(error) 2756 return ret0, ret1 2757 } 2758 2759 // TestFailover indicates an expected call of TestFailover 2760 func (mr *MockElastiCacheAPIMockRecorder) TestFailover(arg0 interface{}) *gomock.Call { 2761 mr.mock.ctrl.T.Helper() 2762 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestFailover", reflect.TypeOf((*MockElastiCacheAPI)(nil).TestFailover), arg0) 2763 } 2764 2765 // TestFailoverWithContext mocks base method 2766 func (m *MockElastiCacheAPI) TestFailoverWithContext(arg0 aws.Context, arg1 *elasticache.TestFailoverInput, arg2 ...request.Option) (*elasticache.TestFailoverOutput, error) { 2767 m.ctrl.T.Helper() 2768 varargs := []interface{}{arg0, arg1} 2769 for _, a := range arg2 { 2770 varargs = append(varargs, a) 2771 } 2772 ret := m.ctrl.Call(m, "TestFailoverWithContext", varargs...) 2773 ret0, _ := ret[0].(*elasticache.TestFailoverOutput) 2774 ret1, _ := ret[1].(error) 2775 return ret0, ret1 2776 } 2777 2778 // TestFailoverWithContext indicates an expected call of TestFailoverWithContext 2779 func (mr *MockElastiCacheAPIMockRecorder) TestFailoverWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2780 mr.mock.ctrl.T.Helper() 2781 varargs := append([]interface{}{arg0, arg1}, arg2...) 2782 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestFailoverWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).TestFailoverWithContext), varargs...) 2783 } 2784 2785 // TestFailoverRequest mocks base method 2786 func (m *MockElastiCacheAPI) TestFailoverRequest(arg0 *elasticache.TestFailoverInput) (*request.Request, *elasticache.TestFailoverOutput) { 2787 m.ctrl.T.Helper() 2788 ret := m.ctrl.Call(m, "TestFailoverRequest", arg0) 2789 ret0, _ := ret[0].(*request.Request) 2790 ret1, _ := ret[1].(*elasticache.TestFailoverOutput) 2791 return ret0, ret1 2792 } 2793 2794 // TestFailoverRequest indicates an expected call of TestFailoverRequest 2795 func (mr *MockElastiCacheAPIMockRecorder) TestFailoverRequest(arg0 interface{}) *gomock.Call { 2796 mr.mock.ctrl.T.Helper() 2797 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestFailoverRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).TestFailoverRequest), arg0) 2798 } 2799 2800 // WaitUntilCacheClusterAvailable mocks base method 2801 func (m *MockElastiCacheAPI) WaitUntilCacheClusterAvailable(arg0 *elasticache.DescribeCacheClustersInput) error { 2802 m.ctrl.T.Helper() 2803 ret := m.ctrl.Call(m, "WaitUntilCacheClusterAvailable", arg0) 2804 ret0, _ := ret[0].(error) 2805 return ret0 2806 } 2807 2808 // WaitUntilCacheClusterAvailable indicates an expected call of WaitUntilCacheClusterAvailable 2809 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterAvailable(arg0 interface{}) *gomock.Call { 2810 mr.mock.ctrl.T.Helper() 2811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterAvailable", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterAvailable), arg0) 2812 } 2813 2814 // WaitUntilCacheClusterAvailableWithContext mocks base method 2815 func (m *MockElastiCacheAPI) WaitUntilCacheClusterAvailableWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 ...request.WaiterOption) error { 2816 m.ctrl.T.Helper() 2817 varargs := []interface{}{arg0, arg1} 2818 for _, a := range arg2 { 2819 varargs = append(varargs, a) 2820 } 2821 ret := m.ctrl.Call(m, "WaitUntilCacheClusterAvailableWithContext", varargs...) 2822 ret0, _ := ret[0].(error) 2823 return ret0 2824 } 2825 2826 // WaitUntilCacheClusterAvailableWithContext indicates an expected call of WaitUntilCacheClusterAvailableWithContext 2827 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2828 mr.mock.ctrl.T.Helper() 2829 varargs := append([]interface{}{arg0, arg1}, arg2...) 2830 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterAvailableWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterAvailableWithContext), varargs...) 2831 } 2832 2833 // WaitUntilCacheClusterDeleted mocks base method 2834 func (m *MockElastiCacheAPI) WaitUntilCacheClusterDeleted(arg0 *elasticache.DescribeCacheClustersInput) error { 2835 m.ctrl.T.Helper() 2836 ret := m.ctrl.Call(m, "WaitUntilCacheClusterDeleted", arg0) 2837 ret0, _ := ret[0].(error) 2838 return ret0 2839 } 2840 2841 // WaitUntilCacheClusterDeleted indicates an expected call of WaitUntilCacheClusterDeleted 2842 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterDeleted(arg0 interface{}) *gomock.Call { 2843 mr.mock.ctrl.T.Helper() 2844 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterDeleted", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterDeleted), arg0) 2845 } 2846 2847 // WaitUntilCacheClusterDeletedWithContext mocks base method 2848 func (m *MockElastiCacheAPI) WaitUntilCacheClusterDeletedWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 ...request.WaiterOption) error { 2849 m.ctrl.T.Helper() 2850 varargs := []interface{}{arg0, arg1} 2851 for _, a := range arg2 { 2852 varargs = append(varargs, a) 2853 } 2854 ret := m.ctrl.Call(m, "WaitUntilCacheClusterDeletedWithContext", varargs...) 2855 ret0, _ := ret[0].(error) 2856 return ret0 2857 } 2858 2859 // WaitUntilCacheClusterDeletedWithContext indicates an expected call of WaitUntilCacheClusterDeletedWithContext 2860 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2861 mr.mock.ctrl.T.Helper() 2862 varargs := append([]interface{}{arg0, arg1}, arg2...) 2863 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterDeletedWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterDeletedWithContext), varargs...) 2864 } 2865 2866 // WaitUntilReplicationGroupAvailable mocks base method 2867 func (m *MockElastiCacheAPI) WaitUntilReplicationGroupAvailable(arg0 *elasticache.DescribeReplicationGroupsInput) error { 2868 m.ctrl.T.Helper() 2869 ret := m.ctrl.Call(m, "WaitUntilReplicationGroupAvailable", arg0) 2870 ret0, _ := ret[0].(error) 2871 return ret0 2872 } 2873 2874 // WaitUntilReplicationGroupAvailable indicates an expected call of WaitUntilReplicationGroupAvailable 2875 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupAvailable(arg0 interface{}) *gomock.Call { 2876 mr.mock.ctrl.T.Helper() 2877 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupAvailable", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupAvailable), arg0) 2878 } 2879 2880 // WaitUntilReplicationGroupAvailableWithContext mocks base method 2881 func (m *MockElastiCacheAPI) WaitUntilReplicationGroupAvailableWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 ...request.WaiterOption) error { 2882 m.ctrl.T.Helper() 2883 varargs := []interface{}{arg0, arg1} 2884 for _, a := range arg2 { 2885 varargs = append(varargs, a) 2886 } 2887 ret := m.ctrl.Call(m, "WaitUntilReplicationGroupAvailableWithContext", varargs...) 2888 ret0, _ := ret[0].(error) 2889 return ret0 2890 } 2891 2892 // WaitUntilReplicationGroupAvailableWithContext indicates an expected call of WaitUntilReplicationGroupAvailableWithContext 2893 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2894 mr.mock.ctrl.T.Helper() 2895 varargs := append([]interface{}{arg0, arg1}, arg2...) 2896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupAvailableWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupAvailableWithContext), varargs...) 2897 } 2898 2899 // WaitUntilReplicationGroupDeleted mocks base method 2900 func (m *MockElastiCacheAPI) WaitUntilReplicationGroupDeleted(arg0 *elasticache.DescribeReplicationGroupsInput) error { 2901 m.ctrl.T.Helper() 2902 ret := m.ctrl.Call(m, "WaitUntilReplicationGroupDeleted", arg0) 2903 ret0, _ := ret[0].(error) 2904 return ret0 2905 } 2906 2907 // WaitUntilReplicationGroupDeleted indicates an expected call of WaitUntilReplicationGroupDeleted 2908 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupDeleted(arg0 interface{}) *gomock.Call { 2909 mr.mock.ctrl.T.Helper() 2910 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupDeleted", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupDeleted), arg0) 2911 } 2912 2913 // WaitUntilReplicationGroupDeletedWithContext mocks base method 2914 func (m *MockElastiCacheAPI) WaitUntilReplicationGroupDeletedWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 ...request.WaiterOption) error { 2915 m.ctrl.T.Helper() 2916 varargs := []interface{}{arg0, arg1} 2917 for _, a := range arg2 { 2918 varargs = append(varargs, a) 2919 } 2920 ret := m.ctrl.Call(m, "WaitUntilReplicationGroupDeletedWithContext", varargs...) 2921 ret0, _ := ret[0].(error) 2922 return ret0 2923 } 2924 2925 // WaitUntilReplicationGroupDeletedWithContext indicates an expected call of WaitUntilReplicationGroupDeletedWithContext 2926 func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2927 mr.mock.ctrl.T.Helper() 2928 varargs := append([]interface{}{arg0, arg1}, arg2...) 2929 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupDeletedWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupDeletedWithContext), varargs...) 2930 }