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