github.com/ablease/cli@v6.37.1-0.20180613014814-3adbb7d7fb19+incompatible/util/clissh/clisshfakes/fake_terminal_helper.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package clisshfakes 3 4 import ( 5 "io" 6 "sync" 7 8 "code.cloudfoundry.org/cli/util/clissh" 9 "github.com/moby/moby/pkg/term" 10 ) 11 12 type FakeTerminalHelper struct { 13 GetFdInfoStub func(in interface{}) (fd uintptr, isTerminal bool) 14 getFdInfoMutex sync.RWMutex 15 getFdInfoArgsForCall []struct { 16 in interface{} 17 } 18 getFdInfoReturns struct { 19 result1 uintptr 20 result2 bool 21 } 22 getFdInfoReturnsOnCall map[int]struct { 23 result1 uintptr 24 result2 bool 25 } 26 SetRawTerminalStub func(fd uintptr) (*term.State, error) 27 setRawTerminalMutex sync.RWMutex 28 setRawTerminalArgsForCall []struct { 29 fd uintptr 30 } 31 setRawTerminalReturns struct { 32 result1 *term.State 33 result2 error 34 } 35 setRawTerminalReturnsOnCall map[int]struct { 36 result1 *term.State 37 result2 error 38 } 39 RestoreTerminalStub func(fd uintptr, state *term.State) error 40 restoreTerminalMutex sync.RWMutex 41 restoreTerminalArgsForCall []struct { 42 fd uintptr 43 state *term.State 44 } 45 restoreTerminalReturns struct { 46 result1 error 47 } 48 restoreTerminalReturnsOnCall map[int]struct { 49 result1 error 50 } 51 GetWinsizeStub func(fd uintptr) (*term.Winsize, error) 52 getWinsizeMutex sync.RWMutex 53 getWinsizeArgsForCall []struct { 54 fd uintptr 55 } 56 getWinsizeReturns struct { 57 result1 *term.Winsize 58 result2 error 59 } 60 getWinsizeReturnsOnCall map[int]struct { 61 result1 *term.Winsize 62 result2 error 63 } 64 StdStreamsStub func() (stdin io.ReadCloser, stdout io.Writer, stderr io.Writer) 65 stdStreamsMutex sync.RWMutex 66 stdStreamsArgsForCall []struct{} 67 stdStreamsReturns struct { 68 result1 io.ReadCloser 69 result2 io.Writer 70 result3 io.Writer 71 } 72 stdStreamsReturnsOnCall map[int]struct { 73 result1 io.ReadCloser 74 result2 io.Writer 75 result3 io.Writer 76 } 77 invocations map[string][][]interface{} 78 invocationsMutex sync.RWMutex 79 } 80 81 func (fake *FakeTerminalHelper) GetFdInfo(in interface{}) (fd uintptr, isTerminal bool) { 82 fake.getFdInfoMutex.Lock() 83 ret, specificReturn := fake.getFdInfoReturnsOnCall[len(fake.getFdInfoArgsForCall)] 84 fake.getFdInfoArgsForCall = append(fake.getFdInfoArgsForCall, struct { 85 in interface{} 86 }{in}) 87 fake.recordInvocation("GetFdInfo", []interface{}{in}) 88 fake.getFdInfoMutex.Unlock() 89 if fake.GetFdInfoStub != nil { 90 return fake.GetFdInfoStub(in) 91 } 92 if specificReturn { 93 return ret.result1, ret.result2 94 } 95 return fake.getFdInfoReturns.result1, fake.getFdInfoReturns.result2 96 } 97 98 func (fake *FakeTerminalHelper) GetFdInfoCallCount() int { 99 fake.getFdInfoMutex.RLock() 100 defer fake.getFdInfoMutex.RUnlock() 101 return len(fake.getFdInfoArgsForCall) 102 } 103 104 func (fake *FakeTerminalHelper) GetFdInfoArgsForCall(i int) interface{} { 105 fake.getFdInfoMutex.RLock() 106 defer fake.getFdInfoMutex.RUnlock() 107 return fake.getFdInfoArgsForCall[i].in 108 } 109 110 func (fake *FakeTerminalHelper) GetFdInfoReturns(result1 uintptr, result2 bool) { 111 fake.GetFdInfoStub = nil 112 fake.getFdInfoReturns = struct { 113 result1 uintptr 114 result2 bool 115 }{result1, result2} 116 } 117 118 func (fake *FakeTerminalHelper) GetFdInfoReturnsOnCall(i int, result1 uintptr, result2 bool) { 119 fake.GetFdInfoStub = nil 120 if fake.getFdInfoReturnsOnCall == nil { 121 fake.getFdInfoReturnsOnCall = make(map[int]struct { 122 result1 uintptr 123 result2 bool 124 }) 125 } 126 fake.getFdInfoReturnsOnCall[i] = struct { 127 result1 uintptr 128 result2 bool 129 }{result1, result2} 130 } 131 132 func (fake *FakeTerminalHelper) SetRawTerminal(fd uintptr) (*term.State, error) { 133 fake.setRawTerminalMutex.Lock() 134 ret, specificReturn := fake.setRawTerminalReturnsOnCall[len(fake.setRawTerminalArgsForCall)] 135 fake.setRawTerminalArgsForCall = append(fake.setRawTerminalArgsForCall, struct { 136 fd uintptr 137 }{fd}) 138 fake.recordInvocation("SetRawTerminal", []interface{}{fd}) 139 fake.setRawTerminalMutex.Unlock() 140 if fake.SetRawTerminalStub != nil { 141 return fake.SetRawTerminalStub(fd) 142 } 143 if specificReturn { 144 return ret.result1, ret.result2 145 } 146 return fake.setRawTerminalReturns.result1, fake.setRawTerminalReturns.result2 147 } 148 149 func (fake *FakeTerminalHelper) SetRawTerminalCallCount() int { 150 fake.setRawTerminalMutex.RLock() 151 defer fake.setRawTerminalMutex.RUnlock() 152 return len(fake.setRawTerminalArgsForCall) 153 } 154 155 func (fake *FakeTerminalHelper) SetRawTerminalArgsForCall(i int) uintptr { 156 fake.setRawTerminalMutex.RLock() 157 defer fake.setRawTerminalMutex.RUnlock() 158 return fake.setRawTerminalArgsForCall[i].fd 159 } 160 161 func (fake *FakeTerminalHelper) SetRawTerminalReturns(result1 *term.State, result2 error) { 162 fake.SetRawTerminalStub = nil 163 fake.setRawTerminalReturns = struct { 164 result1 *term.State 165 result2 error 166 }{result1, result2} 167 } 168 169 func (fake *FakeTerminalHelper) SetRawTerminalReturnsOnCall(i int, result1 *term.State, result2 error) { 170 fake.SetRawTerminalStub = nil 171 if fake.setRawTerminalReturnsOnCall == nil { 172 fake.setRawTerminalReturnsOnCall = make(map[int]struct { 173 result1 *term.State 174 result2 error 175 }) 176 } 177 fake.setRawTerminalReturnsOnCall[i] = struct { 178 result1 *term.State 179 result2 error 180 }{result1, result2} 181 } 182 183 func (fake *FakeTerminalHelper) RestoreTerminal(fd uintptr, state *term.State) error { 184 fake.restoreTerminalMutex.Lock() 185 ret, specificReturn := fake.restoreTerminalReturnsOnCall[len(fake.restoreTerminalArgsForCall)] 186 fake.restoreTerminalArgsForCall = append(fake.restoreTerminalArgsForCall, struct { 187 fd uintptr 188 state *term.State 189 }{fd, state}) 190 fake.recordInvocation("RestoreTerminal", []interface{}{fd, state}) 191 fake.restoreTerminalMutex.Unlock() 192 if fake.RestoreTerminalStub != nil { 193 return fake.RestoreTerminalStub(fd, state) 194 } 195 if specificReturn { 196 return ret.result1 197 } 198 return fake.restoreTerminalReturns.result1 199 } 200 201 func (fake *FakeTerminalHelper) RestoreTerminalCallCount() int { 202 fake.restoreTerminalMutex.RLock() 203 defer fake.restoreTerminalMutex.RUnlock() 204 return len(fake.restoreTerminalArgsForCall) 205 } 206 207 func (fake *FakeTerminalHelper) RestoreTerminalArgsForCall(i int) (uintptr, *term.State) { 208 fake.restoreTerminalMutex.RLock() 209 defer fake.restoreTerminalMutex.RUnlock() 210 return fake.restoreTerminalArgsForCall[i].fd, fake.restoreTerminalArgsForCall[i].state 211 } 212 213 func (fake *FakeTerminalHelper) RestoreTerminalReturns(result1 error) { 214 fake.RestoreTerminalStub = nil 215 fake.restoreTerminalReturns = struct { 216 result1 error 217 }{result1} 218 } 219 220 func (fake *FakeTerminalHelper) RestoreTerminalReturnsOnCall(i int, result1 error) { 221 fake.RestoreTerminalStub = nil 222 if fake.restoreTerminalReturnsOnCall == nil { 223 fake.restoreTerminalReturnsOnCall = make(map[int]struct { 224 result1 error 225 }) 226 } 227 fake.restoreTerminalReturnsOnCall[i] = struct { 228 result1 error 229 }{result1} 230 } 231 232 func (fake *FakeTerminalHelper) GetWinsize(fd uintptr) (*term.Winsize, error) { 233 fake.getWinsizeMutex.Lock() 234 ret, specificReturn := fake.getWinsizeReturnsOnCall[len(fake.getWinsizeArgsForCall)] 235 fake.getWinsizeArgsForCall = append(fake.getWinsizeArgsForCall, struct { 236 fd uintptr 237 }{fd}) 238 fake.recordInvocation("GetWinsize", []interface{}{fd}) 239 fake.getWinsizeMutex.Unlock() 240 if fake.GetWinsizeStub != nil { 241 return fake.GetWinsizeStub(fd) 242 } 243 if specificReturn { 244 return ret.result1, ret.result2 245 } 246 return fake.getWinsizeReturns.result1, fake.getWinsizeReturns.result2 247 } 248 249 func (fake *FakeTerminalHelper) GetWinsizeCallCount() int { 250 fake.getWinsizeMutex.RLock() 251 defer fake.getWinsizeMutex.RUnlock() 252 return len(fake.getWinsizeArgsForCall) 253 } 254 255 func (fake *FakeTerminalHelper) GetWinsizeArgsForCall(i int) uintptr { 256 fake.getWinsizeMutex.RLock() 257 defer fake.getWinsizeMutex.RUnlock() 258 return fake.getWinsizeArgsForCall[i].fd 259 } 260 261 func (fake *FakeTerminalHelper) GetWinsizeReturns(result1 *term.Winsize, result2 error) { 262 fake.GetWinsizeStub = nil 263 fake.getWinsizeReturns = struct { 264 result1 *term.Winsize 265 result2 error 266 }{result1, result2} 267 } 268 269 func (fake *FakeTerminalHelper) GetWinsizeReturnsOnCall(i int, result1 *term.Winsize, result2 error) { 270 fake.GetWinsizeStub = nil 271 if fake.getWinsizeReturnsOnCall == nil { 272 fake.getWinsizeReturnsOnCall = make(map[int]struct { 273 result1 *term.Winsize 274 result2 error 275 }) 276 } 277 fake.getWinsizeReturnsOnCall[i] = struct { 278 result1 *term.Winsize 279 result2 error 280 }{result1, result2} 281 } 282 283 func (fake *FakeTerminalHelper) StdStreams() (stdin io.ReadCloser, stdout io.Writer, stderr io.Writer) { 284 fake.stdStreamsMutex.Lock() 285 ret, specificReturn := fake.stdStreamsReturnsOnCall[len(fake.stdStreamsArgsForCall)] 286 fake.stdStreamsArgsForCall = append(fake.stdStreamsArgsForCall, struct{}{}) 287 fake.recordInvocation("StdStreams", []interface{}{}) 288 fake.stdStreamsMutex.Unlock() 289 if fake.StdStreamsStub != nil { 290 return fake.StdStreamsStub() 291 } 292 if specificReturn { 293 return ret.result1, ret.result2, ret.result3 294 } 295 return fake.stdStreamsReturns.result1, fake.stdStreamsReturns.result2, fake.stdStreamsReturns.result3 296 } 297 298 func (fake *FakeTerminalHelper) StdStreamsCallCount() int { 299 fake.stdStreamsMutex.RLock() 300 defer fake.stdStreamsMutex.RUnlock() 301 return len(fake.stdStreamsArgsForCall) 302 } 303 304 func (fake *FakeTerminalHelper) StdStreamsReturns(result1 io.ReadCloser, result2 io.Writer, result3 io.Writer) { 305 fake.StdStreamsStub = nil 306 fake.stdStreamsReturns = struct { 307 result1 io.ReadCloser 308 result2 io.Writer 309 result3 io.Writer 310 }{result1, result2, result3} 311 } 312 313 func (fake *FakeTerminalHelper) StdStreamsReturnsOnCall(i int, result1 io.ReadCloser, result2 io.Writer, result3 io.Writer) { 314 fake.StdStreamsStub = nil 315 if fake.stdStreamsReturnsOnCall == nil { 316 fake.stdStreamsReturnsOnCall = make(map[int]struct { 317 result1 io.ReadCloser 318 result2 io.Writer 319 result3 io.Writer 320 }) 321 } 322 fake.stdStreamsReturnsOnCall[i] = struct { 323 result1 io.ReadCloser 324 result2 io.Writer 325 result3 io.Writer 326 }{result1, result2, result3} 327 } 328 329 func (fake *FakeTerminalHelper) Invocations() map[string][][]interface{} { 330 fake.invocationsMutex.RLock() 331 defer fake.invocationsMutex.RUnlock() 332 fake.getFdInfoMutex.RLock() 333 defer fake.getFdInfoMutex.RUnlock() 334 fake.setRawTerminalMutex.RLock() 335 defer fake.setRawTerminalMutex.RUnlock() 336 fake.restoreTerminalMutex.RLock() 337 defer fake.restoreTerminalMutex.RUnlock() 338 fake.getWinsizeMutex.RLock() 339 defer fake.getWinsizeMutex.RUnlock() 340 fake.stdStreamsMutex.RLock() 341 defer fake.stdStreamsMutex.RUnlock() 342 copiedInvocations := map[string][][]interface{}{} 343 for key, value := range fake.invocations { 344 copiedInvocations[key] = value 345 } 346 return copiedInvocations 347 } 348 349 func (fake *FakeTerminalHelper) recordInvocation(key string, args []interface{}) { 350 fake.invocationsMutex.Lock() 351 defer fake.invocationsMutex.Unlock() 352 if fake.invocations == nil { 353 fake.invocations = map[string][][]interface{}{} 354 } 355 if fake.invocations[key] == nil { 356 fake.invocations[key] = [][]interface{}{} 357 } 358 fake.invocations[key] = append(fake.invocations[key], args) 359 } 360 361 var _ clissh.TerminalHelper = new(FakeTerminalHelper)