github.com/wata727/tflint@v0.12.2-0.20191013070026-96dd0d36f385/client/aws_ecs_mock.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: ../vendor/github.com/aws/aws-sdk-go/service/ecs/ecsiface/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 ecs "github.com/aws/aws-sdk-go/service/ecs" 11 gomock "github.com/golang/mock/gomock" 12 reflect "reflect" 13 ) 14 15 // MockECSAPI is a mock of ECSAPI interface 16 type MockECSAPI struct { 17 ctrl *gomock.Controller 18 recorder *MockECSAPIMockRecorder 19 } 20 21 // MockECSAPIMockRecorder is the mock recorder for MockECSAPI 22 type MockECSAPIMockRecorder struct { 23 mock *MockECSAPI 24 } 25 26 // NewMockECSAPI creates a new mock instance 27 func NewMockECSAPI(ctrl *gomock.Controller) *MockECSAPI { 28 mock := &MockECSAPI{ctrl: ctrl} 29 mock.recorder = &MockECSAPIMockRecorder{mock} 30 return mock 31 } 32 33 // EXPECT returns an object that allows the caller to indicate expected use 34 func (m *MockECSAPI) EXPECT() *MockECSAPIMockRecorder { 35 return m.recorder 36 } 37 38 // CreateCluster mocks base method 39 func (m *MockECSAPI) CreateCluster(arg0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) { 40 m.ctrl.T.Helper() 41 ret := m.ctrl.Call(m, "CreateCluster", arg0) 42 ret0, _ := ret[0].(*ecs.CreateClusterOutput) 43 ret1, _ := ret[1].(error) 44 return ret0, ret1 45 } 46 47 // CreateCluster indicates an expected call of CreateCluster 48 func (mr *MockECSAPIMockRecorder) CreateCluster(arg0 interface{}) *gomock.Call { 49 mr.mock.ctrl.T.Helper() 50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockECSAPI)(nil).CreateCluster), arg0) 51 } 52 53 // CreateClusterWithContext mocks base method 54 func (m *MockECSAPI) CreateClusterWithContext(arg0 aws.Context, arg1 *ecs.CreateClusterInput, arg2 ...request.Option) (*ecs.CreateClusterOutput, 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, "CreateClusterWithContext", varargs...) 61 ret0, _ := ret[0].(*ecs.CreateClusterOutput) 62 ret1, _ := ret[1].(error) 63 return ret0, ret1 64 } 65 66 // CreateClusterWithContext indicates an expected call of CreateClusterWithContext 67 func (mr *MockECSAPIMockRecorder) CreateClusterWithContext(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, "CreateClusterWithContext", reflect.TypeOf((*MockECSAPI)(nil).CreateClusterWithContext), varargs...) 71 } 72 73 // CreateClusterRequest mocks base method 74 func (m *MockECSAPI) CreateClusterRequest(arg0 *ecs.CreateClusterInput) (*request.Request, *ecs.CreateClusterOutput) { 75 m.ctrl.T.Helper() 76 ret := m.ctrl.Call(m, "CreateClusterRequest", arg0) 77 ret0, _ := ret[0].(*request.Request) 78 ret1, _ := ret[1].(*ecs.CreateClusterOutput) 79 return ret0, ret1 80 } 81 82 // CreateClusterRequest indicates an expected call of CreateClusterRequest 83 func (mr *MockECSAPIMockRecorder) CreateClusterRequest(arg0 interface{}) *gomock.Call { 84 mr.mock.ctrl.T.Helper() 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterRequest", reflect.TypeOf((*MockECSAPI)(nil).CreateClusterRequest), arg0) 86 } 87 88 // CreateService mocks base method 89 func (m *MockECSAPI) CreateService(arg0 *ecs.CreateServiceInput) (*ecs.CreateServiceOutput, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "CreateService", arg0) 92 ret0, _ := ret[0].(*ecs.CreateServiceOutput) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // CreateService indicates an expected call of CreateService 98 func (mr *MockECSAPIMockRecorder) CreateService(arg0 interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateService", reflect.TypeOf((*MockECSAPI)(nil).CreateService), arg0) 101 } 102 103 // CreateServiceWithContext mocks base method 104 func (m *MockECSAPI) CreateServiceWithContext(arg0 aws.Context, arg1 *ecs.CreateServiceInput, arg2 ...request.Option) (*ecs.CreateServiceOutput, 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, "CreateServiceWithContext", varargs...) 111 ret0, _ := ret[0].(*ecs.CreateServiceOutput) 112 ret1, _ := ret[1].(error) 113 return ret0, ret1 114 } 115 116 // CreateServiceWithContext indicates an expected call of CreateServiceWithContext 117 func (mr *MockECSAPIMockRecorder) CreateServiceWithContext(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, "CreateServiceWithContext", reflect.TypeOf((*MockECSAPI)(nil).CreateServiceWithContext), varargs...) 121 } 122 123 // CreateServiceRequest mocks base method 124 func (m *MockECSAPI) CreateServiceRequest(arg0 *ecs.CreateServiceInput) (*request.Request, *ecs.CreateServiceOutput) { 125 m.ctrl.T.Helper() 126 ret := m.ctrl.Call(m, "CreateServiceRequest", arg0) 127 ret0, _ := ret[0].(*request.Request) 128 ret1, _ := ret[1].(*ecs.CreateServiceOutput) 129 return ret0, ret1 130 } 131 132 // CreateServiceRequest indicates an expected call of CreateServiceRequest 133 func (mr *MockECSAPIMockRecorder) CreateServiceRequest(arg0 interface{}) *gomock.Call { 134 mr.mock.ctrl.T.Helper() 135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceRequest", reflect.TypeOf((*MockECSAPI)(nil).CreateServiceRequest), arg0) 136 } 137 138 // CreateTaskSet mocks base method 139 func (m *MockECSAPI) CreateTaskSet(arg0 *ecs.CreateTaskSetInput) (*ecs.CreateTaskSetOutput, error) { 140 m.ctrl.T.Helper() 141 ret := m.ctrl.Call(m, "CreateTaskSet", arg0) 142 ret0, _ := ret[0].(*ecs.CreateTaskSetOutput) 143 ret1, _ := ret[1].(error) 144 return ret0, ret1 145 } 146 147 // CreateTaskSet indicates an expected call of CreateTaskSet 148 func (mr *MockECSAPIMockRecorder) CreateTaskSet(arg0 interface{}) *gomock.Call { 149 mr.mock.ctrl.T.Helper() 150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTaskSet", reflect.TypeOf((*MockECSAPI)(nil).CreateTaskSet), arg0) 151 } 152 153 // CreateTaskSetWithContext mocks base method 154 func (m *MockECSAPI) CreateTaskSetWithContext(arg0 aws.Context, arg1 *ecs.CreateTaskSetInput, arg2 ...request.Option) (*ecs.CreateTaskSetOutput, 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, "CreateTaskSetWithContext", varargs...) 161 ret0, _ := ret[0].(*ecs.CreateTaskSetOutput) 162 ret1, _ := ret[1].(error) 163 return ret0, ret1 164 } 165 166 // CreateTaskSetWithContext indicates an expected call of CreateTaskSetWithContext 167 func (mr *MockECSAPIMockRecorder) CreateTaskSetWithContext(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, "CreateTaskSetWithContext", reflect.TypeOf((*MockECSAPI)(nil).CreateTaskSetWithContext), varargs...) 171 } 172 173 // CreateTaskSetRequest mocks base method 174 func (m *MockECSAPI) CreateTaskSetRequest(arg0 *ecs.CreateTaskSetInput) (*request.Request, *ecs.CreateTaskSetOutput) { 175 m.ctrl.T.Helper() 176 ret := m.ctrl.Call(m, "CreateTaskSetRequest", arg0) 177 ret0, _ := ret[0].(*request.Request) 178 ret1, _ := ret[1].(*ecs.CreateTaskSetOutput) 179 return ret0, ret1 180 } 181 182 // CreateTaskSetRequest indicates an expected call of CreateTaskSetRequest 183 func (mr *MockECSAPIMockRecorder) CreateTaskSetRequest(arg0 interface{}) *gomock.Call { 184 mr.mock.ctrl.T.Helper() 185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTaskSetRequest", reflect.TypeOf((*MockECSAPI)(nil).CreateTaskSetRequest), arg0) 186 } 187 188 // DeleteAccountSetting mocks base method 189 func (m *MockECSAPI) DeleteAccountSetting(arg0 *ecs.DeleteAccountSettingInput) (*ecs.DeleteAccountSettingOutput, error) { 190 m.ctrl.T.Helper() 191 ret := m.ctrl.Call(m, "DeleteAccountSetting", arg0) 192 ret0, _ := ret[0].(*ecs.DeleteAccountSettingOutput) 193 ret1, _ := ret[1].(error) 194 return ret0, ret1 195 } 196 197 // DeleteAccountSetting indicates an expected call of DeleteAccountSetting 198 func (mr *MockECSAPIMockRecorder) DeleteAccountSetting(arg0 interface{}) *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountSetting", reflect.TypeOf((*MockECSAPI)(nil).DeleteAccountSetting), arg0) 201 } 202 203 // DeleteAccountSettingWithContext mocks base method 204 func (m *MockECSAPI) DeleteAccountSettingWithContext(arg0 aws.Context, arg1 *ecs.DeleteAccountSettingInput, arg2 ...request.Option) (*ecs.DeleteAccountSettingOutput, 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, "DeleteAccountSettingWithContext", varargs...) 211 ret0, _ := ret[0].(*ecs.DeleteAccountSettingOutput) 212 ret1, _ := ret[1].(error) 213 return ret0, ret1 214 } 215 216 // DeleteAccountSettingWithContext indicates an expected call of DeleteAccountSettingWithContext 217 func (mr *MockECSAPIMockRecorder) DeleteAccountSettingWithContext(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, "DeleteAccountSettingWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteAccountSettingWithContext), varargs...) 221 } 222 223 // DeleteAccountSettingRequest mocks base method 224 func (m *MockECSAPI) DeleteAccountSettingRequest(arg0 *ecs.DeleteAccountSettingInput) (*request.Request, *ecs.DeleteAccountSettingOutput) { 225 m.ctrl.T.Helper() 226 ret := m.ctrl.Call(m, "DeleteAccountSettingRequest", arg0) 227 ret0, _ := ret[0].(*request.Request) 228 ret1, _ := ret[1].(*ecs.DeleteAccountSettingOutput) 229 return ret0, ret1 230 } 231 232 // DeleteAccountSettingRequest indicates an expected call of DeleteAccountSettingRequest 233 func (mr *MockECSAPIMockRecorder) DeleteAccountSettingRequest(arg0 interface{}) *gomock.Call { 234 mr.mock.ctrl.T.Helper() 235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountSettingRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteAccountSettingRequest), arg0) 236 } 237 238 // DeleteAttributes mocks base method 239 func (m *MockECSAPI) DeleteAttributes(arg0 *ecs.DeleteAttributesInput) (*ecs.DeleteAttributesOutput, error) { 240 m.ctrl.T.Helper() 241 ret := m.ctrl.Call(m, "DeleteAttributes", arg0) 242 ret0, _ := ret[0].(*ecs.DeleteAttributesOutput) 243 ret1, _ := ret[1].(error) 244 return ret0, ret1 245 } 246 247 // DeleteAttributes indicates an expected call of DeleteAttributes 248 func (mr *MockECSAPIMockRecorder) DeleteAttributes(arg0 interface{}) *gomock.Call { 249 mr.mock.ctrl.T.Helper() 250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttributes", reflect.TypeOf((*MockECSAPI)(nil).DeleteAttributes), arg0) 251 } 252 253 // DeleteAttributesWithContext mocks base method 254 func (m *MockECSAPI) DeleteAttributesWithContext(arg0 aws.Context, arg1 *ecs.DeleteAttributesInput, arg2 ...request.Option) (*ecs.DeleteAttributesOutput, 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, "DeleteAttributesWithContext", varargs...) 261 ret0, _ := ret[0].(*ecs.DeleteAttributesOutput) 262 ret1, _ := ret[1].(error) 263 return ret0, ret1 264 } 265 266 // DeleteAttributesWithContext indicates an expected call of DeleteAttributesWithContext 267 func (mr *MockECSAPIMockRecorder) DeleteAttributesWithContext(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, "DeleteAttributesWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteAttributesWithContext), varargs...) 271 } 272 273 // DeleteAttributesRequest mocks base method 274 func (m *MockECSAPI) DeleteAttributesRequest(arg0 *ecs.DeleteAttributesInput) (*request.Request, *ecs.DeleteAttributesOutput) { 275 m.ctrl.T.Helper() 276 ret := m.ctrl.Call(m, "DeleteAttributesRequest", arg0) 277 ret0, _ := ret[0].(*request.Request) 278 ret1, _ := ret[1].(*ecs.DeleteAttributesOutput) 279 return ret0, ret1 280 } 281 282 // DeleteAttributesRequest indicates an expected call of DeleteAttributesRequest 283 func (mr *MockECSAPIMockRecorder) DeleteAttributesRequest(arg0 interface{}) *gomock.Call { 284 mr.mock.ctrl.T.Helper() 285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttributesRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteAttributesRequest), arg0) 286 } 287 288 // DeleteCluster mocks base method 289 func (m *MockECSAPI) DeleteCluster(arg0 *ecs.DeleteClusterInput) (*ecs.DeleteClusterOutput, error) { 290 m.ctrl.T.Helper() 291 ret := m.ctrl.Call(m, "DeleteCluster", arg0) 292 ret0, _ := ret[0].(*ecs.DeleteClusterOutput) 293 ret1, _ := ret[1].(error) 294 return ret0, ret1 295 } 296 297 // DeleteCluster indicates an expected call of DeleteCluster 298 func (mr *MockECSAPIMockRecorder) DeleteCluster(arg0 interface{}) *gomock.Call { 299 mr.mock.ctrl.T.Helper() 300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCluster", reflect.TypeOf((*MockECSAPI)(nil).DeleteCluster), arg0) 301 } 302 303 // DeleteClusterWithContext mocks base method 304 func (m *MockECSAPI) DeleteClusterWithContext(arg0 aws.Context, arg1 *ecs.DeleteClusterInput, arg2 ...request.Option) (*ecs.DeleteClusterOutput, 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, "DeleteClusterWithContext", varargs...) 311 ret0, _ := ret[0].(*ecs.DeleteClusterOutput) 312 ret1, _ := ret[1].(error) 313 return ret0, ret1 314 } 315 316 // DeleteClusterWithContext indicates an expected call of DeleteClusterWithContext 317 func (mr *MockECSAPIMockRecorder) DeleteClusterWithContext(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, "DeleteClusterWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteClusterWithContext), varargs...) 321 } 322 323 // DeleteClusterRequest mocks base method 324 func (m *MockECSAPI) DeleteClusterRequest(arg0 *ecs.DeleteClusterInput) (*request.Request, *ecs.DeleteClusterOutput) { 325 m.ctrl.T.Helper() 326 ret := m.ctrl.Call(m, "DeleteClusterRequest", arg0) 327 ret0, _ := ret[0].(*request.Request) 328 ret1, _ := ret[1].(*ecs.DeleteClusterOutput) 329 return ret0, ret1 330 } 331 332 // DeleteClusterRequest indicates an expected call of DeleteClusterRequest 333 func (mr *MockECSAPIMockRecorder) DeleteClusterRequest(arg0 interface{}) *gomock.Call { 334 mr.mock.ctrl.T.Helper() 335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteClusterRequest), arg0) 336 } 337 338 // DeleteService mocks base method 339 func (m *MockECSAPI) DeleteService(arg0 *ecs.DeleteServiceInput) (*ecs.DeleteServiceOutput, error) { 340 m.ctrl.T.Helper() 341 ret := m.ctrl.Call(m, "DeleteService", arg0) 342 ret0, _ := ret[0].(*ecs.DeleteServiceOutput) 343 ret1, _ := ret[1].(error) 344 return ret0, ret1 345 } 346 347 // DeleteService indicates an expected call of DeleteService 348 func (mr *MockECSAPIMockRecorder) DeleteService(arg0 interface{}) *gomock.Call { 349 mr.mock.ctrl.T.Helper() 350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockECSAPI)(nil).DeleteService), arg0) 351 } 352 353 // DeleteServiceWithContext mocks base method 354 func (m *MockECSAPI) DeleteServiceWithContext(arg0 aws.Context, arg1 *ecs.DeleteServiceInput, arg2 ...request.Option) (*ecs.DeleteServiceOutput, 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, "DeleteServiceWithContext", varargs...) 361 ret0, _ := ret[0].(*ecs.DeleteServiceOutput) 362 ret1, _ := ret[1].(error) 363 return ret0, ret1 364 } 365 366 // DeleteServiceWithContext indicates an expected call of DeleteServiceWithContext 367 func (mr *MockECSAPIMockRecorder) DeleteServiceWithContext(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, "DeleteServiceWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteServiceWithContext), varargs...) 371 } 372 373 // DeleteServiceRequest mocks base method 374 func (m *MockECSAPI) DeleteServiceRequest(arg0 *ecs.DeleteServiceInput) (*request.Request, *ecs.DeleteServiceOutput) { 375 m.ctrl.T.Helper() 376 ret := m.ctrl.Call(m, "DeleteServiceRequest", arg0) 377 ret0, _ := ret[0].(*request.Request) 378 ret1, _ := ret[1].(*ecs.DeleteServiceOutput) 379 return ret0, ret1 380 } 381 382 // DeleteServiceRequest indicates an expected call of DeleteServiceRequest 383 func (mr *MockECSAPIMockRecorder) DeleteServiceRequest(arg0 interface{}) *gomock.Call { 384 mr.mock.ctrl.T.Helper() 385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteServiceRequest), arg0) 386 } 387 388 // DeleteTaskSet mocks base method 389 func (m *MockECSAPI) DeleteTaskSet(arg0 *ecs.DeleteTaskSetInput) (*ecs.DeleteTaskSetOutput, error) { 390 m.ctrl.T.Helper() 391 ret := m.ctrl.Call(m, "DeleteTaskSet", arg0) 392 ret0, _ := ret[0].(*ecs.DeleteTaskSetOutput) 393 ret1, _ := ret[1].(error) 394 return ret0, ret1 395 } 396 397 // DeleteTaskSet indicates an expected call of DeleteTaskSet 398 func (mr *MockECSAPIMockRecorder) DeleteTaskSet(arg0 interface{}) *gomock.Call { 399 mr.mock.ctrl.T.Helper() 400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskSet", reflect.TypeOf((*MockECSAPI)(nil).DeleteTaskSet), arg0) 401 } 402 403 // DeleteTaskSetWithContext mocks base method 404 func (m *MockECSAPI) DeleteTaskSetWithContext(arg0 aws.Context, arg1 *ecs.DeleteTaskSetInput, arg2 ...request.Option) (*ecs.DeleteTaskSetOutput, 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, "DeleteTaskSetWithContext", varargs...) 411 ret0, _ := ret[0].(*ecs.DeleteTaskSetOutput) 412 ret1, _ := ret[1].(error) 413 return ret0, ret1 414 } 415 416 // DeleteTaskSetWithContext indicates an expected call of DeleteTaskSetWithContext 417 func (mr *MockECSAPIMockRecorder) DeleteTaskSetWithContext(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, "DeleteTaskSetWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeleteTaskSetWithContext), varargs...) 421 } 422 423 // DeleteTaskSetRequest mocks base method 424 func (m *MockECSAPI) DeleteTaskSetRequest(arg0 *ecs.DeleteTaskSetInput) (*request.Request, *ecs.DeleteTaskSetOutput) { 425 m.ctrl.T.Helper() 426 ret := m.ctrl.Call(m, "DeleteTaskSetRequest", arg0) 427 ret0, _ := ret[0].(*request.Request) 428 ret1, _ := ret[1].(*ecs.DeleteTaskSetOutput) 429 return ret0, ret1 430 } 431 432 // DeleteTaskSetRequest indicates an expected call of DeleteTaskSetRequest 433 func (mr *MockECSAPIMockRecorder) DeleteTaskSetRequest(arg0 interface{}) *gomock.Call { 434 mr.mock.ctrl.T.Helper() 435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskSetRequest", reflect.TypeOf((*MockECSAPI)(nil).DeleteTaskSetRequest), arg0) 436 } 437 438 // DeregisterContainerInstance mocks base method 439 func (m *MockECSAPI) DeregisterContainerInstance(arg0 *ecs.DeregisterContainerInstanceInput) (*ecs.DeregisterContainerInstanceOutput, error) { 440 m.ctrl.T.Helper() 441 ret := m.ctrl.Call(m, "DeregisterContainerInstance", arg0) 442 ret0, _ := ret[0].(*ecs.DeregisterContainerInstanceOutput) 443 ret1, _ := ret[1].(error) 444 return ret0, ret1 445 } 446 447 // DeregisterContainerInstance indicates an expected call of DeregisterContainerInstance 448 func (mr *MockECSAPIMockRecorder) DeregisterContainerInstance(arg0 interface{}) *gomock.Call { 449 mr.mock.ctrl.T.Helper() 450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterContainerInstance", reflect.TypeOf((*MockECSAPI)(nil).DeregisterContainerInstance), arg0) 451 } 452 453 // DeregisterContainerInstanceWithContext mocks base method 454 func (m *MockECSAPI) DeregisterContainerInstanceWithContext(arg0 aws.Context, arg1 *ecs.DeregisterContainerInstanceInput, arg2 ...request.Option) (*ecs.DeregisterContainerInstanceOutput, 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, "DeregisterContainerInstanceWithContext", varargs...) 461 ret0, _ := ret[0].(*ecs.DeregisterContainerInstanceOutput) 462 ret1, _ := ret[1].(error) 463 return ret0, ret1 464 } 465 466 // DeregisterContainerInstanceWithContext indicates an expected call of DeregisterContainerInstanceWithContext 467 func (mr *MockECSAPIMockRecorder) DeregisterContainerInstanceWithContext(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, "DeregisterContainerInstanceWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeregisterContainerInstanceWithContext), varargs...) 471 } 472 473 // DeregisterContainerInstanceRequest mocks base method 474 func (m *MockECSAPI) DeregisterContainerInstanceRequest(arg0 *ecs.DeregisterContainerInstanceInput) (*request.Request, *ecs.DeregisterContainerInstanceOutput) { 475 m.ctrl.T.Helper() 476 ret := m.ctrl.Call(m, "DeregisterContainerInstanceRequest", arg0) 477 ret0, _ := ret[0].(*request.Request) 478 ret1, _ := ret[1].(*ecs.DeregisterContainerInstanceOutput) 479 return ret0, ret1 480 } 481 482 // DeregisterContainerInstanceRequest indicates an expected call of DeregisterContainerInstanceRequest 483 func (mr *MockECSAPIMockRecorder) DeregisterContainerInstanceRequest(arg0 interface{}) *gomock.Call { 484 mr.mock.ctrl.T.Helper() 485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterContainerInstanceRequest", reflect.TypeOf((*MockECSAPI)(nil).DeregisterContainerInstanceRequest), arg0) 486 } 487 488 // DeregisterTaskDefinition mocks base method 489 func (m *MockECSAPI) DeregisterTaskDefinition(arg0 *ecs.DeregisterTaskDefinitionInput) (*ecs.DeregisterTaskDefinitionOutput, error) { 490 m.ctrl.T.Helper() 491 ret := m.ctrl.Call(m, "DeregisterTaskDefinition", arg0) 492 ret0, _ := ret[0].(*ecs.DeregisterTaskDefinitionOutput) 493 ret1, _ := ret[1].(error) 494 return ret0, ret1 495 } 496 497 // DeregisterTaskDefinition indicates an expected call of DeregisterTaskDefinition 498 func (mr *MockECSAPIMockRecorder) DeregisterTaskDefinition(arg0 interface{}) *gomock.Call { 499 mr.mock.ctrl.T.Helper() 500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskDefinition", reflect.TypeOf((*MockECSAPI)(nil).DeregisterTaskDefinition), arg0) 501 } 502 503 // DeregisterTaskDefinitionWithContext mocks base method 504 func (m *MockECSAPI) DeregisterTaskDefinitionWithContext(arg0 aws.Context, arg1 *ecs.DeregisterTaskDefinitionInput, arg2 ...request.Option) (*ecs.DeregisterTaskDefinitionOutput, 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, "DeregisterTaskDefinitionWithContext", varargs...) 511 ret0, _ := ret[0].(*ecs.DeregisterTaskDefinitionOutput) 512 ret1, _ := ret[1].(error) 513 return ret0, ret1 514 } 515 516 // DeregisterTaskDefinitionWithContext indicates an expected call of DeregisterTaskDefinitionWithContext 517 func (mr *MockECSAPIMockRecorder) DeregisterTaskDefinitionWithContext(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, "DeregisterTaskDefinitionWithContext", reflect.TypeOf((*MockECSAPI)(nil).DeregisterTaskDefinitionWithContext), varargs...) 521 } 522 523 // DeregisterTaskDefinitionRequest mocks base method 524 func (m *MockECSAPI) DeregisterTaskDefinitionRequest(arg0 *ecs.DeregisterTaskDefinitionInput) (*request.Request, *ecs.DeregisterTaskDefinitionOutput) { 525 m.ctrl.T.Helper() 526 ret := m.ctrl.Call(m, "DeregisterTaskDefinitionRequest", arg0) 527 ret0, _ := ret[0].(*request.Request) 528 ret1, _ := ret[1].(*ecs.DeregisterTaskDefinitionOutput) 529 return ret0, ret1 530 } 531 532 // DeregisterTaskDefinitionRequest indicates an expected call of DeregisterTaskDefinitionRequest 533 func (mr *MockECSAPIMockRecorder) DeregisterTaskDefinitionRequest(arg0 interface{}) *gomock.Call { 534 mr.mock.ctrl.T.Helper() 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskDefinitionRequest", reflect.TypeOf((*MockECSAPI)(nil).DeregisterTaskDefinitionRequest), arg0) 536 } 537 538 // DescribeClusters mocks base method 539 func (m *MockECSAPI) DescribeClusters(arg0 *ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error) { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "DescribeClusters", arg0) 542 ret0, _ := ret[0].(*ecs.DescribeClustersOutput) 543 ret1, _ := ret[1].(error) 544 return ret0, ret1 545 } 546 547 // DescribeClusters indicates an expected call of DescribeClusters 548 func (mr *MockECSAPIMockRecorder) DescribeClusters(arg0 interface{}) *gomock.Call { 549 mr.mock.ctrl.T.Helper() 550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClusters", reflect.TypeOf((*MockECSAPI)(nil).DescribeClusters), arg0) 551 } 552 553 // DescribeClustersWithContext mocks base method 554 func (m *MockECSAPI) DescribeClustersWithContext(arg0 aws.Context, arg1 *ecs.DescribeClustersInput, arg2 ...request.Option) (*ecs.DescribeClustersOutput, 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, "DescribeClustersWithContext", varargs...) 561 ret0, _ := ret[0].(*ecs.DescribeClustersOutput) 562 ret1, _ := ret[1].(error) 563 return ret0, ret1 564 } 565 566 // DescribeClustersWithContext indicates an expected call of DescribeClustersWithContext 567 func (mr *MockECSAPIMockRecorder) DescribeClustersWithContext(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, "DescribeClustersWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeClustersWithContext), varargs...) 571 } 572 573 // DescribeClustersRequest mocks base method 574 func (m *MockECSAPI) DescribeClustersRequest(arg0 *ecs.DescribeClustersInput) (*request.Request, *ecs.DescribeClustersOutput) { 575 m.ctrl.T.Helper() 576 ret := m.ctrl.Call(m, "DescribeClustersRequest", arg0) 577 ret0, _ := ret[0].(*request.Request) 578 ret1, _ := ret[1].(*ecs.DescribeClustersOutput) 579 return ret0, ret1 580 } 581 582 // DescribeClustersRequest indicates an expected call of DescribeClustersRequest 583 func (mr *MockECSAPIMockRecorder) DescribeClustersRequest(arg0 interface{}) *gomock.Call { 584 mr.mock.ctrl.T.Helper() 585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClustersRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeClustersRequest), arg0) 586 } 587 588 // DescribeContainerInstances mocks base method 589 func (m *MockECSAPI) DescribeContainerInstances(arg0 *ecs.DescribeContainerInstancesInput) (*ecs.DescribeContainerInstancesOutput, error) { 590 m.ctrl.T.Helper() 591 ret := m.ctrl.Call(m, "DescribeContainerInstances", arg0) 592 ret0, _ := ret[0].(*ecs.DescribeContainerInstancesOutput) 593 ret1, _ := ret[1].(error) 594 return ret0, ret1 595 } 596 597 // DescribeContainerInstances indicates an expected call of DescribeContainerInstances 598 func (mr *MockECSAPIMockRecorder) DescribeContainerInstances(arg0 interface{}) *gomock.Call { 599 mr.mock.ctrl.T.Helper() 600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerInstances", reflect.TypeOf((*MockECSAPI)(nil).DescribeContainerInstances), arg0) 601 } 602 603 // DescribeContainerInstancesWithContext mocks base method 604 func (m *MockECSAPI) DescribeContainerInstancesWithContext(arg0 aws.Context, arg1 *ecs.DescribeContainerInstancesInput, arg2 ...request.Option) (*ecs.DescribeContainerInstancesOutput, 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, "DescribeContainerInstancesWithContext", varargs...) 611 ret0, _ := ret[0].(*ecs.DescribeContainerInstancesOutput) 612 ret1, _ := ret[1].(error) 613 return ret0, ret1 614 } 615 616 // DescribeContainerInstancesWithContext indicates an expected call of DescribeContainerInstancesWithContext 617 func (mr *MockECSAPIMockRecorder) DescribeContainerInstancesWithContext(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, "DescribeContainerInstancesWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeContainerInstancesWithContext), varargs...) 621 } 622 623 // DescribeContainerInstancesRequest mocks base method 624 func (m *MockECSAPI) DescribeContainerInstancesRequest(arg0 *ecs.DescribeContainerInstancesInput) (*request.Request, *ecs.DescribeContainerInstancesOutput) { 625 m.ctrl.T.Helper() 626 ret := m.ctrl.Call(m, "DescribeContainerInstancesRequest", arg0) 627 ret0, _ := ret[0].(*request.Request) 628 ret1, _ := ret[1].(*ecs.DescribeContainerInstancesOutput) 629 return ret0, ret1 630 } 631 632 // DescribeContainerInstancesRequest indicates an expected call of DescribeContainerInstancesRequest 633 func (mr *MockECSAPIMockRecorder) DescribeContainerInstancesRequest(arg0 interface{}) *gomock.Call { 634 mr.mock.ctrl.T.Helper() 635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerInstancesRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeContainerInstancesRequest), arg0) 636 } 637 638 // DescribeServices mocks base method 639 func (m *MockECSAPI) DescribeServices(arg0 *ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error) { 640 m.ctrl.T.Helper() 641 ret := m.ctrl.Call(m, "DescribeServices", arg0) 642 ret0, _ := ret[0].(*ecs.DescribeServicesOutput) 643 ret1, _ := ret[1].(error) 644 return ret0, ret1 645 } 646 647 // DescribeServices indicates an expected call of DescribeServices 648 func (mr *MockECSAPIMockRecorder) DescribeServices(arg0 interface{}) *gomock.Call { 649 mr.mock.ctrl.T.Helper() 650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServices", reflect.TypeOf((*MockECSAPI)(nil).DescribeServices), arg0) 651 } 652 653 // DescribeServicesWithContext mocks base method 654 func (m *MockECSAPI) DescribeServicesWithContext(arg0 aws.Context, arg1 *ecs.DescribeServicesInput, arg2 ...request.Option) (*ecs.DescribeServicesOutput, 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, "DescribeServicesWithContext", varargs...) 661 ret0, _ := ret[0].(*ecs.DescribeServicesOutput) 662 ret1, _ := ret[1].(error) 663 return ret0, ret1 664 } 665 666 // DescribeServicesWithContext indicates an expected call of DescribeServicesWithContext 667 func (mr *MockECSAPIMockRecorder) DescribeServicesWithContext(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, "DescribeServicesWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeServicesWithContext), varargs...) 671 } 672 673 // DescribeServicesRequest mocks base method 674 func (m *MockECSAPI) DescribeServicesRequest(arg0 *ecs.DescribeServicesInput) (*request.Request, *ecs.DescribeServicesOutput) { 675 m.ctrl.T.Helper() 676 ret := m.ctrl.Call(m, "DescribeServicesRequest", arg0) 677 ret0, _ := ret[0].(*request.Request) 678 ret1, _ := ret[1].(*ecs.DescribeServicesOutput) 679 return ret0, ret1 680 } 681 682 // DescribeServicesRequest indicates an expected call of DescribeServicesRequest 683 func (mr *MockECSAPIMockRecorder) DescribeServicesRequest(arg0 interface{}) *gomock.Call { 684 mr.mock.ctrl.T.Helper() 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServicesRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeServicesRequest), arg0) 686 } 687 688 // DescribeTaskDefinition mocks base method 689 func (m *MockECSAPI) DescribeTaskDefinition(arg0 *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "DescribeTaskDefinition", arg0) 692 ret0, _ := ret[0].(*ecs.DescribeTaskDefinitionOutput) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // DescribeTaskDefinition indicates an expected call of DescribeTaskDefinition 698 func (mr *MockECSAPIMockRecorder) DescribeTaskDefinition(arg0 interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskDefinition", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskDefinition), arg0) 701 } 702 703 // DescribeTaskDefinitionWithContext mocks base method 704 func (m *MockECSAPI) DescribeTaskDefinitionWithContext(arg0 aws.Context, arg1 *ecs.DescribeTaskDefinitionInput, arg2 ...request.Option) (*ecs.DescribeTaskDefinitionOutput, 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, "DescribeTaskDefinitionWithContext", varargs...) 711 ret0, _ := ret[0].(*ecs.DescribeTaskDefinitionOutput) 712 ret1, _ := ret[1].(error) 713 return ret0, ret1 714 } 715 716 // DescribeTaskDefinitionWithContext indicates an expected call of DescribeTaskDefinitionWithContext 717 func (mr *MockECSAPIMockRecorder) DescribeTaskDefinitionWithContext(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, "DescribeTaskDefinitionWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskDefinitionWithContext), varargs...) 721 } 722 723 // DescribeTaskDefinitionRequest mocks base method 724 func (m *MockECSAPI) DescribeTaskDefinitionRequest(arg0 *ecs.DescribeTaskDefinitionInput) (*request.Request, *ecs.DescribeTaskDefinitionOutput) { 725 m.ctrl.T.Helper() 726 ret := m.ctrl.Call(m, "DescribeTaskDefinitionRequest", arg0) 727 ret0, _ := ret[0].(*request.Request) 728 ret1, _ := ret[1].(*ecs.DescribeTaskDefinitionOutput) 729 return ret0, ret1 730 } 731 732 // DescribeTaskDefinitionRequest indicates an expected call of DescribeTaskDefinitionRequest 733 func (mr *MockECSAPIMockRecorder) DescribeTaskDefinitionRequest(arg0 interface{}) *gomock.Call { 734 mr.mock.ctrl.T.Helper() 735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskDefinitionRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskDefinitionRequest), arg0) 736 } 737 738 // DescribeTaskSets mocks base method 739 func (m *MockECSAPI) DescribeTaskSets(arg0 *ecs.DescribeTaskSetsInput) (*ecs.DescribeTaskSetsOutput, error) { 740 m.ctrl.T.Helper() 741 ret := m.ctrl.Call(m, "DescribeTaskSets", arg0) 742 ret0, _ := ret[0].(*ecs.DescribeTaskSetsOutput) 743 ret1, _ := ret[1].(error) 744 return ret0, ret1 745 } 746 747 // DescribeTaskSets indicates an expected call of DescribeTaskSets 748 func (mr *MockECSAPIMockRecorder) DescribeTaskSets(arg0 interface{}) *gomock.Call { 749 mr.mock.ctrl.T.Helper() 750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskSets", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskSets), arg0) 751 } 752 753 // DescribeTaskSetsWithContext mocks base method 754 func (m *MockECSAPI) DescribeTaskSetsWithContext(arg0 aws.Context, arg1 *ecs.DescribeTaskSetsInput, arg2 ...request.Option) (*ecs.DescribeTaskSetsOutput, 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, "DescribeTaskSetsWithContext", varargs...) 761 ret0, _ := ret[0].(*ecs.DescribeTaskSetsOutput) 762 ret1, _ := ret[1].(error) 763 return ret0, ret1 764 } 765 766 // DescribeTaskSetsWithContext indicates an expected call of DescribeTaskSetsWithContext 767 func (mr *MockECSAPIMockRecorder) DescribeTaskSetsWithContext(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, "DescribeTaskSetsWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskSetsWithContext), varargs...) 771 } 772 773 // DescribeTaskSetsRequest mocks base method 774 func (m *MockECSAPI) DescribeTaskSetsRequest(arg0 *ecs.DescribeTaskSetsInput) (*request.Request, *ecs.DescribeTaskSetsOutput) { 775 m.ctrl.T.Helper() 776 ret := m.ctrl.Call(m, "DescribeTaskSetsRequest", arg0) 777 ret0, _ := ret[0].(*request.Request) 778 ret1, _ := ret[1].(*ecs.DescribeTaskSetsOutput) 779 return ret0, ret1 780 } 781 782 // DescribeTaskSetsRequest indicates an expected call of DescribeTaskSetsRequest 783 func (mr *MockECSAPIMockRecorder) DescribeTaskSetsRequest(arg0 interface{}) *gomock.Call { 784 mr.mock.ctrl.T.Helper() 785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskSetsRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeTaskSetsRequest), arg0) 786 } 787 788 // DescribeTasks mocks base method 789 func (m *MockECSAPI) DescribeTasks(arg0 *ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error) { 790 m.ctrl.T.Helper() 791 ret := m.ctrl.Call(m, "DescribeTasks", arg0) 792 ret0, _ := ret[0].(*ecs.DescribeTasksOutput) 793 ret1, _ := ret[1].(error) 794 return ret0, ret1 795 } 796 797 // DescribeTasks indicates an expected call of DescribeTasks 798 func (mr *MockECSAPIMockRecorder) DescribeTasks(arg0 interface{}) *gomock.Call { 799 mr.mock.ctrl.T.Helper() 800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTasks", reflect.TypeOf((*MockECSAPI)(nil).DescribeTasks), arg0) 801 } 802 803 // DescribeTasksWithContext mocks base method 804 func (m *MockECSAPI) DescribeTasksWithContext(arg0 aws.Context, arg1 *ecs.DescribeTasksInput, arg2 ...request.Option) (*ecs.DescribeTasksOutput, 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, "DescribeTasksWithContext", varargs...) 811 ret0, _ := ret[0].(*ecs.DescribeTasksOutput) 812 ret1, _ := ret[1].(error) 813 return ret0, ret1 814 } 815 816 // DescribeTasksWithContext indicates an expected call of DescribeTasksWithContext 817 func (mr *MockECSAPIMockRecorder) DescribeTasksWithContext(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, "DescribeTasksWithContext", reflect.TypeOf((*MockECSAPI)(nil).DescribeTasksWithContext), varargs...) 821 } 822 823 // DescribeTasksRequest mocks base method 824 func (m *MockECSAPI) DescribeTasksRequest(arg0 *ecs.DescribeTasksInput) (*request.Request, *ecs.DescribeTasksOutput) { 825 m.ctrl.T.Helper() 826 ret := m.ctrl.Call(m, "DescribeTasksRequest", arg0) 827 ret0, _ := ret[0].(*request.Request) 828 ret1, _ := ret[1].(*ecs.DescribeTasksOutput) 829 return ret0, ret1 830 } 831 832 // DescribeTasksRequest indicates an expected call of DescribeTasksRequest 833 func (mr *MockECSAPIMockRecorder) DescribeTasksRequest(arg0 interface{}) *gomock.Call { 834 mr.mock.ctrl.T.Helper() 835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTasksRequest", reflect.TypeOf((*MockECSAPI)(nil).DescribeTasksRequest), arg0) 836 } 837 838 // DiscoverPollEndpoint mocks base method 839 func (m *MockECSAPI) DiscoverPollEndpoint(arg0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) { 840 m.ctrl.T.Helper() 841 ret := m.ctrl.Call(m, "DiscoverPollEndpoint", arg0) 842 ret0, _ := ret[0].(*ecs.DiscoverPollEndpointOutput) 843 ret1, _ := ret[1].(error) 844 return ret0, ret1 845 } 846 847 // DiscoverPollEndpoint indicates an expected call of DiscoverPollEndpoint 848 func (mr *MockECSAPIMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { 849 mr.mock.ctrl.T.Helper() 850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpoint), arg0) 851 } 852 853 // DiscoverPollEndpointWithContext mocks base method 854 func (m *MockECSAPI) DiscoverPollEndpointWithContext(arg0 aws.Context, arg1 *ecs.DiscoverPollEndpointInput, arg2 ...request.Option) (*ecs.DiscoverPollEndpointOutput, 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, "DiscoverPollEndpointWithContext", varargs...) 861 ret0, _ := ret[0].(*ecs.DiscoverPollEndpointOutput) 862 ret1, _ := ret[1].(error) 863 return ret0, ret1 864 } 865 866 // DiscoverPollEndpointWithContext indicates an expected call of DiscoverPollEndpointWithContext 867 func (mr *MockECSAPIMockRecorder) DiscoverPollEndpointWithContext(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, "DiscoverPollEndpointWithContext", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpointWithContext), varargs...) 871 } 872 873 // DiscoverPollEndpointRequest mocks base method 874 func (m *MockECSAPI) DiscoverPollEndpointRequest(arg0 *ecs.DiscoverPollEndpointInput) (*request.Request, *ecs.DiscoverPollEndpointOutput) { 875 m.ctrl.T.Helper() 876 ret := m.ctrl.Call(m, "DiscoverPollEndpointRequest", arg0) 877 ret0, _ := ret[0].(*request.Request) 878 ret1, _ := ret[1].(*ecs.DiscoverPollEndpointOutput) 879 return ret0, ret1 880 } 881 882 // DiscoverPollEndpointRequest indicates an expected call of DiscoverPollEndpointRequest 883 func (mr *MockECSAPIMockRecorder) DiscoverPollEndpointRequest(arg0 interface{}) *gomock.Call { 884 mr.mock.ctrl.T.Helper() 885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpointRequest", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpointRequest), arg0) 886 } 887 888 // ListAccountSettings mocks base method 889 func (m *MockECSAPI) ListAccountSettings(arg0 *ecs.ListAccountSettingsInput) (*ecs.ListAccountSettingsOutput, error) { 890 m.ctrl.T.Helper() 891 ret := m.ctrl.Call(m, "ListAccountSettings", arg0) 892 ret0, _ := ret[0].(*ecs.ListAccountSettingsOutput) 893 ret1, _ := ret[1].(error) 894 return ret0, ret1 895 } 896 897 // ListAccountSettings indicates an expected call of ListAccountSettings 898 func (mr *MockECSAPIMockRecorder) ListAccountSettings(arg0 interface{}) *gomock.Call { 899 mr.mock.ctrl.T.Helper() 900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountSettings", reflect.TypeOf((*MockECSAPI)(nil).ListAccountSettings), arg0) 901 } 902 903 // ListAccountSettingsWithContext mocks base method 904 func (m *MockECSAPI) ListAccountSettingsWithContext(arg0 aws.Context, arg1 *ecs.ListAccountSettingsInput, arg2 ...request.Option) (*ecs.ListAccountSettingsOutput, 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, "ListAccountSettingsWithContext", varargs...) 911 ret0, _ := ret[0].(*ecs.ListAccountSettingsOutput) 912 ret1, _ := ret[1].(error) 913 return ret0, ret1 914 } 915 916 // ListAccountSettingsWithContext indicates an expected call of ListAccountSettingsWithContext 917 func (mr *MockECSAPIMockRecorder) ListAccountSettingsWithContext(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, "ListAccountSettingsWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListAccountSettingsWithContext), varargs...) 921 } 922 923 // ListAccountSettingsRequest mocks base method 924 func (m *MockECSAPI) ListAccountSettingsRequest(arg0 *ecs.ListAccountSettingsInput) (*request.Request, *ecs.ListAccountSettingsOutput) { 925 m.ctrl.T.Helper() 926 ret := m.ctrl.Call(m, "ListAccountSettingsRequest", arg0) 927 ret0, _ := ret[0].(*request.Request) 928 ret1, _ := ret[1].(*ecs.ListAccountSettingsOutput) 929 return ret0, ret1 930 } 931 932 // ListAccountSettingsRequest indicates an expected call of ListAccountSettingsRequest 933 func (mr *MockECSAPIMockRecorder) ListAccountSettingsRequest(arg0 interface{}) *gomock.Call { 934 mr.mock.ctrl.T.Helper() 935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountSettingsRequest", reflect.TypeOf((*MockECSAPI)(nil).ListAccountSettingsRequest), arg0) 936 } 937 938 // ListAttributes mocks base method 939 func (m *MockECSAPI) ListAttributes(arg0 *ecs.ListAttributesInput) (*ecs.ListAttributesOutput, error) { 940 m.ctrl.T.Helper() 941 ret := m.ctrl.Call(m, "ListAttributes", arg0) 942 ret0, _ := ret[0].(*ecs.ListAttributesOutput) 943 ret1, _ := ret[1].(error) 944 return ret0, ret1 945 } 946 947 // ListAttributes indicates an expected call of ListAttributes 948 func (mr *MockECSAPIMockRecorder) ListAttributes(arg0 interface{}) *gomock.Call { 949 mr.mock.ctrl.T.Helper() 950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttributes", reflect.TypeOf((*MockECSAPI)(nil).ListAttributes), arg0) 951 } 952 953 // ListAttributesWithContext mocks base method 954 func (m *MockECSAPI) ListAttributesWithContext(arg0 aws.Context, arg1 *ecs.ListAttributesInput, arg2 ...request.Option) (*ecs.ListAttributesOutput, 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, "ListAttributesWithContext", varargs...) 961 ret0, _ := ret[0].(*ecs.ListAttributesOutput) 962 ret1, _ := ret[1].(error) 963 return ret0, ret1 964 } 965 966 // ListAttributesWithContext indicates an expected call of ListAttributesWithContext 967 func (mr *MockECSAPIMockRecorder) ListAttributesWithContext(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, "ListAttributesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListAttributesWithContext), varargs...) 971 } 972 973 // ListAttributesRequest mocks base method 974 func (m *MockECSAPI) ListAttributesRequest(arg0 *ecs.ListAttributesInput) (*request.Request, *ecs.ListAttributesOutput) { 975 m.ctrl.T.Helper() 976 ret := m.ctrl.Call(m, "ListAttributesRequest", arg0) 977 ret0, _ := ret[0].(*request.Request) 978 ret1, _ := ret[1].(*ecs.ListAttributesOutput) 979 return ret0, ret1 980 } 981 982 // ListAttributesRequest indicates an expected call of ListAttributesRequest 983 func (mr *MockECSAPIMockRecorder) ListAttributesRequest(arg0 interface{}) *gomock.Call { 984 mr.mock.ctrl.T.Helper() 985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttributesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListAttributesRequest), arg0) 986 } 987 988 // ListClusters mocks base method 989 func (m *MockECSAPI) ListClusters(arg0 *ecs.ListClustersInput) (*ecs.ListClustersOutput, error) { 990 m.ctrl.T.Helper() 991 ret := m.ctrl.Call(m, "ListClusters", arg0) 992 ret0, _ := ret[0].(*ecs.ListClustersOutput) 993 ret1, _ := ret[1].(error) 994 return ret0, ret1 995 } 996 997 // ListClusters indicates an expected call of ListClusters 998 func (mr *MockECSAPIMockRecorder) ListClusters(arg0 interface{}) *gomock.Call { 999 mr.mock.ctrl.T.Helper() 1000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockECSAPI)(nil).ListClusters), arg0) 1001 } 1002 1003 // ListClustersWithContext mocks base method 1004 func (m *MockECSAPI) ListClustersWithContext(arg0 aws.Context, arg1 *ecs.ListClustersInput, arg2 ...request.Option) (*ecs.ListClustersOutput, error) { 1005 m.ctrl.T.Helper() 1006 varargs := []interface{}{arg0, arg1} 1007 for _, a := range arg2 { 1008 varargs = append(varargs, a) 1009 } 1010 ret := m.ctrl.Call(m, "ListClustersWithContext", varargs...) 1011 ret0, _ := ret[0].(*ecs.ListClustersOutput) 1012 ret1, _ := ret[1].(error) 1013 return ret0, ret1 1014 } 1015 1016 // ListClustersWithContext indicates an expected call of ListClustersWithContext 1017 func (mr *MockECSAPIMockRecorder) ListClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1018 mr.mock.ctrl.T.Helper() 1019 varargs := append([]interface{}{arg0, arg1}, arg2...) 1020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListClustersWithContext), varargs...) 1021 } 1022 1023 // ListClustersRequest mocks base method 1024 func (m *MockECSAPI) ListClustersRequest(arg0 *ecs.ListClustersInput) (*request.Request, *ecs.ListClustersOutput) { 1025 m.ctrl.T.Helper() 1026 ret := m.ctrl.Call(m, "ListClustersRequest", arg0) 1027 ret0, _ := ret[0].(*request.Request) 1028 ret1, _ := ret[1].(*ecs.ListClustersOutput) 1029 return ret0, ret1 1030 } 1031 1032 // ListClustersRequest indicates an expected call of ListClustersRequest 1033 func (mr *MockECSAPIMockRecorder) ListClustersRequest(arg0 interface{}) *gomock.Call { 1034 mr.mock.ctrl.T.Helper() 1035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersRequest", reflect.TypeOf((*MockECSAPI)(nil).ListClustersRequest), arg0) 1036 } 1037 1038 // ListClustersPages mocks base method 1039 func (m *MockECSAPI) ListClustersPages(arg0 *ecs.ListClustersInput, arg1 func(*ecs.ListClustersOutput, bool) bool) error { 1040 m.ctrl.T.Helper() 1041 ret := m.ctrl.Call(m, "ListClustersPages", arg0, arg1) 1042 ret0, _ := ret[0].(error) 1043 return ret0 1044 } 1045 1046 // ListClustersPages indicates an expected call of ListClustersPages 1047 func (mr *MockECSAPIMockRecorder) ListClustersPages(arg0, arg1 interface{}) *gomock.Call { 1048 mr.mock.ctrl.T.Helper() 1049 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersPages", reflect.TypeOf((*MockECSAPI)(nil).ListClustersPages), arg0, arg1) 1050 } 1051 1052 // ListClustersPagesWithContext mocks base method 1053 func (m *MockECSAPI) ListClustersPagesWithContext(arg0 aws.Context, arg1 *ecs.ListClustersInput, arg2 func(*ecs.ListClustersOutput, bool) bool, arg3 ...request.Option) error { 1054 m.ctrl.T.Helper() 1055 varargs := []interface{}{arg0, arg1, arg2} 1056 for _, a := range arg3 { 1057 varargs = append(varargs, a) 1058 } 1059 ret := m.ctrl.Call(m, "ListClustersPagesWithContext", varargs...) 1060 ret0, _ := ret[0].(error) 1061 return ret0 1062 } 1063 1064 // ListClustersPagesWithContext indicates an expected call of ListClustersPagesWithContext 1065 func (mr *MockECSAPIMockRecorder) ListClustersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1066 mr.mock.ctrl.T.Helper() 1067 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1068 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListClustersPagesWithContext), varargs...) 1069 } 1070 1071 // ListContainerInstances mocks base method 1072 func (m *MockECSAPI) ListContainerInstances(arg0 *ecs.ListContainerInstancesInput) (*ecs.ListContainerInstancesOutput, error) { 1073 m.ctrl.T.Helper() 1074 ret := m.ctrl.Call(m, "ListContainerInstances", arg0) 1075 ret0, _ := ret[0].(*ecs.ListContainerInstancesOutput) 1076 ret1, _ := ret[1].(error) 1077 return ret0, ret1 1078 } 1079 1080 // ListContainerInstances indicates an expected call of ListContainerInstances 1081 func (mr *MockECSAPIMockRecorder) ListContainerInstances(arg0 interface{}) *gomock.Call { 1082 mr.mock.ctrl.T.Helper() 1083 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstances", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstances), arg0) 1084 } 1085 1086 // ListContainerInstancesWithContext mocks base method 1087 func (m *MockECSAPI) ListContainerInstancesWithContext(arg0 aws.Context, arg1 *ecs.ListContainerInstancesInput, arg2 ...request.Option) (*ecs.ListContainerInstancesOutput, error) { 1088 m.ctrl.T.Helper() 1089 varargs := []interface{}{arg0, arg1} 1090 for _, a := range arg2 { 1091 varargs = append(varargs, a) 1092 } 1093 ret := m.ctrl.Call(m, "ListContainerInstancesWithContext", varargs...) 1094 ret0, _ := ret[0].(*ecs.ListContainerInstancesOutput) 1095 ret1, _ := ret[1].(error) 1096 return ret0, ret1 1097 } 1098 1099 // ListContainerInstancesWithContext indicates an expected call of ListContainerInstancesWithContext 1100 func (mr *MockECSAPIMockRecorder) ListContainerInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1101 mr.mock.ctrl.T.Helper() 1102 varargs := append([]interface{}{arg0, arg1}, arg2...) 1103 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesWithContext), varargs...) 1104 } 1105 1106 // ListContainerInstancesRequest mocks base method 1107 func (m *MockECSAPI) ListContainerInstancesRequest(arg0 *ecs.ListContainerInstancesInput) (*request.Request, *ecs.ListContainerInstancesOutput) { 1108 m.ctrl.T.Helper() 1109 ret := m.ctrl.Call(m, "ListContainerInstancesRequest", arg0) 1110 ret0, _ := ret[0].(*request.Request) 1111 ret1, _ := ret[1].(*ecs.ListContainerInstancesOutput) 1112 return ret0, ret1 1113 } 1114 1115 // ListContainerInstancesRequest indicates an expected call of ListContainerInstancesRequest 1116 func (mr *MockECSAPIMockRecorder) ListContainerInstancesRequest(arg0 interface{}) *gomock.Call { 1117 mr.mock.ctrl.T.Helper() 1118 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesRequest), arg0) 1119 } 1120 1121 // ListContainerInstancesPages mocks base method 1122 func (m *MockECSAPI) ListContainerInstancesPages(arg0 *ecs.ListContainerInstancesInput, arg1 func(*ecs.ListContainerInstancesOutput, bool) bool) error { 1123 m.ctrl.T.Helper() 1124 ret := m.ctrl.Call(m, "ListContainerInstancesPages", arg0, arg1) 1125 ret0, _ := ret[0].(error) 1126 return ret0 1127 } 1128 1129 // ListContainerInstancesPages indicates an expected call of ListContainerInstancesPages 1130 func (mr *MockECSAPIMockRecorder) ListContainerInstancesPages(arg0, arg1 interface{}) *gomock.Call { 1131 mr.mock.ctrl.T.Helper() 1132 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesPages", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesPages), arg0, arg1) 1133 } 1134 1135 // ListContainerInstancesPagesWithContext mocks base method 1136 func (m *MockECSAPI) ListContainerInstancesPagesWithContext(arg0 aws.Context, arg1 *ecs.ListContainerInstancesInput, arg2 func(*ecs.ListContainerInstancesOutput, bool) bool, arg3 ...request.Option) error { 1137 m.ctrl.T.Helper() 1138 varargs := []interface{}{arg0, arg1, arg2} 1139 for _, a := range arg3 { 1140 varargs = append(varargs, a) 1141 } 1142 ret := m.ctrl.Call(m, "ListContainerInstancesPagesWithContext", varargs...) 1143 ret0, _ := ret[0].(error) 1144 return ret0 1145 } 1146 1147 // ListContainerInstancesPagesWithContext indicates an expected call of ListContainerInstancesPagesWithContext 1148 func (mr *MockECSAPIMockRecorder) ListContainerInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1149 mr.mock.ctrl.T.Helper() 1150 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1151 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerInstancesPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListContainerInstancesPagesWithContext), varargs...) 1152 } 1153 1154 // ListServices mocks base method 1155 func (m *MockECSAPI) ListServices(arg0 *ecs.ListServicesInput) (*ecs.ListServicesOutput, error) { 1156 m.ctrl.T.Helper() 1157 ret := m.ctrl.Call(m, "ListServices", arg0) 1158 ret0, _ := ret[0].(*ecs.ListServicesOutput) 1159 ret1, _ := ret[1].(error) 1160 return ret0, ret1 1161 } 1162 1163 // ListServices indicates an expected call of ListServices 1164 func (mr *MockECSAPIMockRecorder) ListServices(arg0 interface{}) *gomock.Call { 1165 mr.mock.ctrl.T.Helper() 1166 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockECSAPI)(nil).ListServices), arg0) 1167 } 1168 1169 // ListServicesWithContext mocks base method 1170 func (m *MockECSAPI) ListServicesWithContext(arg0 aws.Context, arg1 *ecs.ListServicesInput, arg2 ...request.Option) (*ecs.ListServicesOutput, error) { 1171 m.ctrl.T.Helper() 1172 varargs := []interface{}{arg0, arg1} 1173 for _, a := range arg2 { 1174 varargs = append(varargs, a) 1175 } 1176 ret := m.ctrl.Call(m, "ListServicesWithContext", varargs...) 1177 ret0, _ := ret[0].(*ecs.ListServicesOutput) 1178 ret1, _ := ret[1].(error) 1179 return ret0, ret1 1180 } 1181 1182 // ListServicesWithContext indicates an expected call of ListServicesWithContext 1183 func (mr *MockECSAPIMockRecorder) ListServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1184 mr.mock.ctrl.T.Helper() 1185 varargs := append([]interface{}{arg0, arg1}, arg2...) 1186 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListServicesWithContext), varargs...) 1187 } 1188 1189 // ListServicesRequest mocks base method 1190 func (m *MockECSAPI) ListServicesRequest(arg0 *ecs.ListServicesInput) (*request.Request, *ecs.ListServicesOutput) { 1191 m.ctrl.T.Helper() 1192 ret := m.ctrl.Call(m, "ListServicesRequest", arg0) 1193 ret0, _ := ret[0].(*request.Request) 1194 ret1, _ := ret[1].(*ecs.ListServicesOutput) 1195 return ret0, ret1 1196 } 1197 1198 // ListServicesRequest indicates an expected call of ListServicesRequest 1199 func (mr *MockECSAPIMockRecorder) ListServicesRequest(arg0 interface{}) *gomock.Call { 1200 mr.mock.ctrl.T.Helper() 1201 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListServicesRequest), arg0) 1202 } 1203 1204 // ListServicesPages mocks base method 1205 func (m *MockECSAPI) ListServicesPages(arg0 *ecs.ListServicesInput, arg1 func(*ecs.ListServicesOutput, bool) bool) error { 1206 m.ctrl.T.Helper() 1207 ret := m.ctrl.Call(m, "ListServicesPages", arg0, arg1) 1208 ret0, _ := ret[0].(error) 1209 return ret0 1210 } 1211 1212 // ListServicesPages indicates an expected call of ListServicesPages 1213 func (mr *MockECSAPIMockRecorder) ListServicesPages(arg0, arg1 interface{}) *gomock.Call { 1214 mr.mock.ctrl.T.Helper() 1215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesPages", reflect.TypeOf((*MockECSAPI)(nil).ListServicesPages), arg0, arg1) 1216 } 1217 1218 // ListServicesPagesWithContext mocks base method 1219 func (m *MockECSAPI) ListServicesPagesWithContext(arg0 aws.Context, arg1 *ecs.ListServicesInput, arg2 func(*ecs.ListServicesOutput, bool) bool, arg3 ...request.Option) error { 1220 m.ctrl.T.Helper() 1221 varargs := []interface{}{arg0, arg1, arg2} 1222 for _, a := range arg3 { 1223 varargs = append(varargs, a) 1224 } 1225 ret := m.ctrl.Call(m, "ListServicesPagesWithContext", varargs...) 1226 ret0, _ := ret[0].(error) 1227 return ret0 1228 } 1229 1230 // ListServicesPagesWithContext indicates an expected call of ListServicesPagesWithContext 1231 func (mr *MockECSAPIMockRecorder) ListServicesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1232 mr.mock.ctrl.T.Helper() 1233 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1234 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServicesPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListServicesPagesWithContext), varargs...) 1235 } 1236 1237 // ListTagsForResource mocks base method 1238 func (m *MockECSAPI) ListTagsForResource(arg0 *ecs.ListTagsForResourceInput) (*ecs.ListTagsForResourceOutput, error) { 1239 m.ctrl.T.Helper() 1240 ret := m.ctrl.Call(m, "ListTagsForResource", arg0) 1241 ret0, _ := ret[0].(*ecs.ListTagsForResourceOutput) 1242 ret1, _ := ret[1].(error) 1243 return ret0, ret1 1244 } 1245 1246 // ListTagsForResource indicates an expected call of ListTagsForResource 1247 func (mr *MockECSAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { 1248 mr.mock.ctrl.T.Helper() 1249 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockECSAPI)(nil).ListTagsForResource), arg0) 1250 } 1251 1252 // ListTagsForResourceWithContext mocks base method 1253 func (m *MockECSAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *ecs.ListTagsForResourceInput, arg2 ...request.Option) (*ecs.ListTagsForResourceOutput, error) { 1254 m.ctrl.T.Helper() 1255 varargs := []interface{}{arg0, arg1} 1256 for _, a := range arg2 { 1257 varargs = append(varargs, a) 1258 } 1259 ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) 1260 ret0, _ := ret[0].(*ecs.ListTagsForResourceOutput) 1261 ret1, _ := ret[1].(error) 1262 return ret0, ret1 1263 } 1264 1265 // ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext 1266 func (mr *MockECSAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1267 mr.mock.ctrl.T.Helper() 1268 varargs := append([]interface{}{arg0, arg1}, arg2...) 1269 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTagsForResourceWithContext), varargs...) 1270 } 1271 1272 // ListTagsForResourceRequest mocks base method 1273 func (m *MockECSAPI) ListTagsForResourceRequest(arg0 *ecs.ListTagsForResourceInput) (*request.Request, *ecs.ListTagsForResourceOutput) { 1274 m.ctrl.T.Helper() 1275 ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) 1276 ret0, _ := ret[0].(*request.Request) 1277 ret1, _ := ret[1].(*ecs.ListTagsForResourceOutput) 1278 return ret0, ret1 1279 } 1280 1281 // ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest 1282 func (mr *MockECSAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { 1283 mr.mock.ctrl.T.Helper() 1284 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTagsForResourceRequest), arg0) 1285 } 1286 1287 // ListTaskDefinitionFamilies mocks base method 1288 func (m *MockECSAPI) ListTaskDefinitionFamilies(arg0 *ecs.ListTaskDefinitionFamiliesInput) (*ecs.ListTaskDefinitionFamiliesOutput, error) { 1289 m.ctrl.T.Helper() 1290 ret := m.ctrl.Call(m, "ListTaskDefinitionFamilies", arg0) 1291 ret0, _ := ret[0].(*ecs.ListTaskDefinitionFamiliesOutput) 1292 ret1, _ := ret[1].(error) 1293 return ret0, ret1 1294 } 1295 1296 // ListTaskDefinitionFamilies indicates an expected call of ListTaskDefinitionFamilies 1297 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamilies(arg0 interface{}) *gomock.Call { 1298 mr.mock.ctrl.T.Helper() 1299 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamilies", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamilies), arg0) 1300 } 1301 1302 // ListTaskDefinitionFamiliesWithContext mocks base method 1303 func (m *MockECSAPI) ListTaskDefinitionFamiliesWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionFamiliesInput, arg2 ...request.Option) (*ecs.ListTaskDefinitionFamiliesOutput, error) { 1304 m.ctrl.T.Helper() 1305 varargs := []interface{}{arg0, arg1} 1306 for _, a := range arg2 { 1307 varargs = append(varargs, a) 1308 } 1309 ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesWithContext", varargs...) 1310 ret0, _ := ret[0].(*ecs.ListTaskDefinitionFamiliesOutput) 1311 ret1, _ := ret[1].(error) 1312 return ret0, ret1 1313 } 1314 1315 // ListTaskDefinitionFamiliesWithContext indicates an expected call of ListTaskDefinitionFamiliesWithContext 1316 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1317 mr.mock.ctrl.T.Helper() 1318 varargs := append([]interface{}{arg0, arg1}, arg2...) 1319 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesWithContext), varargs...) 1320 } 1321 1322 // ListTaskDefinitionFamiliesRequest mocks base method 1323 func (m *MockECSAPI) ListTaskDefinitionFamiliesRequest(arg0 *ecs.ListTaskDefinitionFamiliesInput) (*request.Request, *ecs.ListTaskDefinitionFamiliesOutput) { 1324 m.ctrl.T.Helper() 1325 ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesRequest", arg0) 1326 ret0, _ := ret[0].(*request.Request) 1327 ret1, _ := ret[1].(*ecs.ListTaskDefinitionFamiliesOutput) 1328 return ret0, ret1 1329 } 1330 1331 // ListTaskDefinitionFamiliesRequest indicates an expected call of ListTaskDefinitionFamiliesRequest 1332 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesRequest(arg0 interface{}) *gomock.Call { 1333 mr.mock.ctrl.T.Helper() 1334 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesRequest), arg0) 1335 } 1336 1337 // ListTaskDefinitionFamiliesPages mocks base method 1338 func (m *MockECSAPI) ListTaskDefinitionFamiliesPages(arg0 *ecs.ListTaskDefinitionFamiliesInput, arg1 func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool) error { 1339 m.ctrl.T.Helper() 1340 ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesPages", arg0, arg1) 1341 ret0, _ := ret[0].(error) 1342 return ret0 1343 } 1344 1345 // ListTaskDefinitionFamiliesPages indicates an expected call of ListTaskDefinitionFamiliesPages 1346 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesPages(arg0, arg1 interface{}) *gomock.Call { 1347 mr.mock.ctrl.T.Helper() 1348 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesPages", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesPages), arg0, arg1) 1349 } 1350 1351 // ListTaskDefinitionFamiliesPagesWithContext mocks base method 1352 func (m *MockECSAPI) ListTaskDefinitionFamiliesPagesWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionFamiliesInput, arg2 func(*ecs.ListTaskDefinitionFamiliesOutput, bool) bool, arg3 ...request.Option) error { 1353 m.ctrl.T.Helper() 1354 varargs := []interface{}{arg0, arg1, arg2} 1355 for _, a := range arg3 { 1356 varargs = append(varargs, a) 1357 } 1358 ret := m.ctrl.Call(m, "ListTaskDefinitionFamiliesPagesWithContext", varargs...) 1359 ret0, _ := ret[0].(error) 1360 return ret0 1361 } 1362 1363 // ListTaskDefinitionFamiliesPagesWithContext indicates an expected call of ListTaskDefinitionFamiliesPagesWithContext 1364 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionFamiliesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1365 mr.mock.ctrl.T.Helper() 1366 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1367 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionFamiliesPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionFamiliesPagesWithContext), varargs...) 1368 } 1369 1370 // ListTaskDefinitions mocks base method 1371 func (m *MockECSAPI) ListTaskDefinitions(arg0 *ecs.ListTaskDefinitionsInput) (*ecs.ListTaskDefinitionsOutput, error) { 1372 m.ctrl.T.Helper() 1373 ret := m.ctrl.Call(m, "ListTaskDefinitions", arg0) 1374 ret0, _ := ret[0].(*ecs.ListTaskDefinitionsOutput) 1375 ret1, _ := ret[1].(error) 1376 return ret0, ret1 1377 } 1378 1379 // ListTaskDefinitions indicates an expected call of ListTaskDefinitions 1380 func (mr *MockECSAPIMockRecorder) ListTaskDefinitions(arg0 interface{}) *gomock.Call { 1381 mr.mock.ctrl.T.Helper() 1382 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitions", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitions), arg0) 1383 } 1384 1385 // ListTaskDefinitionsWithContext mocks base method 1386 func (m *MockECSAPI) ListTaskDefinitionsWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionsInput, arg2 ...request.Option) (*ecs.ListTaskDefinitionsOutput, error) { 1387 m.ctrl.T.Helper() 1388 varargs := []interface{}{arg0, arg1} 1389 for _, a := range arg2 { 1390 varargs = append(varargs, a) 1391 } 1392 ret := m.ctrl.Call(m, "ListTaskDefinitionsWithContext", varargs...) 1393 ret0, _ := ret[0].(*ecs.ListTaskDefinitionsOutput) 1394 ret1, _ := ret[1].(error) 1395 return ret0, ret1 1396 } 1397 1398 // ListTaskDefinitionsWithContext indicates an expected call of ListTaskDefinitionsWithContext 1399 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1400 mr.mock.ctrl.T.Helper() 1401 varargs := append([]interface{}{arg0, arg1}, arg2...) 1402 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsWithContext), varargs...) 1403 } 1404 1405 // ListTaskDefinitionsRequest mocks base method 1406 func (m *MockECSAPI) ListTaskDefinitionsRequest(arg0 *ecs.ListTaskDefinitionsInput) (*request.Request, *ecs.ListTaskDefinitionsOutput) { 1407 m.ctrl.T.Helper() 1408 ret := m.ctrl.Call(m, "ListTaskDefinitionsRequest", arg0) 1409 ret0, _ := ret[0].(*request.Request) 1410 ret1, _ := ret[1].(*ecs.ListTaskDefinitionsOutput) 1411 return ret0, ret1 1412 } 1413 1414 // ListTaskDefinitionsRequest indicates an expected call of ListTaskDefinitionsRequest 1415 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsRequest(arg0 interface{}) *gomock.Call { 1416 mr.mock.ctrl.T.Helper() 1417 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsRequest), arg0) 1418 } 1419 1420 // ListTaskDefinitionsPages mocks base method 1421 func (m *MockECSAPI) ListTaskDefinitionsPages(arg0 *ecs.ListTaskDefinitionsInput, arg1 func(*ecs.ListTaskDefinitionsOutput, bool) bool) error { 1422 m.ctrl.T.Helper() 1423 ret := m.ctrl.Call(m, "ListTaskDefinitionsPages", arg0, arg1) 1424 ret0, _ := ret[0].(error) 1425 return ret0 1426 } 1427 1428 // ListTaskDefinitionsPages indicates an expected call of ListTaskDefinitionsPages 1429 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsPages(arg0, arg1 interface{}) *gomock.Call { 1430 mr.mock.ctrl.T.Helper() 1431 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsPages", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsPages), arg0, arg1) 1432 } 1433 1434 // ListTaskDefinitionsPagesWithContext mocks base method 1435 func (m *MockECSAPI) ListTaskDefinitionsPagesWithContext(arg0 aws.Context, arg1 *ecs.ListTaskDefinitionsInput, arg2 func(*ecs.ListTaskDefinitionsOutput, bool) bool, arg3 ...request.Option) error { 1436 m.ctrl.T.Helper() 1437 varargs := []interface{}{arg0, arg1, arg2} 1438 for _, a := range arg3 { 1439 varargs = append(varargs, a) 1440 } 1441 ret := m.ctrl.Call(m, "ListTaskDefinitionsPagesWithContext", varargs...) 1442 ret0, _ := ret[0].(error) 1443 return ret0 1444 } 1445 1446 // ListTaskDefinitionsPagesWithContext indicates an expected call of ListTaskDefinitionsPagesWithContext 1447 func (mr *MockECSAPIMockRecorder) ListTaskDefinitionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1448 mr.mock.ctrl.T.Helper() 1449 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskDefinitionsPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTaskDefinitionsPagesWithContext), varargs...) 1451 } 1452 1453 // ListTasks mocks base method 1454 func (m *MockECSAPI) ListTasks(arg0 *ecs.ListTasksInput) (*ecs.ListTasksOutput, error) { 1455 m.ctrl.T.Helper() 1456 ret := m.ctrl.Call(m, "ListTasks", arg0) 1457 ret0, _ := ret[0].(*ecs.ListTasksOutput) 1458 ret1, _ := ret[1].(error) 1459 return ret0, ret1 1460 } 1461 1462 // ListTasks indicates an expected call of ListTasks 1463 func (mr *MockECSAPIMockRecorder) ListTasks(arg0 interface{}) *gomock.Call { 1464 mr.mock.ctrl.T.Helper() 1465 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasks", reflect.TypeOf((*MockECSAPI)(nil).ListTasks), arg0) 1466 } 1467 1468 // ListTasksWithContext mocks base method 1469 func (m *MockECSAPI) ListTasksWithContext(arg0 aws.Context, arg1 *ecs.ListTasksInput, arg2 ...request.Option) (*ecs.ListTasksOutput, error) { 1470 m.ctrl.T.Helper() 1471 varargs := []interface{}{arg0, arg1} 1472 for _, a := range arg2 { 1473 varargs = append(varargs, a) 1474 } 1475 ret := m.ctrl.Call(m, "ListTasksWithContext", varargs...) 1476 ret0, _ := ret[0].(*ecs.ListTasksOutput) 1477 ret1, _ := ret[1].(error) 1478 return ret0, ret1 1479 } 1480 1481 // ListTasksWithContext indicates an expected call of ListTasksWithContext 1482 func (mr *MockECSAPIMockRecorder) ListTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1483 mr.mock.ctrl.T.Helper() 1484 varargs := append([]interface{}{arg0, arg1}, arg2...) 1485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTasksWithContext), varargs...) 1486 } 1487 1488 // ListTasksRequest mocks base method 1489 func (m *MockECSAPI) ListTasksRequest(arg0 *ecs.ListTasksInput) (*request.Request, *ecs.ListTasksOutput) { 1490 m.ctrl.T.Helper() 1491 ret := m.ctrl.Call(m, "ListTasksRequest", arg0) 1492 ret0, _ := ret[0].(*request.Request) 1493 ret1, _ := ret[1].(*ecs.ListTasksOutput) 1494 return ret0, ret1 1495 } 1496 1497 // ListTasksRequest indicates an expected call of ListTasksRequest 1498 func (mr *MockECSAPIMockRecorder) ListTasksRequest(arg0 interface{}) *gomock.Call { 1499 mr.mock.ctrl.T.Helper() 1500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksRequest", reflect.TypeOf((*MockECSAPI)(nil).ListTasksRequest), arg0) 1501 } 1502 1503 // ListTasksPages mocks base method 1504 func (m *MockECSAPI) ListTasksPages(arg0 *ecs.ListTasksInput, arg1 func(*ecs.ListTasksOutput, bool) bool) error { 1505 m.ctrl.T.Helper() 1506 ret := m.ctrl.Call(m, "ListTasksPages", arg0, arg1) 1507 ret0, _ := ret[0].(error) 1508 return ret0 1509 } 1510 1511 // ListTasksPages indicates an expected call of ListTasksPages 1512 func (mr *MockECSAPIMockRecorder) ListTasksPages(arg0, arg1 interface{}) *gomock.Call { 1513 mr.mock.ctrl.T.Helper() 1514 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksPages", reflect.TypeOf((*MockECSAPI)(nil).ListTasksPages), arg0, arg1) 1515 } 1516 1517 // ListTasksPagesWithContext mocks base method 1518 func (m *MockECSAPI) ListTasksPagesWithContext(arg0 aws.Context, arg1 *ecs.ListTasksInput, arg2 func(*ecs.ListTasksOutput, bool) bool, arg3 ...request.Option) error { 1519 m.ctrl.T.Helper() 1520 varargs := []interface{}{arg0, arg1, arg2} 1521 for _, a := range arg3 { 1522 varargs = append(varargs, a) 1523 } 1524 ret := m.ctrl.Call(m, "ListTasksPagesWithContext", varargs...) 1525 ret0, _ := ret[0].(error) 1526 return ret0 1527 } 1528 1529 // ListTasksPagesWithContext indicates an expected call of ListTasksPagesWithContext 1530 func (mr *MockECSAPIMockRecorder) ListTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1531 mr.mock.ctrl.T.Helper() 1532 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1533 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasksPagesWithContext", reflect.TypeOf((*MockECSAPI)(nil).ListTasksPagesWithContext), varargs...) 1534 } 1535 1536 // PutAccountSetting mocks base method 1537 func (m *MockECSAPI) PutAccountSetting(arg0 *ecs.PutAccountSettingInput) (*ecs.PutAccountSettingOutput, error) { 1538 m.ctrl.T.Helper() 1539 ret := m.ctrl.Call(m, "PutAccountSetting", arg0) 1540 ret0, _ := ret[0].(*ecs.PutAccountSettingOutput) 1541 ret1, _ := ret[1].(error) 1542 return ret0, ret1 1543 } 1544 1545 // PutAccountSetting indicates an expected call of PutAccountSetting 1546 func (mr *MockECSAPIMockRecorder) PutAccountSetting(arg0 interface{}) *gomock.Call { 1547 mr.mock.ctrl.T.Helper() 1548 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAccountSetting", reflect.TypeOf((*MockECSAPI)(nil).PutAccountSetting), arg0) 1549 } 1550 1551 // PutAccountSettingWithContext mocks base method 1552 func (m *MockECSAPI) PutAccountSettingWithContext(arg0 aws.Context, arg1 *ecs.PutAccountSettingInput, arg2 ...request.Option) (*ecs.PutAccountSettingOutput, error) { 1553 m.ctrl.T.Helper() 1554 varargs := []interface{}{arg0, arg1} 1555 for _, a := range arg2 { 1556 varargs = append(varargs, a) 1557 } 1558 ret := m.ctrl.Call(m, "PutAccountSettingWithContext", varargs...) 1559 ret0, _ := ret[0].(*ecs.PutAccountSettingOutput) 1560 ret1, _ := ret[1].(error) 1561 return ret0, ret1 1562 } 1563 1564 // PutAccountSettingWithContext indicates an expected call of PutAccountSettingWithContext 1565 func (mr *MockECSAPIMockRecorder) PutAccountSettingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1566 mr.mock.ctrl.T.Helper() 1567 varargs := append([]interface{}{arg0, arg1}, arg2...) 1568 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAccountSettingWithContext", reflect.TypeOf((*MockECSAPI)(nil).PutAccountSettingWithContext), varargs...) 1569 } 1570 1571 // PutAccountSettingRequest mocks base method 1572 func (m *MockECSAPI) PutAccountSettingRequest(arg0 *ecs.PutAccountSettingInput) (*request.Request, *ecs.PutAccountSettingOutput) { 1573 m.ctrl.T.Helper() 1574 ret := m.ctrl.Call(m, "PutAccountSettingRequest", arg0) 1575 ret0, _ := ret[0].(*request.Request) 1576 ret1, _ := ret[1].(*ecs.PutAccountSettingOutput) 1577 return ret0, ret1 1578 } 1579 1580 // PutAccountSettingRequest indicates an expected call of PutAccountSettingRequest 1581 func (mr *MockECSAPIMockRecorder) PutAccountSettingRequest(arg0 interface{}) *gomock.Call { 1582 mr.mock.ctrl.T.Helper() 1583 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAccountSettingRequest", reflect.TypeOf((*MockECSAPI)(nil).PutAccountSettingRequest), arg0) 1584 } 1585 1586 // PutAccountSettingDefault mocks base method 1587 func (m *MockECSAPI) PutAccountSettingDefault(arg0 *ecs.PutAccountSettingDefaultInput) (*ecs.PutAccountSettingDefaultOutput, error) { 1588 m.ctrl.T.Helper() 1589 ret := m.ctrl.Call(m, "PutAccountSettingDefault", arg0) 1590 ret0, _ := ret[0].(*ecs.PutAccountSettingDefaultOutput) 1591 ret1, _ := ret[1].(error) 1592 return ret0, ret1 1593 } 1594 1595 // PutAccountSettingDefault indicates an expected call of PutAccountSettingDefault 1596 func (mr *MockECSAPIMockRecorder) PutAccountSettingDefault(arg0 interface{}) *gomock.Call { 1597 mr.mock.ctrl.T.Helper() 1598 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAccountSettingDefault", reflect.TypeOf((*MockECSAPI)(nil).PutAccountSettingDefault), arg0) 1599 } 1600 1601 // PutAccountSettingDefaultWithContext mocks base method 1602 func (m *MockECSAPI) PutAccountSettingDefaultWithContext(arg0 aws.Context, arg1 *ecs.PutAccountSettingDefaultInput, arg2 ...request.Option) (*ecs.PutAccountSettingDefaultOutput, error) { 1603 m.ctrl.T.Helper() 1604 varargs := []interface{}{arg0, arg1} 1605 for _, a := range arg2 { 1606 varargs = append(varargs, a) 1607 } 1608 ret := m.ctrl.Call(m, "PutAccountSettingDefaultWithContext", varargs...) 1609 ret0, _ := ret[0].(*ecs.PutAccountSettingDefaultOutput) 1610 ret1, _ := ret[1].(error) 1611 return ret0, ret1 1612 } 1613 1614 // PutAccountSettingDefaultWithContext indicates an expected call of PutAccountSettingDefaultWithContext 1615 func (mr *MockECSAPIMockRecorder) PutAccountSettingDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1616 mr.mock.ctrl.T.Helper() 1617 varargs := append([]interface{}{arg0, arg1}, arg2...) 1618 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAccountSettingDefaultWithContext", reflect.TypeOf((*MockECSAPI)(nil).PutAccountSettingDefaultWithContext), varargs...) 1619 } 1620 1621 // PutAccountSettingDefaultRequest mocks base method 1622 func (m *MockECSAPI) PutAccountSettingDefaultRequest(arg0 *ecs.PutAccountSettingDefaultInput) (*request.Request, *ecs.PutAccountSettingDefaultOutput) { 1623 m.ctrl.T.Helper() 1624 ret := m.ctrl.Call(m, "PutAccountSettingDefaultRequest", arg0) 1625 ret0, _ := ret[0].(*request.Request) 1626 ret1, _ := ret[1].(*ecs.PutAccountSettingDefaultOutput) 1627 return ret0, ret1 1628 } 1629 1630 // PutAccountSettingDefaultRequest indicates an expected call of PutAccountSettingDefaultRequest 1631 func (mr *MockECSAPIMockRecorder) PutAccountSettingDefaultRequest(arg0 interface{}) *gomock.Call { 1632 mr.mock.ctrl.T.Helper() 1633 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAccountSettingDefaultRequest", reflect.TypeOf((*MockECSAPI)(nil).PutAccountSettingDefaultRequest), arg0) 1634 } 1635 1636 // PutAttributes mocks base method 1637 func (m *MockECSAPI) PutAttributes(arg0 *ecs.PutAttributesInput) (*ecs.PutAttributesOutput, error) { 1638 m.ctrl.T.Helper() 1639 ret := m.ctrl.Call(m, "PutAttributes", arg0) 1640 ret0, _ := ret[0].(*ecs.PutAttributesOutput) 1641 ret1, _ := ret[1].(error) 1642 return ret0, ret1 1643 } 1644 1645 // PutAttributes indicates an expected call of PutAttributes 1646 func (mr *MockECSAPIMockRecorder) PutAttributes(arg0 interface{}) *gomock.Call { 1647 mr.mock.ctrl.T.Helper() 1648 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAttributes", reflect.TypeOf((*MockECSAPI)(nil).PutAttributes), arg0) 1649 } 1650 1651 // PutAttributesWithContext mocks base method 1652 func (m *MockECSAPI) PutAttributesWithContext(arg0 aws.Context, arg1 *ecs.PutAttributesInput, arg2 ...request.Option) (*ecs.PutAttributesOutput, error) { 1653 m.ctrl.T.Helper() 1654 varargs := []interface{}{arg0, arg1} 1655 for _, a := range arg2 { 1656 varargs = append(varargs, a) 1657 } 1658 ret := m.ctrl.Call(m, "PutAttributesWithContext", varargs...) 1659 ret0, _ := ret[0].(*ecs.PutAttributesOutput) 1660 ret1, _ := ret[1].(error) 1661 return ret0, ret1 1662 } 1663 1664 // PutAttributesWithContext indicates an expected call of PutAttributesWithContext 1665 func (mr *MockECSAPIMockRecorder) PutAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1666 mr.mock.ctrl.T.Helper() 1667 varargs := append([]interface{}{arg0, arg1}, arg2...) 1668 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAttributesWithContext", reflect.TypeOf((*MockECSAPI)(nil).PutAttributesWithContext), varargs...) 1669 } 1670 1671 // PutAttributesRequest mocks base method 1672 func (m *MockECSAPI) PutAttributesRequest(arg0 *ecs.PutAttributesInput) (*request.Request, *ecs.PutAttributesOutput) { 1673 m.ctrl.T.Helper() 1674 ret := m.ctrl.Call(m, "PutAttributesRequest", arg0) 1675 ret0, _ := ret[0].(*request.Request) 1676 ret1, _ := ret[1].(*ecs.PutAttributesOutput) 1677 return ret0, ret1 1678 } 1679 1680 // PutAttributesRequest indicates an expected call of PutAttributesRequest 1681 func (mr *MockECSAPIMockRecorder) PutAttributesRequest(arg0 interface{}) *gomock.Call { 1682 mr.mock.ctrl.T.Helper() 1683 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAttributesRequest", reflect.TypeOf((*MockECSAPI)(nil).PutAttributesRequest), arg0) 1684 } 1685 1686 // RegisterContainerInstance mocks base method 1687 func (m *MockECSAPI) RegisterContainerInstance(arg0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) { 1688 m.ctrl.T.Helper() 1689 ret := m.ctrl.Call(m, "RegisterContainerInstance", arg0) 1690 ret0, _ := ret[0].(*ecs.RegisterContainerInstanceOutput) 1691 ret1, _ := ret[1].(error) 1692 return ret0, ret1 1693 } 1694 1695 // RegisterContainerInstance indicates an expected call of RegisterContainerInstance 1696 func (mr *MockECSAPIMockRecorder) RegisterContainerInstance(arg0 interface{}) *gomock.Call { 1697 mr.mock.ctrl.T.Helper() 1698 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstance", reflect.TypeOf((*MockECSAPI)(nil).RegisterContainerInstance), arg0) 1699 } 1700 1701 // RegisterContainerInstanceWithContext mocks base method 1702 func (m *MockECSAPI) RegisterContainerInstanceWithContext(arg0 aws.Context, arg1 *ecs.RegisterContainerInstanceInput, arg2 ...request.Option) (*ecs.RegisterContainerInstanceOutput, error) { 1703 m.ctrl.T.Helper() 1704 varargs := []interface{}{arg0, arg1} 1705 for _, a := range arg2 { 1706 varargs = append(varargs, a) 1707 } 1708 ret := m.ctrl.Call(m, "RegisterContainerInstanceWithContext", varargs...) 1709 ret0, _ := ret[0].(*ecs.RegisterContainerInstanceOutput) 1710 ret1, _ := ret[1].(error) 1711 return ret0, ret1 1712 } 1713 1714 // RegisterContainerInstanceWithContext indicates an expected call of RegisterContainerInstanceWithContext 1715 func (mr *MockECSAPIMockRecorder) RegisterContainerInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1716 mr.mock.ctrl.T.Helper() 1717 varargs := append([]interface{}{arg0, arg1}, arg2...) 1718 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstanceWithContext", reflect.TypeOf((*MockECSAPI)(nil).RegisterContainerInstanceWithContext), varargs...) 1719 } 1720 1721 // RegisterContainerInstanceRequest mocks base method 1722 func (m *MockECSAPI) RegisterContainerInstanceRequest(arg0 *ecs.RegisterContainerInstanceInput) (*request.Request, *ecs.RegisterContainerInstanceOutput) { 1723 m.ctrl.T.Helper() 1724 ret := m.ctrl.Call(m, "RegisterContainerInstanceRequest", arg0) 1725 ret0, _ := ret[0].(*request.Request) 1726 ret1, _ := ret[1].(*ecs.RegisterContainerInstanceOutput) 1727 return ret0, ret1 1728 } 1729 1730 // RegisterContainerInstanceRequest indicates an expected call of RegisterContainerInstanceRequest 1731 func (mr *MockECSAPIMockRecorder) RegisterContainerInstanceRequest(arg0 interface{}) *gomock.Call { 1732 mr.mock.ctrl.T.Helper() 1733 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstanceRequest", reflect.TypeOf((*MockECSAPI)(nil).RegisterContainerInstanceRequest), arg0) 1734 } 1735 1736 // RegisterTaskDefinition mocks base method 1737 func (m *MockECSAPI) RegisterTaskDefinition(arg0 *ecs.RegisterTaskDefinitionInput) (*ecs.RegisterTaskDefinitionOutput, error) { 1738 m.ctrl.T.Helper() 1739 ret := m.ctrl.Call(m, "RegisterTaskDefinition", arg0) 1740 ret0, _ := ret[0].(*ecs.RegisterTaskDefinitionOutput) 1741 ret1, _ := ret[1].(error) 1742 return ret0, ret1 1743 } 1744 1745 // RegisterTaskDefinition indicates an expected call of RegisterTaskDefinition 1746 func (mr *MockECSAPIMockRecorder) RegisterTaskDefinition(arg0 interface{}) *gomock.Call { 1747 mr.mock.ctrl.T.Helper() 1748 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskDefinition", reflect.TypeOf((*MockECSAPI)(nil).RegisterTaskDefinition), arg0) 1749 } 1750 1751 // RegisterTaskDefinitionWithContext mocks base method 1752 func (m *MockECSAPI) RegisterTaskDefinitionWithContext(arg0 aws.Context, arg1 *ecs.RegisterTaskDefinitionInput, arg2 ...request.Option) (*ecs.RegisterTaskDefinitionOutput, error) { 1753 m.ctrl.T.Helper() 1754 varargs := []interface{}{arg0, arg1} 1755 for _, a := range arg2 { 1756 varargs = append(varargs, a) 1757 } 1758 ret := m.ctrl.Call(m, "RegisterTaskDefinitionWithContext", varargs...) 1759 ret0, _ := ret[0].(*ecs.RegisterTaskDefinitionOutput) 1760 ret1, _ := ret[1].(error) 1761 return ret0, ret1 1762 } 1763 1764 // RegisterTaskDefinitionWithContext indicates an expected call of RegisterTaskDefinitionWithContext 1765 func (mr *MockECSAPIMockRecorder) RegisterTaskDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1766 mr.mock.ctrl.T.Helper() 1767 varargs := append([]interface{}{arg0, arg1}, arg2...) 1768 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskDefinitionWithContext", reflect.TypeOf((*MockECSAPI)(nil).RegisterTaskDefinitionWithContext), varargs...) 1769 } 1770 1771 // RegisterTaskDefinitionRequest mocks base method 1772 func (m *MockECSAPI) RegisterTaskDefinitionRequest(arg0 *ecs.RegisterTaskDefinitionInput) (*request.Request, *ecs.RegisterTaskDefinitionOutput) { 1773 m.ctrl.T.Helper() 1774 ret := m.ctrl.Call(m, "RegisterTaskDefinitionRequest", arg0) 1775 ret0, _ := ret[0].(*request.Request) 1776 ret1, _ := ret[1].(*ecs.RegisterTaskDefinitionOutput) 1777 return ret0, ret1 1778 } 1779 1780 // RegisterTaskDefinitionRequest indicates an expected call of RegisterTaskDefinitionRequest 1781 func (mr *MockECSAPIMockRecorder) RegisterTaskDefinitionRequest(arg0 interface{}) *gomock.Call { 1782 mr.mock.ctrl.T.Helper() 1783 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskDefinitionRequest", reflect.TypeOf((*MockECSAPI)(nil).RegisterTaskDefinitionRequest), arg0) 1784 } 1785 1786 // RunTask mocks base method 1787 func (m *MockECSAPI) RunTask(arg0 *ecs.RunTaskInput) (*ecs.RunTaskOutput, error) { 1788 m.ctrl.T.Helper() 1789 ret := m.ctrl.Call(m, "RunTask", arg0) 1790 ret0, _ := ret[0].(*ecs.RunTaskOutput) 1791 ret1, _ := ret[1].(error) 1792 return ret0, ret1 1793 } 1794 1795 // RunTask indicates an expected call of RunTask 1796 func (mr *MockECSAPIMockRecorder) RunTask(arg0 interface{}) *gomock.Call { 1797 mr.mock.ctrl.T.Helper() 1798 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTask", reflect.TypeOf((*MockECSAPI)(nil).RunTask), arg0) 1799 } 1800 1801 // RunTaskWithContext mocks base method 1802 func (m *MockECSAPI) RunTaskWithContext(arg0 aws.Context, arg1 *ecs.RunTaskInput, arg2 ...request.Option) (*ecs.RunTaskOutput, error) { 1803 m.ctrl.T.Helper() 1804 varargs := []interface{}{arg0, arg1} 1805 for _, a := range arg2 { 1806 varargs = append(varargs, a) 1807 } 1808 ret := m.ctrl.Call(m, "RunTaskWithContext", varargs...) 1809 ret0, _ := ret[0].(*ecs.RunTaskOutput) 1810 ret1, _ := ret[1].(error) 1811 return ret0, ret1 1812 } 1813 1814 // RunTaskWithContext indicates an expected call of RunTaskWithContext 1815 func (mr *MockECSAPIMockRecorder) RunTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1816 mr.mock.ctrl.T.Helper() 1817 varargs := append([]interface{}{arg0, arg1}, arg2...) 1818 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTaskWithContext", reflect.TypeOf((*MockECSAPI)(nil).RunTaskWithContext), varargs...) 1819 } 1820 1821 // RunTaskRequest mocks base method 1822 func (m *MockECSAPI) RunTaskRequest(arg0 *ecs.RunTaskInput) (*request.Request, *ecs.RunTaskOutput) { 1823 m.ctrl.T.Helper() 1824 ret := m.ctrl.Call(m, "RunTaskRequest", arg0) 1825 ret0, _ := ret[0].(*request.Request) 1826 ret1, _ := ret[1].(*ecs.RunTaskOutput) 1827 return ret0, ret1 1828 } 1829 1830 // RunTaskRequest indicates an expected call of RunTaskRequest 1831 func (mr *MockECSAPIMockRecorder) RunTaskRequest(arg0 interface{}) *gomock.Call { 1832 mr.mock.ctrl.T.Helper() 1833 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTaskRequest", reflect.TypeOf((*MockECSAPI)(nil).RunTaskRequest), arg0) 1834 } 1835 1836 // StartTask mocks base method 1837 func (m *MockECSAPI) StartTask(arg0 *ecs.StartTaskInput) (*ecs.StartTaskOutput, error) { 1838 m.ctrl.T.Helper() 1839 ret := m.ctrl.Call(m, "StartTask", arg0) 1840 ret0, _ := ret[0].(*ecs.StartTaskOutput) 1841 ret1, _ := ret[1].(error) 1842 return ret0, ret1 1843 } 1844 1845 // StartTask indicates an expected call of StartTask 1846 func (mr *MockECSAPIMockRecorder) StartTask(arg0 interface{}) *gomock.Call { 1847 mr.mock.ctrl.T.Helper() 1848 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTask", reflect.TypeOf((*MockECSAPI)(nil).StartTask), arg0) 1849 } 1850 1851 // StartTaskWithContext mocks base method 1852 func (m *MockECSAPI) StartTaskWithContext(arg0 aws.Context, arg1 *ecs.StartTaskInput, arg2 ...request.Option) (*ecs.StartTaskOutput, error) { 1853 m.ctrl.T.Helper() 1854 varargs := []interface{}{arg0, arg1} 1855 for _, a := range arg2 { 1856 varargs = append(varargs, a) 1857 } 1858 ret := m.ctrl.Call(m, "StartTaskWithContext", varargs...) 1859 ret0, _ := ret[0].(*ecs.StartTaskOutput) 1860 ret1, _ := ret[1].(error) 1861 return ret0, ret1 1862 } 1863 1864 // StartTaskWithContext indicates an expected call of StartTaskWithContext 1865 func (mr *MockECSAPIMockRecorder) StartTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1866 mr.mock.ctrl.T.Helper() 1867 varargs := append([]interface{}{arg0, arg1}, arg2...) 1868 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTaskWithContext", reflect.TypeOf((*MockECSAPI)(nil).StartTaskWithContext), varargs...) 1869 } 1870 1871 // StartTaskRequest mocks base method 1872 func (m *MockECSAPI) StartTaskRequest(arg0 *ecs.StartTaskInput) (*request.Request, *ecs.StartTaskOutput) { 1873 m.ctrl.T.Helper() 1874 ret := m.ctrl.Call(m, "StartTaskRequest", arg0) 1875 ret0, _ := ret[0].(*request.Request) 1876 ret1, _ := ret[1].(*ecs.StartTaskOutput) 1877 return ret0, ret1 1878 } 1879 1880 // StartTaskRequest indicates an expected call of StartTaskRequest 1881 func (mr *MockECSAPIMockRecorder) StartTaskRequest(arg0 interface{}) *gomock.Call { 1882 mr.mock.ctrl.T.Helper() 1883 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTaskRequest", reflect.TypeOf((*MockECSAPI)(nil).StartTaskRequest), arg0) 1884 } 1885 1886 // StopTask mocks base method 1887 func (m *MockECSAPI) StopTask(arg0 *ecs.StopTaskInput) (*ecs.StopTaskOutput, error) { 1888 m.ctrl.T.Helper() 1889 ret := m.ctrl.Call(m, "StopTask", arg0) 1890 ret0, _ := ret[0].(*ecs.StopTaskOutput) 1891 ret1, _ := ret[1].(error) 1892 return ret0, ret1 1893 } 1894 1895 // StopTask indicates an expected call of StopTask 1896 func (mr *MockECSAPIMockRecorder) StopTask(arg0 interface{}) *gomock.Call { 1897 mr.mock.ctrl.T.Helper() 1898 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTask", reflect.TypeOf((*MockECSAPI)(nil).StopTask), arg0) 1899 } 1900 1901 // StopTaskWithContext mocks base method 1902 func (m *MockECSAPI) StopTaskWithContext(arg0 aws.Context, arg1 *ecs.StopTaskInput, arg2 ...request.Option) (*ecs.StopTaskOutput, error) { 1903 m.ctrl.T.Helper() 1904 varargs := []interface{}{arg0, arg1} 1905 for _, a := range arg2 { 1906 varargs = append(varargs, a) 1907 } 1908 ret := m.ctrl.Call(m, "StopTaskWithContext", varargs...) 1909 ret0, _ := ret[0].(*ecs.StopTaskOutput) 1910 ret1, _ := ret[1].(error) 1911 return ret0, ret1 1912 } 1913 1914 // StopTaskWithContext indicates an expected call of StopTaskWithContext 1915 func (mr *MockECSAPIMockRecorder) StopTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1916 mr.mock.ctrl.T.Helper() 1917 varargs := append([]interface{}{arg0, arg1}, arg2...) 1918 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTaskWithContext", reflect.TypeOf((*MockECSAPI)(nil).StopTaskWithContext), varargs...) 1919 } 1920 1921 // StopTaskRequest mocks base method 1922 func (m *MockECSAPI) StopTaskRequest(arg0 *ecs.StopTaskInput) (*request.Request, *ecs.StopTaskOutput) { 1923 m.ctrl.T.Helper() 1924 ret := m.ctrl.Call(m, "StopTaskRequest", arg0) 1925 ret0, _ := ret[0].(*request.Request) 1926 ret1, _ := ret[1].(*ecs.StopTaskOutput) 1927 return ret0, ret1 1928 } 1929 1930 // StopTaskRequest indicates an expected call of StopTaskRequest 1931 func (mr *MockECSAPIMockRecorder) StopTaskRequest(arg0 interface{}) *gomock.Call { 1932 mr.mock.ctrl.T.Helper() 1933 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTaskRequest", reflect.TypeOf((*MockECSAPI)(nil).StopTaskRequest), arg0) 1934 } 1935 1936 // SubmitAttachmentStateChanges mocks base method 1937 func (m *MockECSAPI) SubmitAttachmentStateChanges(arg0 *ecs.SubmitAttachmentStateChangesInput) (*ecs.SubmitAttachmentStateChangesOutput, error) { 1938 m.ctrl.T.Helper() 1939 ret := m.ctrl.Call(m, "SubmitAttachmentStateChanges", arg0) 1940 ret0, _ := ret[0].(*ecs.SubmitAttachmentStateChangesOutput) 1941 ret1, _ := ret[1].(error) 1942 return ret0, ret1 1943 } 1944 1945 // SubmitAttachmentStateChanges indicates an expected call of SubmitAttachmentStateChanges 1946 func (mr *MockECSAPIMockRecorder) SubmitAttachmentStateChanges(arg0 interface{}) *gomock.Call { 1947 mr.mock.ctrl.T.Helper() 1948 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAttachmentStateChanges", reflect.TypeOf((*MockECSAPI)(nil).SubmitAttachmentStateChanges), arg0) 1949 } 1950 1951 // SubmitAttachmentStateChangesWithContext mocks base method 1952 func (m *MockECSAPI) SubmitAttachmentStateChangesWithContext(arg0 aws.Context, arg1 *ecs.SubmitAttachmentStateChangesInput, arg2 ...request.Option) (*ecs.SubmitAttachmentStateChangesOutput, error) { 1953 m.ctrl.T.Helper() 1954 varargs := []interface{}{arg0, arg1} 1955 for _, a := range arg2 { 1956 varargs = append(varargs, a) 1957 } 1958 ret := m.ctrl.Call(m, "SubmitAttachmentStateChangesWithContext", varargs...) 1959 ret0, _ := ret[0].(*ecs.SubmitAttachmentStateChangesOutput) 1960 ret1, _ := ret[1].(error) 1961 return ret0, ret1 1962 } 1963 1964 // SubmitAttachmentStateChangesWithContext indicates an expected call of SubmitAttachmentStateChangesWithContext 1965 func (mr *MockECSAPIMockRecorder) SubmitAttachmentStateChangesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1966 mr.mock.ctrl.T.Helper() 1967 varargs := append([]interface{}{arg0, arg1}, arg2...) 1968 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAttachmentStateChangesWithContext", reflect.TypeOf((*MockECSAPI)(nil).SubmitAttachmentStateChangesWithContext), varargs...) 1969 } 1970 1971 // SubmitAttachmentStateChangesRequest mocks base method 1972 func (m *MockECSAPI) SubmitAttachmentStateChangesRequest(arg0 *ecs.SubmitAttachmentStateChangesInput) (*request.Request, *ecs.SubmitAttachmentStateChangesOutput) { 1973 m.ctrl.T.Helper() 1974 ret := m.ctrl.Call(m, "SubmitAttachmentStateChangesRequest", arg0) 1975 ret0, _ := ret[0].(*request.Request) 1976 ret1, _ := ret[1].(*ecs.SubmitAttachmentStateChangesOutput) 1977 return ret0, ret1 1978 } 1979 1980 // SubmitAttachmentStateChangesRequest indicates an expected call of SubmitAttachmentStateChangesRequest 1981 func (mr *MockECSAPIMockRecorder) SubmitAttachmentStateChangesRequest(arg0 interface{}) *gomock.Call { 1982 mr.mock.ctrl.T.Helper() 1983 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAttachmentStateChangesRequest", reflect.TypeOf((*MockECSAPI)(nil).SubmitAttachmentStateChangesRequest), arg0) 1984 } 1985 1986 // SubmitContainerStateChange mocks base method 1987 func (m *MockECSAPI) SubmitContainerStateChange(arg0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) { 1988 m.ctrl.T.Helper() 1989 ret := m.ctrl.Call(m, "SubmitContainerStateChange", arg0) 1990 ret0, _ := ret[0].(*ecs.SubmitContainerStateChangeOutput) 1991 ret1, _ := ret[1].(error) 1992 return ret0, ret1 1993 } 1994 1995 // SubmitContainerStateChange indicates an expected call of SubmitContainerStateChange 1996 func (mr *MockECSAPIMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { 1997 mr.mock.ctrl.T.Helper() 1998 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSAPI)(nil).SubmitContainerStateChange), arg0) 1999 } 2000 2001 // SubmitContainerStateChangeWithContext mocks base method 2002 func (m *MockECSAPI) SubmitContainerStateChangeWithContext(arg0 aws.Context, arg1 *ecs.SubmitContainerStateChangeInput, arg2 ...request.Option) (*ecs.SubmitContainerStateChangeOutput, error) { 2003 m.ctrl.T.Helper() 2004 varargs := []interface{}{arg0, arg1} 2005 for _, a := range arg2 { 2006 varargs = append(varargs, a) 2007 } 2008 ret := m.ctrl.Call(m, "SubmitContainerStateChangeWithContext", varargs...) 2009 ret0, _ := ret[0].(*ecs.SubmitContainerStateChangeOutput) 2010 ret1, _ := ret[1].(error) 2011 return ret0, ret1 2012 } 2013 2014 // SubmitContainerStateChangeWithContext indicates an expected call of SubmitContainerStateChangeWithContext 2015 func (mr *MockECSAPIMockRecorder) SubmitContainerStateChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2016 mr.mock.ctrl.T.Helper() 2017 varargs := append([]interface{}{arg0, arg1}, arg2...) 2018 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChangeWithContext", reflect.TypeOf((*MockECSAPI)(nil).SubmitContainerStateChangeWithContext), varargs...) 2019 } 2020 2021 // SubmitContainerStateChangeRequest mocks base method 2022 func (m *MockECSAPI) SubmitContainerStateChangeRequest(arg0 *ecs.SubmitContainerStateChangeInput) (*request.Request, *ecs.SubmitContainerStateChangeOutput) { 2023 m.ctrl.T.Helper() 2024 ret := m.ctrl.Call(m, "SubmitContainerStateChangeRequest", arg0) 2025 ret0, _ := ret[0].(*request.Request) 2026 ret1, _ := ret[1].(*ecs.SubmitContainerStateChangeOutput) 2027 return ret0, ret1 2028 } 2029 2030 // SubmitContainerStateChangeRequest indicates an expected call of SubmitContainerStateChangeRequest 2031 func (mr *MockECSAPIMockRecorder) SubmitContainerStateChangeRequest(arg0 interface{}) *gomock.Call { 2032 mr.mock.ctrl.T.Helper() 2033 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChangeRequest", reflect.TypeOf((*MockECSAPI)(nil).SubmitContainerStateChangeRequest), arg0) 2034 } 2035 2036 // SubmitTaskStateChange mocks base method 2037 func (m *MockECSAPI) SubmitTaskStateChange(arg0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) { 2038 m.ctrl.T.Helper() 2039 ret := m.ctrl.Call(m, "SubmitTaskStateChange", arg0) 2040 ret0, _ := ret[0].(*ecs.SubmitTaskStateChangeOutput) 2041 ret1, _ := ret[1].(error) 2042 return ret0, ret1 2043 } 2044 2045 // SubmitTaskStateChange indicates an expected call of SubmitTaskStateChange 2046 func (mr *MockECSAPIMockRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { 2047 mr.mock.ctrl.T.Helper() 2048 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChange", reflect.TypeOf((*MockECSAPI)(nil).SubmitTaskStateChange), arg0) 2049 } 2050 2051 // SubmitTaskStateChangeWithContext mocks base method 2052 func (m *MockECSAPI) SubmitTaskStateChangeWithContext(arg0 aws.Context, arg1 *ecs.SubmitTaskStateChangeInput, arg2 ...request.Option) (*ecs.SubmitTaskStateChangeOutput, error) { 2053 m.ctrl.T.Helper() 2054 varargs := []interface{}{arg0, arg1} 2055 for _, a := range arg2 { 2056 varargs = append(varargs, a) 2057 } 2058 ret := m.ctrl.Call(m, "SubmitTaskStateChangeWithContext", varargs...) 2059 ret0, _ := ret[0].(*ecs.SubmitTaskStateChangeOutput) 2060 ret1, _ := ret[1].(error) 2061 return ret0, ret1 2062 } 2063 2064 // SubmitTaskStateChangeWithContext indicates an expected call of SubmitTaskStateChangeWithContext 2065 func (mr *MockECSAPIMockRecorder) SubmitTaskStateChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2066 mr.mock.ctrl.T.Helper() 2067 varargs := append([]interface{}{arg0, arg1}, arg2...) 2068 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChangeWithContext", reflect.TypeOf((*MockECSAPI)(nil).SubmitTaskStateChangeWithContext), varargs...) 2069 } 2070 2071 // SubmitTaskStateChangeRequest mocks base method 2072 func (m *MockECSAPI) SubmitTaskStateChangeRequest(arg0 *ecs.SubmitTaskStateChangeInput) (*request.Request, *ecs.SubmitTaskStateChangeOutput) { 2073 m.ctrl.T.Helper() 2074 ret := m.ctrl.Call(m, "SubmitTaskStateChangeRequest", arg0) 2075 ret0, _ := ret[0].(*request.Request) 2076 ret1, _ := ret[1].(*ecs.SubmitTaskStateChangeOutput) 2077 return ret0, ret1 2078 } 2079 2080 // SubmitTaskStateChangeRequest indicates an expected call of SubmitTaskStateChangeRequest 2081 func (mr *MockECSAPIMockRecorder) SubmitTaskStateChangeRequest(arg0 interface{}) *gomock.Call { 2082 mr.mock.ctrl.T.Helper() 2083 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChangeRequest", reflect.TypeOf((*MockECSAPI)(nil).SubmitTaskStateChangeRequest), arg0) 2084 } 2085 2086 // TagResource mocks base method 2087 func (m *MockECSAPI) TagResource(arg0 *ecs.TagResourceInput) (*ecs.TagResourceOutput, error) { 2088 m.ctrl.T.Helper() 2089 ret := m.ctrl.Call(m, "TagResource", arg0) 2090 ret0, _ := ret[0].(*ecs.TagResourceOutput) 2091 ret1, _ := ret[1].(error) 2092 return ret0, ret1 2093 } 2094 2095 // TagResource indicates an expected call of TagResource 2096 func (mr *MockECSAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { 2097 mr.mock.ctrl.T.Helper() 2098 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockECSAPI)(nil).TagResource), arg0) 2099 } 2100 2101 // TagResourceWithContext mocks base method 2102 func (m *MockECSAPI) TagResourceWithContext(arg0 aws.Context, arg1 *ecs.TagResourceInput, arg2 ...request.Option) (*ecs.TagResourceOutput, error) { 2103 m.ctrl.T.Helper() 2104 varargs := []interface{}{arg0, arg1} 2105 for _, a := range arg2 { 2106 varargs = append(varargs, a) 2107 } 2108 ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) 2109 ret0, _ := ret[0].(*ecs.TagResourceOutput) 2110 ret1, _ := ret[1].(error) 2111 return ret0, ret1 2112 } 2113 2114 // TagResourceWithContext indicates an expected call of TagResourceWithContext 2115 func (mr *MockECSAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2116 mr.mock.ctrl.T.Helper() 2117 varargs := append([]interface{}{arg0, arg1}, arg2...) 2118 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockECSAPI)(nil).TagResourceWithContext), varargs...) 2119 } 2120 2121 // TagResourceRequest mocks base method 2122 func (m *MockECSAPI) TagResourceRequest(arg0 *ecs.TagResourceInput) (*request.Request, *ecs.TagResourceOutput) { 2123 m.ctrl.T.Helper() 2124 ret := m.ctrl.Call(m, "TagResourceRequest", arg0) 2125 ret0, _ := ret[0].(*request.Request) 2126 ret1, _ := ret[1].(*ecs.TagResourceOutput) 2127 return ret0, ret1 2128 } 2129 2130 // TagResourceRequest indicates an expected call of TagResourceRequest 2131 func (mr *MockECSAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { 2132 mr.mock.ctrl.T.Helper() 2133 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockECSAPI)(nil).TagResourceRequest), arg0) 2134 } 2135 2136 // UntagResource mocks base method 2137 func (m *MockECSAPI) UntagResource(arg0 *ecs.UntagResourceInput) (*ecs.UntagResourceOutput, error) { 2138 m.ctrl.T.Helper() 2139 ret := m.ctrl.Call(m, "UntagResource", arg0) 2140 ret0, _ := ret[0].(*ecs.UntagResourceOutput) 2141 ret1, _ := ret[1].(error) 2142 return ret0, ret1 2143 } 2144 2145 // UntagResource indicates an expected call of UntagResource 2146 func (mr *MockECSAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { 2147 mr.mock.ctrl.T.Helper() 2148 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockECSAPI)(nil).UntagResource), arg0) 2149 } 2150 2151 // UntagResourceWithContext mocks base method 2152 func (m *MockECSAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *ecs.UntagResourceInput, arg2 ...request.Option) (*ecs.UntagResourceOutput, error) { 2153 m.ctrl.T.Helper() 2154 varargs := []interface{}{arg0, arg1} 2155 for _, a := range arg2 { 2156 varargs = append(varargs, a) 2157 } 2158 ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) 2159 ret0, _ := ret[0].(*ecs.UntagResourceOutput) 2160 ret1, _ := ret[1].(error) 2161 return ret0, ret1 2162 } 2163 2164 // UntagResourceWithContext indicates an expected call of UntagResourceWithContext 2165 func (mr *MockECSAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2166 mr.mock.ctrl.T.Helper() 2167 varargs := append([]interface{}{arg0, arg1}, arg2...) 2168 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockECSAPI)(nil).UntagResourceWithContext), varargs...) 2169 } 2170 2171 // UntagResourceRequest mocks base method 2172 func (m *MockECSAPI) UntagResourceRequest(arg0 *ecs.UntagResourceInput) (*request.Request, *ecs.UntagResourceOutput) { 2173 m.ctrl.T.Helper() 2174 ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) 2175 ret0, _ := ret[0].(*request.Request) 2176 ret1, _ := ret[1].(*ecs.UntagResourceOutput) 2177 return ret0, ret1 2178 } 2179 2180 // UntagResourceRequest indicates an expected call of UntagResourceRequest 2181 func (mr *MockECSAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { 2182 mr.mock.ctrl.T.Helper() 2183 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockECSAPI)(nil).UntagResourceRequest), arg0) 2184 } 2185 2186 // UpdateClusterSettings mocks base method 2187 func (m *MockECSAPI) UpdateClusterSettings(arg0 *ecs.UpdateClusterSettingsInput) (*ecs.UpdateClusterSettingsOutput, error) { 2188 m.ctrl.T.Helper() 2189 ret := m.ctrl.Call(m, "UpdateClusterSettings", arg0) 2190 ret0, _ := ret[0].(*ecs.UpdateClusterSettingsOutput) 2191 ret1, _ := ret[1].(error) 2192 return ret0, ret1 2193 } 2194 2195 // UpdateClusterSettings indicates an expected call of UpdateClusterSettings 2196 func (mr *MockECSAPIMockRecorder) UpdateClusterSettings(arg0 interface{}) *gomock.Call { 2197 mr.mock.ctrl.T.Helper() 2198 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSettings", reflect.TypeOf((*MockECSAPI)(nil).UpdateClusterSettings), arg0) 2199 } 2200 2201 // UpdateClusterSettingsWithContext mocks base method 2202 func (m *MockECSAPI) UpdateClusterSettingsWithContext(arg0 aws.Context, arg1 *ecs.UpdateClusterSettingsInput, arg2 ...request.Option) (*ecs.UpdateClusterSettingsOutput, error) { 2203 m.ctrl.T.Helper() 2204 varargs := []interface{}{arg0, arg1} 2205 for _, a := range arg2 { 2206 varargs = append(varargs, a) 2207 } 2208 ret := m.ctrl.Call(m, "UpdateClusterSettingsWithContext", varargs...) 2209 ret0, _ := ret[0].(*ecs.UpdateClusterSettingsOutput) 2210 ret1, _ := ret[1].(error) 2211 return ret0, ret1 2212 } 2213 2214 // UpdateClusterSettingsWithContext indicates an expected call of UpdateClusterSettingsWithContext 2215 func (mr *MockECSAPIMockRecorder) UpdateClusterSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2216 mr.mock.ctrl.T.Helper() 2217 varargs := append([]interface{}{arg0, arg1}, arg2...) 2218 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSettingsWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateClusterSettingsWithContext), varargs...) 2219 } 2220 2221 // UpdateClusterSettingsRequest mocks base method 2222 func (m *MockECSAPI) UpdateClusterSettingsRequest(arg0 *ecs.UpdateClusterSettingsInput) (*request.Request, *ecs.UpdateClusterSettingsOutput) { 2223 m.ctrl.T.Helper() 2224 ret := m.ctrl.Call(m, "UpdateClusterSettingsRequest", arg0) 2225 ret0, _ := ret[0].(*request.Request) 2226 ret1, _ := ret[1].(*ecs.UpdateClusterSettingsOutput) 2227 return ret0, ret1 2228 } 2229 2230 // UpdateClusterSettingsRequest indicates an expected call of UpdateClusterSettingsRequest 2231 func (mr *MockECSAPIMockRecorder) UpdateClusterSettingsRequest(arg0 interface{}) *gomock.Call { 2232 mr.mock.ctrl.T.Helper() 2233 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSettingsRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateClusterSettingsRequest), arg0) 2234 } 2235 2236 // UpdateContainerAgent mocks base method 2237 func (m *MockECSAPI) UpdateContainerAgent(arg0 *ecs.UpdateContainerAgentInput) (*ecs.UpdateContainerAgentOutput, error) { 2238 m.ctrl.T.Helper() 2239 ret := m.ctrl.Call(m, "UpdateContainerAgent", arg0) 2240 ret0, _ := ret[0].(*ecs.UpdateContainerAgentOutput) 2241 ret1, _ := ret[1].(error) 2242 return ret0, ret1 2243 } 2244 2245 // UpdateContainerAgent indicates an expected call of UpdateContainerAgent 2246 func (mr *MockECSAPIMockRecorder) UpdateContainerAgent(arg0 interface{}) *gomock.Call { 2247 mr.mock.ctrl.T.Helper() 2248 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerAgent", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerAgent), arg0) 2249 } 2250 2251 // UpdateContainerAgentWithContext mocks base method 2252 func (m *MockECSAPI) UpdateContainerAgentWithContext(arg0 aws.Context, arg1 *ecs.UpdateContainerAgentInput, arg2 ...request.Option) (*ecs.UpdateContainerAgentOutput, error) { 2253 m.ctrl.T.Helper() 2254 varargs := []interface{}{arg0, arg1} 2255 for _, a := range arg2 { 2256 varargs = append(varargs, a) 2257 } 2258 ret := m.ctrl.Call(m, "UpdateContainerAgentWithContext", varargs...) 2259 ret0, _ := ret[0].(*ecs.UpdateContainerAgentOutput) 2260 ret1, _ := ret[1].(error) 2261 return ret0, ret1 2262 } 2263 2264 // UpdateContainerAgentWithContext indicates an expected call of UpdateContainerAgentWithContext 2265 func (mr *MockECSAPIMockRecorder) UpdateContainerAgentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2266 mr.mock.ctrl.T.Helper() 2267 varargs := append([]interface{}{arg0, arg1}, arg2...) 2268 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerAgentWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerAgentWithContext), varargs...) 2269 } 2270 2271 // UpdateContainerAgentRequest mocks base method 2272 func (m *MockECSAPI) UpdateContainerAgentRequest(arg0 *ecs.UpdateContainerAgentInput) (*request.Request, *ecs.UpdateContainerAgentOutput) { 2273 m.ctrl.T.Helper() 2274 ret := m.ctrl.Call(m, "UpdateContainerAgentRequest", arg0) 2275 ret0, _ := ret[0].(*request.Request) 2276 ret1, _ := ret[1].(*ecs.UpdateContainerAgentOutput) 2277 return ret0, ret1 2278 } 2279 2280 // UpdateContainerAgentRequest indicates an expected call of UpdateContainerAgentRequest 2281 func (mr *MockECSAPIMockRecorder) UpdateContainerAgentRequest(arg0 interface{}) *gomock.Call { 2282 mr.mock.ctrl.T.Helper() 2283 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerAgentRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerAgentRequest), arg0) 2284 } 2285 2286 // UpdateContainerInstancesState mocks base method 2287 func (m *MockECSAPI) UpdateContainerInstancesState(arg0 *ecs.UpdateContainerInstancesStateInput) (*ecs.UpdateContainerInstancesStateOutput, error) { 2288 m.ctrl.T.Helper() 2289 ret := m.ctrl.Call(m, "UpdateContainerInstancesState", arg0) 2290 ret0, _ := ret[0].(*ecs.UpdateContainerInstancesStateOutput) 2291 ret1, _ := ret[1].(error) 2292 return ret0, ret1 2293 } 2294 2295 // UpdateContainerInstancesState indicates an expected call of UpdateContainerInstancesState 2296 func (mr *MockECSAPIMockRecorder) UpdateContainerInstancesState(arg0 interface{}) *gomock.Call { 2297 mr.mock.ctrl.T.Helper() 2298 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerInstancesState", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerInstancesState), arg0) 2299 } 2300 2301 // UpdateContainerInstancesStateWithContext mocks base method 2302 func (m *MockECSAPI) UpdateContainerInstancesStateWithContext(arg0 aws.Context, arg1 *ecs.UpdateContainerInstancesStateInput, arg2 ...request.Option) (*ecs.UpdateContainerInstancesStateOutput, error) { 2303 m.ctrl.T.Helper() 2304 varargs := []interface{}{arg0, arg1} 2305 for _, a := range arg2 { 2306 varargs = append(varargs, a) 2307 } 2308 ret := m.ctrl.Call(m, "UpdateContainerInstancesStateWithContext", varargs...) 2309 ret0, _ := ret[0].(*ecs.UpdateContainerInstancesStateOutput) 2310 ret1, _ := ret[1].(error) 2311 return ret0, ret1 2312 } 2313 2314 // UpdateContainerInstancesStateWithContext indicates an expected call of UpdateContainerInstancesStateWithContext 2315 func (mr *MockECSAPIMockRecorder) UpdateContainerInstancesStateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2316 mr.mock.ctrl.T.Helper() 2317 varargs := append([]interface{}{arg0, arg1}, arg2...) 2318 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerInstancesStateWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerInstancesStateWithContext), varargs...) 2319 } 2320 2321 // UpdateContainerInstancesStateRequest mocks base method 2322 func (m *MockECSAPI) UpdateContainerInstancesStateRequest(arg0 *ecs.UpdateContainerInstancesStateInput) (*request.Request, *ecs.UpdateContainerInstancesStateOutput) { 2323 m.ctrl.T.Helper() 2324 ret := m.ctrl.Call(m, "UpdateContainerInstancesStateRequest", arg0) 2325 ret0, _ := ret[0].(*request.Request) 2326 ret1, _ := ret[1].(*ecs.UpdateContainerInstancesStateOutput) 2327 return ret0, ret1 2328 } 2329 2330 // UpdateContainerInstancesStateRequest indicates an expected call of UpdateContainerInstancesStateRequest 2331 func (mr *MockECSAPIMockRecorder) UpdateContainerInstancesStateRequest(arg0 interface{}) *gomock.Call { 2332 mr.mock.ctrl.T.Helper() 2333 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerInstancesStateRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateContainerInstancesStateRequest), arg0) 2334 } 2335 2336 // UpdateService mocks base method 2337 func (m *MockECSAPI) UpdateService(arg0 *ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error) { 2338 m.ctrl.T.Helper() 2339 ret := m.ctrl.Call(m, "UpdateService", arg0) 2340 ret0, _ := ret[0].(*ecs.UpdateServiceOutput) 2341 ret1, _ := ret[1].(error) 2342 return ret0, ret1 2343 } 2344 2345 // UpdateService indicates an expected call of UpdateService 2346 func (mr *MockECSAPIMockRecorder) UpdateService(arg0 interface{}) *gomock.Call { 2347 mr.mock.ctrl.T.Helper() 2348 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockECSAPI)(nil).UpdateService), arg0) 2349 } 2350 2351 // UpdateServiceWithContext mocks base method 2352 func (m *MockECSAPI) UpdateServiceWithContext(arg0 aws.Context, arg1 *ecs.UpdateServiceInput, arg2 ...request.Option) (*ecs.UpdateServiceOutput, error) { 2353 m.ctrl.T.Helper() 2354 varargs := []interface{}{arg0, arg1} 2355 for _, a := range arg2 { 2356 varargs = append(varargs, a) 2357 } 2358 ret := m.ctrl.Call(m, "UpdateServiceWithContext", varargs...) 2359 ret0, _ := ret[0].(*ecs.UpdateServiceOutput) 2360 ret1, _ := ret[1].(error) 2361 return ret0, ret1 2362 } 2363 2364 // UpdateServiceWithContext indicates an expected call of UpdateServiceWithContext 2365 func (mr *MockECSAPIMockRecorder) UpdateServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2366 mr.mock.ctrl.T.Helper() 2367 varargs := append([]interface{}{arg0, arg1}, arg2...) 2368 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateServiceWithContext), varargs...) 2369 } 2370 2371 // UpdateServiceRequest mocks base method 2372 func (m *MockECSAPI) UpdateServiceRequest(arg0 *ecs.UpdateServiceInput) (*request.Request, *ecs.UpdateServiceOutput) { 2373 m.ctrl.T.Helper() 2374 ret := m.ctrl.Call(m, "UpdateServiceRequest", arg0) 2375 ret0, _ := ret[0].(*request.Request) 2376 ret1, _ := ret[1].(*ecs.UpdateServiceOutput) 2377 return ret0, ret1 2378 } 2379 2380 // UpdateServiceRequest indicates an expected call of UpdateServiceRequest 2381 func (mr *MockECSAPIMockRecorder) UpdateServiceRequest(arg0 interface{}) *gomock.Call { 2382 mr.mock.ctrl.T.Helper() 2383 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateServiceRequest), arg0) 2384 } 2385 2386 // UpdateServicePrimaryTaskSet mocks base method 2387 func (m *MockECSAPI) UpdateServicePrimaryTaskSet(arg0 *ecs.UpdateServicePrimaryTaskSetInput) (*ecs.UpdateServicePrimaryTaskSetOutput, error) { 2388 m.ctrl.T.Helper() 2389 ret := m.ctrl.Call(m, "UpdateServicePrimaryTaskSet", arg0) 2390 ret0, _ := ret[0].(*ecs.UpdateServicePrimaryTaskSetOutput) 2391 ret1, _ := ret[1].(error) 2392 return ret0, ret1 2393 } 2394 2395 // UpdateServicePrimaryTaskSet indicates an expected call of UpdateServicePrimaryTaskSet 2396 func (mr *MockECSAPIMockRecorder) UpdateServicePrimaryTaskSet(arg0 interface{}) *gomock.Call { 2397 mr.mock.ctrl.T.Helper() 2398 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServicePrimaryTaskSet", reflect.TypeOf((*MockECSAPI)(nil).UpdateServicePrimaryTaskSet), arg0) 2399 } 2400 2401 // UpdateServicePrimaryTaskSetWithContext mocks base method 2402 func (m *MockECSAPI) UpdateServicePrimaryTaskSetWithContext(arg0 aws.Context, arg1 *ecs.UpdateServicePrimaryTaskSetInput, arg2 ...request.Option) (*ecs.UpdateServicePrimaryTaskSetOutput, error) { 2403 m.ctrl.T.Helper() 2404 varargs := []interface{}{arg0, arg1} 2405 for _, a := range arg2 { 2406 varargs = append(varargs, a) 2407 } 2408 ret := m.ctrl.Call(m, "UpdateServicePrimaryTaskSetWithContext", varargs...) 2409 ret0, _ := ret[0].(*ecs.UpdateServicePrimaryTaskSetOutput) 2410 ret1, _ := ret[1].(error) 2411 return ret0, ret1 2412 } 2413 2414 // UpdateServicePrimaryTaskSetWithContext indicates an expected call of UpdateServicePrimaryTaskSetWithContext 2415 func (mr *MockECSAPIMockRecorder) UpdateServicePrimaryTaskSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2416 mr.mock.ctrl.T.Helper() 2417 varargs := append([]interface{}{arg0, arg1}, arg2...) 2418 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServicePrimaryTaskSetWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateServicePrimaryTaskSetWithContext), varargs...) 2419 } 2420 2421 // UpdateServicePrimaryTaskSetRequest mocks base method 2422 func (m *MockECSAPI) UpdateServicePrimaryTaskSetRequest(arg0 *ecs.UpdateServicePrimaryTaskSetInput) (*request.Request, *ecs.UpdateServicePrimaryTaskSetOutput) { 2423 m.ctrl.T.Helper() 2424 ret := m.ctrl.Call(m, "UpdateServicePrimaryTaskSetRequest", arg0) 2425 ret0, _ := ret[0].(*request.Request) 2426 ret1, _ := ret[1].(*ecs.UpdateServicePrimaryTaskSetOutput) 2427 return ret0, ret1 2428 } 2429 2430 // UpdateServicePrimaryTaskSetRequest indicates an expected call of UpdateServicePrimaryTaskSetRequest 2431 func (mr *MockECSAPIMockRecorder) UpdateServicePrimaryTaskSetRequest(arg0 interface{}) *gomock.Call { 2432 mr.mock.ctrl.T.Helper() 2433 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServicePrimaryTaskSetRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateServicePrimaryTaskSetRequest), arg0) 2434 } 2435 2436 // UpdateTaskSet mocks base method 2437 func (m *MockECSAPI) UpdateTaskSet(arg0 *ecs.UpdateTaskSetInput) (*ecs.UpdateTaskSetOutput, error) { 2438 m.ctrl.T.Helper() 2439 ret := m.ctrl.Call(m, "UpdateTaskSet", arg0) 2440 ret0, _ := ret[0].(*ecs.UpdateTaskSetOutput) 2441 ret1, _ := ret[1].(error) 2442 return ret0, ret1 2443 } 2444 2445 // UpdateTaskSet indicates an expected call of UpdateTaskSet 2446 func (mr *MockECSAPIMockRecorder) UpdateTaskSet(arg0 interface{}) *gomock.Call { 2447 mr.mock.ctrl.T.Helper() 2448 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskSet", reflect.TypeOf((*MockECSAPI)(nil).UpdateTaskSet), arg0) 2449 } 2450 2451 // UpdateTaskSetWithContext mocks base method 2452 func (m *MockECSAPI) UpdateTaskSetWithContext(arg0 aws.Context, arg1 *ecs.UpdateTaskSetInput, arg2 ...request.Option) (*ecs.UpdateTaskSetOutput, error) { 2453 m.ctrl.T.Helper() 2454 varargs := []interface{}{arg0, arg1} 2455 for _, a := range arg2 { 2456 varargs = append(varargs, a) 2457 } 2458 ret := m.ctrl.Call(m, "UpdateTaskSetWithContext", varargs...) 2459 ret0, _ := ret[0].(*ecs.UpdateTaskSetOutput) 2460 ret1, _ := ret[1].(error) 2461 return ret0, ret1 2462 } 2463 2464 // UpdateTaskSetWithContext indicates an expected call of UpdateTaskSetWithContext 2465 func (mr *MockECSAPIMockRecorder) UpdateTaskSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2466 mr.mock.ctrl.T.Helper() 2467 varargs := append([]interface{}{arg0, arg1}, arg2...) 2468 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskSetWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateTaskSetWithContext), varargs...) 2469 } 2470 2471 // UpdateTaskSetRequest mocks base method 2472 func (m *MockECSAPI) UpdateTaskSetRequest(arg0 *ecs.UpdateTaskSetInput) (*request.Request, *ecs.UpdateTaskSetOutput) { 2473 m.ctrl.T.Helper() 2474 ret := m.ctrl.Call(m, "UpdateTaskSetRequest", arg0) 2475 ret0, _ := ret[0].(*request.Request) 2476 ret1, _ := ret[1].(*ecs.UpdateTaskSetOutput) 2477 return ret0, ret1 2478 } 2479 2480 // UpdateTaskSetRequest indicates an expected call of UpdateTaskSetRequest 2481 func (mr *MockECSAPIMockRecorder) UpdateTaskSetRequest(arg0 interface{}) *gomock.Call { 2482 mr.mock.ctrl.T.Helper() 2483 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskSetRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateTaskSetRequest), arg0) 2484 } 2485 2486 // WaitUntilServicesInactive mocks base method 2487 func (m *MockECSAPI) WaitUntilServicesInactive(arg0 *ecs.DescribeServicesInput) error { 2488 m.ctrl.T.Helper() 2489 ret := m.ctrl.Call(m, "WaitUntilServicesInactive", arg0) 2490 ret0, _ := ret[0].(error) 2491 return ret0 2492 } 2493 2494 // WaitUntilServicesInactive indicates an expected call of WaitUntilServicesInactive 2495 func (mr *MockECSAPIMockRecorder) WaitUntilServicesInactive(arg0 interface{}) *gomock.Call { 2496 mr.mock.ctrl.T.Helper() 2497 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesInactive", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesInactive), arg0) 2498 } 2499 2500 // WaitUntilServicesInactiveWithContext mocks base method 2501 func (m *MockECSAPI) WaitUntilServicesInactiveWithContext(arg0 aws.Context, arg1 *ecs.DescribeServicesInput, arg2 ...request.WaiterOption) error { 2502 m.ctrl.T.Helper() 2503 varargs := []interface{}{arg0, arg1} 2504 for _, a := range arg2 { 2505 varargs = append(varargs, a) 2506 } 2507 ret := m.ctrl.Call(m, "WaitUntilServicesInactiveWithContext", varargs...) 2508 ret0, _ := ret[0].(error) 2509 return ret0 2510 } 2511 2512 // WaitUntilServicesInactiveWithContext indicates an expected call of WaitUntilServicesInactiveWithContext 2513 func (mr *MockECSAPIMockRecorder) WaitUntilServicesInactiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2514 mr.mock.ctrl.T.Helper() 2515 varargs := append([]interface{}{arg0, arg1}, arg2...) 2516 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesInactiveWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesInactiveWithContext), varargs...) 2517 } 2518 2519 // WaitUntilServicesStable mocks base method 2520 func (m *MockECSAPI) WaitUntilServicesStable(arg0 *ecs.DescribeServicesInput) error { 2521 m.ctrl.T.Helper() 2522 ret := m.ctrl.Call(m, "WaitUntilServicesStable", arg0) 2523 ret0, _ := ret[0].(error) 2524 return ret0 2525 } 2526 2527 // WaitUntilServicesStable indicates an expected call of WaitUntilServicesStable 2528 func (mr *MockECSAPIMockRecorder) WaitUntilServicesStable(arg0 interface{}) *gomock.Call { 2529 mr.mock.ctrl.T.Helper() 2530 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesStable", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesStable), arg0) 2531 } 2532 2533 // WaitUntilServicesStableWithContext mocks base method 2534 func (m *MockECSAPI) WaitUntilServicesStableWithContext(arg0 aws.Context, arg1 *ecs.DescribeServicesInput, arg2 ...request.WaiterOption) error { 2535 m.ctrl.T.Helper() 2536 varargs := []interface{}{arg0, arg1} 2537 for _, a := range arg2 { 2538 varargs = append(varargs, a) 2539 } 2540 ret := m.ctrl.Call(m, "WaitUntilServicesStableWithContext", varargs...) 2541 ret0, _ := ret[0].(error) 2542 return ret0 2543 } 2544 2545 // WaitUntilServicesStableWithContext indicates an expected call of WaitUntilServicesStableWithContext 2546 func (mr *MockECSAPIMockRecorder) WaitUntilServicesStableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2547 mr.mock.ctrl.T.Helper() 2548 varargs := append([]interface{}{arg0, arg1}, arg2...) 2549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilServicesStableWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilServicesStableWithContext), varargs...) 2550 } 2551 2552 // WaitUntilTasksRunning mocks base method 2553 func (m *MockECSAPI) WaitUntilTasksRunning(arg0 *ecs.DescribeTasksInput) error { 2554 m.ctrl.T.Helper() 2555 ret := m.ctrl.Call(m, "WaitUntilTasksRunning", arg0) 2556 ret0, _ := ret[0].(error) 2557 return ret0 2558 } 2559 2560 // WaitUntilTasksRunning indicates an expected call of WaitUntilTasksRunning 2561 func (mr *MockECSAPIMockRecorder) WaitUntilTasksRunning(arg0 interface{}) *gomock.Call { 2562 mr.mock.ctrl.T.Helper() 2563 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksRunning", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksRunning), arg0) 2564 } 2565 2566 // WaitUntilTasksRunningWithContext mocks base method 2567 func (m *MockECSAPI) WaitUntilTasksRunningWithContext(arg0 aws.Context, arg1 *ecs.DescribeTasksInput, arg2 ...request.WaiterOption) error { 2568 m.ctrl.T.Helper() 2569 varargs := []interface{}{arg0, arg1} 2570 for _, a := range arg2 { 2571 varargs = append(varargs, a) 2572 } 2573 ret := m.ctrl.Call(m, "WaitUntilTasksRunningWithContext", varargs...) 2574 ret0, _ := ret[0].(error) 2575 return ret0 2576 } 2577 2578 // WaitUntilTasksRunningWithContext indicates an expected call of WaitUntilTasksRunningWithContext 2579 func (mr *MockECSAPIMockRecorder) WaitUntilTasksRunningWithContext(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, "WaitUntilTasksRunningWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksRunningWithContext), varargs...) 2583 } 2584 2585 // WaitUntilTasksStopped mocks base method 2586 func (m *MockECSAPI) WaitUntilTasksStopped(arg0 *ecs.DescribeTasksInput) error { 2587 m.ctrl.T.Helper() 2588 ret := m.ctrl.Call(m, "WaitUntilTasksStopped", arg0) 2589 ret0, _ := ret[0].(error) 2590 return ret0 2591 } 2592 2593 // WaitUntilTasksStopped indicates an expected call of WaitUntilTasksStopped 2594 func (mr *MockECSAPIMockRecorder) WaitUntilTasksStopped(arg0 interface{}) *gomock.Call { 2595 mr.mock.ctrl.T.Helper() 2596 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksStopped", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksStopped), arg0) 2597 } 2598 2599 // WaitUntilTasksStoppedWithContext mocks base method 2600 func (m *MockECSAPI) WaitUntilTasksStoppedWithContext(arg0 aws.Context, arg1 *ecs.DescribeTasksInput, arg2 ...request.WaiterOption) error { 2601 m.ctrl.T.Helper() 2602 varargs := []interface{}{arg0, arg1} 2603 for _, a := range arg2 { 2604 varargs = append(varargs, a) 2605 } 2606 ret := m.ctrl.Call(m, "WaitUntilTasksStoppedWithContext", varargs...) 2607 ret0, _ := ret[0].(error) 2608 return ret0 2609 } 2610 2611 // WaitUntilTasksStoppedWithContext indicates an expected call of WaitUntilTasksStoppedWithContext 2612 func (mr *MockECSAPIMockRecorder) WaitUntilTasksStoppedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2613 mr.mock.ctrl.T.Helper() 2614 varargs := append([]interface{}{arg0, arg1}, arg2...) 2615 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksStoppedWithContext", reflect.TypeOf((*MockECSAPI)(nil).WaitUntilTasksStoppedWithContext), varargs...) 2616 }