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)