1// Code generated by counterfeiter. DO NOT EDIT. 2package mocks 3 4import ( 5 "context" 6 "sync" 7 8 "github.com/syncthing/syncthing/lib/discover" 9 "github.com/syncthing/syncthing/lib/protocol" 10) 11 12type Manager struct { 13 CacheStub func() map[protocol.DeviceID]discover.CacheEntry 14 cacheMutex sync.RWMutex 15 cacheArgsForCall []struct { 16 } 17 cacheReturns struct { 18 result1 map[protocol.DeviceID]discover.CacheEntry 19 } 20 cacheReturnsOnCall map[int]struct { 21 result1 map[protocol.DeviceID]discover.CacheEntry 22 } 23 ChildErrorsStub func() map[string]error 24 childErrorsMutex sync.RWMutex 25 childErrorsArgsForCall []struct { 26 } 27 childErrorsReturns struct { 28 result1 map[string]error 29 } 30 childErrorsReturnsOnCall map[int]struct { 31 result1 map[string]error 32 } 33 ErrorStub func() error 34 errorMutex sync.RWMutex 35 errorArgsForCall []struct { 36 } 37 errorReturns struct { 38 result1 error 39 } 40 errorReturnsOnCall map[int]struct { 41 result1 error 42 } 43 LookupStub func(context.Context, protocol.DeviceID) ([]string, error) 44 lookupMutex sync.RWMutex 45 lookupArgsForCall []struct { 46 arg1 context.Context 47 arg2 protocol.DeviceID 48 } 49 lookupReturns struct { 50 result1 []string 51 result2 error 52 } 53 lookupReturnsOnCall map[int]struct { 54 result1 []string 55 result2 error 56 } 57 ServeStub func(context.Context) error 58 serveMutex sync.RWMutex 59 serveArgsForCall []struct { 60 arg1 context.Context 61 } 62 serveReturns struct { 63 result1 error 64 } 65 serveReturnsOnCall map[int]struct { 66 result1 error 67 } 68 StringStub func() string 69 stringMutex sync.RWMutex 70 stringArgsForCall []struct { 71 } 72 stringReturns struct { 73 result1 string 74 } 75 stringReturnsOnCall map[int]struct { 76 result1 string 77 } 78 invocations map[string][][]interface{} 79 invocationsMutex sync.RWMutex 80} 81 82func (fake *Manager) Cache() map[protocol.DeviceID]discover.CacheEntry { 83 fake.cacheMutex.Lock() 84 ret, specificReturn := fake.cacheReturnsOnCall[len(fake.cacheArgsForCall)] 85 fake.cacheArgsForCall = append(fake.cacheArgsForCall, struct { 86 }{}) 87 stub := fake.CacheStub 88 fakeReturns := fake.cacheReturns 89 fake.recordInvocation("Cache", []interface{}{}) 90 fake.cacheMutex.Unlock() 91 if stub != nil { 92 return stub() 93 } 94 if specificReturn { 95 return ret.result1 96 } 97 return fakeReturns.result1 98} 99 100func (fake *Manager) CacheCallCount() int { 101 fake.cacheMutex.RLock() 102 defer fake.cacheMutex.RUnlock() 103 return len(fake.cacheArgsForCall) 104} 105 106func (fake *Manager) CacheCalls(stub func() map[protocol.DeviceID]discover.CacheEntry) { 107 fake.cacheMutex.Lock() 108 defer fake.cacheMutex.Unlock() 109 fake.CacheStub = stub 110} 111 112func (fake *Manager) CacheReturns(result1 map[protocol.DeviceID]discover.CacheEntry) { 113 fake.cacheMutex.Lock() 114 defer fake.cacheMutex.Unlock() 115 fake.CacheStub = nil 116 fake.cacheReturns = struct { 117 result1 map[protocol.DeviceID]discover.CacheEntry 118 }{result1} 119} 120 121func (fake *Manager) CacheReturnsOnCall(i int, result1 map[protocol.DeviceID]discover.CacheEntry) { 122 fake.cacheMutex.Lock() 123 defer fake.cacheMutex.Unlock() 124 fake.CacheStub = nil 125 if fake.cacheReturnsOnCall == nil { 126 fake.cacheReturnsOnCall = make(map[int]struct { 127 result1 map[protocol.DeviceID]discover.CacheEntry 128 }) 129 } 130 fake.cacheReturnsOnCall[i] = struct { 131 result1 map[protocol.DeviceID]discover.CacheEntry 132 }{result1} 133} 134 135func (fake *Manager) ChildErrors() map[string]error { 136 fake.childErrorsMutex.Lock() 137 ret, specificReturn := fake.childErrorsReturnsOnCall[len(fake.childErrorsArgsForCall)] 138 fake.childErrorsArgsForCall = append(fake.childErrorsArgsForCall, struct { 139 }{}) 140 stub := fake.ChildErrorsStub 141 fakeReturns := fake.childErrorsReturns 142 fake.recordInvocation("ChildErrors", []interface{}{}) 143 fake.childErrorsMutex.Unlock() 144 if stub != nil { 145 return stub() 146 } 147 if specificReturn { 148 return ret.result1 149 } 150 return fakeReturns.result1 151} 152 153func (fake *Manager) ChildErrorsCallCount() int { 154 fake.childErrorsMutex.RLock() 155 defer fake.childErrorsMutex.RUnlock() 156 return len(fake.childErrorsArgsForCall) 157} 158 159func (fake *Manager) ChildErrorsCalls(stub func() map[string]error) { 160 fake.childErrorsMutex.Lock() 161 defer fake.childErrorsMutex.Unlock() 162 fake.ChildErrorsStub = stub 163} 164 165func (fake *Manager) ChildErrorsReturns(result1 map[string]error) { 166 fake.childErrorsMutex.Lock() 167 defer fake.childErrorsMutex.Unlock() 168 fake.ChildErrorsStub = nil 169 fake.childErrorsReturns = struct { 170 result1 map[string]error 171 }{result1} 172} 173 174func (fake *Manager) ChildErrorsReturnsOnCall(i int, result1 map[string]error) { 175 fake.childErrorsMutex.Lock() 176 defer fake.childErrorsMutex.Unlock() 177 fake.ChildErrorsStub = nil 178 if fake.childErrorsReturnsOnCall == nil { 179 fake.childErrorsReturnsOnCall = make(map[int]struct { 180 result1 map[string]error 181 }) 182 } 183 fake.childErrorsReturnsOnCall[i] = struct { 184 result1 map[string]error 185 }{result1} 186} 187 188func (fake *Manager) Error() error { 189 fake.errorMutex.Lock() 190 ret, specificReturn := fake.errorReturnsOnCall[len(fake.errorArgsForCall)] 191 fake.errorArgsForCall = append(fake.errorArgsForCall, struct { 192 }{}) 193 stub := fake.ErrorStub 194 fakeReturns := fake.errorReturns 195 fake.recordInvocation("Error", []interface{}{}) 196 fake.errorMutex.Unlock() 197 if stub != nil { 198 return stub() 199 } 200 if specificReturn { 201 return ret.result1 202 } 203 return fakeReturns.result1 204} 205 206func (fake *Manager) ErrorCallCount() int { 207 fake.errorMutex.RLock() 208 defer fake.errorMutex.RUnlock() 209 return len(fake.errorArgsForCall) 210} 211 212func (fake *Manager) ErrorCalls(stub func() error) { 213 fake.errorMutex.Lock() 214 defer fake.errorMutex.Unlock() 215 fake.ErrorStub = stub 216} 217 218func (fake *Manager) ErrorReturns(result1 error) { 219 fake.errorMutex.Lock() 220 defer fake.errorMutex.Unlock() 221 fake.ErrorStub = nil 222 fake.errorReturns = struct { 223 result1 error 224 }{result1} 225} 226 227func (fake *Manager) ErrorReturnsOnCall(i int, result1 error) { 228 fake.errorMutex.Lock() 229 defer fake.errorMutex.Unlock() 230 fake.ErrorStub = nil 231 if fake.errorReturnsOnCall == nil { 232 fake.errorReturnsOnCall = make(map[int]struct { 233 result1 error 234 }) 235 } 236 fake.errorReturnsOnCall[i] = struct { 237 result1 error 238 }{result1} 239} 240 241func (fake *Manager) Lookup(arg1 context.Context, arg2 protocol.DeviceID) ([]string, error) { 242 fake.lookupMutex.Lock() 243 ret, specificReturn := fake.lookupReturnsOnCall[len(fake.lookupArgsForCall)] 244 fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct { 245 arg1 context.Context 246 arg2 protocol.DeviceID 247 }{arg1, arg2}) 248 stub := fake.LookupStub 249 fakeReturns := fake.lookupReturns 250 fake.recordInvocation("Lookup", []interface{}{arg1, arg2}) 251 fake.lookupMutex.Unlock() 252 if stub != nil { 253 return stub(arg1, arg2) 254 } 255 if specificReturn { 256 return ret.result1, ret.result2 257 } 258 return fakeReturns.result1, fakeReturns.result2 259} 260 261func (fake *Manager) LookupCallCount() int { 262 fake.lookupMutex.RLock() 263 defer fake.lookupMutex.RUnlock() 264 return len(fake.lookupArgsForCall) 265} 266 267func (fake *Manager) LookupCalls(stub func(context.Context, protocol.DeviceID) ([]string, error)) { 268 fake.lookupMutex.Lock() 269 defer fake.lookupMutex.Unlock() 270 fake.LookupStub = stub 271} 272 273func (fake *Manager) LookupArgsForCall(i int) (context.Context, protocol.DeviceID) { 274 fake.lookupMutex.RLock() 275 defer fake.lookupMutex.RUnlock() 276 argsForCall := fake.lookupArgsForCall[i] 277 return argsForCall.arg1, argsForCall.arg2 278} 279 280func (fake *Manager) LookupReturns(result1 []string, result2 error) { 281 fake.lookupMutex.Lock() 282 defer fake.lookupMutex.Unlock() 283 fake.LookupStub = nil 284 fake.lookupReturns = struct { 285 result1 []string 286 result2 error 287 }{result1, result2} 288} 289 290func (fake *Manager) LookupReturnsOnCall(i int, result1 []string, result2 error) { 291 fake.lookupMutex.Lock() 292 defer fake.lookupMutex.Unlock() 293 fake.LookupStub = nil 294 if fake.lookupReturnsOnCall == nil { 295 fake.lookupReturnsOnCall = make(map[int]struct { 296 result1 []string 297 result2 error 298 }) 299 } 300 fake.lookupReturnsOnCall[i] = struct { 301 result1 []string 302 result2 error 303 }{result1, result2} 304} 305 306func (fake *Manager) Serve(arg1 context.Context) error { 307 fake.serveMutex.Lock() 308 ret, specificReturn := fake.serveReturnsOnCall[len(fake.serveArgsForCall)] 309 fake.serveArgsForCall = append(fake.serveArgsForCall, struct { 310 arg1 context.Context 311 }{arg1}) 312 stub := fake.ServeStub 313 fakeReturns := fake.serveReturns 314 fake.recordInvocation("Serve", []interface{}{arg1}) 315 fake.serveMutex.Unlock() 316 if stub != nil { 317 return stub(arg1) 318 } 319 if specificReturn { 320 return ret.result1 321 } 322 return fakeReturns.result1 323} 324 325func (fake *Manager) ServeCallCount() int { 326 fake.serveMutex.RLock() 327 defer fake.serveMutex.RUnlock() 328 return len(fake.serveArgsForCall) 329} 330 331func (fake *Manager) ServeCalls(stub func(context.Context) error) { 332 fake.serveMutex.Lock() 333 defer fake.serveMutex.Unlock() 334 fake.ServeStub = stub 335} 336 337func (fake *Manager) ServeArgsForCall(i int) context.Context { 338 fake.serveMutex.RLock() 339 defer fake.serveMutex.RUnlock() 340 argsForCall := fake.serveArgsForCall[i] 341 return argsForCall.arg1 342} 343 344func (fake *Manager) ServeReturns(result1 error) { 345 fake.serveMutex.Lock() 346 defer fake.serveMutex.Unlock() 347 fake.ServeStub = nil 348 fake.serveReturns = struct { 349 result1 error 350 }{result1} 351} 352 353func (fake *Manager) ServeReturnsOnCall(i int, result1 error) { 354 fake.serveMutex.Lock() 355 defer fake.serveMutex.Unlock() 356 fake.ServeStub = nil 357 if fake.serveReturnsOnCall == nil { 358 fake.serveReturnsOnCall = make(map[int]struct { 359 result1 error 360 }) 361 } 362 fake.serveReturnsOnCall[i] = struct { 363 result1 error 364 }{result1} 365} 366 367func (fake *Manager) String() string { 368 fake.stringMutex.Lock() 369 ret, specificReturn := fake.stringReturnsOnCall[len(fake.stringArgsForCall)] 370 fake.stringArgsForCall = append(fake.stringArgsForCall, struct { 371 }{}) 372 stub := fake.StringStub 373 fakeReturns := fake.stringReturns 374 fake.recordInvocation("String", []interface{}{}) 375 fake.stringMutex.Unlock() 376 if stub != nil { 377 return stub() 378 } 379 if specificReturn { 380 return ret.result1 381 } 382 return fakeReturns.result1 383} 384 385func (fake *Manager) StringCallCount() int { 386 fake.stringMutex.RLock() 387 defer fake.stringMutex.RUnlock() 388 return len(fake.stringArgsForCall) 389} 390 391func (fake *Manager) StringCalls(stub func() string) { 392 fake.stringMutex.Lock() 393 defer fake.stringMutex.Unlock() 394 fake.StringStub = stub 395} 396 397func (fake *Manager) StringReturns(result1 string) { 398 fake.stringMutex.Lock() 399 defer fake.stringMutex.Unlock() 400 fake.StringStub = nil 401 fake.stringReturns = struct { 402 result1 string 403 }{result1} 404} 405 406func (fake *Manager) StringReturnsOnCall(i int, result1 string) { 407 fake.stringMutex.Lock() 408 defer fake.stringMutex.Unlock() 409 fake.StringStub = nil 410 if fake.stringReturnsOnCall == nil { 411 fake.stringReturnsOnCall = make(map[int]struct { 412 result1 string 413 }) 414 } 415 fake.stringReturnsOnCall[i] = struct { 416 result1 string 417 }{result1} 418} 419 420func (fake *Manager) Invocations() map[string][][]interface{} { 421 fake.invocationsMutex.RLock() 422 defer fake.invocationsMutex.RUnlock() 423 fake.cacheMutex.RLock() 424 defer fake.cacheMutex.RUnlock() 425 fake.childErrorsMutex.RLock() 426 defer fake.childErrorsMutex.RUnlock() 427 fake.errorMutex.RLock() 428 defer fake.errorMutex.RUnlock() 429 fake.lookupMutex.RLock() 430 defer fake.lookupMutex.RUnlock() 431 fake.serveMutex.RLock() 432 defer fake.serveMutex.RUnlock() 433 fake.stringMutex.RLock() 434 defer fake.stringMutex.RUnlock() 435 copiedInvocations := map[string][][]interface{}{} 436 for key, value := range fake.invocations { 437 copiedInvocations[key] = value 438 } 439 return copiedInvocations 440} 441 442func (fake *Manager) recordInvocation(key string, args []interface{}) { 443 fake.invocationsMutex.Lock() 444 defer fake.invocationsMutex.Unlock() 445 if fake.invocations == nil { 446 fake.invocations = map[string][][]interface{}{} 447 } 448 if fake.invocations[key] == nil { 449 fake.invocations[key] = [][]interface{}{} 450 } 451 fake.invocations[key] = append(fake.invocations[key], args) 452} 453 454var _ discover.Manager = new(Manager) 455