github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/aclmgmt/mocks/defaultaclprovider.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package mocks 3 4 import ( 5 "sync" 6 ) 7 8 type DefaultACLProvider struct { 9 CheckACLStub func(string, string, interface{}) error 10 checkACLMutex sync.RWMutex 11 checkACLArgsForCall []struct { 12 arg1 string 13 arg2 string 14 arg3 interface{} 15 } 16 checkACLReturns struct { 17 result1 error 18 } 19 checkACLReturnsOnCall map[int]struct { 20 result1 error 21 } 22 CheckACLNoChannelStub func(string, interface{}) error 23 checkACLNoChannelMutex sync.RWMutex 24 checkACLNoChannelArgsForCall []struct { 25 arg1 string 26 arg2 interface{} 27 } 28 checkACLNoChannelReturns struct { 29 result1 error 30 } 31 checkACLNoChannelReturnsOnCall map[int]struct { 32 result1 error 33 } 34 IsPtypePolicyStub func(string) bool 35 isPtypePolicyMutex sync.RWMutex 36 isPtypePolicyArgsForCall []struct { 37 arg1 string 38 } 39 isPtypePolicyReturns struct { 40 result1 bool 41 } 42 isPtypePolicyReturnsOnCall map[int]struct { 43 result1 bool 44 } 45 invocations map[string][][]interface{} 46 invocationsMutex sync.RWMutex 47 } 48 49 func (fake *DefaultACLProvider) CheckACL(arg1 string, arg2 string, arg3 interface{}) error { 50 fake.checkACLMutex.Lock() 51 ret, specificReturn := fake.checkACLReturnsOnCall[len(fake.checkACLArgsForCall)] 52 fake.checkACLArgsForCall = append(fake.checkACLArgsForCall, struct { 53 arg1 string 54 arg2 string 55 arg3 interface{} 56 }{arg1, arg2, arg3}) 57 fake.recordInvocation("CheckACL", []interface{}{arg1, arg2, arg3}) 58 fake.checkACLMutex.Unlock() 59 if fake.CheckACLStub != nil { 60 return fake.CheckACLStub(arg1, arg2, arg3) 61 } 62 if specificReturn { 63 return ret.result1 64 } 65 fakeReturns := fake.checkACLReturns 66 return fakeReturns.result1 67 } 68 69 func (fake *DefaultACLProvider) CheckACLCallCount() int { 70 fake.checkACLMutex.RLock() 71 defer fake.checkACLMutex.RUnlock() 72 return len(fake.checkACLArgsForCall) 73 } 74 75 func (fake *DefaultACLProvider) CheckACLCalls(stub func(string, string, interface{}) error) { 76 fake.checkACLMutex.Lock() 77 defer fake.checkACLMutex.Unlock() 78 fake.CheckACLStub = stub 79 } 80 81 func (fake *DefaultACLProvider) CheckACLArgsForCall(i int) (string, string, interface{}) { 82 fake.checkACLMutex.RLock() 83 defer fake.checkACLMutex.RUnlock() 84 argsForCall := fake.checkACLArgsForCall[i] 85 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 86 } 87 88 func (fake *DefaultACLProvider) CheckACLReturns(result1 error) { 89 fake.checkACLMutex.Lock() 90 defer fake.checkACLMutex.Unlock() 91 fake.CheckACLStub = nil 92 fake.checkACLReturns = struct { 93 result1 error 94 }{result1} 95 } 96 97 func (fake *DefaultACLProvider) CheckACLReturnsOnCall(i int, result1 error) { 98 fake.checkACLMutex.Lock() 99 defer fake.checkACLMutex.Unlock() 100 fake.CheckACLStub = nil 101 if fake.checkACLReturnsOnCall == nil { 102 fake.checkACLReturnsOnCall = make(map[int]struct { 103 result1 error 104 }) 105 } 106 fake.checkACLReturnsOnCall[i] = struct { 107 result1 error 108 }{result1} 109 } 110 111 func (fake *DefaultACLProvider) CheckACLNoChannel(arg1 string, arg2 interface{}) error { 112 fake.checkACLNoChannelMutex.Lock() 113 ret, specificReturn := fake.checkACLNoChannelReturnsOnCall[len(fake.checkACLNoChannelArgsForCall)] 114 fake.checkACLNoChannelArgsForCall = append(fake.checkACLNoChannelArgsForCall, struct { 115 arg1 string 116 arg2 interface{} 117 }{arg1, arg2}) 118 fake.recordInvocation("CheckACLNoChannel", []interface{}{arg1, arg2}) 119 fake.checkACLNoChannelMutex.Unlock() 120 if fake.CheckACLNoChannelStub != nil { 121 return fake.CheckACLNoChannelStub(arg1, arg2) 122 } 123 if specificReturn { 124 return ret.result1 125 } 126 fakeReturns := fake.checkACLNoChannelReturns 127 return fakeReturns.result1 128 } 129 130 func (fake *DefaultACLProvider) CheckACLNoChannelCallCount() int { 131 fake.checkACLNoChannelMutex.RLock() 132 defer fake.checkACLNoChannelMutex.RUnlock() 133 return len(fake.checkACLNoChannelArgsForCall) 134 } 135 136 func (fake *DefaultACLProvider) CheckACLNoChannelCalls(stub func(string, interface{}) error) { 137 fake.checkACLNoChannelMutex.Lock() 138 defer fake.checkACLNoChannelMutex.Unlock() 139 fake.CheckACLNoChannelStub = stub 140 } 141 142 func (fake *DefaultACLProvider) CheckACLNoChannelArgsForCall(i int) (string, interface{}) { 143 fake.checkACLNoChannelMutex.RLock() 144 defer fake.checkACLNoChannelMutex.RUnlock() 145 argsForCall := fake.checkACLNoChannelArgsForCall[i] 146 return argsForCall.arg1, argsForCall.arg2 147 } 148 149 func (fake *DefaultACLProvider) CheckACLNoChannelReturns(result1 error) { 150 fake.checkACLNoChannelMutex.Lock() 151 defer fake.checkACLNoChannelMutex.Unlock() 152 fake.CheckACLNoChannelStub = nil 153 fake.checkACLNoChannelReturns = struct { 154 result1 error 155 }{result1} 156 } 157 158 func (fake *DefaultACLProvider) CheckACLNoChannelReturnsOnCall(i int, result1 error) { 159 fake.checkACLNoChannelMutex.Lock() 160 defer fake.checkACLNoChannelMutex.Unlock() 161 fake.CheckACLNoChannelStub = nil 162 if fake.checkACLNoChannelReturnsOnCall == nil { 163 fake.checkACLNoChannelReturnsOnCall = make(map[int]struct { 164 result1 error 165 }) 166 } 167 fake.checkACLNoChannelReturnsOnCall[i] = struct { 168 result1 error 169 }{result1} 170 } 171 172 func (fake *DefaultACLProvider) IsPtypePolicy(arg1 string) bool { 173 fake.isPtypePolicyMutex.Lock() 174 ret, specificReturn := fake.isPtypePolicyReturnsOnCall[len(fake.isPtypePolicyArgsForCall)] 175 fake.isPtypePolicyArgsForCall = append(fake.isPtypePolicyArgsForCall, struct { 176 arg1 string 177 }{arg1}) 178 fake.recordInvocation("IsPtypePolicy", []interface{}{arg1}) 179 fake.isPtypePolicyMutex.Unlock() 180 if fake.IsPtypePolicyStub != nil { 181 return fake.IsPtypePolicyStub(arg1) 182 } 183 if specificReturn { 184 return ret.result1 185 } 186 fakeReturns := fake.isPtypePolicyReturns 187 return fakeReturns.result1 188 } 189 190 func (fake *DefaultACLProvider) IsPtypePolicyCallCount() int { 191 fake.isPtypePolicyMutex.RLock() 192 defer fake.isPtypePolicyMutex.RUnlock() 193 return len(fake.isPtypePolicyArgsForCall) 194 } 195 196 func (fake *DefaultACLProvider) IsPtypePolicyCalls(stub func(string) bool) { 197 fake.isPtypePolicyMutex.Lock() 198 defer fake.isPtypePolicyMutex.Unlock() 199 fake.IsPtypePolicyStub = stub 200 } 201 202 func (fake *DefaultACLProvider) IsPtypePolicyArgsForCall(i int) string { 203 fake.isPtypePolicyMutex.RLock() 204 defer fake.isPtypePolicyMutex.RUnlock() 205 argsForCall := fake.isPtypePolicyArgsForCall[i] 206 return argsForCall.arg1 207 } 208 209 func (fake *DefaultACLProvider) IsPtypePolicyReturns(result1 bool) { 210 fake.isPtypePolicyMutex.Lock() 211 defer fake.isPtypePolicyMutex.Unlock() 212 fake.IsPtypePolicyStub = nil 213 fake.isPtypePolicyReturns = struct { 214 result1 bool 215 }{result1} 216 } 217 218 func (fake *DefaultACLProvider) IsPtypePolicyReturnsOnCall(i int, result1 bool) { 219 fake.isPtypePolicyMutex.Lock() 220 defer fake.isPtypePolicyMutex.Unlock() 221 fake.IsPtypePolicyStub = nil 222 if fake.isPtypePolicyReturnsOnCall == nil { 223 fake.isPtypePolicyReturnsOnCall = make(map[int]struct { 224 result1 bool 225 }) 226 } 227 fake.isPtypePolicyReturnsOnCall[i] = struct { 228 result1 bool 229 }{result1} 230 } 231 232 func (fake *DefaultACLProvider) Invocations() map[string][][]interface{} { 233 fake.invocationsMutex.RLock() 234 defer fake.invocationsMutex.RUnlock() 235 fake.checkACLMutex.RLock() 236 defer fake.checkACLMutex.RUnlock() 237 fake.checkACLNoChannelMutex.RLock() 238 defer fake.checkACLNoChannelMutex.RUnlock() 239 fake.isPtypePolicyMutex.RLock() 240 defer fake.isPtypePolicyMutex.RUnlock() 241 copiedInvocations := map[string][][]interface{}{} 242 for key, value := range fake.invocations { 243 copiedInvocations[key] = value 244 } 245 return copiedInvocations 246 } 247 248 func (fake *DefaultACLProvider) recordInvocation(key string, args []interface{}) { 249 fake.invocationsMutex.Lock() 250 defer fake.invocationsMutex.Unlock() 251 if fake.invocations == nil { 252 fake.invocations = map[string][][]interface{}{} 253 } 254 if fake.invocations[key] == nil { 255 fake.invocations[key] = [][]interface{}{} 256 } 257 fake.invocations[key] = append(fake.invocations[key], args) 258 }