1// Code generated by counterfeiter. DO NOT EDIT. 2package gclientfakes 3 4import ( 5 "context" 6 "io" 7 "sync" 8 "time" 9 10 "code.cloudfoundry.org/garden" 11 "github.com/concourse/concourse/atc/worker/gclient" 12) 13 14type FakeContainer struct { 15 AttachStub func(context.Context, string, garden.ProcessIO) (garden.Process, error) 16 attachMutex sync.RWMutex 17 attachArgsForCall []struct { 18 arg1 context.Context 19 arg2 string 20 arg3 garden.ProcessIO 21 } 22 attachReturns struct { 23 result1 garden.Process 24 result2 error 25 } 26 attachReturnsOnCall map[int]struct { 27 result1 garden.Process 28 result2 error 29 } 30 BulkNetOutStub func([]garden.NetOutRule) error 31 bulkNetOutMutex sync.RWMutex 32 bulkNetOutArgsForCall []struct { 33 arg1 []garden.NetOutRule 34 } 35 bulkNetOutReturns struct { 36 result1 error 37 } 38 bulkNetOutReturnsOnCall map[int]struct { 39 result1 error 40 } 41 CurrentBandwidthLimitsStub func() (garden.BandwidthLimits, error) 42 currentBandwidthLimitsMutex sync.RWMutex 43 currentBandwidthLimitsArgsForCall []struct { 44 } 45 currentBandwidthLimitsReturns struct { 46 result1 garden.BandwidthLimits 47 result2 error 48 } 49 currentBandwidthLimitsReturnsOnCall map[int]struct { 50 result1 garden.BandwidthLimits 51 result2 error 52 } 53 CurrentCPULimitsStub func() (garden.CPULimits, error) 54 currentCPULimitsMutex sync.RWMutex 55 currentCPULimitsArgsForCall []struct { 56 } 57 currentCPULimitsReturns struct { 58 result1 garden.CPULimits 59 result2 error 60 } 61 currentCPULimitsReturnsOnCall map[int]struct { 62 result1 garden.CPULimits 63 result2 error 64 } 65 CurrentDiskLimitsStub func() (garden.DiskLimits, error) 66 currentDiskLimitsMutex sync.RWMutex 67 currentDiskLimitsArgsForCall []struct { 68 } 69 currentDiskLimitsReturns struct { 70 result1 garden.DiskLimits 71 result2 error 72 } 73 currentDiskLimitsReturnsOnCall map[int]struct { 74 result1 garden.DiskLimits 75 result2 error 76 } 77 CurrentMemoryLimitsStub func() (garden.MemoryLimits, error) 78 currentMemoryLimitsMutex sync.RWMutex 79 currentMemoryLimitsArgsForCall []struct { 80 } 81 currentMemoryLimitsReturns struct { 82 result1 garden.MemoryLimits 83 result2 error 84 } 85 currentMemoryLimitsReturnsOnCall map[int]struct { 86 result1 garden.MemoryLimits 87 result2 error 88 } 89 HandleStub func() string 90 handleMutex sync.RWMutex 91 handleArgsForCall []struct { 92 } 93 handleReturns struct { 94 result1 string 95 } 96 handleReturnsOnCall map[int]struct { 97 result1 string 98 } 99 InfoStub func() (garden.ContainerInfo, error) 100 infoMutex sync.RWMutex 101 infoArgsForCall []struct { 102 } 103 infoReturns struct { 104 result1 garden.ContainerInfo 105 result2 error 106 } 107 infoReturnsOnCall map[int]struct { 108 result1 garden.ContainerInfo 109 result2 error 110 } 111 MetricsStub func() (garden.Metrics, error) 112 metricsMutex sync.RWMutex 113 metricsArgsForCall []struct { 114 } 115 metricsReturns struct { 116 result1 garden.Metrics 117 result2 error 118 } 119 metricsReturnsOnCall map[int]struct { 120 result1 garden.Metrics 121 result2 error 122 } 123 NetInStub func(uint32, uint32) (uint32, uint32, error) 124 netInMutex sync.RWMutex 125 netInArgsForCall []struct { 126 arg1 uint32 127 arg2 uint32 128 } 129 netInReturns struct { 130 result1 uint32 131 result2 uint32 132 result3 error 133 } 134 netInReturnsOnCall map[int]struct { 135 result1 uint32 136 result2 uint32 137 result3 error 138 } 139 NetOutStub func(garden.NetOutRule) error 140 netOutMutex sync.RWMutex 141 netOutArgsForCall []struct { 142 arg1 garden.NetOutRule 143 } 144 netOutReturns struct { 145 result1 error 146 } 147 netOutReturnsOnCall map[int]struct { 148 result1 error 149 } 150 PropertiesStub func() (garden.Properties, error) 151 propertiesMutex sync.RWMutex 152 propertiesArgsForCall []struct { 153 } 154 propertiesReturns struct { 155 result1 garden.Properties 156 result2 error 157 } 158 propertiesReturnsOnCall map[int]struct { 159 result1 garden.Properties 160 result2 error 161 } 162 PropertyStub func(string) (string, error) 163 propertyMutex sync.RWMutex 164 propertyArgsForCall []struct { 165 arg1 string 166 } 167 propertyReturns struct { 168 result1 string 169 result2 error 170 } 171 propertyReturnsOnCall map[int]struct { 172 result1 string 173 result2 error 174 } 175 RemovePropertyStub func(string) error 176 removePropertyMutex sync.RWMutex 177 removePropertyArgsForCall []struct { 178 arg1 string 179 } 180 removePropertyReturns struct { 181 result1 error 182 } 183 removePropertyReturnsOnCall map[int]struct { 184 result1 error 185 } 186 RunStub func(context.Context, garden.ProcessSpec, garden.ProcessIO) (garden.Process, error) 187 runMutex sync.RWMutex 188 runArgsForCall []struct { 189 arg1 context.Context 190 arg2 garden.ProcessSpec 191 arg3 garden.ProcessIO 192 } 193 runReturns struct { 194 result1 garden.Process 195 result2 error 196 } 197 runReturnsOnCall map[int]struct { 198 result1 garden.Process 199 result2 error 200 } 201 SetGraceTimeStub func(time.Duration) error 202 setGraceTimeMutex sync.RWMutex 203 setGraceTimeArgsForCall []struct { 204 arg1 time.Duration 205 } 206 setGraceTimeReturns struct { 207 result1 error 208 } 209 setGraceTimeReturnsOnCall map[int]struct { 210 result1 error 211 } 212 SetPropertyStub func(string, string) error 213 setPropertyMutex sync.RWMutex 214 setPropertyArgsForCall []struct { 215 arg1 string 216 arg2 string 217 } 218 setPropertyReturns struct { 219 result1 error 220 } 221 setPropertyReturnsOnCall map[int]struct { 222 result1 error 223 } 224 StopStub func(bool) error 225 stopMutex sync.RWMutex 226 stopArgsForCall []struct { 227 arg1 bool 228 } 229 stopReturns struct { 230 result1 error 231 } 232 stopReturnsOnCall map[int]struct { 233 result1 error 234 } 235 StreamInStub func(garden.StreamInSpec) error 236 streamInMutex sync.RWMutex 237 streamInArgsForCall []struct { 238 arg1 garden.StreamInSpec 239 } 240 streamInReturns struct { 241 result1 error 242 } 243 streamInReturnsOnCall map[int]struct { 244 result1 error 245 } 246 StreamOutStub func(garden.StreamOutSpec) (io.ReadCloser, error) 247 streamOutMutex sync.RWMutex 248 streamOutArgsForCall []struct { 249 arg1 garden.StreamOutSpec 250 } 251 streamOutReturns struct { 252 result1 io.ReadCloser 253 result2 error 254 } 255 streamOutReturnsOnCall map[int]struct { 256 result1 io.ReadCloser 257 result2 error 258 } 259 invocations map[string][][]interface{} 260 invocationsMutex sync.RWMutex 261} 262 263func (fake *FakeContainer) Attach(arg1 context.Context, arg2 string, arg3 garden.ProcessIO) (garden.Process, error) { 264 fake.attachMutex.Lock() 265 ret, specificReturn := fake.attachReturnsOnCall[len(fake.attachArgsForCall)] 266 fake.attachArgsForCall = append(fake.attachArgsForCall, struct { 267 arg1 context.Context 268 arg2 string 269 arg3 garden.ProcessIO 270 }{arg1, arg2, arg3}) 271 fake.recordInvocation("Attach", []interface{}{arg1, arg2, arg3}) 272 fake.attachMutex.Unlock() 273 if fake.AttachStub != nil { 274 return fake.AttachStub(arg1, arg2, arg3) 275 } 276 if specificReturn { 277 return ret.result1, ret.result2 278 } 279 fakeReturns := fake.attachReturns 280 return fakeReturns.result1, fakeReturns.result2 281} 282 283func (fake *FakeContainer) AttachCallCount() int { 284 fake.attachMutex.RLock() 285 defer fake.attachMutex.RUnlock() 286 return len(fake.attachArgsForCall) 287} 288 289func (fake *FakeContainer) AttachCalls(stub func(context.Context, string, garden.ProcessIO) (garden.Process, error)) { 290 fake.attachMutex.Lock() 291 defer fake.attachMutex.Unlock() 292 fake.AttachStub = stub 293} 294 295func (fake *FakeContainer) AttachArgsForCall(i int) (context.Context, string, garden.ProcessIO) { 296 fake.attachMutex.RLock() 297 defer fake.attachMutex.RUnlock() 298 argsForCall := fake.attachArgsForCall[i] 299 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 300} 301 302func (fake *FakeContainer) AttachReturns(result1 garden.Process, result2 error) { 303 fake.attachMutex.Lock() 304 defer fake.attachMutex.Unlock() 305 fake.AttachStub = nil 306 fake.attachReturns = struct { 307 result1 garden.Process 308 result2 error 309 }{result1, result2} 310} 311 312func (fake *FakeContainer) AttachReturnsOnCall(i int, result1 garden.Process, result2 error) { 313 fake.attachMutex.Lock() 314 defer fake.attachMutex.Unlock() 315 fake.AttachStub = nil 316 if fake.attachReturnsOnCall == nil { 317 fake.attachReturnsOnCall = make(map[int]struct { 318 result1 garden.Process 319 result2 error 320 }) 321 } 322 fake.attachReturnsOnCall[i] = struct { 323 result1 garden.Process 324 result2 error 325 }{result1, result2} 326} 327 328func (fake *FakeContainer) BulkNetOut(arg1 []garden.NetOutRule) error { 329 var arg1Copy []garden.NetOutRule 330 if arg1 != nil { 331 arg1Copy = make([]garden.NetOutRule, len(arg1)) 332 copy(arg1Copy, arg1) 333 } 334 fake.bulkNetOutMutex.Lock() 335 ret, specificReturn := fake.bulkNetOutReturnsOnCall[len(fake.bulkNetOutArgsForCall)] 336 fake.bulkNetOutArgsForCall = append(fake.bulkNetOutArgsForCall, struct { 337 arg1 []garden.NetOutRule 338 }{arg1Copy}) 339 fake.recordInvocation("BulkNetOut", []interface{}{arg1Copy}) 340 fake.bulkNetOutMutex.Unlock() 341 if fake.BulkNetOutStub != nil { 342 return fake.BulkNetOutStub(arg1) 343 } 344 if specificReturn { 345 return ret.result1 346 } 347 fakeReturns := fake.bulkNetOutReturns 348 return fakeReturns.result1 349} 350 351func (fake *FakeContainer) BulkNetOutCallCount() int { 352 fake.bulkNetOutMutex.RLock() 353 defer fake.bulkNetOutMutex.RUnlock() 354 return len(fake.bulkNetOutArgsForCall) 355} 356 357func (fake *FakeContainer) BulkNetOutCalls(stub func([]garden.NetOutRule) error) { 358 fake.bulkNetOutMutex.Lock() 359 defer fake.bulkNetOutMutex.Unlock() 360 fake.BulkNetOutStub = stub 361} 362 363func (fake *FakeContainer) BulkNetOutArgsForCall(i int) []garden.NetOutRule { 364 fake.bulkNetOutMutex.RLock() 365 defer fake.bulkNetOutMutex.RUnlock() 366 argsForCall := fake.bulkNetOutArgsForCall[i] 367 return argsForCall.arg1 368} 369 370func (fake *FakeContainer) BulkNetOutReturns(result1 error) { 371 fake.bulkNetOutMutex.Lock() 372 defer fake.bulkNetOutMutex.Unlock() 373 fake.BulkNetOutStub = nil 374 fake.bulkNetOutReturns = struct { 375 result1 error 376 }{result1} 377} 378 379func (fake *FakeContainer) BulkNetOutReturnsOnCall(i int, result1 error) { 380 fake.bulkNetOutMutex.Lock() 381 defer fake.bulkNetOutMutex.Unlock() 382 fake.BulkNetOutStub = nil 383 if fake.bulkNetOutReturnsOnCall == nil { 384 fake.bulkNetOutReturnsOnCall = make(map[int]struct { 385 result1 error 386 }) 387 } 388 fake.bulkNetOutReturnsOnCall[i] = struct { 389 result1 error 390 }{result1} 391} 392 393func (fake *FakeContainer) CurrentBandwidthLimits() (garden.BandwidthLimits, error) { 394 fake.currentBandwidthLimitsMutex.Lock() 395 ret, specificReturn := fake.currentBandwidthLimitsReturnsOnCall[len(fake.currentBandwidthLimitsArgsForCall)] 396 fake.currentBandwidthLimitsArgsForCall = append(fake.currentBandwidthLimitsArgsForCall, struct { 397 }{}) 398 fake.recordInvocation("CurrentBandwidthLimits", []interface{}{}) 399 fake.currentBandwidthLimitsMutex.Unlock() 400 if fake.CurrentBandwidthLimitsStub != nil { 401 return fake.CurrentBandwidthLimitsStub() 402 } 403 if specificReturn { 404 return ret.result1, ret.result2 405 } 406 fakeReturns := fake.currentBandwidthLimitsReturns 407 return fakeReturns.result1, fakeReturns.result2 408} 409 410func (fake *FakeContainer) CurrentBandwidthLimitsCallCount() int { 411 fake.currentBandwidthLimitsMutex.RLock() 412 defer fake.currentBandwidthLimitsMutex.RUnlock() 413 return len(fake.currentBandwidthLimitsArgsForCall) 414} 415 416func (fake *FakeContainer) CurrentBandwidthLimitsCalls(stub func() (garden.BandwidthLimits, error)) { 417 fake.currentBandwidthLimitsMutex.Lock() 418 defer fake.currentBandwidthLimitsMutex.Unlock() 419 fake.CurrentBandwidthLimitsStub = stub 420} 421 422func (fake *FakeContainer) CurrentBandwidthLimitsReturns(result1 garden.BandwidthLimits, result2 error) { 423 fake.currentBandwidthLimitsMutex.Lock() 424 defer fake.currentBandwidthLimitsMutex.Unlock() 425 fake.CurrentBandwidthLimitsStub = nil 426 fake.currentBandwidthLimitsReturns = struct { 427 result1 garden.BandwidthLimits 428 result2 error 429 }{result1, result2} 430} 431 432func (fake *FakeContainer) CurrentBandwidthLimitsReturnsOnCall(i int, result1 garden.BandwidthLimits, result2 error) { 433 fake.currentBandwidthLimitsMutex.Lock() 434 defer fake.currentBandwidthLimitsMutex.Unlock() 435 fake.CurrentBandwidthLimitsStub = nil 436 if fake.currentBandwidthLimitsReturnsOnCall == nil { 437 fake.currentBandwidthLimitsReturnsOnCall = make(map[int]struct { 438 result1 garden.BandwidthLimits 439 result2 error 440 }) 441 } 442 fake.currentBandwidthLimitsReturnsOnCall[i] = struct { 443 result1 garden.BandwidthLimits 444 result2 error 445 }{result1, result2} 446} 447 448func (fake *FakeContainer) CurrentCPULimits() (garden.CPULimits, error) { 449 fake.currentCPULimitsMutex.Lock() 450 ret, specificReturn := fake.currentCPULimitsReturnsOnCall[len(fake.currentCPULimitsArgsForCall)] 451 fake.currentCPULimitsArgsForCall = append(fake.currentCPULimitsArgsForCall, struct { 452 }{}) 453 fake.recordInvocation("CurrentCPULimits", []interface{}{}) 454 fake.currentCPULimitsMutex.Unlock() 455 if fake.CurrentCPULimitsStub != nil { 456 return fake.CurrentCPULimitsStub() 457 } 458 if specificReturn { 459 return ret.result1, ret.result2 460 } 461 fakeReturns := fake.currentCPULimitsReturns 462 return fakeReturns.result1, fakeReturns.result2 463} 464 465func (fake *FakeContainer) CurrentCPULimitsCallCount() int { 466 fake.currentCPULimitsMutex.RLock() 467 defer fake.currentCPULimitsMutex.RUnlock() 468 return len(fake.currentCPULimitsArgsForCall) 469} 470 471func (fake *FakeContainer) CurrentCPULimitsCalls(stub func() (garden.CPULimits, error)) { 472 fake.currentCPULimitsMutex.Lock() 473 defer fake.currentCPULimitsMutex.Unlock() 474 fake.CurrentCPULimitsStub = stub 475} 476 477func (fake *FakeContainer) CurrentCPULimitsReturns(result1 garden.CPULimits, result2 error) { 478 fake.currentCPULimitsMutex.Lock() 479 defer fake.currentCPULimitsMutex.Unlock() 480 fake.CurrentCPULimitsStub = nil 481 fake.currentCPULimitsReturns = struct { 482 result1 garden.CPULimits 483 result2 error 484 }{result1, result2} 485} 486 487func (fake *FakeContainer) CurrentCPULimitsReturnsOnCall(i int, result1 garden.CPULimits, result2 error) { 488 fake.currentCPULimitsMutex.Lock() 489 defer fake.currentCPULimitsMutex.Unlock() 490 fake.CurrentCPULimitsStub = nil 491 if fake.currentCPULimitsReturnsOnCall == nil { 492 fake.currentCPULimitsReturnsOnCall = make(map[int]struct { 493 result1 garden.CPULimits 494 result2 error 495 }) 496 } 497 fake.currentCPULimitsReturnsOnCall[i] = struct { 498 result1 garden.CPULimits 499 result2 error 500 }{result1, result2} 501} 502 503func (fake *FakeContainer) CurrentDiskLimits() (garden.DiskLimits, error) { 504 fake.currentDiskLimitsMutex.Lock() 505 ret, specificReturn := fake.currentDiskLimitsReturnsOnCall[len(fake.currentDiskLimitsArgsForCall)] 506 fake.currentDiskLimitsArgsForCall = append(fake.currentDiskLimitsArgsForCall, struct { 507 }{}) 508 fake.recordInvocation("CurrentDiskLimits", []interface{}{}) 509 fake.currentDiskLimitsMutex.Unlock() 510 if fake.CurrentDiskLimitsStub != nil { 511 return fake.CurrentDiskLimitsStub() 512 } 513 if specificReturn { 514 return ret.result1, ret.result2 515 } 516 fakeReturns := fake.currentDiskLimitsReturns 517 return fakeReturns.result1, fakeReturns.result2 518} 519 520func (fake *FakeContainer) CurrentDiskLimitsCallCount() int { 521 fake.currentDiskLimitsMutex.RLock() 522 defer fake.currentDiskLimitsMutex.RUnlock() 523 return len(fake.currentDiskLimitsArgsForCall) 524} 525 526func (fake *FakeContainer) CurrentDiskLimitsCalls(stub func() (garden.DiskLimits, error)) { 527 fake.currentDiskLimitsMutex.Lock() 528 defer fake.currentDiskLimitsMutex.Unlock() 529 fake.CurrentDiskLimitsStub = stub 530} 531 532func (fake *FakeContainer) CurrentDiskLimitsReturns(result1 garden.DiskLimits, result2 error) { 533 fake.currentDiskLimitsMutex.Lock() 534 defer fake.currentDiskLimitsMutex.Unlock() 535 fake.CurrentDiskLimitsStub = nil 536 fake.currentDiskLimitsReturns = struct { 537 result1 garden.DiskLimits 538 result2 error 539 }{result1, result2} 540} 541 542func (fake *FakeContainer) CurrentDiskLimitsReturnsOnCall(i int, result1 garden.DiskLimits, result2 error) { 543 fake.currentDiskLimitsMutex.Lock() 544 defer fake.currentDiskLimitsMutex.Unlock() 545 fake.CurrentDiskLimitsStub = nil 546 if fake.currentDiskLimitsReturnsOnCall == nil { 547 fake.currentDiskLimitsReturnsOnCall = make(map[int]struct { 548 result1 garden.DiskLimits 549 result2 error 550 }) 551 } 552 fake.currentDiskLimitsReturnsOnCall[i] = struct { 553 result1 garden.DiskLimits 554 result2 error 555 }{result1, result2} 556} 557 558func (fake *FakeContainer) CurrentMemoryLimits() (garden.MemoryLimits, error) { 559 fake.currentMemoryLimitsMutex.Lock() 560 ret, specificReturn := fake.currentMemoryLimitsReturnsOnCall[len(fake.currentMemoryLimitsArgsForCall)] 561 fake.currentMemoryLimitsArgsForCall = append(fake.currentMemoryLimitsArgsForCall, struct { 562 }{}) 563 fake.recordInvocation("CurrentMemoryLimits", []interface{}{}) 564 fake.currentMemoryLimitsMutex.Unlock() 565 if fake.CurrentMemoryLimitsStub != nil { 566 return fake.CurrentMemoryLimitsStub() 567 } 568 if specificReturn { 569 return ret.result1, ret.result2 570 } 571 fakeReturns := fake.currentMemoryLimitsReturns 572 return fakeReturns.result1, fakeReturns.result2 573} 574 575func (fake *FakeContainer) CurrentMemoryLimitsCallCount() int { 576 fake.currentMemoryLimitsMutex.RLock() 577 defer fake.currentMemoryLimitsMutex.RUnlock() 578 return len(fake.currentMemoryLimitsArgsForCall) 579} 580 581func (fake *FakeContainer) CurrentMemoryLimitsCalls(stub func() (garden.MemoryLimits, error)) { 582 fake.currentMemoryLimitsMutex.Lock() 583 defer fake.currentMemoryLimitsMutex.Unlock() 584 fake.CurrentMemoryLimitsStub = stub 585} 586 587func (fake *FakeContainer) CurrentMemoryLimitsReturns(result1 garden.MemoryLimits, result2 error) { 588 fake.currentMemoryLimitsMutex.Lock() 589 defer fake.currentMemoryLimitsMutex.Unlock() 590 fake.CurrentMemoryLimitsStub = nil 591 fake.currentMemoryLimitsReturns = struct { 592 result1 garden.MemoryLimits 593 result2 error 594 }{result1, result2} 595} 596 597func (fake *FakeContainer) CurrentMemoryLimitsReturnsOnCall(i int, result1 garden.MemoryLimits, result2 error) { 598 fake.currentMemoryLimitsMutex.Lock() 599 defer fake.currentMemoryLimitsMutex.Unlock() 600 fake.CurrentMemoryLimitsStub = nil 601 if fake.currentMemoryLimitsReturnsOnCall == nil { 602 fake.currentMemoryLimitsReturnsOnCall = make(map[int]struct { 603 result1 garden.MemoryLimits 604 result2 error 605 }) 606 } 607 fake.currentMemoryLimitsReturnsOnCall[i] = struct { 608 result1 garden.MemoryLimits 609 result2 error 610 }{result1, result2} 611} 612 613func (fake *FakeContainer) Handle() string { 614 fake.handleMutex.Lock() 615 ret, specificReturn := fake.handleReturnsOnCall[len(fake.handleArgsForCall)] 616 fake.handleArgsForCall = append(fake.handleArgsForCall, struct { 617 }{}) 618 fake.recordInvocation("Handle", []interface{}{}) 619 fake.handleMutex.Unlock() 620 if fake.HandleStub != nil { 621 return fake.HandleStub() 622 } 623 if specificReturn { 624 return ret.result1 625 } 626 fakeReturns := fake.handleReturns 627 return fakeReturns.result1 628} 629 630func (fake *FakeContainer) HandleCallCount() int { 631 fake.handleMutex.RLock() 632 defer fake.handleMutex.RUnlock() 633 return len(fake.handleArgsForCall) 634} 635 636func (fake *FakeContainer) HandleCalls(stub func() string) { 637 fake.handleMutex.Lock() 638 defer fake.handleMutex.Unlock() 639 fake.HandleStub = stub 640} 641 642func (fake *FakeContainer) HandleReturns(result1 string) { 643 fake.handleMutex.Lock() 644 defer fake.handleMutex.Unlock() 645 fake.HandleStub = nil 646 fake.handleReturns = struct { 647 result1 string 648 }{result1} 649} 650 651func (fake *FakeContainer) HandleReturnsOnCall(i int, result1 string) { 652 fake.handleMutex.Lock() 653 defer fake.handleMutex.Unlock() 654 fake.HandleStub = nil 655 if fake.handleReturnsOnCall == nil { 656 fake.handleReturnsOnCall = make(map[int]struct { 657 result1 string 658 }) 659 } 660 fake.handleReturnsOnCall[i] = struct { 661 result1 string 662 }{result1} 663} 664 665func (fake *FakeContainer) Info() (garden.ContainerInfo, error) { 666 fake.infoMutex.Lock() 667 ret, specificReturn := fake.infoReturnsOnCall[len(fake.infoArgsForCall)] 668 fake.infoArgsForCall = append(fake.infoArgsForCall, struct { 669 }{}) 670 fake.recordInvocation("Info", []interface{}{}) 671 fake.infoMutex.Unlock() 672 if fake.InfoStub != nil { 673 return fake.InfoStub() 674 } 675 if specificReturn { 676 return ret.result1, ret.result2 677 } 678 fakeReturns := fake.infoReturns 679 return fakeReturns.result1, fakeReturns.result2 680} 681 682func (fake *FakeContainer) InfoCallCount() int { 683 fake.infoMutex.RLock() 684 defer fake.infoMutex.RUnlock() 685 return len(fake.infoArgsForCall) 686} 687 688func (fake *FakeContainer) InfoCalls(stub func() (garden.ContainerInfo, error)) { 689 fake.infoMutex.Lock() 690 defer fake.infoMutex.Unlock() 691 fake.InfoStub = stub 692} 693 694func (fake *FakeContainer) InfoReturns(result1 garden.ContainerInfo, result2 error) { 695 fake.infoMutex.Lock() 696 defer fake.infoMutex.Unlock() 697 fake.InfoStub = nil 698 fake.infoReturns = struct { 699 result1 garden.ContainerInfo 700 result2 error 701 }{result1, result2} 702} 703 704func (fake *FakeContainer) InfoReturnsOnCall(i int, result1 garden.ContainerInfo, result2 error) { 705 fake.infoMutex.Lock() 706 defer fake.infoMutex.Unlock() 707 fake.InfoStub = nil 708 if fake.infoReturnsOnCall == nil { 709 fake.infoReturnsOnCall = make(map[int]struct { 710 result1 garden.ContainerInfo 711 result2 error 712 }) 713 } 714 fake.infoReturnsOnCall[i] = struct { 715 result1 garden.ContainerInfo 716 result2 error 717 }{result1, result2} 718} 719 720func (fake *FakeContainer) Metrics() (garden.Metrics, error) { 721 fake.metricsMutex.Lock() 722 ret, specificReturn := fake.metricsReturnsOnCall[len(fake.metricsArgsForCall)] 723 fake.metricsArgsForCall = append(fake.metricsArgsForCall, struct { 724 }{}) 725 fake.recordInvocation("Metrics", []interface{}{}) 726 fake.metricsMutex.Unlock() 727 if fake.MetricsStub != nil { 728 return fake.MetricsStub() 729 } 730 if specificReturn { 731 return ret.result1, ret.result2 732 } 733 fakeReturns := fake.metricsReturns 734 return fakeReturns.result1, fakeReturns.result2 735} 736 737func (fake *FakeContainer) MetricsCallCount() int { 738 fake.metricsMutex.RLock() 739 defer fake.metricsMutex.RUnlock() 740 return len(fake.metricsArgsForCall) 741} 742 743func (fake *FakeContainer) MetricsCalls(stub func() (garden.Metrics, error)) { 744 fake.metricsMutex.Lock() 745 defer fake.metricsMutex.Unlock() 746 fake.MetricsStub = stub 747} 748 749func (fake *FakeContainer) MetricsReturns(result1 garden.Metrics, result2 error) { 750 fake.metricsMutex.Lock() 751 defer fake.metricsMutex.Unlock() 752 fake.MetricsStub = nil 753 fake.metricsReturns = struct { 754 result1 garden.Metrics 755 result2 error 756 }{result1, result2} 757} 758 759func (fake *FakeContainer) MetricsReturnsOnCall(i int, result1 garden.Metrics, result2 error) { 760 fake.metricsMutex.Lock() 761 defer fake.metricsMutex.Unlock() 762 fake.MetricsStub = nil 763 if fake.metricsReturnsOnCall == nil { 764 fake.metricsReturnsOnCall = make(map[int]struct { 765 result1 garden.Metrics 766 result2 error 767 }) 768 } 769 fake.metricsReturnsOnCall[i] = struct { 770 result1 garden.Metrics 771 result2 error 772 }{result1, result2} 773} 774 775func (fake *FakeContainer) NetIn(arg1 uint32, arg2 uint32) (uint32, uint32, error) { 776 fake.netInMutex.Lock() 777 ret, specificReturn := fake.netInReturnsOnCall[len(fake.netInArgsForCall)] 778 fake.netInArgsForCall = append(fake.netInArgsForCall, struct { 779 arg1 uint32 780 arg2 uint32 781 }{arg1, arg2}) 782 fake.recordInvocation("NetIn", []interface{}{arg1, arg2}) 783 fake.netInMutex.Unlock() 784 if fake.NetInStub != nil { 785 return fake.NetInStub(arg1, arg2) 786 } 787 if specificReturn { 788 return ret.result1, ret.result2, ret.result3 789 } 790 fakeReturns := fake.netInReturns 791 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 792} 793 794func (fake *FakeContainer) NetInCallCount() int { 795 fake.netInMutex.RLock() 796 defer fake.netInMutex.RUnlock() 797 return len(fake.netInArgsForCall) 798} 799 800func (fake *FakeContainer) NetInCalls(stub func(uint32, uint32) (uint32, uint32, error)) { 801 fake.netInMutex.Lock() 802 defer fake.netInMutex.Unlock() 803 fake.NetInStub = stub 804} 805 806func (fake *FakeContainer) NetInArgsForCall(i int) (uint32, uint32) { 807 fake.netInMutex.RLock() 808 defer fake.netInMutex.RUnlock() 809 argsForCall := fake.netInArgsForCall[i] 810 return argsForCall.arg1, argsForCall.arg2 811} 812 813func (fake *FakeContainer) NetInReturns(result1 uint32, result2 uint32, result3 error) { 814 fake.netInMutex.Lock() 815 defer fake.netInMutex.Unlock() 816 fake.NetInStub = nil 817 fake.netInReturns = struct { 818 result1 uint32 819 result2 uint32 820 result3 error 821 }{result1, result2, result3} 822} 823 824func (fake *FakeContainer) NetInReturnsOnCall(i int, result1 uint32, result2 uint32, result3 error) { 825 fake.netInMutex.Lock() 826 defer fake.netInMutex.Unlock() 827 fake.NetInStub = nil 828 if fake.netInReturnsOnCall == nil { 829 fake.netInReturnsOnCall = make(map[int]struct { 830 result1 uint32 831 result2 uint32 832 result3 error 833 }) 834 } 835 fake.netInReturnsOnCall[i] = struct { 836 result1 uint32 837 result2 uint32 838 result3 error 839 }{result1, result2, result3} 840} 841 842func (fake *FakeContainer) NetOut(arg1 garden.NetOutRule) error { 843 fake.netOutMutex.Lock() 844 ret, specificReturn := fake.netOutReturnsOnCall[len(fake.netOutArgsForCall)] 845 fake.netOutArgsForCall = append(fake.netOutArgsForCall, struct { 846 arg1 garden.NetOutRule 847 }{arg1}) 848 fake.recordInvocation("NetOut", []interface{}{arg1}) 849 fake.netOutMutex.Unlock() 850 if fake.NetOutStub != nil { 851 return fake.NetOutStub(arg1) 852 } 853 if specificReturn { 854 return ret.result1 855 } 856 fakeReturns := fake.netOutReturns 857 return fakeReturns.result1 858} 859 860func (fake *FakeContainer) NetOutCallCount() int { 861 fake.netOutMutex.RLock() 862 defer fake.netOutMutex.RUnlock() 863 return len(fake.netOutArgsForCall) 864} 865 866func (fake *FakeContainer) NetOutCalls(stub func(garden.NetOutRule) error) { 867 fake.netOutMutex.Lock() 868 defer fake.netOutMutex.Unlock() 869 fake.NetOutStub = stub 870} 871 872func (fake *FakeContainer) NetOutArgsForCall(i int) garden.NetOutRule { 873 fake.netOutMutex.RLock() 874 defer fake.netOutMutex.RUnlock() 875 argsForCall := fake.netOutArgsForCall[i] 876 return argsForCall.arg1 877} 878 879func (fake *FakeContainer) NetOutReturns(result1 error) { 880 fake.netOutMutex.Lock() 881 defer fake.netOutMutex.Unlock() 882 fake.NetOutStub = nil 883 fake.netOutReturns = struct { 884 result1 error 885 }{result1} 886} 887 888func (fake *FakeContainer) NetOutReturnsOnCall(i int, result1 error) { 889 fake.netOutMutex.Lock() 890 defer fake.netOutMutex.Unlock() 891 fake.NetOutStub = nil 892 if fake.netOutReturnsOnCall == nil { 893 fake.netOutReturnsOnCall = make(map[int]struct { 894 result1 error 895 }) 896 } 897 fake.netOutReturnsOnCall[i] = struct { 898 result1 error 899 }{result1} 900} 901 902func (fake *FakeContainer) Properties() (garden.Properties, error) { 903 fake.propertiesMutex.Lock() 904 ret, specificReturn := fake.propertiesReturnsOnCall[len(fake.propertiesArgsForCall)] 905 fake.propertiesArgsForCall = append(fake.propertiesArgsForCall, struct { 906 }{}) 907 fake.recordInvocation("Properties", []interface{}{}) 908 fake.propertiesMutex.Unlock() 909 if fake.PropertiesStub != nil { 910 return fake.PropertiesStub() 911 } 912 if specificReturn { 913 return ret.result1, ret.result2 914 } 915 fakeReturns := fake.propertiesReturns 916 return fakeReturns.result1, fakeReturns.result2 917} 918 919func (fake *FakeContainer) PropertiesCallCount() int { 920 fake.propertiesMutex.RLock() 921 defer fake.propertiesMutex.RUnlock() 922 return len(fake.propertiesArgsForCall) 923} 924 925func (fake *FakeContainer) PropertiesCalls(stub func() (garden.Properties, error)) { 926 fake.propertiesMutex.Lock() 927 defer fake.propertiesMutex.Unlock() 928 fake.PropertiesStub = stub 929} 930 931func (fake *FakeContainer) PropertiesReturns(result1 garden.Properties, result2 error) { 932 fake.propertiesMutex.Lock() 933 defer fake.propertiesMutex.Unlock() 934 fake.PropertiesStub = nil 935 fake.propertiesReturns = struct { 936 result1 garden.Properties 937 result2 error 938 }{result1, result2} 939} 940 941func (fake *FakeContainer) PropertiesReturnsOnCall(i int, result1 garden.Properties, result2 error) { 942 fake.propertiesMutex.Lock() 943 defer fake.propertiesMutex.Unlock() 944 fake.PropertiesStub = nil 945 if fake.propertiesReturnsOnCall == nil { 946 fake.propertiesReturnsOnCall = make(map[int]struct { 947 result1 garden.Properties 948 result2 error 949 }) 950 } 951 fake.propertiesReturnsOnCall[i] = struct { 952 result1 garden.Properties 953 result2 error 954 }{result1, result2} 955} 956 957func (fake *FakeContainer) Property(arg1 string) (string, error) { 958 fake.propertyMutex.Lock() 959 ret, specificReturn := fake.propertyReturnsOnCall[len(fake.propertyArgsForCall)] 960 fake.propertyArgsForCall = append(fake.propertyArgsForCall, struct { 961 arg1 string 962 }{arg1}) 963 fake.recordInvocation("Property", []interface{}{arg1}) 964 fake.propertyMutex.Unlock() 965 if fake.PropertyStub != nil { 966 return fake.PropertyStub(arg1) 967 } 968 if specificReturn { 969 return ret.result1, ret.result2 970 } 971 fakeReturns := fake.propertyReturns 972 return fakeReturns.result1, fakeReturns.result2 973} 974 975func (fake *FakeContainer) PropertyCallCount() int { 976 fake.propertyMutex.RLock() 977 defer fake.propertyMutex.RUnlock() 978 return len(fake.propertyArgsForCall) 979} 980 981func (fake *FakeContainer) PropertyCalls(stub func(string) (string, error)) { 982 fake.propertyMutex.Lock() 983 defer fake.propertyMutex.Unlock() 984 fake.PropertyStub = stub 985} 986 987func (fake *FakeContainer) PropertyArgsForCall(i int) string { 988 fake.propertyMutex.RLock() 989 defer fake.propertyMutex.RUnlock() 990 argsForCall := fake.propertyArgsForCall[i] 991 return argsForCall.arg1 992} 993 994func (fake *FakeContainer) PropertyReturns(result1 string, result2 error) { 995 fake.propertyMutex.Lock() 996 defer fake.propertyMutex.Unlock() 997 fake.PropertyStub = nil 998 fake.propertyReturns = struct { 999 result1 string 1000 result2 error 1001 }{result1, result2} 1002} 1003 1004func (fake *FakeContainer) PropertyReturnsOnCall(i int, result1 string, result2 error) { 1005 fake.propertyMutex.Lock() 1006 defer fake.propertyMutex.Unlock() 1007 fake.PropertyStub = nil 1008 if fake.propertyReturnsOnCall == nil { 1009 fake.propertyReturnsOnCall = make(map[int]struct { 1010 result1 string 1011 result2 error 1012 }) 1013 } 1014 fake.propertyReturnsOnCall[i] = struct { 1015 result1 string 1016 result2 error 1017 }{result1, result2} 1018} 1019 1020func (fake *FakeContainer) RemoveProperty(arg1 string) error { 1021 fake.removePropertyMutex.Lock() 1022 ret, specificReturn := fake.removePropertyReturnsOnCall[len(fake.removePropertyArgsForCall)] 1023 fake.removePropertyArgsForCall = append(fake.removePropertyArgsForCall, struct { 1024 arg1 string 1025 }{arg1}) 1026 fake.recordInvocation("RemoveProperty", []interface{}{arg1}) 1027 fake.removePropertyMutex.Unlock() 1028 if fake.RemovePropertyStub != nil { 1029 return fake.RemovePropertyStub(arg1) 1030 } 1031 if specificReturn { 1032 return ret.result1 1033 } 1034 fakeReturns := fake.removePropertyReturns 1035 return fakeReturns.result1 1036} 1037 1038func (fake *FakeContainer) RemovePropertyCallCount() int { 1039 fake.removePropertyMutex.RLock() 1040 defer fake.removePropertyMutex.RUnlock() 1041 return len(fake.removePropertyArgsForCall) 1042} 1043 1044func (fake *FakeContainer) RemovePropertyCalls(stub func(string) error) { 1045 fake.removePropertyMutex.Lock() 1046 defer fake.removePropertyMutex.Unlock() 1047 fake.RemovePropertyStub = stub 1048} 1049 1050func (fake *FakeContainer) RemovePropertyArgsForCall(i int) string { 1051 fake.removePropertyMutex.RLock() 1052 defer fake.removePropertyMutex.RUnlock() 1053 argsForCall := fake.removePropertyArgsForCall[i] 1054 return argsForCall.arg1 1055} 1056 1057func (fake *FakeContainer) RemovePropertyReturns(result1 error) { 1058 fake.removePropertyMutex.Lock() 1059 defer fake.removePropertyMutex.Unlock() 1060 fake.RemovePropertyStub = nil 1061 fake.removePropertyReturns = struct { 1062 result1 error 1063 }{result1} 1064} 1065 1066func (fake *FakeContainer) RemovePropertyReturnsOnCall(i int, result1 error) { 1067 fake.removePropertyMutex.Lock() 1068 defer fake.removePropertyMutex.Unlock() 1069 fake.RemovePropertyStub = nil 1070 if fake.removePropertyReturnsOnCall == nil { 1071 fake.removePropertyReturnsOnCall = make(map[int]struct { 1072 result1 error 1073 }) 1074 } 1075 fake.removePropertyReturnsOnCall[i] = struct { 1076 result1 error 1077 }{result1} 1078} 1079 1080func (fake *FakeContainer) Run(arg1 context.Context, arg2 garden.ProcessSpec, arg3 garden.ProcessIO) (garden.Process, error) { 1081 fake.runMutex.Lock() 1082 ret, specificReturn := fake.runReturnsOnCall[len(fake.runArgsForCall)] 1083 fake.runArgsForCall = append(fake.runArgsForCall, struct { 1084 arg1 context.Context 1085 arg2 garden.ProcessSpec 1086 arg3 garden.ProcessIO 1087 }{arg1, arg2, arg3}) 1088 fake.recordInvocation("Run", []interface{}{arg1, arg2, arg3}) 1089 fake.runMutex.Unlock() 1090 if fake.RunStub != nil { 1091 return fake.RunStub(arg1, arg2, arg3) 1092 } 1093 if specificReturn { 1094 return ret.result1, ret.result2 1095 } 1096 fakeReturns := fake.runReturns 1097 return fakeReturns.result1, fakeReturns.result2 1098} 1099 1100func (fake *FakeContainer) RunCallCount() int { 1101 fake.runMutex.RLock() 1102 defer fake.runMutex.RUnlock() 1103 return len(fake.runArgsForCall) 1104} 1105 1106func (fake *FakeContainer) RunCalls(stub func(context.Context, garden.ProcessSpec, garden.ProcessIO) (garden.Process, error)) { 1107 fake.runMutex.Lock() 1108 defer fake.runMutex.Unlock() 1109 fake.RunStub = stub 1110} 1111 1112func (fake *FakeContainer) RunArgsForCall(i int) (context.Context, garden.ProcessSpec, garden.ProcessIO) { 1113 fake.runMutex.RLock() 1114 defer fake.runMutex.RUnlock() 1115 argsForCall := fake.runArgsForCall[i] 1116 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1117} 1118 1119func (fake *FakeContainer) RunReturns(result1 garden.Process, result2 error) { 1120 fake.runMutex.Lock() 1121 defer fake.runMutex.Unlock() 1122 fake.RunStub = nil 1123 fake.runReturns = struct { 1124 result1 garden.Process 1125 result2 error 1126 }{result1, result2} 1127} 1128 1129func (fake *FakeContainer) RunReturnsOnCall(i int, result1 garden.Process, result2 error) { 1130 fake.runMutex.Lock() 1131 defer fake.runMutex.Unlock() 1132 fake.RunStub = nil 1133 if fake.runReturnsOnCall == nil { 1134 fake.runReturnsOnCall = make(map[int]struct { 1135 result1 garden.Process 1136 result2 error 1137 }) 1138 } 1139 fake.runReturnsOnCall[i] = struct { 1140 result1 garden.Process 1141 result2 error 1142 }{result1, result2} 1143} 1144 1145func (fake *FakeContainer) SetGraceTime(arg1 time.Duration) error { 1146 fake.setGraceTimeMutex.Lock() 1147 ret, specificReturn := fake.setGraceTimeReturnsOnCall[len(fake.setGraceTimeArgsForCall)] 1148 fake.setGraceTimeArgsForCall = append(fake.setGraceTimeArgsForCall, struct { 1149 arg1 time.Duration 1150 }{arg1}) 1151 fake.recordInvocation("SetGraceTime", []interface{}{arg1}) 1152 fake.setGraceTimeMutex.Unlock() 1153 if fake.SetGraceTimeStub != nil { 1154 return fake.SetGraceTimeStub(arg1) 1155 } 1156 if specificReturn { 1157 return ret.result1 1158 } 1159 fakeReturns := fake.setGraceTimeReturns 1160 return fakeReturns.result1 1161} 1162 1163func (fake *FakeContainer) SetGraceTimeCallCount() int { 1164 fake.setGraceTimeMutex.RLock() 1165 defer fake.setGraceTimeMutex.RUnlock() 1166 return len(fake.setGraceTimeArgsForCall) 1167} 1168 1169func (fake *FakeContainer) SetGraceTimeCalls(stub func(time.Duration) error) { 1170 fake.setGraceTimeMutex.Lock() 1171 defer fake.setGraceTimeMutex.Unlock() 1172 fake.SetGraceTimeStub = stub 1173} 1174 1175func (fake *FakeContainer) SetGraceTimeArgsForCall(i int) time.Duration { 1176 fake.setGraceTimeMutex.RLock() 1177 defer fake.setGraceTimeMutex.RUnlock() 1178 argsForCall := fake.setGraceTimeArgsForCall[i] 1179 return argsForCall.arg1 1180} 1181 1182func (fake *FakeContainer) SetGraceTimeReturns(result1 error) { 1183 fake.setGraceTimeMutex.Lock() 1184 defer fake.setGraceTimeMutex.Unlock() 1185 fake.SetGraceTimeStub = nil 1186 fake.setGraceTimeReturns = struct { 1187 result1 error 1188 }{result1} 1189} 1190 1191func (fake *FakeContainer) SetGraceTimeReturnsOnCall(i int, result1 error) { 1192 fake.setGraceTimeMutex.Lock() 1193 defer fake.setGraceTimeMutex.Unlock() 1194 fake.SetGraceTimeStub = nil 1195 if fake.setGraceTimeReturnsOnCall == nil { 1196 fake.setGraceTimeReturnsOnCall = make(map[int]struct { 1197 result1 error 1198 }) 1199 } 1200 fake.setGraceTimeReturnsOnCall[i] = struct { 1201 result1 error 1202 }{result1} 1203} 1204 1205func (fake *FakeContainer) SetProperty(arg1 string, arg2 string) error { 1206 fake.setPropertyMutex.Lock() 1207 ret, specificReturn := fake.setPropertyReturnsOnCall[len(fake.setPropertyArgsForCall)] 1208 fake.setPropertyArgsForCall = append(fake.setPropertyArgsForCall, struct { 1209 arg1 string 1210 arg2 string 1211 }{arg1, arg2}) 1212 fake.recordInvocation("SetProperty", []interface{}{arg1, arg2}) 1213 fake.setPropertyMutex.Unlock() 1214 if fake.SetPropertyStub != nil { 1215 return fake.SetPropertyStub(arg1, arg2) 1216 } 1217 if specificReturn { 1218 return ret.result1 1219 } 1220 fakeReturns := fake.setPropertyReturns 1221 return fakeReturns.result1 1222} 1223 1224func (fake *FakeContainer) SetPropertyCallCount() int { 1225 fake.setPropertyMutex.RLock() 1226 defer fake.setPropertyMutex.RUnlock() 1227 return len(fake.setPropertyArgsForCall) 1228} 1229 1230func (fake *FakeContainer) SetPropertyCalls(stub func(string, string) error) { 1231 fake.setPropertyMutex.Lock() 1232 defer fake.setPropertyMutex.Unlock() 1233 fake.SetPropertyStub = stub 1234} 1235 1236func (fake *FakeContainer) SetPropertyArgsForCall(i int) (string, string) { 1237 fake.setPropertyMutex.RLock() 1238 defer fake.setPropertyMutex.RUnlock() 1239 argsForCall := fake.setPropertyArgsForCall[i] 1240 return argsForCall.arg1, argsForCall.arg2 1241} 1242 1243func (fake *FakeContainer) SetPropertyReturns(result1 error) { 1244 fake.setPropertyMutex.Lock() 1245 defer fake.setPropertyMutex.Unlock() 1246 fake.SetPropertyStub = nil 1247 fake.setPropertyReturns = struct { 1248 result1 error 1249 }{result1} 1250} 1251 1252func (fake *FakeContainer) SetPropertyReturnsOnCall(i int, result1 error) { 1253 fake.setPropertyMutex.Lock() 1254 defer fake.setPropertyMutex.Unlock() 1255 fake.SetPropertyStub = nil 1256 if fake.setPropertyReturnsOnCall == nil { 1257 fake.setPropertyReturnsOnCall = make(map[int]struct { 1258 result1 error 1259 }) 1260 } 1261 fake.setPropertyReturnsOnCall[i] = struct { 1262 result1 error 1263 }{result1} 1264} 1265 1266func (fake *FakeContainer) Stop(arg1 bool) error { 1267 fake.stopMutex.Lock() 1268 ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)] 1269 fake.stopArgsForCall = append(fake.stopArgsForCall, struct { 1270 arg1 bool 1271 }{arg1}) 1272 fake.recordInvocation("Stop", []interface{}{arg1}) 1273 fake.stopMutex.Unlock() 1274 if fake.StopStub != nil { 1275 return fake.StopStub(arg1) 1276 } 1277 if specificReturn { 1278 return ret.result1 1279 } 1280 fakeReturns := fake.stopReturns 1281 return fakeReturns.result1 1282} 1283 1284func (fake *FakeContainer) StopCallCount() int { 1285 fake.stopMutex.RLock() 1286 defer fake.stopMutex.RUnlock() 1287 return len(fake.stopArgsForCall) 1288} 1289 1290func (fake *FakeContainer) StopCalls(stub func(bool) error) { 1291 fake.stopMutex.Lock() 1292 defer fake.stopMutex.Unlock() 1293 fake.StopStub = stub 1294} 1295 1296func (fake *FakeContainer) StopArgsForCall(i int) bool { 1297 fake.stopMutex.RLock() 1298 defer fake.stopMutex.RUnlock() 1299 argsForCall := fake.stopArgsForCall[i] 1300 return argsForCall.arg1 1301} 1302 1303func (fake *FakeContainer) StopReturns(result1 error) { 1304 fake.stopMutex.Lock() 1305 defer fake.stopMutex.Unlock() 1306 fake.StopStub = nil 1307 fake.stopReturns = struct { 1308 result1 error 1309 }{result1} 1310} 1311 1312func (fake *FakeContainer) StopReturnsOnCall(i int, result1 error) { 1313 fake.stopMutex.Lock() 1314 defer fake.stopMutex.Unlock() 1315 fake.StopStub = nil 1316 if fake.stopReturnsOnCall == nil { 1317 fake.stopReturnsOnCall = make(map[int]struct { 1318 result1 error 1319 }) 1320 } 1321 fake.stopReturnsOnCall[i] = struct { 1322 result1 error 1323 }{result1} 1324} 1325 1326func (fake *FakeContainer) StreamIn(arg1 garden.StreamInSpec) error { 1327 fake.streamInMutex.Lock() 1328 ret, specificReturn := fake.streamInReturnsOnCall[len(fake.streamInArgsForCall)] 1329 fake.streamInArgsForCall = append(fake.streamInArgsForCall, struct { 1330 arg1 garden.StreamInSpec 1331 }{arg1}) 1332 fake.recordInvocation("StreamIn", []interface{}{arg1}) 1333 fake.streamInMutex.Unlock() 1334 if fake.StreamInStub != nil { 1335 return fake.StreamInStub(arg1) 1336 } 1337 if specificReturn { 1338 return ret.result1 1339 } 1340 fakeReturns := fake.streamInReturns 1341 return fakeReturns.result1 1342} 1343 1344func (fake *FakeContainer) StreamInCallCount() int { 1345 fake.streamInMutex.RLock() 1346 defer fake.streamInMutex.RUnlock() 1347 return len(fake.streamInArgsForCall) 1348} 1349 1350func (fake *FakeContainer) StreamInCalls(stub func(garden.StreamInSpec) error) { 1351 fake.streamInMutex.Lock() 1352 defer fake.streamInMutex.Unlock() 1353 fake.StreamInStub = stub 1354} 1355 1356func (fake *FakeContainer) StreamInArgsForCall(i int) garden.StreamInSpec { 1357 fake.streamInMutex.RLock() 1358 defer fake.streamInMutex.RUnlock() 1359 argsForCall := fake.streamInArgsForCall[i] 1360 return argsForCall.arg1 1361} 1362 1363func (fake *FakeContainer) StreamInReturns(result1 error) { 1364 fake.streamInMutex.Lock() 1365 defer fake.streamInMutex.Unlock() 1366 fake.StreamInStub = nil 1367 fake.streamInReturns = struct { 1368 result1 error 1369 }{result1} 1370} 1371 1372func (fake *FakeContainer) StreamInReturnsOnCall(i int, result1 error) { 1373 fake.streamInMutex.Lock() 1374 defer fake.streamInMutex.Unlock() 1375 fake.StreamInStub = nil 1376 if fake.streamInReturnsOnCall == nil { 1377 fake.streamInReturnsOnCall = make(map[int]struct { 1378 result1 error 1379 }) 1380 } 1381 fake.streamInReturnsOnCall[i] = struct { 1382 result1 error 1383 }{result1} 1384} 1385 1386func (fake *FakeContainer) StreamOut(arg1 garden.StreamOutSpec) (io.ReadCloser, error) { 1387 fake.streamOutMutex.Lock() 1388 ret, specificReturn := fake.streamOutReturnsOnCall[len(fake.streamOutArgsForCall)] 1389 fake.streamOutArgsForCall = append(fake.streamOutArgsForCall, struct { 1390 arg1 garden.StreamOutSpec 1391 }{arg1}) 1392 fake.recordInvocation("StreamOut", []interface{}{arg1}) 1393 fake.streamOutMutex.Unlock() 1394 if fake.StreamOutStub != nil { 1395 return fake.StreamOutStub(arg1) 1396 } 1397 if specificReturn { 1398 return ret.result1, ret.result2 1399 } 1400 fakeReturns := fake.streamOutReturns 1401 return fakeReturns.result1, fakeReturns.result2 1402} 1403 1404func (fake *FakeContainer) StreamOutCallCount() int { 1405 fake.streamOutMutex.RLock() 1406 defer fake.streamOutMutex.RUnlock() 1407 return len(fake.streamOutArgsForCall) 1408} 1409 1410func (fake *FakeContainer) StreamOutCalls(stub func(garden.StreamOutSpec) (io.ReadCloser, error)) { 1411 fake.streamOutMutex.Lock() 1412 defer fake.streamOutMutex.Unlock() 1413 fake.StreamOutStub = stub 1414} 1415 1416func (fake *FakeContainer) StreamOutArgsForCall(i int) garden.StreamOutSpec { 1417 fake.streamOutMutex.RLock() 1418 defer fake.streamOutMutex.RUnlock() 1419 argsForCall := fake.streamOutArgsForCall[i] 1420 return argsForCall.arg1 1421} 1422 1423func (fake *FakeContainer) StreamOutReturns(result1 io.ReadCloser, result2 error) { 1424 fake.streamOutMutex.Lock() 1425 defer fake.streamOutMutex.Unlock() 1426 fake.StreamOutStub = nil 1427 fake.streamOutReturns = struct { 1428 result1 io.ReadCloser 1429 result2 error 1430 }{result1, result2} 1431} 1432 1433func (fake *FakeContainer) StreamOutReturnsOnCall(i int, result1 io.ReadCloser, result2 error) { 1434 fake.streamOutMutex.Lock() 1435 defer fake.streamOutMutex.Unlock() 1436 fake.StreamOutStub = nil 1437 if fake.streamOutReturnsOnCall == nil { 1438 fake.streamOutReturnsOnCall = make(map[int]struct { 1439 result1 io.ReadCloser 1440 result2 error 1441 }) 1442 } 1443 fake.streamOutReturnsOnCall[i] = struct { 1444 result1 io.ReadCloser 1445 result2 error 1446 }{result1, result2} 1447} 1448 1449func (fake *FakeContainer) Invocations() map[string][][]interface{} { 1450 fake.invocationsMutex.RLock() 1451 defer fake.invocationsMutex.RUnlock() 1452 fake.attachMutex.RLock() 1453 defer fake.attachMutex.RUnlock() 1454 fake.bulkNetOutMutex.RLock() 1455 defer fake.bulkNetOutMutex.RUnlock() 1456 fake.currentBandwidthLimitsMutex.RLock() 1457 defer fake.currentBandwidthLimitsMutex.RUnlock() 1458 fake.currentCPULimitsMutex.RLock() 1459 defer fake.currentCPULimitsMutex.RUnlock() 1460 fake.currentDiskLimitsMutex.RLock() 1461 defer fake.currentDiskLimitsMutex.RUnlock() 1462 fake.currentMemoryLimitsMutex.RLock() 1463 defer fake.currentMemoryLimitsMutex.RUnlock() 1464 fake.handleMutex.RLock() 1465 defer fake.handleMutex.RUnlock() 1466 fake.infoMutex.RLock() 1467 defer fake.infoMutex.RUnlock() 1468 fake.metricsMutex.RLock() 1469 defer fake.metricsMutex.RUnlock() 1470 fake.netInMutex.RLock() 1471 defer fake.netInMutex.RUnlock() 1472 fake.netOutMutex.RLock() 1473 defer fake.netOutMutex.RUnlock() 1474 fake.propertiesMutex.RLock() 1475 defer fake.propertiesMutex.RUnlock() 1476 fake.propertyMutex.RLock() 1477 defer fake.propertyMutex.RUnlock() 1478 fake.removePropertyMutex.RLock() 1479 defer fake.removePropertyMutex.RUnlock() 1480 fake.runMutex.RLock() 1481 defer fake.runMutex.RUnlock() 1482 fake.setGraceTimeMutex.RLock() 1483 defer fake.setGraceTimeMutex.RUnlock() 1484 fake.setPropertyMutex.RLock() 1485 defer fake.setPropertyMutex.RUnlock() 1486 fake.stopMutex.RLock() 1487 defer fake.stopMutex.RUnlock() 1488 fake.streamInMutex.RLock() 1489 defer fake.streamInMutex.RUnlock() 1490 fake.streamOutMutex.RLock() 1491 defer fake.streamOutMutex.RUnlock() 1492 copiedInvocations := map[string][][]interface{}{} 1493 for key, value := range fake.invocations { 1494 copiedInvocations[key] = value 1495 } 1496 return copiedInvocations 1497} 1498 1499func (fake *FakeContainer) recordInvocation(key string, args []interface{}) { 1500 fake.invocationsMutex.Lock() 1501 defer fake.invocationsMutex.Unlock() 1502 if fake.invocations == nil { 1503 fake.invocations = map[string][][]interface{}{} 1504 } 1505 if fake.invocations[key] == nil { 1506 fake.invocations[key] = [][]interface{}{} 1507 } 1508 fake.invocations[key] = append(fake.invocations[key], args) 1509} 1510 1511var _ gclient.Container = new(FakeContainer) 1512