github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/tsa/tsafakes/fake_conn.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  // Generated by running "go run github.com/maxbrunsfeld/counterfeiter/v6 "golang.org/x/crypto/ssh.Conn"
     3  
     4  package tsafakes
     5  
     6  import (
     7  	"net"
     8  	"sync"
     9  
    10  	"golang.org/x/crypto/ssh"
    11  )
    12  
    13  type FakeConn struct {
    14  	ClientVersionStub        func() []byte
    15  	clientVersionMutex       sync.RWMutex
    16  	clientVersionArgsForCall []struct {
    17  	}
    18  	clientVersionReturns struct {
    19  		result1 []byte
    20  	}
    21  	clientVersionReturnsOnCall map[int]struct {
    22  		result1 []byte
    23  	}
    24  	CloseStub        func() error
    25  	closeMutex       sync.RWMutex
    26  	closeArgsForCall []struct {
    27  	}
    28  	closeReturns struct {
    29  		result1 error
    30  	}
    31  	closeReturnsOnCall map[int]struct {
    32  		result1 error
    33  	}
    34  	LocalAddrStub        func() net.Addr
    35  	localAddrMutex       sync.RWMutex
    36  	localAddrArgsForCall []struct {
    37  	}
    38  	localAddrReturns struct {
    39  		result1 net.Addr
    40  	}
    41  	localAddrReturnsOnCall map[int]struct {
    42  		result1 net.Addr
    43  	}
    44  	OpenChannelStub        func(string, []byte) (ssh.Channel, <-chan *ssh.Request, error)
    45  	openChannelMutex       sync.RWMutex
    46  	openChannelArgsForCall []struct {
    47  		arg1 string
    48  		arg2 []byte
    49  	}
    50  	openChannelReturns struct {
    51  		result1 ssh.Channel
    52  		result2 <-chan *ssh.Request
    53  		result3 error
    54  	}
    55  	openChannelReturnsOnCall map[int]struct {
    56  		result1 ssh.Channel
    57  		result2 <-chan *ssh.Request
    58  		result3 error
    59  	}
    60  	RemoteAddrStub        func() net.Addr
    61  	remoteAddrMutex       sync.RWMutex
    62  	remoteAddrArgsForCall []struct {
    63  	}
    64  	remoteAddrReturns struct {
    65  		result1 net.Addr
    66  	}
    67  	remoteAddrReturnsOnCall map[int]struct {
    68  		result1 net.Addr
    69  	}
    70  	SendRequestStub        func(string, bool, []byte) (bool, []byte, error)
    71  	sendRequestMutex       sync.RWMutex
    72  	sendRequestArgsForCall []struct {
    73  		arg1 string
    74  		arg2 bool
    75  		arg3 []byte
    76  	}
    77  	sendRequestReturns struct {
    78  		result1 bool
    79  		result2 []byte
    80  		result3 error
    81  	}
    82  	sendRequestReturnsOnCall map[int]struct {
    83  		result1 bool
    84  		result2 []byte
    85  		result3 error
    86  	}
    87  	ServerVersionStub        func() []byte
    88  	serverVersionMutex       sync.RWMutex
    89  	serverVersionArgsForCall []struct {
    90  	}
    91  	serverVersionReturns struct {
    92  		result1 []byte
    93  	}
    94  	serverVersionReturnsOnCall map[int]struct {
    95  		result1 []byte
    96  	}
    97  	SessionIDStub        func() []byte
    98  	sessionIDMutex       sync.RWMutex
    99  	sessionIDArgsForCall []struct {
   100  	}
   101  	sessionIDReturns struct {
   102  		result1 []byte
   103  	}
   104  	sessionIDReturnsOnCall map[int]struct {
   105  		result1 []byte
   106  	}
   107  	UserStub        func() string
   108  	userMutex       sync.RWMutex
   109  	userArgsForCall []struct {
   110  	}
   111  	userReturns struct {
   112  		result1 string
   113  	}
   114  	userReturnsOnCall map[int]struct {
   115  		result1 string
   116  	}
   117  	WaitStub        func() error
   118  	waitMutex       sync.RWMutex
   119  	waitArgsForCall []struct {
   120  	}
   121  	waitReturns struct {
   122  		result1 error
   123  	}
   124  	waitReturnsOnCall map[int]struct {
   125  		result1 error
   126  	}
   127  	invocations      map[string][][]interface{}
   128  	invocationsMutex sync.RWMutex
   129  }
   130  
   131  func (fake *FakeConn) ClientVersion() []byte {
   132  	fake.clientVersionMutex.Lock()
   133  	ret, specificReturn := fake.clientVersionReturnsOnCall[len(fake.clientVersionArgsForCall)]
   134  	fake.clientVersionArgsForCall = append(fake.clientVersionArgsForCall, struct {
   135  	}{})
   136  	fake.recordInvocation("ClientVersion", []interface{}{})
   137  	fake.clientVersionMutex.Unlock()
   138  	if fake.ClientVersionStub != nil {
   139  		return fake.ClientVersionStub()
   140  	}
   141  	if specificReturn {
   142  		return ret.result1
   143  	}
   144  	fakeReturns := fake.clientVersionReturns
   145  	return fakeReturns.result1
   146  }
   147  
   148  func (fake *FakeConn) ClientVersionCallCount() int {
   149  	fake.clientVersionMutex.RLock()
   150  	defer fake.clientVersionMutex.RUnlock()
   151  	return len(fake.clientVersionArgsForCall)
   152  }
   153  
   154  func (fake *FakeConn) ClientVersionCalls(stub func() []byte) {
   155  	fake.clientVersionMutex.Lock()
   156  	defer fake.clientVersionMutex.Unlock()
   157  	fake.ClientVersionStub = stub
   158  }
   159  
   160  func (fake *FakeConn) ClientVersionReturns(result1 []byte) {
   161  	fake.clientVersionMutex.Lock()
   162  	defer fake.clientVersionMutex.Unlock()
   163  	fake.ClientVersionStub = nil
   164  	fake.clientVersionReturns = struct {
   165  		result1 []byte
   166  	}{result1}
   167  }
   168  
   169  func (fake *FakeConn) ClientVersionReturnsOnCall(i int, result1 []byte) {
   170  	fake.clientVersionMutex.Lock()
   171  	defer fake.clientVersionMutex.Unlock()
   172  	fake.ClientVersionStub = nil
   173  	if fake.clientVersionReturnsOnCall == nil {
   174  		fake.clientVersionReturnsOnCall = make(map[int]struct {
   175  			result1 []byte
   176  		})
   177  	}
   178  	fake.clientVersionReturnsOnCall[i] = struct {
   179  		result1 []byte
   180  	}{result1}
   181  }
   182  
   183  func (fake *FakeConn) Close() error {
   184  	fake.closeMutex.Lock()
   185  	ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)]
   186  	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
   187  	}{})
   188  	fake.recordInvocation("Close", []interface{}{})
   189  	fake.closeMutex.Unlock()
   190  	if fake.CloseStub != nil {
   191  		return fake.CloseStub()
   192  	}
   193  	if specificReturn {
   194  		return ret.result1
   195  	}
   196  	fakeReturns := fake.closeReturns
   197  	return fakeReturns.result1
   198  }
   199  
   200  func (fake *FakeConn) CloseCallCount() int {
   201  	fake.closeMutex.RLock()
   202  	defer fake.closeMutex.RUnlock()
   203  	return len(fake.closeArgsForCall)
   204  }
   205  
   206  func (fake *FakeConn) CloseCalls(stub func() error) {
   207  	fake.closeMutex.Lock()
   208  	defer fake.closeMutex.Unlock()
   209  	fake.CloseStub = stub
   210  }
   211  
   212  func (fake *FakeConn) CloseReturns(result1 error) {
   213  	fake.closeMutex.Lock()
   214  	defer fake.closeMutex.Unlock()
   215  	fake.CloseStub = nil
   216  	fake.closeReturns = struct {
   217  		result1 error
   218  	}{result1}
   219  }
   220  
   221  func (fake *FakeConn) CloseReturnsOnCall(i int, result1 error) {
   222  	fake.closeMutex.Lock()
   223  	defer fake.closeMutex.Unlock()
   224  	fake.CloseStub = nil
   225  	if fake.closeReturnsOnCall == nil {
   226  		fake.closeReturnsOnCall = make(map[int]struct {
   227  			result1 error
   228  		})
   229  	}
   230  	fake.closeReturnsOnCall[i] = struct {
   231  		result1 error
   232  	}{result1}
   233  }
   234  
   235  func (fake *FakeConn) LocalAddr() net.Addr {
   236  	fake.localAddrMutex.Lock()
   237  	ret, specificReturn := fake.localAddrReturnsOnCall[len(fake.localAddrArgsForCall)]
   238  	fake.localAddrArgsForCall = append(fake.localAddrArgsForCall, struct {
   239  	}{})
   240  	fake.recordInvocation("LocalAddr", []interface{}{})
   241  	fake.localAddrMutex.Unlock()
   242  	if fake.LocalAddrStub != nil {
   243  		return fake.LocalAddrStub()
   244  	}
   245  	if specificReturn {
   246  		return ret.result1
   247  	}
   248  	fakeReturns := fake.localAddrReturns
   249  	return fakeReturns.result1
   250  }
   251  
   252  func (fake *FakeConn) LocalAddrCallCount() int {
   253  	fake.localAddrMutex.RLock()
   254  	defer fake.localAddrMutex.RUnlock()
   255  	return len(fake.localAddrArgsForCall)
   256  }
   257  
   258  func (fake *FakeConn) LocalAddrCalls(stub func() net.Addr) {
   259  	fake.localAddrMutex.Lock()
   260  	defer fake.localAddrMutex.Unlock()
   261  	fake.LocalAddrStub = stub
   262  }
   263  
   264  func (fake *FakeConn) LocalAddrReturns(result1 net.Addr) {
   265  	fake.localAddrMutex.Lock()
   266  	defer fake.localAddrMutex.Unlock()
   267  	fake.LocalAddrStub = nil
   268  	fake.localAddrReturns = struct {
   269  		result1 net.Addr
   270  	}{result1}
   271  }
   272  
   273  func (fake *FakeConn) LocalAddrReturnsOnCall(i int, result1 net.Addr) {
   274  	fake.localAddrMutex.Lock()
   275  	defer fake.localAddrMutex.Unlock()
   276  	fake.LocalAddrStub = nil
   277  	if fake.localAddrReturnsOnCall == nil {
   278  		fake.localAddrReturnsOnCall = make(map[int]struct {
   279  			result1 net.Addr
   280  		})
   281  	}
   282  	fake.localAddrReturnsOnCall[i] = struct {
   283  		result1 net.Addr
   284  	}{result1}
   285  }
   286  
   287  func (fake *FakeConn) OpenChannel(arg1 string, arg2 []byte) (ssh.Channel, <-chan *ssh.Request, error) {
   288  	var arg2Copy []byte
   289  	if arg2 != nil {
   290  		arg2Copy = make([]byte, len(arg2))
   291  		copy(arg2Copy, arg2)
   292  	}
   293  	fake.openChannelMutex.Lock()
   294  	ret, specificReturn := fake.openChannelReturnsOnCall[len(fake.openChannelArgsForCall)]
   295  	fake.openChannelArgsForCall = append(fake.openChannelArgsForCall, struct {
   296  		arg1 string
   297  		arg2 []byte
   298  	}{arg1, arg2Copy})
   299  	fake.recordInvocation("OpenChannel", []interface{}{arg1, arg2Copy})
   300  	fake.openChannelMutex.Unlock()
   301  	if fake.OpenChannelStub != nil {
   302  		return fake.OpenChannelStub(arg1, arg2)
   303  	}
   304  	if specificReturn {
   305  		return ret.result1, ret.result2, ret.result3
   306  	}
   307  	fakeReturns := fake.openChannelReturns
   308  	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
   309  }
   310  
   311  func (fake *FakeConn) OpenChannelCallCount() int {
   312  	fake.openChannelMutex.RLock()
   313  	defer fake.openChannelMutex.RUnlock()
   314  	return len(fake.openChannelArgsForCall)
   315  }
   316  
   317  func (fake *FakeConn) OpenChannelCalls(stub func(string, []byte) (ssh.Channel, <-chan *ssh.Request, error)) {
   318  	fake.openChannelMutex.Lock()
   319  	defer fake.openChannelMutex.Unlock()
   320  	fake.OpenChannelStub = stub
   321  }
   322  
   323  func (fake *FakeConn) OpenChannelArgsForCall(i int) (string, []byte) {
   324  	fake.openChannelMutex.RLock()
   325  	defer fake.openChannelMutex.RUnlock()
   326  	argsForCall := fake.openChannelArgsForCall[i]
   327  	return argsForCall.arg1, argsForCall.arg2
   328  }
   329  
   330  func (fake *FakeConn) OpenChannelReturns(result1 ssh.Channel, result2 <-chan *ssh.Request, result3 error) {
   331  	fake.openChannelMutex.Lock()
   332  	defer fake.openChannelMutex.Unlock()
   333  	fake.OpenChannelStub = nil
   334  	fake.openChannelReturns = struct {
   335  		result1 ssh.Channel
   336  		result2 <-chan *ssh.Request
   337  		result3 error
   338  	}{result1, result2, result3}
   339  }
   340  
   341  func (fake *FakeConn) OpenChannelReturnsOnCall(i int, result1 ssh.Channel, result2 <-chan *ssh.Request, result3 error) {
   342  	fake.openChannelMutex.Lock()
   343  	defer fake.openChannelMutex.Unlock()
   344  	fake.OpenChannelStub = nil
   345  	if fake.openChannelReturnsOnCall == nil {
   346  		fake.openChannelReturnsOnCall = make(map[int]struct {
   347  			result1 ssh.Channel
   348  			result2 <-chan *ssh.Request
   349  			result3 error
   350  		})
   351  	}
   352  	fake.openChannelReturnsOnCall[i] = struct {
   353  		result1 ssh.Channel
   354  		result2 <-chan *ssh.Request
   355  		result3 error
   356  	}{result1, result2, result3}
   357  }
   358  
   359  func (fake *FakeConn) RemoteAddr() net.Addr {
   360  	fake.remoteAddrMutex.Lock()
   361  	ret, specificReturn := fake.remoteAddrReturnsOnCall[len(fake.remoteAddrArgsForCall)]
   362  	fake.remoteAddrArgsForCall = append(fake.remoteAddrArgsForCall, struct {
   363  	}{})
   364  	fake.recordInvocation("RemoteAddr", []interface{}{})
   365  	fake.remoteAddrMutex.Unlock()
   366  	if fake.RemoteAddrStub != nil {
   367  		return fake.RemoteAddrStub()
   368  	}
   369  	if specificReturn {
   370  		return ret.result1
   371  	}
   372  	fakeReturns := fake.remoteAddrReturns
   373  	return fakeReturns.result1
   374  }
   375  
   376  func (fake *FakeConn) RemoteAddrCallCount() int {
   377  	fake.remoteAddrMutex.RLock()
   378  	defer fake.remoteAddrMutex.RUnlock()
   379  	return len(fake.remoteAddrArgsForCall)
   380  }
   381  
   382  func (fake *FakeConn) RemoteAddrCalls(stub func() net.Addr) {
   383  	fake.remoteAddrMutex.Lock()
   384  	defer fake.remoteAddrMutex.Unlock()
   385  	fake.RemoteAddrStub = stub
   386  }
   387  
   388  func (fake *FakeConn) RemoteAddrReturns(result1 net.Addr) {
   389  	fake.remoteAddrMutex.Lock()
   390  	defer fake.remoteAddrMutex.Unlock()
   391  	fake.RemoteAddrStub = nil
   392  	fake.remoteAddrReturns = struct {
   393  		result1 net.Addr
   394  	}{result1}
   395  }
   396  
   397  func (fake *FakeConn) RemoteAddrReturnsOnCall(i int, result1 net.Addr) {
   398  	fake.remoteAddrMutex.Lock()
   399  	defer fake.remoteAddrMutex.Unlock()
   400  	fake.RemoteAddrStub = nil
   401  	if fake.remoteAddrReturnsOnCall == nil {
   402  		fake.remoteAddrReturnsOnCall = make(map[int]struct {
   403  			result1 net.Addr
   404  		})
   405  	}
   406  	fake.remoteAddrReturnsOnCall[i] = struct {
   407  		result1 net.Addr
   408  	}{result1}
   409  }
   410  
   411  func (fake *FakeConn) SendRequest(arg1 string, arg2 bool, arg3 []byte) (bool, []byte, error) {
   412  	var arg3Copy []byte
   413  	if arg3 != nil {
   414  		arg3Copy = make([]byte, len(arg3))
   415  		copy(arg3Copy, arg3)
   416  	}
   417  	fake.sendRequestMutex.Lock()
   418  	ret, specificReturn := fake.sendRequestReturnsOnCall[len(fake.sendRequestArgsForCall)]
   419  	fake.sendRequestArgsForCall = append(fake.sendRequestArgsForCall, struct {
   420  		arg1 string
   421  		arg2 bool
   422  		arg3 []byte
   423  	}{arg1, arg2, arg3Copy})
   424  	fake.recordInvocation("SendRequest", []interface{}{arg1, arg2, arg3Copy})
   425  	fake.sendRequestMutex.Unlock()
   426  	if fake.SendRequestStub != nil {
   427  		return fake.SendRequestStub(arg1, arg2, arg3)
   428  	}
   429  	if specificReturn {
   430  		return ret.result1, ret.result2, ret.result3
   431  	}
   432  	fakeReturns := fake.sendRequestReturns
   433  	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
   434  }
   435  
   436  func (fake *FakeConn) SendRequestCallCount() int {
   437  	fake.sendRequestMutex.RLock()
   438  	defer fake.sendRequestMutex.RUnlock()
   439  	return len(fake.sendRequestArgsForCall)
   440  }
   441  
   442  func (fake *FakeConn) SendRequestCalls(stub func(string, bool, []byte) (bool, []byte, error)) {
   443  	fake.sendRequestMutex.Lock()
   444  	defer fake.sendRequestMutex.Unlock()
   445  	fake.SendRequestStub = stub
   446  }
   447  
   448  func (fake *FakeConn) SendRequestArgsForCall(i int) (string, bool, []byte) {
   449  	fake.sendRequestMutex.RLock()
   450  	defer fake.sendRequestMutex.RUnlock()
   451  	argsForCall := fake.sendRequestArgsForCall[i]
   452  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
   453  }
   454  
   455  func (fake *FakeConn) SendRequestReturns(result1 bool, result2 []byte, result3 error) {
   456  	fake.sendRequestMutex.Lock()
   457  	defer fake.sendRequestMutex.Unlock()
   458  	fake.SendRequestStub = nil
   459  	fake.sendRequestReturns = struct {
   460  		result1 bool
   461  		result2 []byte
   462  		result3 error
   463  	}{result1, result2, result3}
   464  }
   465  
   466  func (fake *FakeConn) SendRequestReturnsOnCall(i int, result1 bool, result2 []byte, result3 error) {
   467  	fake.sendRequestMutex.Lock()
   468  	defer fake.sendRequestMutex.Unlock()
   469  	fake.SendRequestStub = nil
   470  	if fake.sendRequestReturnsOnCall == nil {
   471  		fake.sendRequestReturnsOnCall = make(map[int]struct {
   472  			result1 bool
   473  			result2 []byte
   474  			result3 error
   475  		})
   476  	}
   477  	fake.sendRequestReturnsOnCall[i] = struct {
   478  		result1 bool
   479  		result2 []byte
   480  		result3 error
   481  	}{result1, result2, result3}
   482  }
   483  
   484  func (fake *FakeConn) ServerVersion() []byte {
   485  	fake.serverVersionMutex.Lock()
   486  	ret, specificReturn := fake.serverVersionReturnsOnCall[len(fake.serverVersionArgsForCall)]
   487  	fake.serverVersionArgsForCall = append(fake.serverVersionArgsForCall, struct {
   488  	}{})
   489  	fake.recordInvocation("ServerVersion", []interface{}{})
   490  	fake.serverVersionMutex.Unlock()
   491  	if fake.ServerVersionStub != nil {
   492  		return fake.ServerVersionStub()
   493  	}
   494  	if specificReturn {
   495  		return ret.result1
   496  	}
   497  	fakeReturns := fake.serverVersionReturns
   498  	return fakeReturns.result1
   499  }
   500  
   501  func (fake *FakeConn) ServerVersionCallCount() int {
   502  	fake.serverVersionMutex.RLock()
   503  	defer fake.serverVersionMutex.RUnlock()
   504  	return len(fake.serverVersionArgsForCall)
   505  }
   506  
   507  func (fake *FakeConn) ServerVersionCalls(stub func() []byte) {
   508  	fake.serverVersionMutex.Lock()
   509  	defer fake.serverVersionMutex.Unlock()
   510  	fake.ServerVersionStub = stub
   511  }
   512  
   513  func (fake *FakeConn) ServerVersionReturns(result1 []byte) {
   514  	fake.serverVersionMutex.Lock()
   515  	defer fake.serverVersionMutex.Unlock()
   516  	fake.ServerVersionStub = nil
   517  	fake.serverVersionReturns = struct {
   518  		result1 []byte
   519  	}{result1}
   520  }
   521  
   522  func (fake *FakeConn) ServerVersionReturnsOnCall(i int, result1 []byte) {
   523  	fake.serverVersionMutex.Lock()
   524  	defer fake.serverVersionMutex.Unlock()
   525  	fake.ServerVersionStub = nil
   526  	if fake.serverVersionReturnsOnCall == nil {
   527  		fake.serverVersionReturnsOnCall = make(map[int]struct {
   528  			result1 []byte
   529  		})
   530  	}
   531  	fake.serverVersionReturnsOnCall[i] = struct {
   532  		result1 []byte
   533  	}{result1}
   534  }
   535  
   536  func (fake *FakeConn) SessionID() []byte {
   537  	fake.sessionIDMutex.Lock()
   538  	ret, specificReturn := fake.sessionIDReturnsOnCall[len(fake.sessionIDArgsForCall)]
   539  	fake.sessionIDArgsForCall = append(fake.sessionIDArgsForCall, struct {
   540  	}{})
   541  	fake.recordInvocation("SessionID", []interface{}{})
   542  	fake.sessionIDMutex.Unlock()
   543  	if fake.SessionIDStub != nil {
   544  		return fake.SessionIDStub()
   545  	}
   546  	if specificReturn {
   547  		return ret.result1
   548  	}
   549  	fakeReturns := fake.sessionIDReturns
   550  	return fakeReturns.result1
   551  }
   552  
   553  func (fake *FakeConn) SessionIDCallCount() int {
   554  	fake.sessionIDMutex.RLock()
   555  	defer fake.sessionIDMutex.RUnlock()
   556  	return len(fake.sessionIDArgsForCall)
   557  }
   558  
   559  func (fake *FakeConn) SessionIDCalls(stub func() []byte) {
   560  	fake.sessionIDMutex.Lock()
   561  	defer fake.sessionIDMutex.Unlock()
   562  	fake.SessionIDStub = stub
   563  }
   564  
   565  func (fake *FakeConn) SessionIDReturns(result1 []byte) {
   566  	fake.sessionIDMutex.Lock()
   567  	defer fake.sessionIDMutex.Unlock()
   568  	fake.SessionIDStub = nil
   569  	fake.sessionIDReturns = struct {
   570  		result1 []byte
   571  	}{result1}
   572  }
   573  
   574  func (fake *FakeConn) SessionIDReturnsOnCall(i int, result1 []byte) {
   575  	fake.sessionIDMutex.Lock()
   576  	defer fake.sessionIDMutex.Unlock()
   577  	fake.SessionIDStub = nil
   578  	if fake.sessionIDReturnsOnCall == nil {
   579  		fake.sessionIDReturnsOnCall = make(map[int]struct {
   580  			result1 []byte
   581  		})
   582  	}
   583  	fake.sessionIDReturnsOnCall[i] = struct {
   584  		result1 []byte
   585  	}{result1}
   586  }
   587  
   588  func (fake *FakeConn) User() string {
   589  	fake.userMutex.Lock()
   590  	ret, specificReturn := fake.userReturnsOnCall[len(fake.userArgsForCall)]
   591  	fake.userArgsForCall = append(fake.userArgsForCall, struct {
   592  	}{})
   593  	fake.recordInvocation("User", []interface{}{})
   594  	fake.userMutex.Unlock()
   595  	if fake.UserStub != nil {
   596  		return fake.UserStub()
   597  	}
   598  	if specificReturn {
   599  		return ret.result1
   600  	}
   601  	fakeReturns := fake.userReturns
   602  	return fakeReturns.result1
   603  }
   604  
   605  func (fake *FakeConn) UserCallCount() int {
   606  	fake.userMutex.RLock()
   607  	defer fake.userMutex.RUnlock()
   608  	return len(fake.userArgsForCall)
   609  }
   610  
   611  func (fake *FakeConn) UserCalls(stub func() string) {
   612  	fake.userMutex.Lock()
   613  	defer fake.userMutex.Unlock()
   614  	fake.UserStub = stub
   615  }
   616  
   617  func (fake *FakeConn) UserReturns(result1 string) {
   618  	fake.userMutex.Lock()
   619  	defer fake.userMutex.Unlock()
   620  	fake.UserStub = nil
   621  	fake.userReturns = struct {
   622  		result1 string
   623  	}{result1}
   624  }
   625  
   626  func (fake *FakeConn) UserReturnsOnCall(i int, result1 string) {
   627  	fake.userMutex.Lock()
   628  	defer fake.userMutex.Unlock()
   629  	fake.UserStub = nil
   630  	if fake.userReturnsOnCall == nil {
   631  		fake.userReturnsOnCall = make(map[int]struct {
   632  			result1 string
   633  		})
   634  	}
   635  	fake.userReturnsOnCall[i] = struct {
   636  		result1 string
   637  	}{result1}
   638  }
   639  
   640  func (fake *FakeConn) Wait() error {
   641  	fake.waitMutex.Lock()
   642  	ret, specificReturn := fake.waitReturnsOnCall[len(fake.waitArgsForCall)]
   643  	fake.waitArgsForCall = append(fake.waitArgsForCall, struct {
   644  	}{})
   645  	fake.recordInvocation("Wait", []interface{}{})
   646  	fake.waitMutex.Unlock()
   647  	if fake.WaitStub != nil {
   648  		return fake.WaitStub()
   649  	}
   650  	if specificReturn {
   651  		return ret.result1
   652  	}
   653  	fakeReturns := fake.waitReturns
   654  	return fakeReturns.result1
   655  }
   656  
   657  func (fake *FakeConn) WaitCallCount() int {
   658  	fake.waitMutex.RLock()
   659  	defer fake.waitMutex.RUnlock()
   660  	return len(fake.waitArgsForCall)
   661  }
   662  
   663  func (fake *FakeConn) WaitCalls(stub func() error) {
   664  	fake.waitMutex.Lock()
   665  	defer fake.waitMutex.Unlock()
   666  	fake.WaitStub = stub
   667  }
   668  
   669  func (fake *FakeConn) WaitReturns(result1 error) {
   670  	fake.waitMutex.Lock()
   671  	defer fake.waitMutex.Unlock()
   672  	fake.WaitStub = nil
   673  	fake.waitReturns = struct {
   674  		result1 error
   675  	}{result1}
   676  }
   677  
   678  func (fake *FakeConn) WaitReturnsOnCall(i int, result1 error) {
   679  	fake.waitMutex.Lock()
   680  	defer fake.waitMutex.Unlock()
   681  	fake.WaitStub = nil
   682  	if fake.waitReturnsOnCall == nil {
   683  		fake.waitReturnsOnCall = make(map[int]struct {
   684  			result1 error
   685  		})
   686  	}
   687  	fake.waitReturnsOnCall[i] = struct {
   688  		result1 error
   689  	}{result1}
   690  }
   691  
   692  func (fake *FakeConn) Invocations() map[string][][]interface{} {
   693  	fake.invocationsMutex.RLock()
   694  	defer fake.invocationsMutex.RUnlock()
   695  	fake.clientVersionMutex.RLock()
   696  	defer fake.clientVersionMutex.RUnlock()
   697  	fake.closeMutex.RLock()
   698  	defer fake.closeMutex.RUnlock()
   699  	fake.localAddrMutex.RLock()
   700  	defer fake.localAddrMutex.RUnlock()
   701  	fake.openChannelMutex.RLock()
   702  	defer fake.openChannelMutex.RUnlock()
   703  	fake.remoteAddrMutex.RLock()
   704  	defer fake.remoteAddrMutex.RUnlock()
   705  	fake.sendRequestMutex.RLock()
   706  	defer fake.sendRequestMutex.RUnlock()
   707  	fake.serverVersionMutex.RLock()
   708  	defer fake.serverVersionMutex.RUnlock()
   709  	fake.sessionIDMutex.RLock()
   710  	defer fake.sessionIDMutex.RUnlock()
   711  	fake.userMutex.RLock()
   712  	defer fake.userMutex.RUnlock()
   713  	fake.waitMutex.RLock()
   714  	defer fake.waitMutex.RUnlock()
   715  	copiedInvocations := map[string][][]interface{}{}
   716  	for key, value := range fake.invocations {
   717  		copiedInvocations[key] = value
   718  	}
   719  	return copiedInvocations
   720  }
   721  
   722  func (fake *FakeConn) recordInvocation(key string, args []interface{}) {
   723  	fake.invocationsMutex.Lock()
   724  	defer fake.invocationsMutex.Unlock()
   725  	if fake.invocations == nil {
   726  		fake.invocations = map[string][][]interface{}{}
   727  	}
   728  	if fake.invocations[key] == nil {
   729  		fake.invocations[key] = [][]interface{}{}
   730  	}
   731  	fake.invocations[key] = append(fake.invocations[key], args)
   732  }
   733  
   734  var _ ssh.Conn = new(FakeConn)