registy.go

// Code generated by counterfeiter. DO NOT EDIT.
package fakes

import (
	"sync"

	"github.com/vmware-tanzu/tanzu-cli/pkg/registry"
)

type Registry struct {
	CopyImageFromTarStub        func(string, string) error
	copyImageFromTarMutex       sync.RWMutex
	copyImageFromTarArgsForCall []struct {
		arg1 string
		arg2 string
	}
	copyImageFromTarReturns struct {
		result1 error
	}
	copyImageFromTarReturnsOnCall map[int]struct {
		result1 error
	}
	CopyImageToTarStub        func(string, string) error
	copyImageToTarMutex       sync.RWMutex
	copyImageToTarArgsForCall []struct {
		arg1 string
		arg2 string
	}
	copyImageToTarReturns struct {
		result1 error
	}
	copyImageToTarReturnsOnCall map[int]struct {
		result1 error
	}
	DownloadBundleStub        func(string, string) error
	downloadBundleMutex       sync.RWMutex
	downloadBundleArgsForCall []struct {
		arg1 string
		arg2 string
	}
	downloadBundleReturns struct {
		result1 error
	}
	downloadBundleReturnsOnCall map[int]struct {
		result1 error
	}
	DownloadImageStub        func(string, string) error
	downloadImageMutex       sync.RWMutex
	downloadImageArgsForCall []struct {
		arg1 string
		arg2 string
	}
	downloadImageReturns struct {
		result1 error
	}
	downloadImageReturnsOnCall map[int]struct {
		result1 error
	}
	GetFileStub        func(string, string) ([]byte, error)
	getFileMutex       sync.RWMutex
	getFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getFileReturns struct {
		result1 []byte
		result2 error
	}
	getFileReturnsOnCall map[int]struct {
		result1 []byte
		result2 error
	}
	GetFilesStub        func(string) (map[string][]byte, error)
	getFilesMutex       sync.RWMutex
	getFilesArgsForCall []struct {
		arg1 string
	}
	getFilesReturns struct {
		result1 map[string][]byte
		result2 error
	}
	getFilesReturnsOnCall map[int]struct {
		result1 map[string][]byte
		result2 error
	}
	GetImageDigestStub        func(string) (string, string, error)
	getImageDigestMutex       sync.RWMutex
	getImageDigestArgsForCall []struct {
		arg1 string
	}
	getImageDigestReturns struct {
		result1 string
		result2 string
		result3 error
	}
	getImageDigestReturnsOnCall map[int]struct {
		result1 string
		result2 string
		result3 error
	}
	ListImageTagsStub        func(string) ([]string, error)
	listImageTagsMutex       sync.RWMutex
	listImageTagsArgsForCall []struct {
		arg1 string
	}
	listImageTagsReturns struct {
		result1 []string
		result2 error
	}
	listImageTagsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	PushImageStub        func(string, []string) error
	pushImageMutex       sync.RWMutex
	pushImageArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	pushImageReturns struct {
		result1 error
	}
	pushImageReturnsOnCall map[int]struct {
		result1 error
	}
	ResolveImageStub        func(string) error
	resolveImageMutex       sync.RWMutex
	resolveImageArgsForCall []struct {
		arg1 string
	}
	resolveImageReturns struct {
		result1 error
	}
	resolveImageReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *Registry) CopyImageFromTar(arg1 string, arg2 string) error {
	fake.copyImageFromTarMutex.Lock()
	ret, specificReturn := fake.copyImageFromTarReturnsOnCall[len(fake.copyImageFromTarArgsForCall)]
	fake.copyImageFromTarArgsForCall = append(fake.copyImageFromTarArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.CopyImageFromTarStub
	fakeReturns := fake.copyImageFromTarReturns
	fake.recordInvocation("CopyImageFromTar", []interface{}{arg1, arg2})
	fake.copyImageFromTarMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Registry) CopyImageFromTarCallCount() int {
	fake.copyImageFromTarMutex.RLock()
	defer fake.copyImageFromTarMutex.RUnlock()
	return len(fake.copyImageFromTarArgsForCall)
}

func (fake *Registry) CopyImageFromTarCalls(stub func(string, string) error) {
	fake.copyImageFromTarMutex.Lock()
	defer fake.copyImageFromTarMutex.Unlock()
	fake.CopyImageFromTarStub = stub
}

func (fake *Registry) CopyImageFromTarArgsForCall(i int) (string, string) {
	fake.copyImageFromTarMutex.RLock()
	defer fake.copyImageFromTarMutex.RUnlock()
	argsForCall := fake.copyImageFromTarArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Registry) CopyImageFromTarReturns(result1 error) {
	fake.copyImageFromTarMutex.Lock()
	defer fake.copyImageFromTarMutex.Unlock()
	fake.CopyImageFromTarStub = nil
	fake.copyImageFromTarReturns = struct {
		result1 error
	}{result1}
}

func (fake *Registry) CopyImageFromTarReturnsOnCall(i int, result1 error) {
	fake.copyImageFromTarMutex.Lock()
	defer fake.copyImageFromTarMutex.Unlock()
	fake.CopyImageFromTarStub = nil
	if fake.copyImageFromTarReturnsOnCall == nil {
		fake.copyImageFromTarReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.copyImageFromTarReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Registry) CopyImageToTar(arg1 string, arg2 string) error {
	fake.copyImageToTarMutex.Lock()
	ret, specificReturn := fake.copyImageToTarReturnsOnCall[len(fake.copyImageToTarArgsForCall)]
	fake.copyImageToTarArgsForCall = append(fake.copyImageToTarArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.CopyImageToTarStub
	fakeReturns := fake.copyImageToTarReturns
	fake.recordInvocation("CopyImageToTar", []interface{}{arg1, arg2})
	fake.copyImageToTarMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Registry) CopyImageToTarCallCount() int {
	fake.copyImageToTarMutex.RLock()
	defer fake.copyImageToTarMutex.RUnlock()
	return len(fake.copyImageToTarArgsForCall)
}

func (fake *Registry) CopyImageToTarCalls(stub func(string, string) error) {
	fake.copyImageToTarMutex.Lock()
	defer fake.copyImageToTarMutex.Unlock()
	fake.CopyImageToTarStub = stub
}

func (fake *Registry) CopyImageToTarArgsForCall(i int) (string, string) {
	fake.copyImageToTarMutex.RLock()
	defer fake.copyImageToTarMutex.RUnlock()
	argsForCall := fake.copyImageToTarArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Registry) CopyImageToTarReturns(result1 error) {
	fake.copyImageToTarMutex.Lock()
	defer fake.copyImageToTarMutex.Unlock()
	fake.CopyImageToTarStub = nil
	fake.copyImageToTarReturns = struct {
		result1 error
	}{result1}
}

func (fake *Registry) CopyImageToTarReturnsOnCall(i int, result1 error) {
	fake.copyImageToTarMutex.Lock()
	defer fake.copyImageToTarMutex.Unlock()
	fake.CopyImageToTarStub = nil
	if fake.copyImageToTarReturnsOnCall == nil {
		fake.copyImageToTarReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.copyImageToTarReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Registry) DownloadBundle(arg1 string, arg2 string) error {
	fake.downloadBundleMutex.Lock()
	ret, specificReturn := fake.downloadBundleReturnsOnCall[len(fake.downloadBundleArgsForCall)]
	fake.downloadBundleArgsForCall = append(fake.downloadBundleArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DownloadBundleStub
	fakeReturns := fake.downloadBundleReturns
	fake.recordInvocation("DownloadBundle", []interface{}{arg1, arg2})
	fake.downloadBundleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Registry) DownloadBundleCallCount() int {
	fake.downloadBundleMutex.RLock()
	defer fake.downloadBundleMutex.RUnlock()
	return len(fake.downloadBundleArgsForCall)
}

func (fake *Registry) DownloadBundleCalls(stub func(string, string) error) {
	fake.downloadBundleMutex.Lock()
	defer fake.downloadBundleMutex.Unlock()
	fake.DownloadBundleStub = stub
}

func (fake *Registry) DownloadBundleArgsForCall(i int) (string, string) {
	fake.downloadBundleMutex.RLock()
	defer fake.downloadBundleMutex.RUnlock()
	argsForCall := fake.downloadBundleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Registry) DownloadBundleReturns(result1 error) {
	fake.downloadBundleMutex.Lock()
	defer fake.downloadBundleMutex.Unlock()
	fake.DownloadBundleStub = nil
	fake.downloadBundleReturns = struct {
		result1 error
	}{result1}
}

func (fake *Registry) DownloadBundleReturnsOnCall(i int, result1 error) {
	fake.downloadBundleMutex.Lock()
	defer fake.downloadBundleMutex.Unlock()
	fake.DownloadBundleStub = nil
	if fake.downloadBundleReturnsOnCall == nil {
		fake.downloadBundleReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.downloadBundleReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Registry) DownloadImage(arg1 string, arg2 string) error {
	fake.downloadImageMutex.Lock()
	ret, specificReturn := fake.downloadImageReturnsOnCall[len(fake.downloadImageArgsForCall)]
	fake.downloadImageArgsForCall = append(fake.downloadImageArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DownloadImageStub
	fakeReturns := fake.downloadImageReturns
	fake.recordInvocation("DownloadImage", []interface{}{arg1, arg2})
	fake.downloadImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Registry) DownloadImageCallCount() int {
	fake.downloadImageMutex.RLock()
	defer fake.downloadImageMutex.RUnlock()
	return len(fake.downloadImageArgsForCall)
}

func (fake *Registry) DownloadImageCalls(stub func(string, string) error) {
	fake.downloadImageMutex.Lock()
	defer fake.downloadImageMutex.Unlock()
	fake.DownloadImageStub = stub
}

func (fake *Registry) DownloadImageArgsForCall(i int) (string, string) {
	fake.downloadImageMutex.RLock()
	defer fake.downloadImageMutex.RUnlock()
	argsForCall := fake.downloadImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Registry) DownloadImageReturns(result1 error) {
	fake.downloadImageMutex.Lock()
	defer fake.downloadImageMutex.Unlock()
	fake.DownloadImageStub = nil
	fake.downloadImageReturns = struct {
		result1 error
	}{result1}
}

func (fake *Registry) DownloadImageReturnsOnCall(i int, result1 error) {
	fake.downloadImageMutex.Lock()
	defer fake.downloadImageMutex.Unlock()
	fake.DownloadImageStub = nil
	if fake.downloadImageReturnsOnCall == nil {
		fake.downloadImageReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.downloadImageReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Registry) GetFile(arg1 string, arg2 string) ([]byte, error) {
	fake.getFileMutex.Lock()
	ret, specificReturn := fake.getFileReturnsOnCall[len(fake.getFileArgsForCall)]
	fake.getFileArgsForCall = append(fake.getFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetFileStub
	fakeReturns := fake.getFileReturns
	fake.recordInvocation("GetFile", []interface{}{arg1, arg2})
	fake.getFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *Registry) GetFileCallCount() int {
	fake.getFileMutex.RLock()
	defer fake.getFileMutex.RUnlock()
	return len(fake.getFileArgsForCall)
}

func (fake *Registry) GetFileCalls(stub func(string, string) ([]byte, error)) {
	fake.getFileMutex.Lock()
	defer fake.getFileMutex.Unlock()
	fake.GetFileStub = stub
}

func (fake *Registry) GetFileArgsForCall(i int) (string, string) {
	fake.getFileMutex.RLock()
	defer fake.getFileMutex.RUnlock()
	argsForCall := fake.getFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Registry) GetFileReturns(result1 []byte, result2 error) {
	fake.getFileMutex.Lock()
	defer fake.getFileMutex.Unlock()
	fake.GetFileStub = nil
	fake.getFileReturns = struct {
		result1 []byte
		result2 error
	}{result1, result2}
}

func (fake *Registry) GetFileReturnsOnCall(i int, result1 []byte, result2 error) {
	fake.getFileMutex.Lock()
	defer fake.getFileMutex.Unlock()
	fake.GetFileStub = nil
	if fake.getFileReturnsOnCall == nil {
		fake.getFileReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 error
		})
	}
	fake.getFileReturnsOnCall[i] = struct {
		result1 []byte
		result2 error
	}{result1, result2}
}

func (fake *Registry) GetFiles(arg1 string) (map[string][]byte, error) {
	fake.getFilesMutex.Lock()
	ret, specificReturn := fake.getFilesReturnsOnCall[len(fake.getFilesArgsForCall)]
	fake.getFilesArgsForCall = append(fake.getFilesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetFilesStub
	fakeReturns := fake.getFilesReturns
	fake.recordInvocation("GetFiles", []interface{}{arg1})
	fake.getFilesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *Registry) GetFilesCallCount() int {
	fake.getFilesMutex.RLock()
	defer fake.getFilesMutex.RUnlock()
	return len(fake.getFilesArgsForCall)
}

func (fake *Registry) GetFilesCalls(stub func(string) (map[string][]byte, error)) {
	fake.getFilesMutex.Lock()
	defer fake.getFilesMutex.Unlock()
	fake.GetFilesStub = stub
}

func (fake *Registry) GetFilesArgsForCall(i int) string {
	fake.getFilesMutex.RLock()
	defer fake.getFilesMutex.RUnlock()
	argsForCall := fake.getFilesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *Registry) GetFilesReturns(result1 map[string][]byte, result2 error) {
	fake.getFilesMutex.Lock()
	defer fake.getFilesMutex.Unlock()
	fake.GetFilesStub = nil
	fake.getFilesReturns = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *Registry) GetFilesReturnsOnCall(i int, result1 map[string][]byte, result2 error) {
	fake.getFilesMutex.Lock()
	defer fake.getFilesMutex.Unlock()
	fake.GetFilesStub = nil
	if fake.getFilesReturnsOnCall == nil {
		fake.getFilesReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
			result2 error
		})
	}
	fake.getFilesReturnsOnCall[i] = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *Registry) GetImageDigest(arg1 string) (string, string, error) {
	fake.getImageDigestMutex.Lock()
	ret, specificReturn := fake.getImageDigestReturnsOnCall[len(fake.getImageDigestArgsForCall)]
	fake.getImageDigestArgsForCall = append(fake.getImageDigestArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetImageDigestStub
	fakeReturns := fake.getImageDigestReturns
	fake.recordInvocation("GetImageDigest", []interface{}{arg1})
	fake.getImageDigestMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *Registry) GetImageDigestCallCount() int {
	fake.getImageDigestMutex.RLock()
	defer fake.getImageDigestMutex.RUnlock()
	return len(fake.getImageDigestArgsForCall)
}

func (fake *Registry) GetImageDigestCalls(stub func(string) (string, string, error)) {
	fake.getImageDigestMutex.Lock()
	defer fake.getImageDigestMutex.Unlock()
	fake.GetImageDigestStub = stub
}

func (fake *Registry) GetImageDigestArgsForCall(i int) string {
	fake.getImageDigestMutex.RLock()
	defer fake.getImageDigestMutex.RUnlock()
	argsForCall := fake.getImageDigestArgsForCall[i]
	return argsForCall.arg1
}

func (fake *Registry) GetImageDigestReturns(result1 string, result2 string, result3 error) {
	fake.getImageDigestMutex.Lock()
	defer fake.getImageDigestMutex.Unlock()
	fake.GetImageDigestStub = nil
	fake.getImageDigestReturns = struct {
		result1 string
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *Registry) GetImageDigestReturnsOnCall(i int, result1 string, result2 string, result3 error) {
	fake.getImageDigestMutex.Lock()
	defer fake.getImageDigestMutex.Unlock()
	fake.GetImageDigestStub = nil
	if fake.getImageDigestReturnsOnCall == nil {
		fake.getImageDigestReturnsOnCall = make(map[int]struct {
			result1 string
			result2 string
			result3 error
		})
	}
	fake.getImageDigestReturnsOnCall[i] = struct {
		result1 string
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *Registry) ListImageTags(arg1 string) ([]string, error) {
	fake.listImageTagsMutex.Lock()
	ret, specificReturn := fake.listImageTagsReturnsOnCall[len(fake.listImageTagsArgsForCall)]
	fake.listImageTagsArgsForCall = append(fake.listImageTagsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ListImageTagsStub
	fakeReturns := fake.listImageTagsReturns
	fake.recordInvocation("ListImageTags", []interface{}{arg1})
	fake.listImageTagsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *Registry) ListImageTagsCallCount() int {
	fake.listImageTagsMutex.RLock()
	defer fake.listImageTagsMutex.RUnlock()
	return len(fake.listImageTagsArgsForCall)
}

func (fake *Registry) ListImageTagsCalls(stub func(string) ([]string, error)) {
	fake.listImageTagsMutex.Lock()
	defer fake.listImageTagsMutex.Unlock()
	fake.ListImageTagsStub = stub
}

func (fake *Registry) ListImageTagsArgsForCall(i int) string {
	fake.listImageTagsMutex.RLock()
	defer fake.listImageTagsMutex.RUnlock()
	argsForCall := fake.listImageTagsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *Registry) ListImageTagsReturns(result1 []string, result2 error) {
	fake.listImageTagsMutex.Lock()
	defer fake.listImageTagsMutex.Unlock()
	fake.ListImageTagsStub = nil
	fake.listImageTagsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *Registry) ListImageTagsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.listImageTagsMutex.Lock()
	defer fake.listImageTagsMutex.Unlock()
	fake.ListImageTagsStub = nil
	if fake.listImageTagsReturnsOnCall == nil {
		fake.listImageTagsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.listImageTagsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *Registry) PushImage(arg1 string, arg2 []string) error {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.pushImageMutex.Lock()
	ret, specificReturn := fake.pushImageReturnsOnCall[len(fake.pushImageArgsForCall)]
	fake.pushImageArgsForCall = append(fake.pushImageArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.PushImageStub
	fakeReturns := fake.pushImageReturns
	fake.recordInvocation("PushImage", []interface{}{arg1, arg2Copy})
	fake.pushImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Registry) PushImageCallCount() int {
	fake.pushImageMutex.RLock()
	defer fake.pushImageMutex.RUnlock()
	return len(fake.pushImageArgsForCall)
}

func (fake *Registry) PushImageCalls(stub func(string, []string) error) {
	fake.pushImageMutex.Lock()
	defer fake.pushImageMutex.Unlock()
	fake.PushImageStub = stub
}

func (fake *Registry) PushImageArgsForCall(i int) (string, []string) {
	fake.pushImageMutex.RLock()
	defer fake.pushImageMutex.RUnlock()
	argsForCall := fake.pushImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Registry) PushImageReturns(result1 error) {
	fake.pushImageMutex.Lock()
	defer fake.pushImageMutex.Unlock()
	fake.PushImageStub = nil
	fake.pushImageReturns = struct {
		result1 error
	}{result1}
}

func (fake *Registry) PushImageReturnsOnCall(i int, result1 error) {
	fake.pushImageMutex.Lock()
	defer fake.pushImageMutex.Unlock()
	fake.PushImageStub = nil
	if fake.pushImageReturnsOnCall == nil {
		fake.pushImageReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.pushImageReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Registry) ResolveImage(arg1 string) error {
	fake.resolveImageMutex.Lock()
	ret, specificReturn := fake.resolveImageReturnsOnCall[len(fake.resolveImageArgsForCall)]
	fake.resolveImageArgsForCall = append(fake.resolveImageArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ResolveImageStub
	fakeReturns := fake.resolveImageReturns
	fake.recordInvocation("ResolveImage", []interface{}{arg1})
	fake.resolveImageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Registry) ResolveImageCallCount() int {
	fake.resolveImageMutex.RLock()
	defer fake.resolveImageMutex.RUnlock()
	return len(fake.resolveImageArgsForCall)
}

func (fake *Registry) ResolveImageCalls(stub func(string) error) {
	fake.resolveImageMutex.Lock()
	defer fake.resolveImageMutex.Unlock()
	fake.ResolveImageStub = stub
}

func (fake *Registry) ResolveImageArgsForCall(i int) string {
	fake.resolveImageMutex.RLock()
	defer fake.resolveImageMutex.RUnlock()
	argsForCall := fake.resolveImageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *Registry) ResolveImageReturns(result1 error) {
	fake.resolveImageMutex.Lock()
	defer fake.resolveImageMutex.Unlock()
	fake.ResolveImageStub = nil
	fake.resolveImageReturns = struct {
		result1 error
	}{result1}
}

func (fake *Registry) ResolveImageReturnsOnCall(i int, result1 error) {
	fake.resolveImageMutex.Lock()
	defer fake.resolveImageMutex.Unlock()
	fake.ResolveImageStub = nil
	if fake.resolveImageReturnsOnCall == nil {
		fake.resolveImageReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.resolveImageReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Registry) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.copyImageFromTarMutex.RLock()
	defer fake.copyImageFromTarMutex.RUnlock()
	fake.copyImageToTarMutex.RLock()
	defer fake.copyImageToTarMutex.RUnlock()
	fake.downloadBundleMutex.RLock()
	defer fake.downloadBundleMutex.RUnlock()
	fake.downloadImageMutex.RLock()
	defer fake.downloadImageMutex.RUnlock()
	fake.getFileMutex.RLock()
	defer fake.getFileMutex.RUnlock()
	fake.getFilesMutex.RLock()
	defer fake.getFilesMutex.RUnlock()
	fake.getImageDigestMutex.RLock()
	defer fake.getImageDigestMutex.RUnlock()
	fake.listImageTagsMutex.RLock()
	defer fake.listImageTagsMutex.RUnlock()
	fake.pushImageMutex.RLock()
	defer fake.pushImageMutex.RUnlock()
	fake.resolveImageMutex.RLock()
	defer fake.resolveImageMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *Registry) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ registry.Registry = new(Registry)