github.com/wata727/tflint@v0.12.2-0.20191013070026-96dd0d36f385/client/aws_elb_mock.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: ../vendor/github.com/aws/aws-sdk-go/service/elb/elbiface/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 elb "github.com/aws/aws-sdk-go/service/elb" 11 gomock "github.com/golang/mock/gomock" 12 reflect "reflect" 13 ) 14 15 // MockELBAPI is a mock of ELBAPI interface 16 type MockELBAPI struct { 17 ctrl *gomock.Controller 18 recorder *MockELBAPIMockRecorder 19 } 20 21 // MockELBAPIMockRecorder is the mock recorder for MockELBAPI 22 type MockELBAPIMockRecorder struct { 23 mock *MockELBAPI 24 } 25 26 // NewMockELBAPI creates a new mock instance 27 func NewMockELBAPI(ctrl *gomock.Controller) *MockELBAPI { 28 mock := &MockELBAPI{ctrl: ctrl} 29 mock.recorder = &MockELBAPIMockRecorder{mock} 30 return mock 31 } 32 33 // EXPECT returns an object that allows the caller to indicate expected use 34 func (m *MockELBAPI) EXPECT() *MockELBAPIMockRecorder { 35 return m.recorder 36 } 37 38 // AddTags mocks base method 39 func (m *MockELBAPI) AddTags(arg0 *elb.AddTagsInput) (*elb.AddTagsOutput, error) { 40 m.ctrl.T.Helper() 41 ret := m.ctrl.Call(m, "AddTags", arg0) 42 ret0, _ := ret[0].(*elb.AddTagsOutput) 43 ret1, _ := ret[1].(error) 44 return ret0, ret1 45 } 46 47 // AddTags indicates an expected call of AddTags 48 func (mr *MockELBAPIMockRecorder) AddTags(arg0 interface{}) *gomock.Call { 49 mr.mock.ctrl.T.Helper() 50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBAPI)(nil).AddTags), arg0) 51 } 52 53 // AddTagsWithContext mocks base method 54 func (m *MockELBAPI) AddTagsWithContext(arg0 aws.Context, arg1 *elb.AddTagsInput, arg2 ...request.Option) (*elb.AddTagsOutput, 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, "AddTagsWithContext", varargs...) 61 ret0, _ := ret[0].(*elb.AddTagsOutput) 62 ret1, _ := ret[1].(error) 63 return ret0, ret1 64 } 65 66 // AddTagsWithContext indicates an expected call of AddTagsWithContext 67 func (mr *MockELBAPIMockRecorder) AddTagsWithContext(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, "AddTagsWithContext", reflect.TypeOf((*MockELBAPI)(nil).AddTagsWithContext), varargs...) 71 } 72 73 // AddTagsRequest mocks base method 74 func (m *MockELBAPI) AddTagsRequest(arg0 *elb.AddTagsInput) (*request.Request, *elb.AddTagsOutput) { 75 m.ctrl.T.Helper() 76 ret := m.ctrl.Call(m, "AddTagsRequest", arg0) 77 ret0, _ := ret[0].(*request.Request) 78 ret1, _ := ret[1].(*elb.AddTagsOutput) 79 return ret0, ret1 80 } 81 82 // AddTagsRequest indicates an expected call of AddTagsRequest 83 func (mr *MockELBAPIMockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call { 84 mr.mock.ctrl.T.Helper() 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockELBAPI)(nil).AddTagsRequest), arg0) 86 } 87 88 // ApplySecurityGroupsToLoadBalancer mocks base method 89 func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancer(arg0 *elb.ApplySecurityGroupsToLoadBalancerInput) (*elb.ApplySecurityGroupsToLoadBalancerOutput, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "ApplySecurityGroupsToLoadBalancer", arg0) 92 ret0, _ := ret[0].(*elb.ApplySecurityGroupsToLoadBalancerOutput) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // ApplySecurityGroupsToLoadBalancer indicates an expected call of ApplySecurityGroupsToLoadBalancer 98 func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancer(arg0 interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancer), arg0) 101 } 102 103 // ApplySecurityGroupsToLoadBalancerWithContext mocks base method 104 func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.ApplySecurityGroupsToLoadBalancerInput, arg2 ...request.Option) (*elb.ApplySecurityGroupsToLoadBalancerOutput, 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, "ApplySecurityGroupsToLoadBalancerWithContext", varargs...) 111 ret0, _ := ret[0].(*elb.ApplySecurityGroupsToLoadBalancerOutput) 112 ret1, _ := ret[1].(error) 113 return ret0, ret1 114 } 115 116 // ApplySecurityGroupsToLoadBalancerWithContext indicates an expected call of ApplySecurityGroupsToLoadBalancerWithContext 117 func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancerWithContext(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, "ApplySecurityGroupsToLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancerWithContext), varargs...) 121 } 122 123 // ApplySecurityGroupsToLoadBalancerRequest mocks base method 124 func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancerRequest(arg0 *elb.ApplySecurityGroupsToLoadBalancerInput) (*request.Request, *elb.ApplySecurityGroupsToLoadBalancerOutput) { 125 m.ctrl.T.Helper() 126 ret := m.ctrl.Call(m, "ApplySecurityGroupsToLoadBalancerRequest", arg0) 127 ret0, _ := ret[0].(*request.Request) 128 ret1, _ := ret[1].(*elb.ApplySecurityGroupsToLoadBalancerOutput) 129 return ret0, ret1 130 } 131 132 // ApplySecurityGroupsToLoadBalancerRequest indicates an expected call of ApplySecurityGroupsToLoadBalancerRequest 133 func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancerRequest(arg0 interface{}) *gomock.Call { 134 mr.mock.ctrl.T.Helper() 135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancerRequest), arg0) 136 } 137 138 // AttachLoadBalancerToSubnets mocks base method 139 func (m *MockELBAPI) AttachLoadBalancerToSubnets(arg0 *elb.AttachLoadBalancerToSubnetsInput) (*elb.AttachLoadBalancerToSubnetsOutput, error) { 140 m.ctrl.T.Helper() 141 ret := m.ctrl.Call(m, "AttachLoadBalancerToSubnets", arg0) 142 ret0, _ := ret[0].(*elb.AttachLoadBalancerToSubnetsOutput) 143 ret1, _ := ret[1].(error) 144 return ret0, ret1 145 } 146 147 // AttachLoadBalancerToSubnets indicates an expected call of AttachLoadBalancerToSubnets 148 func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnets(arg0 interface{}) *gomock.Call { 149 mr.mock.ctrl.T.Helper() 150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerToSubnets", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnets), arg0) 151 } 152 153 // AttachLoadBalancerToSubnetsWithContext mocks base method 154 func (m *MockELBAPI) AttachLoadBalancerToSubnetsWithContext(arg0 aws.Context, arg1 *elb.AttachLoadBalancerToSubnetsInput, arg2 ...request.Option) (*elb.AttachLoadBalancerToSubnetsOutput, 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, "AttachLoadBalancerToSubnetsWithContext", varargs...) 161 ret0, _ := ret[0].(*elb.AttachLoadBalancerToSubnetsOutput) 162 ret1, _ := ret[1].(error) 163 return ret0, ret1 164 } 165 166 // AttachLoadBalancerToSubnetsWithContext indicates an expected call of AttachLoadBalancerToSubnetsWithContext 167 func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnetsWithContext(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, "AttachLoadBalancerToSubnetsWithContext", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnetsWithContext), varargs...) 171 } 172 173 // AttachLoadBalancerToSubnetsRequest mocks base method 174 func (m *MockELBAPI) AttachLoadBalancerToSubnetsRequest(arg0 *elb.AttachLoadBalancerToSubnetsInput) (*request.Request, *elb.AttachLoadBalancerToSubnetsOutput) { 175 m.ctrl.T.Helper() 176 ret := m.ctrl.Call(m, "AttachLoadBalancerToSubnetsRequest", arg0) 177 ret0, _ := ret[0].(*request.Request) 178 ret1, _ := ret[1].(*elb.AttachLoadBalancerToSubnetsOutput) 179 return ret0, ret1 180 } 181 182 // AttachLoadBalancerToSubnetsRequest indicates an expected call of AttachLoadBalancerToSubnetsRequest 183 func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnetsRequest(arg0 interface{}) *gomock.Call { 184 mr.mock.ctrl.T.Helper() 185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerToSubnetsRequest", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnetsRequest), arg0) 186 } 187 188 // ConfigureHealthCheck mocks base method 189 func (m *MockELBAPI) ConfigureHealthCheck(arg0 *elb.ConfigureHealthCheckInput) (*elb.ConfigureHealthCheckOutput, error) { 190 m.ctrl.T.Helper() 191 ret := m.ctrl.Call(m, "ConfigureHealthCheck", arg0) 192 ret0, _ := ret[0].(*elb.ConfigureHealthCheckOutput) 193 ret1, _ := ret[1].(error) 194 return ret0, ret1 195 } 196 197 // ConfigureHealthCheck indicates an expected call of ConfigureHealthCheck 198 func (mr *MockELBAPIMockRecorder) ConfigureHealthCheck(arg0 interface{}) *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureHealthCheck", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheck), arg0) 201 } 202 203 // ConfigureHealthCheckWithContext mocks base method 204 func (m *MockELBAPI) ConfigureHealthCheckWithContext(arg0 aws.Context, arg1 *elb.ConfigureHealthCheckInput, arg2 ...request.Option) (*elb.ConfigureHealthCheckOutput, 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, "ConfigureHealthCheckWithContext", varargs...) 211 ret0, _ := ret[0].(*elb.ConfigureHealthCheckOutput) 212 ret1, _ := ret[1].(error) 213 return ret0, ret1 214 } 215 216 // ConfigureHealthCheckWithContext indicates an expected call of ConfigureHealthCheckWithContext 217 func (mr *MockELBAPIMockRecorder) ConfigureHealthCheckWithContext(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, "ConfigureHealthCheckWithContext", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheckWithContext), varargs...) 221 } 222 223 // ConfigureHealthCheckRequest mocks base method 224 func (m *MockELBAPI) ConfigureHealthCheckRequest(arg0 *elb.ConfigureHealthCheckInput) (*request.Request, *elb.ConfigureHealthCheckOutput) { 225 m.ctrl.T.Helper() 226 ret := m.ctrl.Call(m, "ConfigureHealthCheckRequest", arg0) 227 ret0, _ := ret[0].(*request.Request) 228 ret1, _ := ret[1].(*elb.ConfigureHealthCheckOutput) 229 return ret0, ret1 230 } 231 232 // ConfigureHealthCheckRequest indicates an expected call of ConfigureHealthCheckRequest 233 func (mr *MockELBAPIMockRecorder) ConfigureHealthCheckRequest(arg0 interface{}) *gomock.Call { 234 mr.mock.ctrl.T.Helper() 235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureHealthCheckRequest", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheckRequest), arg0) 236 } 237 238 // CreateAppCookieStickinessPolicy mocks base method 239 func (m *MockELBAPI) CreateAppCookieStickinessPolicy(arg0 *elb.CreateAppCookieStickinessPolicyInput) (*elb.CreateAppCookieStickinessPolicyOutput, error) { 240 m.ctrl.T.Helper() 241 ret := m.ctrl.Call(m, "CreateAppCookieStickinessPolicy", arg0) 242 ret0, _ := ret[0].(*elb.CreateAppCookieStickinessPolicyOutput) 243 ret1, _ := ret[1].(error) 244 return ret0, ret1 245 } 246 247 // CreateAppCookieStickinessPolicy indicates an expected call of CreateAppCookieStickinessPolicy 248 func (mr *MockELBAPIMockRecorder) CreateAppCookieStickinessPolicy(arg0 interface{}) *gomock.Call { 249 mr.mock.ctrl.T.Helper() 250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAppCookieStickinessPolicy", reflect.TypeOf((*MockELBAPI)(nil).CreateAppCookieStickinessPolicy), arg0) 251 } 252 253 // CreateAppCookieStickinessPolicyWithContext mocks base method 254 func (m *MockELBAPI) CreateAppCookieStickinessPolicyWithContext(arg0 aws.Context, arg1 *elb.CreateAppCookieStickinessPolicyInput, arg2 ...request.Option) (*elb.CreateAppCookieStickinessPolicyOutput, 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, "CreateAppCookieStickinessPolicyWithContext", varargs...) 261 ret0, _ := ret[0].(*elb.CreateAppCookieStickinessPolicyOutput) 262 ret1, _ := ret[1].(error) 263 return ret0, ret1 264 } 265 266 // CreateAppCookieStickinessPolicyWithContext indicates an expected call of CreateAppCookieStickinessPolicyWithContext 267 func (mr *MockELBAPIMockRecorder) CreateAppCookieStickinessPolicyWithContext(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, "CreateAppCookieStickinessPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateAppCookieStickinessPolicyWithContext), varargs...) 271 } 272 273 // CreateAppCookieStickinessPolicyRequest mocks base method 274 func (m *MockELBAPI) CreateAppCookieStickinessPolicyRequest(arg0 *elb.CreateAppCookieStickinessPolicyInput) (*request.Request, *elb.CreateAppCookieStickinessPolicyOutput) { 275 m.ctrl.T.Helper() 276 ret := m.ctrl.Call(m, "CreateAppCookieStickinessPolicyRequest", arg0) 277 ret0, _ := ret[0].(*request.Request) 278 ret1, _ := ret[1].(*elb.CreateAppCookieStickinessPolicyOutput) 279 return ret0, ret1 280 } 281 282 // CreateAppCookieStickinessPolicyRequest indicates an expected call of CreateAppCookieStickinessPolicyRequest 283 func (mr *MockELBAPIMockRecorder) CreateAppCookieStickinessPolicyRequest(arg0 interface{}) *gomock.Call { 284 mr.mock.ctrl.T.Helper() 285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAppCookieStickinessPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateAppCookieStickinessPolicyRequest), arg0) 286 } 287 288 // CreateLBCookieStickinessPolicy mocks base method 289 func (m *MockELBAPI) CreateLBCookieStickinessPolicy(arg0 *elb.CreateLBCookieStickinessPolicyInput) (*elb.CreateLBCookieStickinessPolicyOutput, error) { 290 m.ctrl.T.Helper() 291 ret := m.ctrl.Call(m, "CreateLBCookieStickinessPolicy", arg0) 292 ret0, _ := ret[0].(*elb.CreateLBCookieStickinessPolicyOutput) 293 ret1, _ := ret[1].(error) 294 return ret0, ret1 295 } 296 297 // CreateLBCookieStickinessPolicy indicates an expected call of CreateLBCookieStickinessPolicy 298 func (mr *MockELBAPIMockRecorder) CreateLBCookieStickinessPolicy(arg0 interface{}) *gomock.Call { 299 mr.mock.ctrl.T.Helper() 300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLBCookieStickinessPolicy", reflect.TypeOf((*MockELBAPI)(nil).CreateLBCookieStickinessPolicy), arg0) 301 } 302 303 // CreateLBCookieStickinessPolicyWithContext mocks base method 304 func (m *MockELBAPI) CreateLBCookieStickinessPolicyWithContext(arg0 aws.Context, arg1 *elb.CreateLBCookieStickinessPolicyInput, arg2 ...request.Option) (*elb.CreateLBCookieStickinessPolicyOutput, 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, "CreateLBCookieStickinessPolicyWithContext", varargs...) 311 ret0, _ := ret[0].(*elb.CreateLBCookieStickinessPolicyOutput) 312 ret1, _ := ret[1].(error) 313 return ret0, ret1 314 } 315 316 // CreateLBCookieStickinessPolicyWithContext indicates an expected call of CreateLBCookieStickinessPolicyWithContext 317 func (mr *MockELBAPIMockRecorder) CreateLBCookieStickinessPolicyWithContext(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, "CreateLBCookieStickinessPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLBCookieStickinessPolicyWithContext), varargs...) 321 } 322 323 // CreateLBCookieStickinessPolicyRequest mocks base method 324 func (m *MockELBAPI) CreateLBCookieStickinessPolicyRequest(arg0 *elb.CreateLBCookieStickinessPolicyInput) (*request.Request, *elb.CreateLBCookieStickinessPolicyOutput) { 325 m.ctrl.T.Helper() 326 ret := m.ctrl.Call(m, "CreateLBCookieStickinessPolicyRequest", arg0) 327 ret0, _ := ret[0].(*request.Request) 328 ret1, _ := ret[1].(*elb.CreateLBCookieStickinessPolicyOutput) 329 return ret0, ret1 330 } 331 332 // CreateLBCookieStickinessPolicyRequest indicates an expected call of CreateLBCookieStickinessPolicyRequest 333 func (mr *MockELBAPIMockRecorder) CreateLBCookieStickinessPolicyRequest(arg0 interface{}) *gomock.Call { 334 mr.mock.ctrl.T.Helper() 335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLBCookieStickinessPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLBCookieStickinessPolicyRequest), arg0) 336 } 337 338 // CreateLoadBalancer mocks base method 339 func (m *MockELBAPI) CreateLoadBalancer(arg0 *elb.CreateLoadBalancerInput) (*elb.CreateLoadBalancerOutput, error) { 340 m.ctrl.T.Helper() 341 ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0) 342 ret0, _ := ret[0].(*elb.CreateLoadBalancerOutput) 343 ret1, _ := ret[1].(error) 344 return ret0, ret1 345 } 346 347 // CreateLoadBalancer indicates an expected call of CreateLoadBalancer 348 func (mr *MockELBAPIMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call { 349 mr.mock.ctrl.T.Helper() 350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancer), arg0) 351 } 352 353 // CreateLoadBalancerWithContext mocks base method 354 func (m *MockELBAPI) CreateLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.CreateLoadBalancerInput, arg2 ...request.Option) (*elb.CreateLoadBalancerOutput, 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, "CreateLoadBalancerWithContext", varargs...) 361 ret0, _ := ret[0].(*elb.CreateLoadBalancerOutput) 362 ret1, _ := ret[1].(error) 363 return ret0, ret1 364 } 365 366 // CreateLoadBalancerWithContext indicates an expected call of CreateLoadBalancerWithContext 367 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerWithContext(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, "CreateLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerWithContext), varargs...) 371 } 372 373 // CreateLoadBalancerRequest mocks base method 374 func (m *MockELBAPI) CreateLoadBalancerRequest(arg0 *elb.CreateLoadBalancerInput) (*request.Request, *elb.CreateLoadBalancerOutput) { 375 m.ctrl.T.Helper() 376 ret := m.ctrl.Call(m, "CreateLoadBalancerRequest", arg0) 377 ret0, _ := ret[0].(*request.Request) 378 ret1, _ := ret[1].(*elb.CreateLoadBalancerOutput) 379 return ret0, ret1 380 } 381 382 // CreateLoadBalancerRequest indicates an expected call of CreateLoadBalancerRequest 383 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerRequest(arg0 interface{}) *gomock.Call { 384 mr.mock.ctrl.T.Helper() 385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerRequest), arg0) 386 } 387 388 // CreateLoadBalancerListeners mocks base method 389 func (m *MockELBAPI) CreateLoadBalancerListeners(arg0 *elb.CreateLoadBalancerListenersInput) (*elb.CreateLoadBalancerListenersOutput, error) { 390 m.ctrl.T.Helper() 391 ret := m.ctrl.Call(m, "CreateLoadBalancerListeners", arg0) 392 ret0, _ := ret[0].(*elb.CreateLoadBalancerListenersOutput) 393 ret1, _ := ret[1].(error) 394 return ret0, ret1 395 } 396 397 // CreateLoadBalancerListeners indicates an expected call of CreateLoadBalancerListeners 398 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerListeners(arg0 interface{}) *gomock.Call { 399 mr.mock.ctrl.T.Helper() 400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerListeners", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerListeners), arg0) 401 } 402 403 // CreateLoadBalancerListenersWithContext mocks base method 404 func (m *MockELBAPI) CreateLoadBalancerListenersWithContext(arg0 aws.Context, arg1 *elb.CreateLoadBalancerListenersInput, arg2 ...request.Option) (*elb.CreateLoadBalancerListenersOutput, 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, "CreateLoadBalancerListenersWithContext", varargs...) 411 ret0, _ := ret[0].(*elb.CreateLoadBalancerListenersOutput) 412 ret1, _ := ret[1].(error) 413 return ret0, ret1 414 } 415 416 // CreateLoadBalancerListenersWithContext indicates an expected call of CreateLoadBalancerListenersWithContext 417 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerListenersWithContext(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, "CreateLoadBalancerListenersWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerListenersWithContext), varargs...) 421 } 422 423 // CreateLoadBalancerListenersRequest mocks base method 424 func (m *MockELBAPI) CreateLoadBalancerListenersRequest(arg0 *elb.CreateLoadBalancerListenersInput) (*request.Request, *elb.CreateLoadBalancerListenersOutput) { 425 m.ctrl.T.Helper() 426 ret := m.ctrl.Call(m, "CreateLoadBalancerListenersRequest", arg0) 427 ret0, _ := ret[0].(*request.Request) 428 ret1, _ := ret[1].(*elb.CreateLoadBalancerListenersOutput) 429 return ret0, ret1 430 } 431 432 // CreateLoadBalancerListenersRequest indicates an expected call of CreateLoadBalancerListenersRequest 433 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerListenersRequest(arg0 interface{}) *gomock.Call { 434 mr.mock.ctrl.T.Helper() 435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerListenersRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerListenersRequest), arg0) 436 } 437 438 // CreateLoadBalancerPolicy mocks base method 439 func (m *MockELBAPI) CreateLoadBalancerPolicy(arg0 *elb.CreateLoadBalancerPolicyInput) (*elb.CreateLoadBalancerPolicyOutput, error) { 440 m.ctrl.T.Helper() 441 ret := m.ctrl.Call(m, "CreateLoadBalancerPolicy", arg0) 442 ret0, _ := ret[0].(*elb.CreateLoadBalancerPolicyOutput) 443 ret1, _ := ret[1].(error) 444 return ret0, ret1 445 } 446 447 // CreateLoadBalancerPolicy indicates an expected call of CreateLoadBalancerPolicy 448 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerPolicy(arg0 interface{}) *gomock.Call { 449 mr.mock.ctrl.T.Helper() 450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerPolicy", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerPolicy), arg0) 451 } 452 453 // CreateLoadBalancerPolicyWithContext mocks base method 454 func (m *MockELBAPI) CreateLoadBalancerPolicyWithContext(arg0 aws.Context, arg1 *elb.CreateLoadBalancerPolicyInput, arg2 ...request.Option) (*elb.CreateLoadBalancerPolicyOutput, 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, "CreateLoadBalancerPolicyWithContext", varargs...) 461 ret0, _ := ret[0].(*elb.CreateLoadBalancerPolicyOutput) 462 ret1, _ := ret[1].(error) 463 return ret0, ret1 464 } 465 466 // CreateLoadBalancerPolicyWithContext indicates an expected call of CreateLoadBalancerPolicyWithContext 467 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerPolicyWithContext(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, "CreateLoadBalancerPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerPolicyWithContext), varargs...) 471 } 472 473 // CreateLoadBalancerPolicyRequest mocks base method 474 func (m *MockELBAPI) CreateLoadBalancerPolicyRequest(arg0 *elb.CreateLoadBalancerPolicyInput) (*request.Request, *elb.CreateLoadBalancerPolicyOutput) { 475 m.ctrl.T.Helper() 476 ret := m.ctrl.Call(m, "CreateLoadBalancerPolicyRequest", arg0) 477 ret0, _ := ret[0].(*request.Request) 478 ret1, _ := ret[1].(*elb.CreateLoadBalancerPolicyOutput) 479 return ret0, ret1 480 } 481 482 // CreateLoadBalancerPolicyRequest indicates an expected call of CreateLoadBalancerPolicyRequest 483 func (mr *MockELBAPIMockRecorder) CreateLoadBalancerPolicyRequest(arg0 interface{}) *gomock.Call { 484 mr.mock.ctrl.T.Helper() 485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerPolicyRequest), arg0) 486 } 487 488 // DeleteLoadBalancer mocks base method 489 func (m *MockELBAPI) DeleteLoadBalancer(arg0 *elb.DeleteLoadBalancerInput) (*elb.DeleteLoadBalancerOutput, error) { 490 m.ctrl.T.Helper() 491 ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0) 492 ret0, _ := ret[0].(*elb.DeleteLoadBalancerOutput) 493 ret1, _ := ret[1].(error) 494 return ret0, ret1 495 } 496 497 // DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer 498 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call { 499 mr.mock.ctrl.T.Helper() 500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancer), arg0) 501 } 502 503 // DeleteLoadBalancerWithContext mocks base method 504 func (m *MockELBAPI) DeleteLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.DeleteLoadBalancerInput, arg2 ...request.Option) (*elb.DeleteLoadBalancerOutput, 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, "DeleteLoadBalancerWithContext", varargs...) 511 ret0, _ := ret[0].(*elb.DeleteLoadBalancerOutput) 512 ret1, _ := ret[1].(error) 513 return ret0, ret1 514 } 515 516 // DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext 517 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerWithContext(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, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerWithContext), varargs...) 521 } 522 523 // DeleteLoadBalancerRequest mocks base method 524 func (m *MockELBAPI) DeleteLoadBalancerRequest(arg0 *elb.DeleteLoadBalancerInput) (*request.Request, *elb.DeleteLoadBalancerOutput) { 525 m.ctrl.T.Helper() 526 ret := m.ctrl.Call(m, "DeleteLoadBalancerRequest", arg0) 527 ret0, _ := ret[0].(*request.Request) 528 ret1, _ := ret[1].(*elb.DeleteLoadBalancerOutput) 529 return ret0, ret1 530 } 531 532 // DeleteLoadBalancerRequest indicates an expected call of DeleteLoadBalancerRequest 533 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerRequest(arg0 interface{}) *gomock.Call { 534 mr.mock.ctrl.T.Helper() 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerRequest), arg0) 536 } 537 538 // DeleteLoadBalancerListeners mocks base method 539 func (m *MockELBAPI) DeleteLoadBalancerListeners(arg0 *elb.DeleteLoadBalancerListenersInput) (*elb.DeleteLoadBalancerListenersOutput, error) { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "DeleteLoadBalancerListeners", arg0) 542 ret0, _ := ret[0].(*elb.DeleteLoadBalancerListenersOutput) 543 ret1, _ := ret[1].(error) 544 return ret0, ret1 545 } 546 547 // DeleteLoadBalancerListeners indicates an expected call of DeleteLoadBalancerListeners 548 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerListeners(arg0 interface{}) *gomock.Call { 549 mr.mock.ctrl.T.Helper() 550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerListeners", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerListeners), arg0) 551 } 552 553 // DeleteLoadBalancerListenersWithContext mocks base method 554 func (m *MockELBAPI) DeleteLoadBalancerListenersWithContext(arg0 aws.Context, arg1 *elb.DeleteLoadBalancerListenersInput, arg2 ...request.Option) (*elb.DeleteLoadBalancerListenersOutput, 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, "DeleteLoadBalancerListenersWithContext", varargs...) 561 ret0, _ := ret[0].(*elb.DeleteLoadBalancerListenersOutput) 562 ret1, _ := ret[1].(error) 563 return ret0, ret1 564 } 565 566 // DeleteLoadBalancerListenersWithContext indicates an expected call of DeleteLoadBalancerListenersWithContext 567 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerListenersWithContext(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, "DeleteLoadBalancerListenersWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerListenersWithContext), varargs...) 571 } 572 573 // DeleteLoadBalancerListenersRequest mocks base method 574 func (m *MockELBAPI) DeleteLoadBalancerListenersRequest(arg0 *elb.DeleteLoadBalancerListenersInput) (*request.Request, *elb.DeleteLoadBalancerListenersOutput) { 575 m.ctrl.T.Helper() 576 ret := m.ctrl.Call(m, "DeleteLoadBalancerListenersRequest", arg0) 577 ret0, _ := ret[0].(*request.Request) 578 ret1, _ := ret[1].(*elb.DeleteLoadBalancerListenersOutput) 579 return ret0, ret1 580 } 581 582 // DeleteLoadBalancerListenersRequest indicates an expected call of DeleteLoadBalancerListenersRequest 583 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerListenersRequest(arg0 interface{}) *gomock.Call { 584 mr.mock.ctrl.T.Helper() 585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerListenersRequest", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerListenersRequest), arg0) 586 } 587 588 // DeleteLoadBalancerPolicy mocks base method 589 func (m *MockELBAPI) DeleteLoadBalancerPolicy(arg0 *elb.DeleteLoadBalancerPolicyInput) (*elb.DeleteLoadBalancerPolicyOutput, error) { 590 m.ctrl.T.Helper() 591 ret := m.ctrl.Call(m, "DeleteLoadBalancerPolicy", arg0) 592 ret0, _ := ret[0].(*elb.DeleteLoadBalancerPolicyOutput) 593 ret1, _ := ret[1].(error) 594 return ret0, ret1 595 } 596 597 // DeleteLoadBalancerPolicy indicates an expected call of DeleteLoadBalancerPolicy 598 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerPolicy(arg0 interface{}) *gomock.Call { 599 mr.mock.ctrl.T.Helper() 600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerPolicy", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerPolicy), arg0) 601 } 602 603 // DeleteLoadBalancerPolicyWithContext mocks base method 604 func (m *MockELBAPI) DeleteLoadBalancerPolicyWithContext(arg0 aws.Context, arg1 *elb.DeleteLoadBalancerPolicyInput, arg2 ...request.Option) (*elb.DeleteLoadBalancerPolicyOutput, 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, "DeleteLoadBalancerPolicyWithContext", varargs...) 611 ret0, _ := ret[0].(*elb.DeleteLoadBalancerPolicyOutput) 612 ret1, _ := ret[1].(error) 613 return ret0, ret1 614 } 615 616 // DeleteLoadBalancerPolicyWithContext indicates an expected call of DeleteLoadBalancerPolicyWithContext 617 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerPolicyWithContext(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, "DeleteLoadBalancerPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerPolicyWithContext), varargs...) 621 } 622 623 // DeleteLoadBalancerPolicyRequest mocks base method 624 func (m *MockELBAPI) DeleteLoadBalancerPolicyRequest(arg0 *elb.DeleteLoadBalancerPolicyInput) (*request.Request, *elb.DeleteLoadBalancerPolicyOutput) { 625 m.ctrl.T.Helper() 626 ret := m.ctrl.Call(m, "DeleteLoadBalancerPolicyRequest", arg0) 627 ret0, _ := ret[0].(*request.Request) 628 ret1, _ := ret[1].(*elb.DeleteLoadBalancerPolicyOutput) 629 return ret0, ret1 630 } 631 632 // DeleteLoadBalancerPolicyRequest indicates an expected call of DeleteLoadBalancerPolicyRequest 633 func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerPolicyRequest(arg0 interface{}) *gomock.Call { 634 mr.mock.ctrl.T.Helper() 635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerPolicyRequest), arg0) 636 } 637 638 // DeregisterInstancesFromLoadBalancer mocks base method 639 func (m *MockELBAPI) DeregisterInstancesFromLoadBalancer(arg0 *elb.DeregisterInstancesFromLoadBalancerInput) (*elb.DeregisterInstancesFromLoadBalancerOutput, error) { 640 m.ctrl.T.Helper() 641 ret := m.ctrl.Call(m, "DeregisterInstancesFromLoadBalancer", arg0) 642 ret0, _ := ret[0].(*elb.DeregisterInstancesFromLoadBalancerOutput) 643 ret1, _ := ret[1].(error) 644 return ret0, ret1 645 } 646 647 // DeregisterInstancesFromLoadBalancer indicates an expected call of DeregisterInstancesFromLoadBalancer 648 func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancer(arg0 interface{}) *gomock.Call { 649 mr.mock.ctrl.T.Helper() 650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstancesFromLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancer), arg0) 651 } 652 653 // DeregisterInstancesFromLoadBalancerWithContext mocks base method 654 func (m *MockELBAPI) DeregisterInstancesFromLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.DeregisterInstancesFromLoadBalancerInput, arg2 ...request.Option) (*elb.DeregisterInstancesFromLoadBalancerOutput, 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, "DeregisterInstancesFromLoadBalancerWithContext", varargs...) 661 ret0, _ := ret[0].(*elb.DeregisterInstancesFromLoadBalancerOutput) 662 ret1, _ := ret[1].(error) 663 return ret0, ret1 664 } 665 666 // DeregisterInstancesFromLoadBalancerWithContext indicates an expected call of DeregisterInstancesFromLoadBalancerWithContext 667 func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancerWithContext(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, "DeregisterInstancesFromLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancerWithContext), varargs...) 671 } 672 673 // DeregisterInstancesFromLoadBalancerRequest mocks base method 674 func (m *MockELBAPI) DeregisterInstancesFromLoadBalancerRequest(arg0 *elb.DeregisterInstancesFromLoadBalancerInput) (*request.Request, *elb.DeregisterInstancesFromLoadBalancerOutput) { 675 m.ctrl.T.Helper() 676 ret := m.ctrl.Call(m, "DeregisterInstancesFromLoadBalancerRequest", arg0) 677 ret0, _ := ret[0].(*request.Request) 678 ret1, _ := ret[1].(*elb.DeregisterInstancesFromLoadBalancerOutput) 679 return ret0, ret1 680 } 681 682 // DeregisterInstancesFromLoadBalancerRequest indicates an expected call of DeregisterInstancesFromLoadBalancerRequest 683 func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancerRequest(arg0 interface{}) *gomock.Call { 684 mr.mock.ctrl.T.Helper() 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstancesFromLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancerRequest), arg0) 686 } 687 688 // DescribeAccountLimits mocks base method 689 func (m *MockELBAPI) DescribeAccountLimits(arg0 *elb.DescribeAccountLimitsInput) (*elb.DescribeAccountLimitsOutput, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0) 692 ret0, _ := ret[0].(*elb.DescribeAccountLimitsOutput) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // DescribeAccountLimits indicates an expected call of DescribeAccountLimits 698 func (mr *MockELBAPIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockELBAPI)(nil).DescribeAccountLimits), arg0) 701 } 702 703 // DescribeAccountLimitsWithContext mocks base method 704 func (m *MockELBAPI) DescribeAccountLimitsWithContext(arg0 aws.Context, arg1 *elb.DescribeAccountLimitsInput, arg2 ...request.Option) (*elb.DescribeAccountLimitsOutput, 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, "DescribeAccountLimitsWithContext", varargs...) 711 ret0, _ := ret[0].(*elb.DescribeAccountLimitsOutput) 712 ret1, _ := ret[1].(error) 713 return ret0, ret1 714 } 715 716 // DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext 717 func (mr *MockELBAPIMockRecorder) DescribeAccountLimitsWithContext(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, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeAccountLimitsWithContext), varargs...) 721 } 722 723 // DescribeAccountLimitsRequest mocks base method 724 func (m *MockELBAPI) DescribeAccountLimitsRequest(arg0 *elb.DescribeAccountLimitsInput) (*request.Request, *elb.DescribeAccountLimitsOutput) { 725 m.ctrl.T.Helper() 726 ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0) 727 ret0, _ := ret[0].(*request.Request) 728 ret1, _ := ret[1].(*elb.DescribeAccountLimitsOutput) 729 return ret0, ret1 730 } 731 732 // DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest 733 func (mr *MockELBAPIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call { 734 mr.mock.ctrl.T.Helper() 735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeAccountLimitsRequest), arg0) 736 } 737 738 // DescribeInstanceHealth mocks base method 739 func (m *MockELBAPI) DescribeInstanceHealth(arg0 *elb.DescribeInstanceHealthInput) (*elb.DescribeInstanceHealthOutput, error) { 740 m.ctrl.T.Helper() 741 ret := m.ctrl.Call(m, "DescribeInstanceHealth", arg0) 742 ret0, _ := ret[0].(*elb.DescribeInstanceHealthOutput) 743 ret1, _ := ret[1].(error) 744 return ret0, ret1 745 } 746 747 // DescribeInstanceHealth indicates an expected call of DescribeInstanceHealth 748 func (mr *MockELBAPIMockRecorder) DescribeInstanceHealth(arg0 interface{}) *gomock.Call { 749 mr.mock.ctrl.T.Helper() 750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceHealth", reflect.TypeOf((*MockELBAPI)(nil).DescribeInstanceHealth), arg0) 751 } 752 753 // DescribeInstanceHealthWithContext mocks base method 754 func (m *MockELBAPI) DescribeInstanceHealthWithContext(arg0 aws.Context, arg1 *elb.DescribeInstanceHealthInput, arg2 ...request.Option) (*elb.DescribeInstanceHealthOutput, 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, "DescribeInstanceHealthWithContext", varargs...) 761 ret0, _ := ret[0].(*elb.DescribeInstanceHealthOutput) 762 ret1, _ := ret[1].(error) 763 return ret0, ret1 764 } 765 766 // DescribeInstanceHealthWithContext indicates an expected call of DescribeInstanceHealthWithContext 767 func (mr *MockELBAPIMockRecorder) DescribeInstanceHealthWithContext(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, "DescribeInstanceHealthWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeInstanceHealthWithContext), varargs...) 771 } 772 773 // DescribeInstanceHealthRequest mocks base method 774 func (m *MockELBAPI) DescribeInstanceHealthRequest(arg0 *elb.DescribeInstanceHealthInput) (*request.Request, *elb.DescribeInstanceHealthOutput) { 775 m.ctrl.T.Helper() 776 ret := m.ctrl.Call(m, "DescribeInstanceHealthRequest", arg0) 777 ret0, _ := ret[0].(*request.Request) 778 ret1, _ := ret[1].(*elb.DescribeInstanceHealthOutput) 779 return ret0, ret1 780 } 781 782 // DescribeInstanceHealthRequest indicates an expected call of DescribeInstanceHealthRequest 783 func (mr *MockELBAPIMockRecorder) DescribeInstanceHealthRequest(arg0 interface{}) *gomock.Call { 784 mr.mock.ctrl.T.Helper() 785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceHealthRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeInstanceHealthRequest), arg0) 786 } 787 788 // DescribeLoadBalancerAttributes mocks base method 789 func (m *MockELBAPI) DescribeLoadBalancerAttributes(arg0 *elb.DescribeLoadBalancerAttributesInput) (*elb.DescribeLoadBalancerAttributesOutput, error) { 790 m.ctrl.T.Helper() 791 ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", arg0) 792 ret0, _ := ret[0].(*elb.DescribeLoadBalancerAttributesOutput) 793 ret1, _ := ret[1].(error) 794 return ret0, ret1 795 } 796 797 // DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes 798 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributes(arg0 interface{}) *gomock.Call { 799 mr.mock.ctrl.T.Helper() 800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributes), arg0) 801 } 802 803 // DescribeLoadBalancerAttributesWithContext mocks base method 804 func (m *MockELBAPI) DescribeLoadBalancerAttributesWithContext(arg0 aws.Context, arg1 *elb.DescribeLoadBalancerAttributesInput, arg2 ...request.Option) (*elb.DescribeLoadBalancerAttributesOutput, 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, "DescribeLoadBalancerAttributesWithContext", varargs...) 811 ret0, _ := ret[0].(*elb.DescribeLoadBalancerAttributesOutput) 812 ret1, _ := ret[1].(error) 813 return ret0, ret1 814 } 815 816 // DescribeLoadBalancerAttributesWithContext indicates an expected call of DescribeLoadBalancerAttributesWithContext 817 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributesWithContext(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, "DescribeLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributesWithContext), varargs...) 821 } 822 823 // DescribeLoadBalancerAttributesRequest mocks base method 824 func (m *MockELBAPI) DescribeLoadBalancerAttributesRequest(arg0 *elb.DescribeLoadBalancerAttributesInput) (*request.Request, *elb.DescribeLoadBalancerAttributesOutput) { 825 m.ctrl.T.Helper() 826 ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesRequest", arg0) 827 ret0, _ := ret[0].(*request.Request) 828 ret1, _ := ret[1].(*elb.DescribeLoadBalancerAttributesOutput) 829 return ret0, ret1 830 } 831 832 // DescribeLoadBalancerAttributesRequest indicates an expected call of DescribeLoadBalancerAttributesRequest 833 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { 834 mr.mock.ctrl.T.Helper() 835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributesRequest), arg0) 836 } 837 838 // DescribeLoadBalancerPolicies mocks base method 839 func (m *MockELBAPI) DescribeLoadBalancerPolicies(arg0 *elb.DescribeLoadBalancerPoliciesInput) (*elb.DescribeLoadBalancerPoliciesOutput, error) { 840 m.ctrl.T.Helper() 841 ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicies", arg0) 842 ret0, _ := ret[0].(*elb.DescribeLoadBalancerPoliciesOutput) 843 ret1, _ := ret[1].(error) 844 return ret0, ret1 845 } 846 847 // DescribeLoadBalancerPolicies indicates an expected call of DescribeLoadBalancerPolicies 848 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicies(arg0 interface{}) *gomock.Call { 849 mr.mock.ctrl.T.Helper() 850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPolicies", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicies), arg0) 851 } 852 853 // DescribeLoadBalancerPoliciesWithContext mocks base method 854 func (m *MockELBAPI) DescribeLoadBalancerPoliciesWithContext(arg0 aws.Context, arg1 *elb.DescribeLoadBalancerPoliciesInput, arg2 ...request.Option) (*elb.DescribeLoadBalancerPoliciesOutput, 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, "DescribeLoadBalancerPoliciesWithContext", varargs...) 861 ret0, _ := ret[0].(*elb.DescribeLoadBalancerPoliciesOutput) 862 ret1, _ := ret[1].(error) 863 return ret0, ret1 864 } 865 866 // DescribeLoadBalancerPoliciesWithContext indicates an expected call of DescribeLoadBalancerPoliciesWithContext 867 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPoliciesWithContext(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, "DescribeLoadBalancerPoliciesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPoliciesWithContext), varargs...) 871 } 872 873 // DescribeLoadBalancerPoliciesRequest mocks base method 874 func (m *MockELBAPI) DescribeLoadBalancerPoliciesRequest(arg0 *elb.DescribeLoadBalancerPoliciesInput) (*request.Request, *elb.DescribeLoadBalancerPoliciesOutput) { 875 m.ctrl.T.Helper() 876 ret := m.ctrl.Call(m, "DescribeLoadBalancerPoliciesRequest", arg0) 877 ret0, _ := ret[0].(*request.Request) 878 ret1, _ := ret[1].(*elb.DescribeLoadBalancerPoliciesOutput) 879 return ret0, ret1 880 } 881 882 // DescribeLoadBalancerPoliciesRequest indicates an expected call of DescribeLoadBalancerPoliciesRequest 883 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPoliciesRequest(arg0 interface{}) *gomock.Call { 884 mr.mock.ctrl.T.Helper() 885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPoliciesRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPoliciesRequest), arg0) 886 } 887 888 // DescribeLoadBalancerPolicyTypes mocks base method 889 func (m *MockELBAPI) DescribeLoadBalancerPolicyTypes(arg0 *elb.DescribeLoadBalancerPolicyTypesInput) (*elb.DescribeLoadBalancerPolicyTypesOutput, error) { 890 m.ctrl.T.Helper() 891 ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicyTypes", arg0) 892 ret0, _ := ret[0].(*elb.DescribeLoadBalancerPolicyTypesOutput) 893 ret1, _ := ret[1].(error) 894 return ret0, ret1 895 } 896 897 // DescribeLoadBalancerPolicyTypes indicates an expected call of DescribeLoadBalancerPolicyTypes 898 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicyTypes(arg0 interface{}) *gomock.Call { 899 mr.mock.ctrl.T.Helper() 900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPolicyTypes", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicyTypes), arg0) 901 } 902 903 // DescribeLoadBalancerPolicyTypesWithContext mocks base method 904 func (m *MockELBAPI) DescribeLoadBalancerPolicyTypesWithContext(arg0 aws.Context, arg1 *elb.DescribeLoadBalancerPolicyTypesInput, arg2 ...request.Option) (*elb.DescribeLoadBalancerPolicyTypesOutput, 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, "DescribeLoadBalancerPolicyTypesWithContext", varargs...) 911 ret0, _ := ret[0].(*elb.DescribeLoadBalancerPolicyTypesOutput) 912 ret1, _ := ret[1].(error) 913 return ret0, ret1 914 } 915 916 // DescribeLoadBalancerPolicyTypesWithContext indicates an expected call of DescribeLoadBalancerPolicyTypesWithContext 917 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicyTypesWithContext(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, "DescribeLoadBalancerPolicyTypesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicyTypesWithContext), varargs...) 921 } 922 923 // DescribeLoadBalancerPolicyTypesRequest mocks base method 924 func (m *MockELBAPI) DescribeLoadBalancerPolicyTypesRequest(arg0 *elb.DescribeLoadBalancerPolicyTypesInput) (*request.Request, *elb.DescribeLoadBalancerPolicyTypesOutput) { 925 m.ctrl.T.Helper() 926 ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicyTypesRequest", arg0) 927 ret0, _ := ret[0].(*request.Request) 928 ret1, _ := ret[1].(*elb.DescribeLoadBalancerPolicyTypesOutput) 929 return ret0, ret1 930 } 931 932 // DescribeLoadBalancerPolicyTypesRequest indicates an expected call of DescribeLoadBalancerPolicyTypesRequest 933 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicyTypesRequest(arg0 interface{}) *gomock.Call { 934 mr.mock.ctrl.T.Helper() 935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPolicyTypesRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicyTypesRequest), arg0) 936 } 937 938 // DescribeLoadBalancers mocks base method 939 func (m *MockELBAPI) DescribeLoadBalancers(arg0 *elb.DescribeLoadBalancersInput) (*elb.DescribeLoadBalancersOutput, error) { 940 m.ctrl.T.Helper() 941 ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0) 942 ret0, _ := ret[0].(*elb.DescribeLoadBalancersOutput) 943 ret1, _ := ret[1].(error) 944 return ret0, ret1 945 } 946 947 // DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers 948 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call { 949 mr.mock.ctrl.T.Helper() 950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancers), arg0) 951 } 952 953 // DescribeLoadBalancersWithContext mocks base method 954 func (m *MockELBAPI) DescribeLoadBalancersWithContext(arg0 aws.Context, arg1 *elb.DescribeLoadBalancersInput, arg2 ...request.Option) (*elb.DescribeLoadBalancersOutput, 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, "DescribeLoadBalancersWithContext", varargs...) 961 ret0, _ := ret[0].(*elb.DescribeLoadBalancersOutput) 962 ret1, _ := ret[1].(error) 963 return ret0, ret1 964 } 965 966 // DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext 967 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancersWithContext(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, "DescribeLoadBalancersWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersWithContext), varargs...) 971 } 972 973 // DescribeLoadBalancersRequest mocks base method 974 func (m *MockELBAPI) DescribeLoadBalancersRequest(arg0 *elb.DescribeLoadBalancersInput) (*request.Request, *elb.DescribeLoadBalancersOutput) { 975 m.ctrl.T.Helper() 976 ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0) 977 ret0, _ := ret[0].(*request.Request) 978 ret1, _ := ret[1].(*elb.DescribeLoadBalancersOutput) 979 return ret0, ret1 980 } 981 982 // DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest 983 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call { 984 mr.mock.ctrl.T.Helper() 985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersRequest), arg0) 986 } 987 988 // DescribeLoadBalancersPages mocks base method 989 func (m *MockELBAPI) DescribeLoadBalancersPages(arg0 *elb.DescribeLoadBalancersInput, arg1 func(*elb.DescribeLoadBalancersOutput, bool) bool) error { 990 m.ctrl.T.Helper() 991 ret := m.ctrl.Call(m, "DescribeLoadBalancersPages", arg0, arg1) 992 ret0, _ := ret[0].(error) 993 return ret0 994 } 995 996 // DescribeLoadBalancersPages indicates an expected call of DescribeLoadBalancersPages 997 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call { 998 mr.mock.ctrl.T.Helper() 999 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersPages), arg0, arg1) 1000 } 1001 1002 // DescribeLoadBalancersPagesWithContext mocks base method 1003 func (m *MockELBAPI) DescribeLoadBalancersPagesWithContext(arg0 aws.Context, arg1 *elb.DescribeLoadBalancersInput, arg2 func(*elb.DescribeLoadBalancersOutput, bool) bool, arg3 ...request.Option) error { 1004 m.ctrl.T.Helper() 1005 varargs := []interface{}{arg0, arg1, arg2} 1006 for _, a := range arg3 { 1007 varargs = append(varargs, a) 1008 } 1009 ret := m.ctrl.Call(m, "DescribeLoadBalancersPagesWithContext", varargs...) 1010 ret0, _ := ret[0].(error) 1011 return ret0 1012 } 1013 1014 // DescribeLoadBalancersPagesWithContext indicates an expected call of DescribeLoadBalancersPagesWithContext 1015 func (mr *MockELBAPIMockRecorder) DescribeLoadBalancersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1016 mr.mock.ctrl.T.Helper() 1017 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1018 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPagesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersPagesWithContext), varargs...) 1019 } 1020 1021 // DescribeTags mocks base method 1022 func (m *MockELBAPI) DescribeTags(arg0 *elb.DescribeTagsInput) (*elb.DescribeTagsOutput, error) { 1023 m.ctrl.T.Helper() 1024 ret := m.ctrl.Call(m, "DescribeTags", arg0) 1025 ret0, _ := ret[0].(*elb.DescribeTagsOutput) 1026 ret1, _ := ret[1].(error) 1027 return ret0, ret1 1028 } 1029 1030 // DescribeTags indicates an expected call of DescribeTags 1031 func (mr *MockELBAPIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { 1032 mr.mock.ctrl.T.Helper() 1033 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBAPI)(nil).DescribeTags), arg0) 1034 } 1035 1036 // DescribeTagsWithContext mocks base method 1037 func (m *MockELBAPI) DescribeTagsWithContext(arg0 aws.Context, arg1 *elb.DescribeTagsInput, arg2 ...request.Option) (*elb.DescribeTagsOutput, error) { 1038 m.ctrl.T.Helper() 1039 varargs := []interface{}{arg0, arg1} 1040 for _, a := range arg2 { 1041 varargs = append(varargs, a) 1042 } 1043 ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...) 1044 ret0, _ := ret[0].(*elb.DescribeTagsOutput) 1045 ret1, _ := ret[1].(error) 1046 return ret0, ret1 1047 } 1048 1049 // DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext 1050 func (mr *MockELBAPIMockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1051 mr.mock.ctrl.T.Helper() 1052 varargs := append([]interface{}{arg0, arg1}, arg2...) 1053 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeTagsWithContext), varargs...) 1054 } 1055 1056 // DescribeTagsRequest mocks base method 1057 func (m *MockELBAPI) DescribeTagsRequest(arg0 *elb.DescribeTagsInput) (*request.Request, *elb.DescribeTagsOutput) { 1058 m.ctrl.T.Helper() 1059 ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) 1060 ret0, _ := ret[0].(*request.Request) 1061 ret1, _ := ret[1].(*elb.DescribeTagsOutput) 1062 return ret0, ret1 1063 } 1064 1065 // DescribeTagsRequest indicates an expected call of DescribeTagsRequest 1066 func (mr *MockELBAPIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { 1067 mr.mock.ctrl.T.Helper() 1068 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeTagsRequest), arg0) 1069 } 1070 1071 // DetachLoadBalancerFromSubnets mocks base method 1072 func (m *MockELBAPI) DetachLoadBalancerFromSubnets(arg0 *elb.DetachLoadBalancerFromSubnetsInput) (*elb.DetachLoadBalancerFromSubnetsOutput, error) { 1073 m.ctrl.T.Helper() 1074 ret := m.ctrl.Call(m, "DetachLoadBalancerFromSubnets", arg0) 1075 ret0, _ := ret[0].(*elb.DetachLoadBalancerFromSubnetsOutput) 1076 ret1, _ := ret[1].(error) 1077 return ret0, ret1 1078 } 1079 1080 // DetachLoadBalancerFromSubnets indicates an expected call of DetachLoadBalancerFromSubnets 1081 func (mr *MockELBAPIMockRecorder) DetachLoadBalancerFromSubnets(arg0 interface{}) *gomock.Call { 1082 mr.mock.ctrl.T.Helper() 1083 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerFromSubnets", reflect.TypeOf((*MockELBAPI)(nil).DetachLoadBalancerFromSubnets), arg0) 1084 } 1085 1086 // DetachLoadBalancerFromSubnetsWithContext mocks base method 1087 func (m *MockELBAPI) DetachLoadBalancerFromSubnetsWithContext(arg0 aws.Context, arg1 *elb.DetachLoadBalancerFromSubnetsInput, arg2 ...request.Option) (*elb.DetachLoadBalancerFromSubnetsOutput, 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, "DetachLoadBalancerFromSubnetsWithContext", varargs...) 1094 ret0, _ := ret[0].(*elb.DetachLoadBalancerFromSubnetsOutput) 1095 ret1, _ := ret[1].(error) 1096 return ret0, ret1 1097 } 1098 1099 // DetachLoadBalancerFromSubnetsWithContext indicates an expected call of DetachLoadBalancerFromSubnetsWithContext 1100 func (mr *MockELBAPIMockRecorder) DetachLoadBalancerFromSubnetsWithContext(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, "DetachLoadBalancerFromSubnetsWithContext", reflect.TypeOf((*MockELBAPI)(nil).DetachLoadBalancerFromSubnetsWithContext), varargs...) 1104 } 1105 1106 // DetachLoadBalancerFromSubnetsRequest mocks base method 1107 func (m *MockELBAPI) DetachLoadBalancerFromSubnetsRequest(arg0 *elb.DetachLoadBalancerFromSubnetsInput) (*request.Request, *elb.DetachLoadBalancerFromSubnetsOutput) { 1108 m.ctrl.T.Helper() 1109 ret := m.ctrl.Call(m, "DetachLoadBalancerFromSubnetsRequest", arg0) 1110 ret0, _ := ret[0].(*request.Request) 1111 ret1, _ := ret[1].(*elb.DetachLoadBalancerFromSubnetsOutput) 1112 return ret0, ret1 1113 } 1114 1115 // DetachLoadBalancerFromSubnetsRequest indicates an expected call of DetachLoadBalancerFromSubnetsRequest 1116 func (mr *MockELBAPIMockRecorder) DetachLoadBalancerFromSubnetsRequest(arg0 interface{}) *gomock.Call { 1117 mr.mock.ctrl.T.Helper() 1118 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerFromSubnetsRequest", reflect.TypeOf((*MockELBAPI)(nil).DetachLoadBalancerFromSubnetsRequest), arg0) 1119 } 1120 1121 // DisableAvailabilityZonesForLoadBalancer mocks base method 1122 func (m *MockELBAPI) DisableAvailabilityZonesForLoadBalancer(arg0 *elb.DisableAvailabilityZonesForLoadBalancerInput) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, error) { 1123 m.ctrl.T.Helper() 1124 ret := m.ctrl.Call(m, "DisableAvailabilityZonesForLoadBalancer", arg0) 1125 ret0, _ := ret[0].(*elb.DisableAvailabilityZonesForLoadBalancerOutput) 1126 ret1, _ := ret[1].(error) 1127 return ret0, ret1 1128 } 1129 1130 // DisableAvailabilityZonesForLoadBalancer indicates an expected call of DisableAvailabilityZonesForLoadBalancer 1131 func (mr *MockELBAPIMockRecorder) DisableAvailabilityZonesForLoadBalancer(arg0 interface{}) *gomock.Call { 1132 mr.mock.ctrl.T.Helper() 1133 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAvailabilityZonesForLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DisableAvailabilityZonesForLoadBalancer), arg0) 1134 } 1135 1136 // DisableAvailabilityZonesForLoadBalancerWithContext mocks base method 1137 func (m *MockELBAPI) DisableAvailabilityZonesForLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.DisableAvailabilityZonesForLoadBalancerInput, arg2 ...request.Option) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, error) { 1138 m.ctrl.T.Helper() 1139 varargs := []interface{}{arg0, arg1} 1140 for _, a := range arg2 { 1141 varargs = append(varargs, a) 1142 } 1143 ret := m.ctrl.Call(m, "DisableAvailabilityZonesForLoadBalancerWithContext", varargs...) 1144 ret0, _ := ret[0].(*elb.DisableAvailabilityZonesForLoadBalancerOutput) 1145 ret1, _ := ret[1].(error) 1146 return ret0, ret1 1147 } 1148 1149 // DisableAvailabilityZonesForLoadBalancerWithContext indicates an expected call of DisableAvailabilityZonesForLoadBalancerWithContext 1150 func (mr *MockELBAPIMockRecorder) DisableAvailabilityZonesForLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1151 mr.mock.ctrl.T.Helper() 1152 varargs := append([]interface{}{arg0, arg1}, arg2...) 1153 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAvailabilityZonesForLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).DisableAvailabilityZonesForLoadBalancerWithContext), varargs...) 1154 } 1155 1156 // DisableAvailabilityZonesForLoadBalancerRequest mocks base method 1157 func (m *MockELBAPI) DisableAvailabilityZonesForLoadBalancerRequest(arg0 *elb.DisableAvailabilityZonesForLoadBalancerInput) (*request.Request, *elb.DisableAvailabilityZonesForLoadBalancerOutput) { 1158 m.ctrl.T.Helper() 1159 ret := m.ctrl.Call(m, "DisableAvailabilityZonesForLoadBalancerRequest", arg0) 1160 ret0, _ := ret[0].(*request.Request) 1161 ret1, _ := ret[1].(*elb.DisableAvailabilityZonesForLoadBalancerOutput) 1162 return ret0, ret1 1163 } 1164 1165 // DisableAvailabilityZonesForLoadBalancerRequest indicates an expected call of DisableAvailabilityZonesForLoadBalancerRequest 1166 func (mr *MockELBAPIMockRecorder) DisableAvailabilityZonesForLoadBalancerRequest(arg0 interface{}) *gomock.Call { 1167 mr.mock.ctrl.T.Helper() 1168 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAvailabilityZonesForLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).DisableAvailabilityZonesForLoadBalancerRequest), arg0) 1169 } 1170 1171 // EnableAvailabilityZonesForLoadBalancer mocks base method 1172 func (m *MockELBAPI) EnableAvailabilityZonesForLoadBalancer(arg0 *elb.EnableAvailabilityZonesForLoadBalancerInput) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, error) { 1173 m.ctrl.T.Helper() 1174 ret := m.ctrl.Call(m, "EnableAvailabilityZonesForLoadBalancer", arg0) 1175 ret0, _ := ret[0].(*elb.EnableAvailabilityZonesForLoadBalancerOutput) 1176 ret1, _ := ret[1].(error) 1177 return ret0, ret1 1178 } 1179 1180 // EnableAvailabilityZonesForLoadBalancer indicates an expected call of EnableAvailabilityZonesForLoadBalancer 1181 func (mr *MockELBAPIMockRecorder) EnableAvailabilityZonesForLoadBalancer(arg0 interface{}) *gomock.Call { 1182 mr.mock.ctrl.T.Helper() 1183 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAvailabilityZonesForLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).EnableAvailabilityZonesForLoadBalancer), arg0) 1184 } 1185 1186 // EnableAvailabilityZonesForLoadBalancerWithContext mocks base method 1187 func (m *MockELBAPI) EnableAvailabilityZonesForLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.EnableAvailabilityZonesForLoadBalancerInput, arg2 ...request.Option) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, error) { 1188 m.ctrl.T.Helper() 1189 varargs := []interface{}{arg0, arg1} 1190 for _, a := range arg2 { 1191 varargs = append(varargs, a) 1192 } 1193 ret := m.ctrl.Call(m, "EnableAvailabilityZonesForLoadBalancerWithContext", varargs...) 1194 ret0, _ := ret[0].(*elb.EnableAvailabilityZonesForLoadBalancerOutput) 1195 ret1, _ := ret[1].(error) 1196 return ret0, ret1 1197 } 1198 1199 // EnableAvailabilityZonesForLoadBalancerWithContext indicates an expected call of EnableAvailabilityZonesForLoadBalancerWithContext 1200 func (mr *MockELBAPIMockRecorder) EnableAvailabilityZonesForLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1201 mr.mock.ctrl.T.Helper() 1202 varargs := append([]interface{}{arg0, arg1}, arg2...) 1203 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAvailabilityZonesForLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).EnableAvailabilityZonesForLoadBalancerWithContext), varargs...) 1204 } 1205 1206 // EnableAvailabilityZonesForLoadBalancerRequest mocks base method 1207 func (m *MockELBAPI) EnableAvailabilityZonesForLoadBalancerRequest(arg0 *elb.EnableAvailabilityZonesForLoadBalancerInput) (*request.Request, *elb.EnableAvailabilityZonesForLoadBalancerOutput) { 1208 m.ctrl.T.Helper() 1209 ret := m.ctrl.Call(m, "EnableAvailabilityZonesForLoadBalancerRequest", arg0) 1210 ret0, _ := ret[0].(*request.Request) 1211 ret1, _ := ret[1].(*elb.EnableAvailabilityZonesForLoadBalancerOutput) 1212 return ret0, ret1 1213 } 1214 1215 // EnableAvailabilityZonesForLoadBalancerRequest indicates an expected call of EnableAvailabilityZonesForLoadBalancerRequest 1216 func (mr *MockELBAPIMockRecorder) EnableAvailabilityZonesForLoadBalancerRequest(arg0 interface{}) *gomock.Call { 1217 mr.mock.ctrl.T.Helper() 1218 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAvailabilityZonesForLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).EnableAvailabilityZonesForLoadBalancerRequest), arg0) 1219 } 1220 1221 // ModifyLoadBalancerAttributes mocks base method 1222 func (m *MockELBAPI) ModifyLoadBalancerAttributes(arg0 *elb.ModifyLoadBalancerAttributesInput) (*elb.ModifyLoadBalancerAttributesOutput, error) { 1223 m.ctrl.T.Helper() 1224 ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", arg0) 1225 ret0, _ := ret[0].(*elb.ModifyLoadBalancerAttributesOutput) 1226 ret1, _ := ret[1].(error) 1227 return ret0, ret1 1228 } 1229 1230 // ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes 1231 func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributes(arg0 interface{}) *gomock.Call { 1232 mr.mock.ctrl.T.Helper() 1233 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributes), arg0) 1234 } 1235 1236 // ModifyLoadBalancerAttributesWithContext mocks base method 1237 func (m *MockELBAPI) ModifyLoadBalancerAttributesWithContext(arg0 aws.Context, arg1 *elb.ModifyLoadBalancerAttributesInput, arg2 ...request.Option) (*elb.ModifyLoadBalancerAttributesOutput, error) { 1238 m.ctrl.T.Helper() 1239 varargs := []interface{}{arg0, arg1} 1240 for _, a := range arg2 { 1241 varargs = append(varargs, a) 1242 } 1243 ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesWithContext", varargs...) 1244 ret0, _ := ret[0].(*elb.ModifyLoadBalancerAttributesOutput) 1245 ret1, _ := ret[1].(error) 1246 return ret0, ret1 1247 } 1248 1249 // ModifyLoadBalancerAttributesWithContext indicates an expected call of ModifyLoadBalancerAttributesWithContext 1250 func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1251 mr.mock.ctrl.T.Helper() 1252 varargs := append([]interface{}{arg0, arg1}, arg2...) 1253 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributesWithContext), varargs...) 1254 } 1255 1256 // ModifyLoadBalancerAttributesRequest mocks base method 1257 func (m *MockELBAPI) ModifyLoadBalancerAttributesRequest(arg0 *elb.ModifyLoadBalancerAttributesInput) (*request.Request, *elb.ModifyLoadBalancerAttributesOutput) { 1258 m.ctrl.T.Helper() 1259 ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesRequest", arg0) 1260 ret0, _ := ret[0].(*request.Request) 1261 ret1, _ := ret[1].(*elb.ModifyLoadBalancerAttributesOutput) 1262 return ret0, ret1 1263 } 1264 1265 // ModifyLoadBalancerAttributesRequest indicates an expected call of ModifyLoadBalancerAttributesRequest 1266 func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { 1267 mr.mock.ctrl.T.Helper() 1268 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributesRequest), arg0) 1269 } 1270 1271 // RegisterInstancesWithLoadBalancer mocks base method 1272 func (m *MockELBAPI) RegisterInstancesWithLoadBalancer(arg0 *elb.RegisterInstancesWithLoadBalancerInput) (*elb.RegisterInstancesWithLoadBalancerOutput, error) { 1273 m.ctrl.T.Helper() 1274 ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancer", arg0) 1275 ret0, _ := ret[0].(*elb.RegisterInstancesWithLoadBalancerOutput) 1276 ret1, _ := ret[1].(error) 1277 return ret0, ret1 1278 } 1279 1280 // RegisterInstancesWithLoadBalancer indicates an expected call of RegisterInstancesWithLoadBalancer 1281 func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancer(arg0 interface{}) *gomock.Call { 1282 mr.mock.ctrl.T.Helper() 1283 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstancesWithLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancer), arg0) 1284 } 1285 1286 // RegisterInstancesWithLoadBalancerWithContext mocks base method 1287 func (m *MockELBAPI) RegisterInstancesWithLoadBalancerWithContext(arg0 aws.Context, arg1 *elb.RegisterInstancesWithLoadBalancerInput, arg2 ...request.Option) (*elb.RegisterInstancesWithLoadBalancerOutput, error) { 1288 m.ctrl.T.Helper() 1289 varargs := []interface{}{arg0, arg1} 1290 for _, a := range arg2 { 1291 varargs = append(varargs, a) 1292 } 1293 ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancerWithContext", varargs...) 1294 ret0, _ := ret[0].(*elb.RegisterInstancesWithLoadBalancerOutput) 1295 ret1, _ := ret[1].(error) 1296 return ret0, ret1 1297 } 1298 1299 // RegisterInstancesWithLoadBalancerWithContext indicates an expected call of RegisterInstancesWithLoadBalancerWithContext 1300 func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1301 mr.mock.ctrl.T.Helper() 1302 varargs := append([]interface{}{arg0, arg1}, arg2...) 1303 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstancesWithLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancerWithContext), varargs...) 1304 } 1305 1306 // RegisterInstancesWithLoadBalancerRequest mocks base method 1307 func (m *MockELBAPI) RegisterInstancesWithLoadBalancerRequest(arg0 *elb.RegisterInstancesWithLoadBalancerInput) (*request.Request, *elb.RegisterInstancesWithLoadBalancerOutput) { 1308 m.ctrl.T.Helper() 1309 ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancerRequest", arg0) 1310 ret0, _ := ret[0].(*request.Request) 1311 ret1, _ := ret[1].(*elb.RegisterInstancesWithLoadBalancerOutput) 1312 return ret0, ret1 1313 } 1314 1315 // RegisterInstancesWithLoadBalancerRequest indicates an expected call of RegisterInstancesWithLoadBalancerRequest 1316 func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancerRequest(arg0 interface{}) *gomock.Call { 1317 mr.mock.ctrl.T.Helper() 1318 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstancesWithLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancerRequest), arg0) 1319 } 1320 1321 // RemoveTags mocks base method 1322 func (m *MockELBAPI) RemoveTags(arg0 *elb.RemoveTagsInput) (*elb.RemoveTagsOutput, error) { 1323 m.ctrl.T.Helper() 1324 ret := m.ctrl.Call(m, "RemoveTags", arg0) 1325 ret0, _ := ret[0].(*elb.RemoveTagsOutput) 1326 ret1, _ := ret[1].(error) 1327 return ret0, ret1 1328 } 1329 1330 // RemoveTags indicates an expected call of RemoveTags 1331 func (mr *MockELBAPIMockRecorder) RemoveTags(arg0 interface{}) *gomock.Call { 1332 mr.mock.ctrl.T.Helper() 1333 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBAPI)(nil).RemoveTags), arg0) 1334 } 1335 1336 // RemoveTagsWithContext mocks base method 1337 func (m *MockELBAPI) RemoveTagsWithContext(arg0 aws.Context, arg1 *elb.RemoveTagsInput, arg2 ...request.Option) (*elb.RemoveTagsOutput, error) { 1338 m.ctrl.T.Helper() 1339 varargs := []interface{}{arg0, arg1} 1340 for _, a := range arg2 { 1341 varargs = append(varargs, a) 1342 } 1343 ret := m.ctrl.Call(m, "RemoveTagsWithContext", varargs...) 1344 ret0, _ := ret[0].(*elb.RemoveTagsOutput) 1345 ret1, _ := ret[1].(error) 1346 return ret0, ret1 1347 } 1348 1349 // RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext 1350 func (mr *MockELBAPIMockRecorder) RemoveTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1351 mr.mock.ctrl.T.Helper() 1352 varargs := append([]interface{}{arg0, arg1}, arg2...) 1353 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsWithContext", reflect.TypeOf((*MockELBAPI)(nil).RemoveTagsWithContext), varargs...) 1354 } 1355 1356 // RemoveTagsRequest mocks base method 1357 func (m *MockELBAPI) RemoveTagsRequest(arg0 *elb.RemoveTagsInput) (*request.Request, *elb.RemoveTagsOutput) { 1358 m.ctrl.T.Helper() 1359 ret := m.ctrl.Call(m, "RemoveTagsRequest", arg0) 1360 ret0, _ := ret[0].(*request.Request) 1361 ret1, _ := ret[1].(*elb.RemoveTagsOutput) 1362 return ret0, ret1 1363 } 1364 1365 // RemoveTagsRequest indicates an expected call of RemoveTagsRequest 1366 func (mr *MockELBAPIMockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call { 1367 mr.mock.ctrl.T.Helper() 1368 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockELBAPI)(nil).RemoveTagsRequest), arg0) 1369 } 1370 1371 // SetLoadBalancerListenerSSLCertificate mocks base method 1372 func (m *MockELBAPI) SetLoadBalancerListenerSSLCertificate(arg0 *elb.SetLoadBalancerListenerSSLCertificateInput) (*elb.SetLoadBalancerListenerSSLCertificateOutput, error) { 1373 m.ctrl.T.Helper() 1374 ret := m.ctrl.Call(m, "SetLoadBalancerListenerSSLCertificate", arg0) 1375 ret0, _ := ret[0].(*elb.SetLoadBalancerListenerSSLCertificateOutput) 1376 ret1, _ := ret[1].(error) 1377 return ret0, ret1 1378 } 1379 1380 // SetLoadBalancerListenerSSLCertificate indicates an expected call of SetLoadBalancerListenerSSLCertificate 1381 func (mr *MockELBAPIMockRecorder) SetLoadBalancerListenerSSLCertificate(arg0 interface{}) *gomock.Call { 1382 mr.mock.ctrl.T.Helper() 1383 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerListenerSSLCertificate", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerListenerSSLCertificate), arg0) 1384 } 1385 1386 // SetLoadBalancerListenerSSLCertificateWithContext mocks base method 1387 func (m *MockELBAPI) SetLoadBalancerListenerSSLCertificateWithContext(arg0 aws.Context, arg1 *elb.SetLoadBalancerListenerSSLCertificateInput, arg2 ...request.Option) (*elb.SetLoadBalancerListenerSSLCertificateOutput, error) { 1388 m.ctrl.T.Helper() 1389 varargs := []interface{}{arg0, arg1} 1390 for _, a := range arg2 { 1391 varargs = append(varargs, a) 1392 } 1393 ret := m.ctrl.Call(m, "SetLoadBalancerListenerSSLCertificateWithContext", varargs...) 1394 ret0, _ := ret[0].(*elb.SetLoadBalancerListenerSSLCertificateOutput) 1395 ret1, _ := ret[1].(error) 1396 return ret0, ret1 1397 } 1398 1399 // SetLoadBalancerListenerSSLCertificateWithContext indicates an expected call of SetLoadBalancerListenerSSLCertificateWithContext 1400 func (mr *MockELBAPIMockRecorder) SetLoadBalancerListenerSSLCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1401 mr.mock.ctrl.T.Helper() 1402 varargs := append([]interface{}{arg0, arg1}, arg2...) 1403 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerListenerSSLCertificateWithContext", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerListenerSSLCertificateWithContext), varargs...) 1404 } 1405 1406 // SetLoadBalancerListenerSSLCertificateRequest mocks base method 1407 func (m *MockELBAPI) SetLoadBalancerListenerSSLCertificateRequest(arg0 *elb.SetLoadBalancerListenerSSLCertificateInput) (*request.Request, *elb.SetLoadBalancerListenerSSLCertificateOutput) { 1408 m.ctrl.T.Helper() 1409 ret := m.ctrl.Call(m, "SetLoadBalancerListenerSSLCertificateRequest", arg0) 1410 ret0, _ := ret[0].(*request.Request) 1411 ret1, _ := ret[1].(*elb.SetLoadBalancerListenerSSLCertificateOutput) 1412 return ret0, ret1 1413 } 1414 1415 // SetLoadBalancerListenerSSLCertificateRequest indicates an expected call of SetLoadBalancerListenerSSLCertificateRequest 1416 func (mr *MockELBAPIMockRecorder) SetLoadBalancerListenerSSLCertificateRequest(arg0 interface{}) *gomock.Call { 1417 mr.mock.ctrl.T.Helper() 1418 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerListenerSSLCertificateRequest", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerListenerSSLCertificateRequest), arg0) 1419 } 1420 1421 // SetLoadBalancerPoliciesForBackendServer mocks base method 1422 func (m *MockELBAPI) SetLoadBalancerPoliciesForBackendServer(arg0 *elb.SetLoadBalancerPoliciesForBackendServerInput) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, error) { 1423 m.ctrl.T.Helper() 1424 ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesForBackendServer", arg0) 1425 ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesForBackendServerOutput) 1426 ret1, _ := ret[1].(error) 1427 return ret0, ret1 1428 } 1429 1430 // SetLoadBalancerPoliciesForBackendServer indicates an expected call of SetLoadBalancerPoliciesForBackendServer 1431 func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesForBackendServer(arg0 interface{}) *gomock.Call { 1432 mr.mock.ctrl.T.Helper() 1433 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesForBackendServer", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesForBackendServer), arg0) 1434 } 1435 1436 // SetLoadBalancerPoliciesForBackendServerWithContext mocks base method 1437 func (m *MockELBAPI) SetLoadBalancerPoliciesForBackendServerWithContext(arg0 aws.Context, arg1 *elb.SetLoadBalancerPoliciesForBackendServerInput, arg2 ...request.Option) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, error) { 1438 m.ctrl.T.Helper() 1439 varargs := []interface{}{arg0, arg1} 1440 for _, a := range arg2 { 1441 varargs = append(varargs, a) 1442 } 1443 ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesForBackendServerWithContext", varargs...) 1444 ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesForBackendServerOutput) 1445 ret1, _ := ret[1].(error) 1446 return ret0, ret1 1447 } 1448 1449 // SetLoadBalancerPoliciesForBackendServerWithContext indicates an expected call of SetLoadBalancerPoliciesForBackendServerWithContext 1450 func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesForBackendServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1451 mr.mock.ctrl.T.Helper() 1452 varargs := append([]interface{}{arg0, arg1}, arg2...) 1453 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesForBackendServerWithContext", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesForBackendServerWithContext), varargs...) 1454 } 1455 1456 // SetLoadBalancerPoliciesForBackendServerRequest mocks base method 1457 func (m *MockELBAPI) SetLoadBalancerPoliciesForBackendServerRequest(arg0 *elb.SetLoadBalancerPoliciesForBackendServerInput) (*request.Request, *elb.SetLoadBalancerPoliciesForBackendServerOutput) { 1458 m.ctrl.T.Helper() 1459 ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesForBackendServerRequest", arg0) 1460 ret0, _ := ret[0].(*request.Request) 1461 ret1, _ := ret[1].(*elb.SetLoadBalancerPoliciesForBackendServerOutput) 1462 return ret0, ret1 1463 } 1464 1465 // SetLoadBalancerPoliciesForBackendServerRequest indicates an expected call of SetLoadBalancerPoliciesForBackendServerRequest 1466 func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesForBackendServerRequest(arg0 interface{}) *gomock.Call { 1467 mr.mock.ctrl.T.Helper() 1468 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesForBackendServerRequest", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesForBackendServerRequest), arg0) 1469 } 1470 1471 // SetLoadBalancerPoliciesOfListener mocks base method 1472 func (m *MockELBAPI) SetLoadBalancerPoliciesOfListener(arg0 *elb.SetLoadBalancerPoliciesOfListenerInput) (*elb.SetLoadBalancerPoliciesOfListenerOutput, error) { 1473 m.ctrl.T.Helper() 1474 ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesOfListener", arg0) 1475 ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesOfListenerOutput) 1476 ret1, _ := ret[1].(error) 1477 return ret0, ret1 1478 } 1479 1480 // SetLoadBalancerPoliciesOfListener indicates an expected call of SetLoadBalancerPoliciesOfListener 1481 func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesOfListener(arg0 interface{}) *gomock.Call { 1482 mr.mock.ctrl.T.Helper() 1483 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesOfListener", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesOfListener), arg0) 1484 } 1485 1486 // SetLoadBalancerPoliciesOfListenerWithContext mocks base method 1487 func (m *MockELBAPI) SetLoadBalancerPoliciesOfListenerWithContext(arg0 aws.Context, arg1 *elb.SetLoadBalancerPoliciesOfListenerInput, arg2 ...request.Option) (*elb.SetLoadBalancerPoliciesOfListenerOutput, error) { 1488 m.ctrl.T.Helper() 1489 varargs := []interface{}{arg0, arg1} 1490 for _, a := range arg2 { 1491 varargs = append(varargs, a) 1492 } 1493 ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesOfListenerWithContext", varargs...) 1494 ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesOfListenerOutput) 1495 ret1, _ := ret[1].(error) 1496 return ret0, ret1 1497 } 1498 1499 // SetLoadBalancerPoliciesOfListenerWithContext indicates an expected call of SetLoadBalancerPoliciesOfListenerWithContext 1500 func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesOfListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1501 mr.mock.ctrl.T.Helper() 1502 varargs := append([]interface{}{arg0, arg1}, arg2...) 1503 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesOfListenerWithContext", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesOfListenerWithContext), varargs...) 1504 } 1505 1506 // SetLoadBalancerPoliciesOfListenerRequest mocks base method 1507 func (m *MockELBAPI) SetLoadBalancerPoliciesOfListenerRequest(arg0 *elb.SetLoadBalancerPoliciesOfListenerInput) (*request.Request, *elb.SetLoadBalancerPoliciesOfListenerOutput) { 1508 m.ctrl.T.Helper() 1509 ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesOfListenerRequest", arg0) 1510 ret0, _ := ret[0].(*request.Request) 1511 ret1, _ := ret[1].(*elb.SetLoadBalancerPoliciesOfListenerOutput) 1512 return ret0, ret1 1513 } 1514 1515 // SetLoadBalancerPoliciesOfListenerRequest indicates an expected call of SetLoadBalancerPoliciesOfListenerRequest 1516 func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesOfListenerRequest(arg0 interface{}) *gomock.Call { 1517 mr.mock.ctrl.T.Helper() 1518 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesOfListenerRequest", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesOfListenerRequest), arg0) 1519 } 1520 1521 // WaitUntilAnyInstanceInService mocks base method 1522 func (m *MockELBAPI) WaitUntilAnyInstanceInService(arg0 *elb.DescribeInstanceHealthInput) error { 1523 m.ctrl.T.Helper() 1524 ret := m.ctrl.Call(m, "WaitUntilAnyInstanceInService", arg0) 1525 ret0, _ := ret[0].(error) 1526 return ret0 1527 } 1528 1529 // WaitUntilAnyInstanceInService indicates an expected call of WaitUntilAnyInstanceInService 1530 func (mr *MockELBAPIMockRecorder) WaitUntilAnyInstanceInService(arg0 interface{}) *gomock.Call { 1531 mr.mock.ctrl.T.Helper() 1532 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilAnyInstanceInService", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilAnyInstanceInService), arg0) 1533 } 1534 1535 // WaitUntilAnyInstanceInServiceWithContext mocks base method 1536 func (m *MockELBAPI) WaitUntilAnyInstanceInServiceWithContext(arg0 aws.Context, arg1 *elb.DescribeInstanceHealthInput, arg2 ...request.WaiterOption) error { 1537 m.ctrl.T.Helper() 1538 varargs := []interface{}{arg0, arg1} 1539 for _, a := range arg2 { 1540 varargs = append(varargs, a) 1541 } 1542 ret := m.ctrl.Call(m, "WaitUntilAnyInstanceInServiceWithContext", varargs...) 1543 ret0, _ := ret[0].(error) 1544 return ret0 1545 } 1546 1547 // WaitUntilAnyInstanceInServiceWithContext indicates an expected call of WaitUntilAnyInstanceInServiceWithContext 1548 func (mr *MockELBAPIMockRecorder) WaitUntilAnyInstanceInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1549 mr.mock.ctrl.T.Helper() 1550 varargs := append([]interface{}{arg0, arg1}, arg2...) 1551 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilAnyInstanceInServiceWithContext", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilAnyInstanceInServiceWithContext), varargs...) 1552 } 1553 1554 // WaitUntilInstanceDeregistered mocks base method 1555 func (m *MockELBAPI) WaitUntilInstanceDeregistered(arg0 *elb.DescribeInstanceHealthInput) error { 1556 m.ctrl.T.Helper() 1557 ret := m.ctrl.Call(m, "WaitUntilInstanceDeregistered", arg0) 1558 ret0, _ := ret[0].(error) 1559 return ret0 1560 } 1561 1562 // WaitUntilInstanceDeregistered indicates an expected call of WaitUntilInstanceDeregistered 1563 func (mr *MockELBAPIMockRecorder) WaitUntilInstanceDeregistered(arg0 interface{}) *gomock.Call { 1564 mr.mock.ctrl.T.Helper() 1565 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceDeregistered", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceDeregistered), arg0) 1566 } 1567 1568 // WaitUntilInstanceDeregisteredWithContext mocks base method 1569 func (m *MockELBAPI) WaitUntilInstanceDeregisteredWithContext(arg0 aws.Context, arg1 *elb.DescribeInstanceHealthInput, arg2 ...request.WaiterOption) error { 1570 m.ctrl.T.Helper() 1571 varargs := []interface{}{arg0, arg1} 1572 for _, a := range arg2 { 1573 varargs = append(varargs, a) 1574 } 1575 ret := m.ctrl.Call(m, "WaitUntilInstanceDeregisteredWithContext", varargs...) 1576 ret0, _ := ret[0].(error) 1577 return ret0 1578 } 1579 1580 // WaitUntilInstanceDeregisteredWithContext indicates an expected call of WaitUntilInstanceDeregisteredWithContext 1581 func (mr *MockELBAPIMockRecorder) WaitUntilInstanceDeregisteredWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1582 mr.mock.ctrl.T.Helper() 1583 varargs := append([]interface{}{arg0, arg1}, arg2...) 1584 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceDeregisteredWithContext", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceDeregisteredWithContext), varargs...) 1585 } 1586 1587 // WaitUntilInstanceInService mocks base method 1588 func (m *MockELBAPI) WaitUntilInstanceInService(arg0 *elb.DescribeInstanceHealthInput) error { 1589 m.ctrl.T.Helper() 1590 ret := m.ctrl.Call(m, "WaitUntilInstanceInService", arg0) 1591 ret0, _ := ret[0].(error) 1592 return ret0 1593 } 1594 1595 // WaitUntilInstanceInService indicates an expected call of WaitUntilInstanceInService 1596 func (mr *MockELBAPIMockRecorder) WaitUntilInstanceInService(arg0 interface{}) *gomock.Call { 1597 mr.mock.ctrl.T.Helper() 1598 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceInService", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceInService), arg0) 1599 } 1600 1601 // WaitUntilInstanceInServiceWithContext mocks base method 1602 func (m *MockELBAPI) WaitUntilInstanceInServiceWithContext(arg0 aws.Context, arg1 *elb.DescribeInstanceHealthInput, arg2 ...request.WaiterOption) 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, "WaitUntilInstanceInServiceWithContext", varargs...) 1609 ret0, _ := ret[0].(error) 1610 return ret0 1611 } 1612 1613 // WaitUntilInstanceInServiceWithContext indicates an expected call of WaitUntilInstanceInServiceWithContext 1614 func (mr *MockELBAPIMockRecorder) WaitUntilInstanceInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1615 mr.mock.ctrl.T.Helper() 1616 varargs := append([]interface{}{arg0, arg1}, arg2...) 1617 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceInServiceWithContext", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceInServiceWithContext), varargs...) 1618 }