1// Code generated by counterfeiter. DO NOT EDIT.
2package execfakes
3
4import (
5	"sync"
6
7	"github.com/concourse/concourse/atc"
8	"github.com/concourse/concourse/atc/exec"
9	"github.com/concourse/concourse/atc/exec/build"
10)
11
12type FakeRunState struct {
13	ArtifactRepositoryStub        func() *build.Repository
14	artifactRepositoryMutex       sync.RWMutex
15	artifactRepositoryArgsForCall []struct {
16	}
17	artifactRepositoryReturns struct {
18		result1 *build.Repository
19	}
20	artifactRepositoryReturnsOnCall map[int]struct {
21		result1 *build.Repository
22	}
23	ResultStub        func(atc.PlanID, interface{}) bool
24	resultMutex       sync.RWMutex
25	resultArgsForCall []struct {
26		arg1 atc.PlanID
27		arg2 interface{}
28	}
29	resultReturns struct {
30		result1 bool
31	}
32	resultReturnsOnCall map[int]struct {
33		result1 bool
34	}
35	StoreResultStub        func(atc.PlanID, interface{})
36	storeResultMutex       sync.RWMutex
37	storeResultArgsForCall []struct {
38		arg1 atc.PlanID
39		arg2 interface{}
40	}
41	invocations      map[string][][]interface{}
42	invocationsMutex sync.RWMutex
43}
44
45func (fake *FakeRunState) ArtifactRepository() *build.Repository {
46	fake.artifactRepositoryMutex.Lock()
47	ret, specificReturn := fake.artifactRepositoryReturnsOnCall[len(fake.artifactRepositoryArgsForCall)]
48	fake.artifactRepositoryArgsForCall = append(fake.artifactRepositoryArgsForCall, struct {
49	}{})
50	fake.recordInvocation("ArtifactRepository", []interface{}{})
51	fake.artifactRepositoryMutex.Unlock()
52	if fake.ArtifactRepositoryStub != nil {
53		return fake.ArtifactRepositoryStub()
54	}
55	if specificReturn {
56		return ret.result1
57	}
58	fakeReturns := fake.artifactRepositoryReturns
59	return fakeReturns.result1
60}
61
62func (fake *FakeRunState) ArtifactRepositoryCallCount() int {
63	fake.artifactRepositoryMutex.RLock()
64	defer fake.artifactRepositoryMutex.RUnlock()
65	return len(fake.artifactRepositoryArgsForCall)
66}
67
68func (fake *FakeRunState) ArtifactRepositoryCalls(stub func() *build.Repository) {
69	fake.artifactRepositoryMutex.Lock()
70	defer fake.artifactRepositoryMutex.Unlock()
71	fake.ArtifactRepositoryStub = stub
72}
73
74func (fake *FakeRunState) ArtifactRepositoryReturns(result1 *build.Repository) {
75	fake.artifactRepositoryMutex.Lock()
76	defer fake.artifactRepositoryMutex.Unlock()
77	fake.ArtifactRepositoryStub = nil
78	fake.artifactRepositoryReturns = struct {
79		result1 *build.Repository
80	}{result1}
81}
82
83func (fake *FakeRunState) ArtifactRepositoryReturnsOnCall(i int, result1 *build.Repository) {
84	fake.artifactRepositoryMutex.Lock()
85	defer fake.artifactRepositoryMutex.Unlock()
86	fake.ArtifactRepositoryStub = nil
87	if fake.artifactRepositoryReturnsOnCall == nil {
88		fake.artifactRepositoryReturnsOnCall = make(map[int]struct {
89			result1 *build.Repository
90		})
91	}
92	fake.artifactRepositoryReturnsOnCall[i] = struct {
93		result1 *build.Repository
94	}{result1}
95}
96
97func (fake *FakeRunState) Result(arg1 atc.PlanID, arg2 interface{}) bool {
98	fake.resultMutex.Lock()
99	ret, specificReturn := fake.resultReturnsOnCall[len(fake.resultArgsForCall)]
100	fake.resultArgsForCall = append(fake.resultArgsForCall, struct {
101		arg1 atc.PlanID
102		arg2 interface{}
103	}{arg1, arg2})
104	fake.recordInvocation("Result", []interface{}{arg1, arg2})
105	fake.resultMutex.Unlock()
106	if fake.ResultStub != nil {
107		return fake.ResultStub(arg1, arg2)
108	}
109	if specificReturn {
110		return ret.result1
111	}
112	fakeReturns := fake.resultReturns
113	return fakeReturns.result1
114}
115
116func (fake *FakeRunState) ResultCallCount() int {
117	fake.resultMutex.RLock()
118	defer fake.resultMutex.RUnlock()
119	return len(fake.resultArgsForCall)
120}
121
122func (fake *FakeRunState) ResultCalls(stub func(atc.PlanID, interface{}) bool) {
123	fake.resultMutex.Lock()
124	defer fake.resultMutex.Unlock()
125	fake.ResultStub = stub
126}
127
128func (fake *FakeRunState) ResultArgsForCall(i int) (atc.PlanID, interface{}) {
129	fake.resultMutex.RLock()
130	defer fake.resultMutex.RUnlock()
131	argsForCall := fake.resultArgsForCall[i]
132	return argsForCall.arg1, argsForCall.arg2
133}
134
135func (fake *FakeRunState) ResultReturns(result1 bool) {
136	fake.resultMutex.Lock()
137	defer fake.resultMutex.Unlock()
138	fake.ResultStub = nil
139	fake.resultReturns = struct {
140		result1 bool
141	}{result1}
142}
143
144func (fake *FakeRunState) ResultReturnsOnCall(i int, result1 bool) {
145	fake.resultMutex.Lock()
146	defer fake.resultMutex.Unlock()
147	fake.ResultStub = nil
148	if fake.resultReturnsOnCall == nil {
149		fake.resultReturnsOnCall = make(map[int]struct {
150			result1 bool
151		})
152	}
153	fake.resultReturnsOnCall[i] = struct {
154		result1 bool
155	}{result1}
156}
157
158func (fake *FakeRunState) StoreResult(arg1 atc.PlanID, arg2 interface{}) {
159	fake.storeResultMutex.Lock()
160	fake.storeResultArgsForCall = append(fake.storeResultArgsForCall, struct {
161		arg1 atc.PlanID
162		arg2 interface{}
163	}{arg1, arg2})
164	fake.recordInvocation("StoreResult", []interface{}{arg1, arg2})
165	fake.storeResultMutex.Unlock()
166	if fake.StoreResultStub != nil {
167		fake.StoreResultStub(arg1, arg2)
168	}
169}
170
171func (fake *FakeRunState) StoreResultCallCount() int {
172	fake.storeResultMutex.RLock()
173	defer fake.storeResultMutex.RUnlock()
174	return len(fake.storeResultArgsForCall)
175}
176
177func (fake *FakeRunState) StoreResultCalls(stub func(atc.PlanID, interface{})) {
178	fake.storeResultMutex.Lock()
179	defer fake.storeResultMutex.Unlock()
180	fake.StoreResultStub = stub
181}
182
183func (fake *FakeRunState) StoreResultArgsForCall(i int) (atc.PlanID, interface{}) {
184	fake.storeResultMutex.RLock()
185	defer fake.storeResultMutex.RUnlock()
186	argsForCall := fake.storeResultArgsForCall[i]
187	return argsForCall.arg1, argsForCall.arg2
188}
189
190func (fake *FakeRunState) Invocations() map[string][][]interface{} {
191	fake.invocationsMutex.RLock()
192	defer fake.invocationsMutex.RUnlock()
193	fake.artifactRepositoryMutex.RLock()
194	defer fake.artifactRepositoryMutex.RUnlock()
195	fake.resultMutex.RLock()
196	defer fake.resultMutex.RUnlock()
197	fake.storeResultMutex.RLock()
198	defer fake.storeResultMutex.RUnlock()
199	copiedInvocations := map[string][][]interface{}{}
200	for key, value := range fake.invocations {
201		copiedInvocations[key] = value
202	}
203	return copiedInvocations
204}
205
206func (fake *FakeRunState) recordInvocation(key string, args []interface{}) {
207	fake.invocationsMutex.Lock()
208	defer fake.invocationsMutex.Unlock()
209	if fake.invocations == nil {
210		fake.invocations = map[string][][]interface{}{}
211	}
212	if fake.invocations[key] == nil {
213		fake.invocations[key] = [][]interface{}{}
214	}
215	fake.invocations[key] = append(fake.invocations[key], args)
216}
217
218var _ exec.RunState = new(FakeRunState)
219