1
2 package fake
3
4 import (
5 "sync"
6
7 v1 "github.com/google/go-containerregistry/pkg/v1"
8 "github.com/google/go-containerregistry/pkg/v1/types"
9 )
10
11 type FakeImage struct {
12 ConfigFileStub func() (*v1.ConfigFile, error)
13 configFileMutex sync.RWMutex
14 configFileArgsForCall []struct {
15 }
16 configFileReturns struct {
17 result1 *v1.ConfigFile
18 result2 error
19 }
20 configFileReturnsOnCall map[int]struct {
21 result1 *v1.ConfigFile
22 result2 error
23 }
24 ConfigNameStub func() (v1.Hash, error)
25 configNameMutex sync.RWMutex
26 configNameArgsForCall []struct {
27 }
28 configNameReturns struct {
29 result1 v1.Hash
30 result2 error
31 }
32 configNameReturnsOnCall map[int]struct {
33 result1 v1.Hash
34 result2 error
35 }
36 DigestStub func() (v1.Hash, error)
37 digestMutex sync.RWMutex
38 digestArgsForCall []struct {
39 }
40 digestReturns struct {
41 result1 v1.Hash
42 result2 error
43 }
44 digestReturnsOnCall map[int]struct {
45 result1 v1.Hash
46 result2 error
47 }
48 LayerByDiffIDStub func(v1.Hash) (v1.Layer, error)
49 layerByDiffIDMutex sync.RWMutex
50 layerByDiffIDArgsForCall []struct {
51 arg1 v1.Hash
52 }
53 layerByDiffIDReturns struct {
54 result1 v1.Layer
55 result2 error
56 }
57 layerByDiffIDReturnsOnCall map[int]struct {
58 result1 v1.Layer
59 result2 error
60 }
61 LayerByDigestStub func(v1.Hash) (v1.Layer, error)
62 layerByDigestMutex sync.RWMutex
63 layerByDigestArgsForCall []struct {
64 arg1 v1.Hash
65 }
66 layerByDigestReturns struct {
67 result1 v1.Layer
68 result2 error
69 }
70 layerByDigestReturnsOnCall map[int]struct {
71 result1 v1.Layer
72 result2 error
73 }
74 LayersStub func() ([]v1.Layer, error)
75 layersMutex sync.RWMutex
76 layersArgsForCall []struct {
77 }
78 layersReturns struct {
79 result1 []v1.Layer
80 result2 error
81 }
82 layersReturnsOnCall map[int]struct {
83 result1 []v1.Layer
84 result2 error
85 }
86 ManifestStub func() (*v1.Manifest, error)
87 manifestMutex sync.RWMutex
88 manifestArgsForCall []struct {
89 }
90 manifestReturns struct {
91 result1 *v1.Manifest
92 result2 error
93 }
94 manifestReturnsOnCall map[int]struct {
95 result1 *v1.Manifest
96 result2 error
97 }
98 MediaTypeStub func() (types.MediaType, error)
99 mediaTypeMutex sync.RWMutex
100 mediaTypeArgsForCall []struct {
101 }
102 mediaTypeReturns struct {
103 result1 types.MediaType
104 result2 error
105 }
106 mediaTypeReturnsOnCall map[int]struct {
107 result1 types.MediaType
108 result2 error
109 }
110 RawConfigFileStub func() ([]byte, error)
111 rawConfigFileMutex sync.RWMutex
112 rawConfigFileArgsForCall []struct {
113 }
114 rawConfigFileReturns struct {
115 result1 []byte
116 result2 error
117 }
118 rawConfigFileReturnsOnCall map[int]struct {
119 result1 []byte
120 result2 error
121 }
122 RawManifestStub func() ([]byte, error)
123 rawManifestMutex sync.RWMutex
124 rawManifestArgsForCall []struct {
125 }
126 rawManifestReturns struct {
127 result1 []byte
128 result2 error
129 }
130 rawManifestReturnsOnCall map[int]struct {
131 result1 []byte
132 result2 error
133 }
134 SizeStub func() (int64, error)
135 sizeMutex sync.RWMutex
136 sizeArgsForCall []struct {
137 }
138 sizeReturns struct {
139 result1 int64
140 result2 error
141 }
142 sizeReturnsOnCall map[int]struct {
143 result1 int64
144 result2 error
145 }
146 invocations map[string][][]interface{}
147 invocationsMutex sync.RWMutex
148 }
149
150 func (fake *FakeImage) ConfigFile() (*v1.ConfigFile, error) {
151 fake.configFileMutex.Lock()
152 ret, specificReturn := fake.configFileReturnsOnCall[len(fake.configFileArgsForCall)]
153 fake.configFileArgsForCall = append(fake.configFileArgsForCall, struct {
154 }{})
155 stub := fake.ConfigFileStub
156 fakeReturns := fake.configFileReturns
157 fake.recordInvocation("ConfigFile", []interface{}{})
158 fake.configFileMutex.Unlock()
159 if stub != nil {
160 return stub()
161 }
162 if specificReturn {
163 return ret.result1, ret.result2
164 }
165 return fakeReturns.result1, fakeReturns.result2
166 }
167
168 func (fake *FakeImage) ConfigFileCallCount() int {
169 fake.configFileMutex.RLock()
170 defer fake.configFileMutex.RUnlock()
171 return len(fake.configFileArgsForCall)
172 }
173
174 func (fake *FakeImage) ConfigFileCalls(stub func() (*v1.ConfigFile, error)) {
175 fake.configFileMutex.Lock()
176 defer fake.configFileMutex.Unlock()
177 fake.ConfigFileStub = stub
178 }
179
180 func (fake *FakeImage) ConfigFileReturns(result1 *v1.ConfigFile, result2 error) {
181 fake.configFileMutex.Lock()
182 defer fake.configFileMutex.Unlock()
183 fake.ConfigFileStub = nil
184 fake.configFileReturns = struct {
185 result1 *v1.ConfigFile
186 result2 error
187 }{result1, result2}
188 }
189
190 func (fake *FakeImage) ConfigFileReturnsOnCall(i int, result1 *v1.ConfigFile, result2 error) {
191 fake.configFileMutex.Lock()
192 defer fake.configFileMutex.Unlock()
193 fake.ConfigFileStub = nil
194 if fake.configFileReturnsOnCall == nil {
195 fake.configFileReturnsOnCall = make(map[int]struct {
196 result1 *v1.ConfigFile
197 result2 error
198 })
199 }
200 fake.configFileReturnsOnCall[i] = struct {
201 result1 *v1.ConfigFile
202 result2 error
203 }{result1, result2}
204 }
205
206 func (fake *FakeImage) ConfigName() (v1.Hash, error) {
207 fake.configNameMutex.Lock()
208 ret, specificReturn := fake.configNameReturnsOnCall[len(fake.configNameArgsForCall)]
209 fake.configNameArgsForCall = append(fake.configNameArgsForCall, struct {
210 }{})
211 stub := fake.ConfigNameStub
212 fakeReturns := fake.configNameReturns
213 fake.recordInvocation("ConfigName", []interface{}{})
214 fake.configNameMutex.Unlock()
215 if stub != nil {
216 return stub()
217 }
218 if specificReturn {
219 return ret.result1, ret.result2
220 }
221 return fakeReturns.result1, fakeReturns.result2
222 }
223
224 func (fake *FakeImage) ConfigNameCallCount() int {
225 fake.configNameMutex.RLock()
226 defer fake.configNameMutex.RUnlock()
227 return len(fake.configNameArgsForCall)
228 }
229
230 func (fake *FakeImage) ConfigNameCalls(stub func() (v1.Hash, error)) {
231 fake.configNameMutex.Lock()
232 defer fake.configNameMutex.Unlock()
233 fake.ConfigNameStub = stub
234 }
235
236 func (fake *FakeImage) ConfigNameReturns(result1 v1.Hash, result2 error) {
237 fake.configNameMutex.Lock()
238 defer fake.configNameMutex.Unlock()
239 fake.ConfigNameStub = nil
240 fake.configNameReturns = struct {
241 result1 v1.Hash
242 result2 error
243 }{result1, result2}
244 }
245
246 func (fake *FakeImage) ConfigNameReturnsOnCall(i int, result1 v1.Hash, result2 error) {
247 fake.configNameMutex.Lock()
248 defer fake.configNameMutex.Unlock()
249 fake.ConfigNameStub = nil
250 if fake.configNameReturnsOnCall == nil {
251 fake.configNameReturnsOnCall = make(map[int]struct {
252 result1 v1.Hash
253 result2 error
254 })
255 }
256 fake.configNameReturnsOnCall[i] = struct {
257 result1 v1.Hash
258 result2 error
259 }{result1, result2}
260 }
261
262 func (fake *FakeImage) Digest() (v1.Hash, error) {
263 fake.digestMutex.Lock()
264 ret, specificReturn := fake.digestReturnsOnCall[len(fake.digestArgsForCall)]
265 fake.digestArgsForCall = append(fake.digestArgsForCall, struct {
266 }{})
267 stub := fake.DigestStub
268 fakeReturns := fake.digestReturns
269 fake.recordInvocation("Digest", []interface{}{})
270 fake.digestMutex.Unlock()
271 if stub != nil {
272 return stub()
273 }
274 if specificReturn {
275 return ret.result1, ret.result2
276 }
277 return fakeReturns.result1, fakeReturns.result2
278 }
279
280 func (fake *FakeImage) DigestCallCount() int {
281 fake.digestMutex.RLock()
282 defer fake.digestMutex.RUnlock()
283 return len(fake.digestArgsForCall)
284 }
285
286 func (fake *FakeImage) DigestCalls(stub func() (v1.Hash, error)) {
287 fake.digestMutex.Lock()
288 defer fake.digestMutex.Unlock()
289 fake.DigestStub = stub
290 }
291
292 func (fake *FakeImage) DigestReturns(result1 v1.Hash, result2 error) {
293 fake.digestMutex.Lock()
294 defer fake.digestMutex.Unlock()
295 fake.DigestStub = nil
296 fake.digestReturns = struct {
297 result1 v1.Hash
298 result2 error
299 }{result1, result2}
300 }
301
302 func (fake *FakeImage) DigestReturnsOnCall(i int, result1 v1.Hash, result2 error) {
303 fake.digestMutex.Lock()
304 defer fake.digestMutex.Unlock()
305 fake.DigestStub = nil
306 if fake.digestReturnsOnCall == nil {
307 fake.digestReturnsOnCall = make(map[int]struct {
308 result1 v1.Hash
309 result2 error
310 })
311 }
312 fake.digestReturnsOnCall[i] = struct {
313 result1 v1.Hash
314 result2 error
315 }{result1, result2}
316 }
317
318 func (fake *FakeImage) LayerByDiffID(arg1 v1.Hash) (v1.Layer, error) {
319 fake.layerByDiffIDMutex.Lock()
320 ret, specificReturn := fake.layerByDiffIDReturnsOnCall[len(fake.layerByDiffIDArgsForCall)]
321 fake.layerByDiffIDArgsForCall = append(fake.layerByDiffIDArgsForCall, struct {
322 arg1 v1.Hash
323 }{arg1})
324 stub := fake.LayerByDiffIDStub
325 fakeReturns := fake.layerByDiffIDReturns
326 fake.recordInvocation("LayerByDiffID", []interface{}{arg1})
327 fake.layerByDiffIDMutex.Unlock()
328 if stub != nil {
329 return stub(arg1)
330 }
331 if specificReturn {
332 return ret.result1, ret.result2
333 }
334 return fakeReturns.result1, fakeReturns.result2
335 }
336
337 func (fake *FakeImage) LayerByDiffIDCallCount() int {
338 fake.layerByDiffIDMutex.RLock()
339 defer fake.layerByDiffIDMutex.RUnlock()
340 return len(fake.layerByDiffIDArgsForCall)
341 }
342
343 func (fake *FakeImage) LayerByDiffIDCalls(stub func(v1.Hash) (v1.Layer, error)) {
344 fake.layerByDiffIDMutex.Lock()
345 defer fake.layerByDiffIDMutex.Unlock()
346 fake.LayerByDiffIDStub = stub
347 }
348
349 func (fake *FakeImage) LayerByDiffIDArgsForCall(i int) v1.Hash {
350 fake.layerByDiffIDMutex.RLock()
351 defer fake.layerByDiffIDMutex.RUnlock()
352 argsForCall := fake.layerByDiffIDArgsForCall[i]
353 return argsForCall.arg1
354 }
355
356 func (fake *FakeImage) LayerByDiffIDReturns(result1 v1.Layer, result2 error) {
357 fake.layerByDiffIDMutex.Lock()
358 defer fake.layerByDiffIDMutex.Unlock()
359 fake.LayerByDiffIDStub = nil
360 fake.layerByDiffIDReturns = struct {
361 result1 v1.Layer
362 result2 error
363 }{result1, result2}
364 }
365
366 func (fake *FakeImage) LayerByDiffIDReturnsOnCall(i int, result1 v1.Layer, result2 error) {
367 fake.layerByDiffIDMutex.Lock()
368 defer fake.layerByDiffIDMutex.Unlock()
369 fake.LayerByDiffIDStub = nil
370 if fake.layerByDiffIDReturnsOnCall == nil {
371 fake.layerByDiffIDReturnsOnCall = make(map[int]struct {
372 result1 v1.Layer
373 result2 error
374 })
375 }
376 fake.layerByDiffIDReturnsOnCall[i] = struct {
377 result1 v1.Layer
378 result2 error
379 }{result1, result2}
380 }
381
382 func (fake *FakeImage) LayerByDigest(arg1 v1.Hash) (v1.Layer, error) {
383 fake.layerByDigestMutex.Lock()
384 ret, specificReturn := fake.layerByDigestReturnsOnCall[len(fake.layerByDigestArgsForCall)]
385 fake.layerByDigestArgsForCall = append(fake.layerByDigestArgsForCall, struct {
386 arg1 v1.Hash
387 }{arg1})
388 stub := fake.LayerByDigestStub
389 fakeReturns := fake.layerByDigestReturns
390 fake.recordInvocation("LayerByDigest", []interface{}{arg1})
391 fake.layerByDigestMutex.Unlock()
392 if stub != nil {
393 return stub(arg1)
394 }
395 if specificReturn {
396 return ret.result1, ret.result2
397 }
398 return fakeReturns.result1, fakeReturns.result2
399 }
400
401 func (fake *FakeImage) LayerByDigestCallCount() int {
402 fake.layerByDigestMutex.RLock()
403 defer fake.layerByDigestMutex.RUnlock()
404 return len(fake.layerByDigestArgsForCall)
405 }
406
407 func (fake *FakeImage) LayerByDigestCalls(stub func(v1.Hash) (v1.Layer, error)) {
408 fake.layerByDigestMutex.Lock()
409 defer fake.layerByDigestMutex.Unlock()
410 fake.LayerByDigestStub = stub
411 }
412
413 func (fake *FakeImage) LayerByDigestArgsForCall(i int) v1.Hash {
414 fake.layerByDigestMutex.RLock()
415 defer fake.layerByDigestMutex.RUnlock()
416 argsForCall := fake.layerByDigestArgsForCall[i]
417 return argsForCall.arg1
418 }
419
420 func (fake *FakeImage) LayerByDigestReturns(result1 v1.Layer, result2 error) {
421 fake.layerByDigestMutex.Lock()
422 defer fake.layerByDigestMutex.Unlock()
423 fake.LayerByDigestStub = nil
424 fake.layerByDigestReturns = struct {
425 result1 v1.Layer
426 result2 error
427 }{result1, result2}
428 }
429
430 func (fake *FakeImage) LayerByDigestReturnsOnCall(i int, result1 v1.Layer, result2 error) {
431 fake.layerByDigestMutex.Lock()
432 defer fake.layerByDigestMutex.Unlock()
433 fake.LayerByDigestStub = nil
434 if fake.layerByDigestReturnsOnCall == nil {
435 fake.layerByDigestReturnsOnCall = make(map[int]struct {
436 result1 v1.Layer
437 result2 error
438 })
439 }
440 fake.layerByDigestReturnsOnCall[i] = struct {
441 result1 v1.Layer
442 result2 error
443 }{result1, result2}
444 }
445
446 func (fake *FakeImage) Layers() ([]v1.Layer, error) {
447 fake.layersMutex.Lock()
448 ret, specificReturn := fake.layersReturnsOnCall[len(fake.layersArgsForCall)]
449 fake.layersArgsForCall = append(fake.layersArgsForCall, struct {
450 }{})
451 stub := fake.LayersStub
452 fakeReturns := fake.layersReturns
453 fake.recordInvocation("Layers", []interface{}{})
454 fake.layersMutex.Unlock()
455 if stub != nil {
456 return stub()
457 }
458 if specificReturn {
459 return ret.result1, ret.result2
460 }
461 return fakeReturns.result1, fakeReturns.result2
462 }
463
464 func (fake *FakeImage) LayersCallCount() int {
465 fake.layersMutex.RLock()
466 defer fake.layersMutex.RUnlock()
467 return len(fake.layersArgsForCall)
468 }
469
470 func (fake *FakeImage) LayersCalls(stub func() ([]v1.Layer, error)) {
471 fake.layersMutex.Lock()
472 defer fake.layersMutex.Unlock()
473 fake.LayersStub = stub
474 }
475
476 func (fake *FakeImage) LayersReturns(result1 []v1.Layer, result2 error) {
477 fake.layersMutex.Lock()
478 defer fake.layersMutex.Unlock()
479 fake.LayersStub = nil
480 fake.layersReturns = struct {
481 result1 []v1.Layer
482 result2 error
483 }{result1, result2}
484 }
485
486 func (fake *FakeImage) LayersReturnsOnCall(i int, result1 []v1.Layer, result2 error) {
487 fake.layersMutex.Lock()
488 defer fake.layersMutex.Unlock()
489 fake.LayersStub = nil
490 if fake.layersReturnsOnCall == nil {
491 fake.layersReturnsOnCall = make(map[int]struct {
492 result1 []v1.Layer
493 result2 error
494 })
495 }
496 fake.layersReturnsOnCall[i] = struct {
497 result1 []v1.Layer
498 result2 error
499 }{result1, result2}
500 }
501
502 func (fake *FakeImage) Manifest() (*v1.Manifest, error) {
503 fake.manifestMutex.Lock()
504 ret, specificReturn := fake.manifestReturnsOnCall[len(fake.manifestArgsForCall)]
505 fake.manifestArgsForCall = append(fake.manifestArgsForCall, struct {
506 }{})
507 stub := fake.ManifestStub
508 fakeReturns := fake.manifestReturns
509 fake.recordInvocation("Manifest", []interface{}{})
510 fake.manifestMutex.Unlock()
511 if stub != nil {
512 return stub()
513 }
514 if specificReturn {
515 return ret.result1, ret.result2
516 }
517 return fakeReturns.result1, fakeReturns.result2
518 }
519
520 func (fake *FakeImage) ManifestCallCount() int {
521 fake.manifestMutex.RLock()
522 defer fake.manifestMutex.RUnlock()
523 return len(fake.manifestArgsForCall)
524 }
525
526 func (fake *FakeImage) ManifestCalls(stub func() (*v1.Manifest, error)) {
527 fake.manifestMutex.Lock()
528 defer fake.manifestMutex.Unlock()
529 fake.ManifestStub = stub
530 }
531
532 func (fake *FakeImage) ManifestReturns(result1 *v1.Manifest, result2 error) {
533 fake.manifestMutex.Lock()
534 defer fake.manifestMutex.Unlock()
535 fake.ManifestStub = nil
536 fake.manifestReturns = struct {
537 result1 *v1.Manifest
538 result2 error
539 }{result1, result2}
540 }
541
542 func (fake *FakeImage) ManifestReturnsOnCall(i int, result1 *v1.Manifest, result2 error) {
543 fake.manifestMutex.Lock()
544 defer fake.manifestMutex.Unlock()
545 fake.ManifestStub = nil
546 if fake.manifestReturnsOnCall == nil {
547 fake.manifestReturnsOnCall = make(map[int]struct {
548 result1 *v1.Manifest
549 result2 error
550 })
551 }
552 fake.manifestReturnsOnCall[i] = struct {
553 result1 *v1.Manifest
554 result2 error
555 }{result1, result2}
556 }
557
558 func (fake *FakeImage) MediaType() (types.MediaType, error) {
559 fake.mediaTypeMutex.Lock()
560 ret, specificReturn := fake.mediaTypeReturnsOnCall[len(fake.mediaTypeArgsForCall)]
561 fake.mediaTypeArgsForCall = append(fake.mediaTypeArgsForCall, struct {
562 }{})
563 stub := fake.MediaTypeStub
564 fakeReturns := fake.mediaTypeReturns
565 fake.recordInvocation("MediaType", []interface{}{})
566 fake.mediaTypeMutex.Unlock()
567 if stub != nil {
568 return stub()
569 }
570 if specificReturn {
571 return ret.result1, ret.result2
572 }
573 return fakeReturns.result1, fakeReturns.result2
574 }
575
576 func (fake *FakeImage) MediaTypeCallCount() int {
577 fake.mediaTypeMutex.RLock()
578 defer fake.mediaTypeMutex.RUnlock()
579 return len(fake.mediaTypeArgsForCall)
580 }
581
582 func (fake *FakeImage) MediaTypeCalls(stub func() (types.MediaType, error)) {
583 fake.mediaTypeMutex.Lock()
584 defer fake.mediaTypeMutex.Unlock()
585 fake.MediaTypeStub = stub
586 }
587
588 func (fake *FakeImage) MediaTypeReturns(result1 types.MediaType, result2 error) {
589 fake.mediaTypeMutex.Lock()
590 defer fake.mediaTypeMutex.Unlock()
591 fake.MediaTypeStub = nil
592 fake.mediaTypeReturns = struct {
593 result1 types.MediaType
594 result2 error
595 }{result1, result2}
596 }
597
598 func (fake *FakeImage) MediaTypeReturnsOnCall(i int, result1 types.MediaType, result2 error) {
599 fake.mediaTypeMutex.Lock()
600 defer fake.mediaTypeMutex.Unlock()
601 fake.MediaTypeStub = nil
602 if fake.mediaTypeReturnsOnCall == nil {
603 fake.mediaTypeReturnsOnCall = make(map[int]struct {
604 result1 types.MediaType
605 result2 error
606 })
607 }
608 fake.mediaTypeReturnsOnCall[i] = struct {
609 result1 types.MediaType
610 result2 error
611 }{result1, result2}
612 }
613
614 func (fake *FakeImage) RawConfigFile() ([]byte, error) {
615 fake.rawConfigFileMutex.Lock()
616 ret, specificReturn := fake.rawConfigFileReturnsOnCall[len(fake.rawConfigFileArgsForCall)]
617 fake.rawConfigFileArgsForCall = append(fake.rawConfigFileArgsForCall, struct {
618 }{})
619 stub := fake.RawConfigFileStub
620 fakeReturns := fake.rawConfigFileReturns
621 fake.recordInvocation("RawConfigFile", []interface{}{})
622 fake.rawConfigFileMutex.Unlock()
623 if stub != nil {
624 return stub()
625 }
626 if specificReturn {
627 return ret.result1, ret.result2
628 }
629 return fakeReturns.result1, fakeReturns.result2
630 }
631
632 func (fake *FakeImage) RawConfigFileCallCount() int {
633 fake.rawConfigFileMutex.RLock()
634 defer fake.rawConfigFileMutex.RUnlock()
635 return len(fake.rawConfigFileArgsForCall)
636 }
637
638 func (fake *FakeImage) RawConfigFileCalls(stub func() ([]byte, error)) {
639 fake.rawConfigFileMutex.Lock()
640 defer fake.rawConfigFileMutex.Unlock()
641 fake.RawConfigFileStub = stub
642 }
643
644 func (fake *FakeImage) RawConfigFileReturns(result1 []byte, result2 error) {
645 fake.rawConfigFileMutex.Lock()
646 defer fake.rawConfigFileMutex.Unlock()
647 fake.RawConfigFileStub = nil
648 fake.rawConfigFileReturns = struct {
649 result1 []byte
650 result2 error
651 }{result1, result2}
652 }
653
654 func (fake *FakeImage) RawConfigFileReturnsOnCall(i int, result1 []byte, result2 error) {
655 fake.rawConfigFileMutex.Lock()
656 defer fake.rawConfigFileMutex.Unlock()
657 fake.RawConfigFileStub = nil
658 if fake.rawConfigFileReturnsOnCall == nil {
659 fake.rawConfigFileReturnsOnCall = make(map[int]struct {
660 result1 []byte
661 result2 error
662 })
663 }
664 fake.rawConfigFileReturnsOnCall[i] = struct {
665 result1 []byte
666 result2 error
667 }{result1, result2}
668 }
669
670 func (fake *FakeImage) RawManifest() ([]byte, error) {
671 fake.rawManifestMutex.Lock()
672 ret, specificReturn := fake.rawManifestReturnsOnCall[len(fake.rawManifestArgsForCall)]
673 fake.rawManifestArgsForCall = append(fake.rawManifestArgsForCall, struct {
674 }{})
675 stub := fake.RawManifestStub
676 fakeReturns := fake.rawManifestReturns
677 fake.recordInvocation("RawManifest", []interface{}{})
678 fake.rawManifestMutex.Unlock()
679 if stub != nil {
680 return stub()
681 }
682 if specificReturn {
683 return ret.result1, ret.result2
684 }
685 return fakeReturns.result1, fakeReturns.result2
686 }
687
688 func (fake *FakeImage) RawManifestCallCount() int {
689 fake.rawManifestMutex.RLock()
690 defer fake.rawManifestMutex.RUnlock()
691 return len(fake.rawManifestArgsForCall)
692 }
693
694 func (fake *FakeImage) RawManifestCalls(stub func() ([]byte, error)) {
695 fake.rawManifestMutex.Lock()
696 defer fake.rawManifestMutex.Unlock()
697 fake.RawManifestStub = stub
698 }
699
700 func (fake *FakeImage) RawManifestReturns(result1 []byte, result2 error) {
701 fake.rawManifestMutex.Lock()
702 defer fake.rawManifestMutex.Unlock()
703 fake.RawManifestStub = nil
704 fake.rawManifestReturns = struct {
705 result1 []byte
706 result2 error
707 }{result1, result2}
708 }
709
710 func (fake *FakeImage) RawManifestReturnsOnCall(i int, result1 []byte, result2 error) {
711 fake.rawManifestMutex.Lock()
712 defer fake.rawManifestMutex.Unlock()
713 fake.RawManifestStub = nil
714 if fake.rawManifestReturnsOnCall == nil {
715 fake.rawManifestReturnsOnCall = make(map[int]struct {
716 result1 []byte
717 result2 error
718 })
719 }
720 fake.rawManifestReturnsOnCall[i] = struct {
721 result1 []byte
722 result2 error
723 }{result1, result2}
724 }
725
726 func (fake *FakeImage) Size() (int64, error) {
727 fake.sizeMutex.Lock()
728 ret, specificReturn := fake.sizeReturnsOnCall[len(fake.sizeArgsForCall)]
729 fake.sizeArgsForCall = append(fake.sizeArgsForCall, struct {
730 }{})
731 stub := fake.SizeStub
732 fakeReturns := fake.sizeReturns
733 fake.recordInvocation("Size", []interface{}{})
734 fake.sizeMutex.Unlock()
735 if stub != nil {
736 return stub()
737 }
738 if specificReturn {
739 return ret.result1, ret.result2
740 }
741 return fakeReturns.result1, fakeReturns.result2
742 }
743
744 func (fake *FakeImage) SizeCallCount() int {
745 fake.sizeMutex.RLock()
746 defer fake.sizeMutex.RUnlock()
747 return len(fake.sizeArgsForCall)
748 }
749
750 func (fake *FakeImage) SizeCalls(stub func() (int64, error)) {
751 fake.sizeMutex.Lock()
752 defer fake.sizeMutex.Unlock()
753 fake.SizeStub = stub
754 }
755
756 func (fake *FakeImage) SizeReturns(result1 int64, result2 error) {
757 fake.sizeMutex.Lock()
758 defer fake.sizeMutex.Unlock()
759 fake.SizeStub = nil
760 fake.sizeReturns = struct {
761 result1 int64
762 result2 error
763 }{result1, result2}
764 }
765
766 func (fake *FakeImage) SizeReturnsOnCall(i int, result1 int64, result2 error) {
767 fake.sizeMutex.Lock()
768 defer fake.sizeMutex.Unlock()
769 fake.SizeStub = nil
770 if fake.sizeReturnsOnCall == nil {
771 fake.sizeReturnsOnCall = make(map[int]struct {
772 result1 int64
773 result2 error
774 })
775 }
776 fake.sizeReturnsOnCall[i] = struct {
777 result1 int64
778 result2 error
779 }{result1, result2}
780 }
781
782 func (fake *FakeImage) Invocations() map[string][][]interface{} {
783 fake.invocationsMutex.RLock()
784 defer fake.invocationsMutex.RUnlock()
785 fake.configFileMutex.RLock()
786 defer fake.configFileMutex.RUnlock()
787 fake.configNameMutex.RLock()
788 defer fake.configNameMutex.RUnlock()
789 fake.digestMutex.RLock()
790 defer fake.digestMutex.RUnlock()
791 fake.layerByDiffIDMutex.RLock()
792 defer fake.layerByDiffIDMutex.RUnlock()
793 fake.layerByDigestMutex.RLock()
794 defer fake.layerByDigestMutex.RUnlock()
795 fake.layersMutex.RLock()
796 defer fake.layersMutex.RUnlock()
797 fake.manifestMutex.RLock()
798 defer fake.manifestMutex.RUnlock()
799 fake.mediaTypeMutex.RLock()
800 defer fake.mediaTypeMutex.RUnlock()
801 fake.rawConfigFileMutex.RLock()
802 defer fake.rawConfigFileMutex.RUnlock()
803 fake.rawManifestMutex.RLock()
804 defer fake.rawManifestMutex.RUnlock()
805 fake.sizeMutex.RLock()
806 defer fake.sizeMutex.RUnlock()
807 copiedInvocations := map[string][][]interface{}{}
808 for key, value := range fake.invocations {
809 copiedInvocations[key] = value
810 }
811 return copiedInvocations
812 }
813
814 func (fake *FakeImage) recordInvocation(key string, args []interface{}) {
815 fake.invocationsMutex.Lock()
816 defer fake.invocationsMutex.Unlock()
817 if fake.invocations == nil {
818 fake.invocations = map[string][][]interface{}{}
819 }
820 if fake.invocations[key] == nil {
821 fake.invocations[key] = [][]interface{}{}
822 }
823 fake.invocations[key] = append(fake.invocations[key], args)
824 }
825
826 var _ v1.Image = new(FakeImage)
827
View as plain text