github.com/cloudfoundry-incubator/stembuild@v0.0.0-20211223202937-5b61d62226c6/construct/constructfakes/fake_construct_messenger.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package constructfakes
     3  
     4  import (
     5  	"sync"
     6  
     7  	"github.com/cloudfoundry-incubator/stembuild/construct"
     8  )
     9  
    10  type FakeConstructMessenger struct {
    11  	CreateProvisionDirStartedStub        func()
    12  	createProvisionDirStartedMutex       sync.RWMutex
    13  	createProvisionDirStartedArgsForCall []struct {
    14  	}
    15  	CreateProvisionDirSucceededStub        func()
    16  	createProvisionDirSucceededMutex       sync.RWMutex
    17  	createProvisionDirSucceededArgsForCall []struct {
    18  	}
    19  	EnableWinRMStartedStub        func()
    20  	enableWinRMStartedMutex       sync.RWMutex
    21  	enableWinRMStartedArgsForCall []struct {
    22  	}
    23  	EnableWinRMSucceededStub        func()
    24  	enableWinRMSucceededMutex       sync.RWMutex
    25  	enableWinRMSucceededArgsForCall []struct {
    26  	}
    27  	ExecutePostRebootScriptStartedStub        func()
    28  	executePostRebootScriptStartedMutex       sync.RWMutex
    29  	executePostRebootScriptStartedArgsForCall []struct {
    30  	}
    31  	ExecutePostRebootScriptSucceededStub        func()
    32  	executePostRebootScriptSucceededMutex       sync.RWMutex
    33  	executePostRebootScriptSucceededArgsForCall []struct {
    34  	}
    35  	ExecutePostRebootWarningStub        func(string)
    36  	executePostRebootWarningMutex       sync.RWMutex
    37  	executePostRebootWarningArgsForCall []struct {
    38  		arg1 string
    39  	}
    40  	ExecuteSetupScriptStartedStub        func()
    41  	executeSetupScriptStartedMutex       sync.RWMutex
    42  	executeSetupScriptStartedArgsForCall []struct {
    43  	}
    44  	ExecuteSetupScriptSucceededStub        func()
    45  	executeSetupScriptSucceededMutex       sync.RWMutex
    46  	executeSetupScriptSucceededArgsForCall []struct {
    47  	}
    48  	ExtractArtifactsStartedStub        func()
    49  	extractArtifactsStartedMutex       sync.RWMutex
    50  	extractArtifactsStartedArgsForCall []struct {
    51  	}
    52  	ExtractArtifactsSucceededStub        func()
    53  	extractArtifactsSucceededMutex       sync.RWMutex
    54  	extractArtifactsSucceededArgsForCall []struct {
    55  	}
    56  	LogOutUsersStartedStub        func()
    57  	logOutUsersStartedMutex       sync.RWMutex
    58  	logOutUsersStartedArgsForCall []struct {
    59  	}
    60  	LogOutUsersSucceededStub        func()
    61  	logOutUsersSucceededMutex       sync.RWMutex
    62  	logOutUsersSucceededArgsForCall []struct {
    63  	}
    64  	RebootHasFinishedStub        func()
    65  	rebootHasFinishedMutex       sync.RWMutex
    66  	rebootHasFinishedArgsForCall []struct {
    67  	}
    68  	RebootHasStartedStub        func()
    69  	rebootHasStartedMutex       sync.RWMutex
    70  	rebootHasStartedArgsForCall []struct {
    71  	}
    72  	ShutdownCompletedStub        func()
    73  	shutdownCompletedMutex       sync.RWMutex
    74  	shutdownCompletedArgsForCall []struct {
    75  	}
    76  	UploadArtifactsStartedStub        func()
    77  	uploadArtifactsStartedMutex       sync.RWMutex
    78  	uploadArtifactsStartedArgsForCall []struct {
    79  	}
    80  	UploadArtifactsSucceededStub        func()
    81  	uploadArtifactsSucceededMutex       sync.RWMutex
    82  	uploadArtifactsSucceededArgsForCall []struct {
    83  	}
    84  	UploadFileStartedStub        func(string)
    85  	uploadFileStartedMutex       sync.RWMutex
    86  	uploadFileStartedArgsForCall []struct {
    87  		arg1 string
    88  	}
    89  	UploadFileSucceededStub        func()
    90  	uploadFileSucceededMutex       sync.RWMutex
    91  	uploadFileSucceededArgsForCall []struct {
    92  	}
    93  	ValidateVMConnectionStartedStub        func()
    94  	validateVMConnectionStartedMutex       sync.RWMutex
    95  	validateVMConnectionStartedArgsForCall []struct {
    96  	}
    97  	ValidateVMConnectionSucceededStub        func()
    98  	validateVMConnectionSucceededMutex       sync.RWMutex
    99  	validateVMConnectionSucceededArgsForCall []struct {
   100  	}
   101  	WaitingForShutdownStub        func()
   102  	waitingForShutdownMutex       sync.RWMutex
   103  	waitingForShutdownArgsForCall []struct {
   104  	}
   105  	WinRMDisconnectedForRebootStub        func()
   106  	winRMDisconnectedForRebootMutex       sync.RWMutex
   107  	winRMDisconnectedForRebootArgsForCall []struct {
   108  	}
   109  	invocations      map[string][][]interface{}
   110  	invocationsMutex sync.RWMutex
   111  }
   112  
   113  func (fake *FakeConstructMessenger) CreateProvisionDirStarted() {
   114  	fake.createProvisionDirStartedMutex.Lock()
   115  	fake.createProvisionDirStartedArgsForCall = append(fake.createProvisionDirStartedArgsForCall, struct {
   116  	}{})
   117  	fake.recordInvocation("CreateProvisionDirStarted", []interface{}{})
   118  	fake.createProvisionDirStartedMutex.Unlock()
   119  	if fake.CreateProvisionDirStartedStub != nil {
   120  		fake.CreateProvisionDirStartedStub()
   121  	}
   122  }
   123  
   124  func (fake *FakeConstructMessenger) CreateProvisionDirStartedCallCount() int {
   125  	fake.createProvisionDirStartedMutex.RLock()
   126  	defer fake.createProvisionDirStartedMutex.RUnlock()
   127  	return len(fake.createProvisionDirStartedArgsForCall)
   128  }
   129  
   130  func (fake *FakeConstructMessenger) CreateProvisionDirStartedCalls(stub func()) {
   131  	fake.createProvisionDirStartedMutex.Lock()
   132  	defer fake.createProvisionDirStartedMutex.Unlock()
   133  	fake.CreateProvisionDirStartedStub = stub
   134  }
   135  
   136  func (fake *FakeConstructMessenger) CreateProvisionDirSucceeded() {
   137  	fake.createProvisionDirSucceededMutex.Lock()
   138  	fake.createProvisionDirSucceededArgsForCall = append(fake.createProvisionDirSucceededArgsForCall, struct {
   139  	}{})
   140  	fake.recordInvocation("CreateProvisionDirSucceeded", []interface{}{})
   141  	fake.createProvisionDirSucceededMutex.Unlock()
   142  	if fake.CreateProvisionDirSucceededStub != nil {
   143  		fake.CreateProvisionDirSucceededStub()
   144  	}
   145  }
   146  
   147  func (fake *FakeConstructMessenger) CreateProvisionDirSucceededCallCount() int {
   148  	fake.createProvisionDirSucceededMutex.RLock()
   149  	defer fake.createProvisionDirSucceededMutex.RUnlock()
   150  	return len(fake.createProvisionDirSucceededArgsForCall)
   151  }
   152  
   153  func (fake *FakeConstructMessenger) CreateProvisionDirSucceededCalls(stub func()) {
   154  	fake.createProvisionDirSucceededMutex.Lock()
   155  	defer fake.createProvisionDirSucceededMutex.Unlock()
   156  	fake.CreateProvisionDirSucceededStub = stub
   157  }
   158  
   159  func (fake *FakeConstructMessenger) EnableWinRMStarted() {
   160  	fake.enableWinRMStartedMutex.Lock()
   161  	fake.enableWinRMStartedArgsForCall = append(fake.enableWinRMStartedArgsForCall, struct {
   162  	}{})
   163  	fake.recordInvocation("EnableWinRMStarted", []interface{}{})
   164  	fake.enableWinRMStartedMutex.Unlock()
   165  	if fake.EnableWinRMStartedStub != nil {
   166  		fake.EnableWinRMStartedStub()
   167  	}
   168  }
   169  
   170  func (fake *FakeConstructMessenger) EnableWinRMStartedCallCount() int {
   171  	fake.enableWinRMStartedMutex.RLock()
   172  	defer fake.enableWinRMStartedMutex.RUnlock()
   173  	return len(fake.enableWinRMStartedArgsForCall)
   174  }
   175  
   176  func (fake *FakeConstructMessenger) EnableWinRMStartedCalls(stub func()) {
   177  	fake.enableWinRMStartedMutex.Lock()
   178  	defer fake.enableWinRMStartedMutex.Unlock()
   179  	fake.EnableWinRMStartedStub = stub
   180  }
   181  
   182  func (fake *FakeConstructMessenger) EnableWinRMSucceeded() {
   183  	fake.enableWinRMSucceededMutex.Lock()
   184  	fake.enableWinRMSucceededArgsForCall = append(fake.enableWinRMSucceededArgsForCall, struct {
   185  	}{})
   186  	fake.recordInvocation("EnableWinRMSucceeded", []interface{}{})
   187  	fake.enableWinRMSucceededMutex.Unlock()
   188  	if fake.EnableWinRMSucceededStub != nil {
   189  		fake.EnableWinRMSucceededStub()
   190  	}
   191  }
   192  
   193  func (fake *FakeConstructMessenger) EnableWinRMSucceededCallCount() int {
   194  	fake.enableWinRMSucceededMutex.RLock()
   195  	defer fake.enableWinRMSucceededMutex.RUnlock()
   196  	return len(fake.enableWinRMSucceededArgsForCall)
   197  }
   198  
   199  func (fake *FakeConstructMessenger) EnableWinRMSucceededCalls(stub func()) {
   200  	fake.enableWinRMSucceededMutex.Lock()
   201  	defer fake.enableWinRMSucceededMutex.Unlock()
   202  	fake.EnableWinRMSucceededStub = stub
   203  }
   204  
   205  func (fake *FakeConstructMessenger) ExecutePostRebootScriptStarted() {
   206  	fake.executePostRebootScriptStartedMutex.Lock()
   207  	fake.executePostRebootScriptStartedArgsForCall = append(fake.executePostRebootScriptStartedArgsForCall, struct {
   208  	}{})
   209  	fake.recordInvocation("ExecutePostRebootScriptStarted", []interface{}{})
   210  	fake.executePostRebootScriptStartedMutex.Unlock()
   211  	if fake.ExecutePostRebootScriptStartedStub != nil {
   212  		fake.ExecutePostRebootScriptStartedStub()
   213  	}
   214  }
   215  
   216  func (fake *FakeConstructMessenger) ExecutePostRebootScriptStartedCallCount() int {
   217  	fake.executePostRebootScriptStartedMutex.RLock()
   218  	defer fake.executePostRebootScriptStartedMutex.RUnlock()
   219  	return len(fake.executePostRebootScriptStartedArgsForCall)
   220  }
   221  
   222  func (fake *FakeConstructMessenger) ExecutePostRebootScriptStartedCalls(stub func()) {
   223  	fake.executePostRebootScriptStartedMutex.Lock()
   224  	defer fake.executePostRebootScriptStartedMutex.Unlock()
   225  	fake.ExecutePostRebootScriptStartedStub = stub
   226  }
   227  
   228  func (fake *FakeConstructMessenger) ExecutePostRebootScriptSucceeded() {
   229  	fake.executePostRebootScriptSucceededMutex.Lock()
   230  	fake.executePostRebootScriptSucceededArgsForCall = append(fake.executePostRebootScriptSucceededArgsForCall, struct {
   231  	}{})
   232  	fake.recordInvocation("ExecutePostRebootScriptSucceeded", []interface{}{})
   233  	fake.executePostRebootScriptSucceededMutex.Unlock()
   234  	if fake.ExecutePostRebootScriptSucceededStub != nil {
   235  		fake.ExecutePostRebootScriptSucceededStub()
   236  	}
   237  }
   238  
   239  func (fake *FakeConstructMessenger) ExecutePostRebootScriptSucceededCallCount() int {
   240  	fake.executePostRebootScriptSucceededMutex.RLock()
   241  	defer fake.executePostRebootScriptSucceededMutex.RUnlock()
   242  	return len(fake.executePostRebootScriptSucceededArgsForCall)
   243  }
   244  
   245  func (fake *FakeConstructMessenger) ExecutePostRebootScriptSucceededCalls(stub func()) {
   246  	fake.executePostRebootScriptSucceededMutex.Lock()
   247  	defer fake.executePostRebootScriptSucceededMutex.Unlock()
   248  	fake.ExecutePostRebootScriptSucceededStub = stub
   249  }
   250  
   251  func (fake *FakeConstructMessenger) ExecutePostRebootWarning(arg1 string) {
   252  	fake.executePostRebootWarningMutex.Lock()
   253  	fake.executePostRebootWarningArgsForCall = append(fake.executePostRebootWarningArgsForCall, struct {
   254  		arg1 string
   255  	}{arg1})
   256  	fake.recordInvocation("ExecutePostRebootWarning", []interface{}{arg1})
   257  	fake.executePostRebootWarningMutex.Unlock()
   258  	if fake.ExecutePostRebootWarningStub != nil {
   259  		fake.ExecutePostRebootWarningStub(arg1)
   260  	}
   261  }
   262  
   263  func (fake *FakeConstructMessenger) ExecutePostRebootWarningCallCount() int {
   264  	fake.executePostRebootWarningMutex.RLock()
   265  	defer fake.executePostRebootWarningMutex.RUnlock()
   266  	return len(fake.executePostRebootWarningArgsForCall)
   267  }
   268  
   269  func (fake *FakeConstructMessenger) ExecutePostRebootWarningCalls(stub func(string)) {
   270  	fake.executePostRebootWarningMutex.Lock()
   271  	defer fake.executePostRebootWarningMutex.Unlock()
   272  	fake.ExecutePostRebootWarningStub = stub
   273  }
   274  
   275  func (fake *FakeConstructMessenger) ExecutePostRebootWarningArgsForCall(i int) string {
   276  	fake.executePostRebootWarningMutex.RLock()
   277  	defer fake.executePostRebootWarningMutex.RUnlock()
   278  	argsForCall := fake.executePostRebootWarningArgsForCall[i]
   279  	return argsForCall.arg1
   280  }
   281  
   282  func (fake *FakeConstructMessenger) ExecuteSetupScriptStarted() {
   283  	fake.executeSetupScriptStartedMutex.Lock()
   284  	fake.executeSetupScriptStartedArgsForCall = append(fake.executeSetupScriptStartedArgsForCall, struct {
   285  	}{})
   286  	fake.recordInvocation("ExecuteSetupScriptStarted", []interface{}{})
   287  	fake.executeSetupScriptStartedMutex.Unlock()
   288  	if fake.ExecuteSetupScriptStartedStub != nil {
   289  		fake.ExecuteSetupScriptStartedStub()
   290  	}
   291  }
   292  
   293  func (fake *FakeConstructMessenger) ExecuteSetupScriptStartedCallCount() int {
   294  	fake.executeSetupScriptStartedMutex.RLock()
   295  	defer fake.executeSetupScriptStartedMutex.RUnlock()
   296  	return len(fake.executeSetupScriptStartedArgsForCall)
   297  }
   298  
   299  func (fake *FakeConstructMessenger) ExecuteSetupScriptStartedCalls(stub func()) {
   300  	fake.executeSetupScriptStartedMutex.Lock()
   301  	defer fake.executeSetupScriptStartedMutex.Unlock()
   302  	fake.ExecuteSetupScriptStartedStub = stub
   303  }
   304  
   305  func (fake *FakeConstructMessenger) ExecuteSetupScriptSucceeded() {
   306  	fake.executeSetupScriptSucceededMutex.Lock()
   307  	fake.executeSetupScriptSucceededArgsForCall = append(fake.executeSetupScriptSucceededArgsForCall, struct {
   308  	}{})
   309  	fake.recordInvocation("ExecuteSetupScriptSucceeded", []interface{}{})
   310  	fake.executeSetupScriptSucceededMutex.Unlock()
   311  	if fake.ExecuteSetupScriptSucceededStub != nil {
   312  		fake.ExecuteSetupScriptSucceededStub()
   313  	}
   314  }
   315  
   316  func (fake *FakeConstructMessenger) ExecuteSetupScriptSucceededCallCount() int {
   317  	fake.executeSetupScriptSucceededMutex.RLock()
   318  	defer fake.executeSetupScriptSucceededMutex.RUnlock()
   319  	return len(fake.executeSetupScriptSucceededArgsForCall)
   320  }
   321  
   322  func (fake *FakeConstructMessenger) ExecuteSetupScriptSucceededCalls(stub func()) {
   323  	fake.executeSetupScriptSucceededMutex.Lock()
   324  	defer fake.executeSetupScriptSucceededMutex.Unlock()
   325  	fake.ExecuteSetupScriptSucceededStub = stub
   326  }
   327  
   328  func (fake *FakeConstructMessenger) ExtractArtifactsStarted() {
   329  	fake.extractArtifactsStartedMutex.Lock()
   330  	fake.extractArtifactsStartedArgsForCall = append(fake.extractArtifactsStartedArgsForCall, struct {
   331  	}{})
   332  	fake.recordInvocation("ExtractArtifactsStarted", []interface{}{})
   333  	fake.extractArtifactsStartedMutex.Unlock()
   334  	if fake.ExtractArtifactsStartedStub != nil {
   335  		fake.ExtractArtifactsStartedStub()
   336  	}
   337  }
   338  
   339  func (fake *FakeConstructMessenger) ExtractArtifactsStartedCallCount() int {
   340  	fake.extractArtifactsStartedMutex.RLock()
   341  	defer fake.extractArtifactsStartedMutex.RUnlock()
   342  	return len(fake.extractArtifactsStartedArgsForCall)
   343  }
   344  
   345  func (fake *FakeConstructMessenger) ExtractArtifactsStartedCalls(stub func()) {
   346  	fake.extractArtifactsStartedMutex.Lock()
   347  	defer fake.extractArtifactsStartedMutex.Unlock()
   348  	fake.ExtractArtifactsStartedStub = stub
   349  }
   350  
   351  func (fake *FakeConstructMessenger) ExtractArtifactsSucceeded() {
   352  	fake.extractArtifactsSucceededMutex.Lock()
   353  	fake.extractArtifactsSucceededArgsForCall = append(fake.extractArtifactsSucceededArgsForCall, struct {
   354  	}{})
   355  	fake.recordInvocation("ExtractArtifactsSucceeded", []interface{}{})
   356  	fake.extractArtifactsSucceededMutex.Unlock()
   357  	if fake.ExtractArtifactsSucceededStub != nil {
   358  		fake.ExtractArtifactsSucceededStub()
   359  	}
   360  }
   361  
   362  func (fake *FakeConstructMessenger) ExtractArtifactsSucceededCallCount() int {
   363  	fake.extractArtifactsSucceededMutex.RLock()
   364  	defer fake.extractArtifactsSucceededMutex.RUnlock()
   365  	return len(fake.extractArtifactsSucceededArgsForCall)
   366  }
   367  
   368  func (fake *FakeConstructMessenger) ExtractArtifactsSucceededCalls(stub func()) {
   369  	fake.extractArtifactsSucceededMutex.Lock()
   370  	defer fake.extractArtifactsSucceededMutex.Unlock()
   371  	fake.ExtractArtifactsSucceededStub = stub
   372  }
   373  
   374  func (fake *FakeConstructMessenger) LogOutUsersStarted() {
   375  	fake.logOutUsersStartedMutex.Lock()
   376  	fake.logOutUsersStartedArgsForCall = append(fake.logOutUsersStartedArgsForCall, struct {
   377  	}{})
   378  	fake.recordInvocation("LogOutUsersStarted", []interface{}{})
   379  	fake.logOutUsersStartedMutex.Unlock()
   380  	if fake.LogOutUsersStartedStub != nil {
   381  		fake.LogOutUsersStartedStub()
   382  	}
   383  }
   384  
   385  func (fake *FakeConstructMessenger) LogOutUsersStartedCallCount() int {
   386  	fake.logOutUsersStartedMutex.RLock()
   387  	defer fake.logOutUsersStartedMutex.RUnlock()
   388  	return len(fake.logOutUsersStartedArgsForCall)
   389  }
   390  
   391  func (fake *FakeConstructMessenger) LogOutUsersStartedCalls(stub func()) {
   392  	fake.logOutUsersStartedMutex.Lock()
   393  	defer fake.logOutUsersStartedMutex.Unlock()
   394  	fake.LogOutUsersStartedStub = stub
   395  }
   396  
   397  func (fake *FakeConstructMessenger) LogOutUsersSucceeded() {
   398  	fake.logOutUsersSucceededMutex.Lock()
   399  	fake.logOutUsersSucceededArgsForCall = append(fake.logOutUsersSucceededArgsForCall, struct {
   400  	}{})
   401  	fake.recordInvocation("LogOutUsersSucceeded", []interface{}{})
   402  	fake.logOutUsersSucceededMutex.Unlock()
   403  	if fake.LogOutUsersSucceededStub != nil {
   404  		fake.LogOutUsersSucceededStub()
   405  	}
   406  }
   407  
   408  func (fake *FakeConstructMessenger) LogOutUsersSucceededCallCount() int {
   409  	fake.logOutUsersSucceededMutex.RLock()
   410  	defer fake.logOutUsersSucceededMutex.RUnlock()
   411  	return len(fake.logOutUsersSucceededArgsForCall)
   412  }
   413  
   414  func (fake *FakeConstructMessenger) LogOutUsersSucceededCalls(stub func()) {
   415  	fake.logOutUsersSucceededMutex.Lock()
   416  	defer fake.logOutUsersSucceededMutex.Unlock()
   417  	fake.LogOutUsersSucceededStub = stub
   418  }
   419  
   420  func (fake *FakeConstructMessenger) RebootHasFinished() {
   421  	fake.rebootHasFinishedMutex.Lock()
   422  	fake.rebootHasFinishedArgsForCall = append(fake.rebootHasFinishedArgsForCall, struct {
   423  	}{})
   424  	fake.recordInvocation("RebootHasFinished", []interface{}{})
   425  	fake.rebootHasFinishedMutex.Unlock()
   426  	if fake.RebootHasFinishedStub != nil {
   427  		fake.RebootHasFinishedStub()
   428  	}
   429  }
   430  
   431  func (fake *FakeConstructMessenger) RebootHasFinishedCallCount() int {
   432  	fake.rebootHasFinishedMutex.RLock()
   433  	defer fake.rebootHasFinishedMutex.RUnlock()
   434  	return len(fake.rebootHasFinishedArgsForCall)
   435  }
   436  
   437  func (fake *FakeConstructMessenger) RebootHasFinishedCalls(stub func()) {
   438  	fake.rebootHasFinishedMutex.Lock()
   439  	defer fake.rebootHasFinishedMutex.Unlock()
   440  	fake.RebootHasFinishedStub = stub
   441  }
   442  
   443  func (fake *FakeConstructMessenger) RebootHasStarted() {
   444  	fake.rebootHasStartedMutex.Lock()
   445  	fake.rebootHasStartedArgsForCall = append(fake.rebootHasStartedArgsForCall, struct {
   446  	}{})
   447  	fake.recordInvocation("RebootHasStarted", []interface{}{})
   448  	fake.rebootHasStartedMutex.Unlock()
   449  	if fake.RebootHasStartedStub != nil {
   450  		fake.RebootHasStartedStub()
   451  	}
   452  }
   453  
   454  func (fake *FakeConstructMessenger) RebootHasStartedCallCount() int {
   455  	fake.rebootHasStartedMutex.RLock()
   456  	defer fake.rebootHasStartedMutex.RUnlock()
   457  	return len(fake.rebootHasStartedArgsForCall)
   458  }
   459  
   460  func (fake *FakeConstructMessenger) RebootHasStartedCalls(stub func()) {
   461  	fake.rebootHasStartedMutex.Lock()
   462  	defer fake.rebootHasStartedMutex.Unlock()
   463  	fake.RebootHasStartedStub = stub
   464  }
   465  
   466  func (fake *FakeConstructMessenger) ShutdownCompleted() {
   467  	fake.shutdownCompletedMutex.Lock()
   468  	fake.shutdownCompletedArgsForCall = append(fake.shutdownCompletedArgsForCall, struct {
   469  	}{})
   470  	fake.recordInvocation("ShutdownCompleted", []interface{}{})
   471  	fake.shutdownCompletedMutex.Unlock()
   472  	if fake.ShutdownCompletedStub != nil {
   473  		fake.ShutdownCompletedStub()
   474  	}
   475  }
   476  
   477  func (fake *FakeConstructMessenger) ShutdownCompletedCallCount() int {
   478  	fake.shutdownCompletedMutex.RLock()
   479  	defer fake.shutdownCompletedMutex.RUnlock()
   480  	return len(fake.shutdownCompletedArgsForCall)
   481  }
   482  
   483  func (fake *FakeConstructMessenger) ShutdownCompletedCalls(stub func()) {
   484  	fake.shutdownCompletedMutex.Lock()
   485  	defer fake.shutdownCompletedMutex.Unlock()
   486  	fake.ShutdownCompletedStub = stub
   487  }
   488  
   489  func (fake *FakeConstructMessenger) UploadArtifactsStarted() {
   490  	fake.uploadArtifactsStartedMutex.Lock()
   491  	fake.uploadArtifactsStartedArgsForCall = append(fake.uploadArtifactsStartedArgsForCall, struct {
   492  	}{})
   493  	fake.recordInvocation("UploadArtifactsStarted", []interface{}{})
   494  	fake.uploadArtifactsStartedMutex.Unlock()
   495  	if fake.UploadArtifactsStartedStub != nil {
   496  		fake.UploadArtifactsStartedStub()
   497  	}
   498  }
   499  
   500  func (fake *FakeConstructMessenger) UploadArtifactsStartedCallCount() int {
   501  	fake.uploadArtifactsStartedMutex.RLock()
   502  	defer fake.uploadArtifactsStartedMutex.RUnlock()
   503  	return len(fake.uploadArtifactsStartedArgsForCall)
   504  }
   505  
   506  func (fake *FakeConstructMessenger) UploadArtifactsStartedCalls(stub func()) {
   507  	fake.uploadArtifactsStartedMutex.Lock()
   508  	defer fake.uploadArtifactsStartedMutex.Unlock()
   509  	fake.UploadArtifactsStartedStub = stub
   510  }
   511  
   512  func (fake *FakeConstructMessenger) UploadArtifactsSucceeded() {
   513  	fake.uploadArtifactsSucceededMutex.Lock()
   514  	fake.uploadArtifactsSucceededArgsForCall = append(fake.uploadArtifactsSucceededArgsForCall, struct {
   515  	}{})
   516  	fake.recordInvocation("UploadArtifactsSucceeded", []interface{}{})
   517  	fake.uploadArtifactsSucceededMutex.Unlock()
   518  	if fake.UploadArtifactsSucceededStub != nil {
   519  		fake.UploadArtifactsSucceededStub()
   520  	}
   521  }
   522  
   523  func (fake *FakeConstructMessenger) UploadArtifactsSucceededCallCount() int {
   524  	fake.uploadArtifactsSucceededMutex.RLock()
   525  	defer fake.uploadArtifactsSucceededMutex.RUnlock()
   526  	return len(fake.uploadArtifactsSucceededArgsForCall)
   527  }
   528  
   529  func (fake *FakeConstructMessenger) UploadArtifactsSucceededCalls(stub func()) {
   530  	fake.uploadArtifactsSucceededMutex.Lock()
   531  	defer fake.uploadArtifactsSucceededMutex.Unlock()
   532  	fake.UploadArtifactsSucceededStub = stub
   533  }
   534  
   535  func (fake *FakeConstructMessenger) UploadFileStarted(arg1 string) {
   536  	fake.uploadFileStartedMutex.Lock()
   537  	fake.uploadFileStartedArgsForCall = append(fake.uploadFileStartedArgsForCall, struct {
   538  		arg1 string
   539  	}{arg1})
   540  	fake.recordInvocation("UploadFileStarted", []interface{}{arg1})
   541  	fake.uploadFileStartedMutex.Unlock()
   542  	if fake.UploadFileStartedStub != nil {
   543  		fake.UploadFileStartedStub(arg1)
   544  	}
   545  }
   546  
   547  func (fake *FakeConstructMessenger) UploadFileStartedCallCount() int {
   548  	fake.uploadFileStartedMutex.RLock()
   549  	defer fake.uploadFileStartedMutex.RUnlock()
   550  	return len(fake.uploadFileStartedArgsForCall)
   551  }
   552  
   553  func (fake *FakeConstructMessenger) UploadFileStartedCalls(stub func(string)) {
   554  	fake.uploadFileStartedMutex.Lock()
   555  	defer fake.uploadFileStartedMutex.Unlock()
   556  	fake.UploadFileStartedStub = stub
   557  }
   558  
   559  func (fake *FakeConstructMessenger) UploadFileStartedArgsForCall(i int) string {
   560  	fake.uploadFileStartedMutex.RLock()
   561  	defer fake.uploadFileStartedMutex.RUnlock()
   562  	argsForCall := fake.uploadFileStartedArgsForCall[i]
   563  	return argsForCall.arg1
   564  }
   565  
   566  func (fake *FakeConstructMessenger) UploadFileSucceeded() {
   567  	fake.uploadFileSucceededMutex.Lock()
   568  	fake.uploadFileSucceededArgsForCall = append(fake.uploadFileSucceededArgsForCall, struct {
   569  	}{})
   570  	fake.recordInvocation("UploadFileSucceeded", []interface{}{})
   571  	fake.uploadFileSucceededMutex.Unlock()
   572  	if fake.UploadFileSucceededStub != nil {
   573  		fake.UploadFileSucceededStub()
   574  	}
   575  }
   576  
   577  func (fake *FakeConstructMessenger) UploadFileSucceededCallCount() int {
   578  	fake.uploadFileSucceededMutex.RLock()
   579  	defer fake.uploadFileSucceededMutex.RUnlock()
   580  	return len(fake.uploadFileSucceededArgsForCall)
   581  }
   582  
   583  func (fake *FakeConstructMessenger) UploadFileSucceededCalls(stub func()) {
   584  	fake.uploadFileSucceededMutex.Lock()
   585  	defer fake.uploadFileSucceededMutex.Unlock()
   586  	fake.UploadFileSucceededStub = stub
   587  }
   588  
   589  func (fake *FakeConstructMessenger) ValidateVMConnectionStarted() {
   590  	fake.validateVMConnectionStartedMutex.Lock()
   591  	fake.validateVMConnectionStartedArgsForCall = append(fake.validateVMConnectionStartedArgsForCall, struct {
   592  	}{})
   593  	fake.recordInvocation("ValidateVMConnectionStarted", []interface{}{})
   594  	fake.validateVMConnectionStartedMutex.Unlock()
   595  	if fake.ValidateVMConnectionStartedStub != nil {
   596  		fake.ValidateVMConnectionStartedStub()
   597  	}
   598  }
   599  
   600  func (fake *FakeConstructMessenger) ValidateVMConnectionStartedCallCount() int {
   601  	fake.validateVMConnectionStartedMutex.RLock()
   602  	defer fake.validateVMConnectionStartedMutex.RUnlock()
   603  	return len(fake.validateVMConnectionStartedArgsForCall)
   604  }
   605  
   606  func (fake *FakeConstructMessenger) ValidateVMConnectionStartedCalls(stub func()) {
   607  	fake.validateVMConnectionStartedMutex.Lock()
   608  	defer fake.validateVMConnectionStartedMutex.Unlock()
   609  	fake.ValidateVMConnectionStartedStub = stub
   610  }
   611  
   612  func (fake *FakeConstructMessenger) ValidateVMConnectionSucceeded() {
   613  	fake.validateVMConnectionSucceededMutex.Lock()
   614  	fake.validateVMConnectionSucceededArgsForCall = append(fake.validateVMConnectionSucceededArgsForCall, struct {
   615  	}{})
   616  	fake.recordInvocation("ValidateVMConnectionSucceeded", []interface{}{})
   617  	fake.validateVMConnectionSucceededMutex.Unlock()
   618  	if fake.ValidateVMConnectionSucceededStub != nil {
   619  		fake.ValidateVMConnectionSucceededStub()
   620  	}
   621  }
   622  
   623  func (fake *FakeConstructMessenger) ValidateVMConnectionSucceededCallCount() int {
   624  	fake.validateVMConnectionSucceededMutex.RLock()
   625  	defer fake.validateVMConnectionSucceededMutex.RUnlock()
   626  	return len(fake.validateVMConnectionSucceededArgsForCall)
   627  }
   628  
   629  func (fake *FakeConstructMessenger) ValidateVMConnectionSucceededCalls(stub func()) {
   630  	fake.validateVMConnectionSucceededMutex.Lock()
   631  	defer fake.validateVMConnectionSucceededMutex.Unlock()
   632  	fake.ValidateVMConnectionSucceededStub = stub
   633  }
   634  
   635  func (fake *FakeConstructMessenger) WaitingForShutdown() {
   636  	fake.waitingForShutdownMutex.Lock()
   637  	fake.waitingForShutdownArgsForCall = append(fake.waitingForShutdownArgsForCall, struct {
   638  	}{})
   639  	fake.recordInvocation("WaitingForShutdown", []interface{}{})
   640  	fake.waitingForShutdownMutex.Unlock()
   641  	if fake.WaitingForShutdownStub != nil {
   642  		fake.WaitingForShutdownStub()
   643  	}
   644  }
   645  
   646  func (fake *FakeConstructMessenger) WaitingForShutdownCallCount() int {
   647  	fake.waitingForShutdownMutex.RLock()
   648  	defer fake.waitingForShutdownMutex.RUnlock()
   649  	return len(fake.waitingForShutdownArgsForCall)
   650  }
   651  
   652  func (fake *FakeConstructMessenger) WaitingForShutdownCalls(stub func()) {
   653  	fake.waitingForShutdownMutex.Lock()
   654  	defer fake.waitingForShutdownMutex.Unlock()
   655  	fake.WaitingForShutdownStub = stub
   656  }
   657  
   658  func (fake *FakeConstructMessenger) WinRMDisconnectedForReboot() {
   659  	fake.winRMDisconnectedForRebootMutex.Lock()
   660  	fake.winRMDisconnectedForRebootArgsForCall = append(fake.winRMDisconnectedForRebootArgsForCall, struct {
   661  	}{})
   662  	fake.recordInvocation("WinRMDisconnectedForReboot", []interface{}{})
   663  	fake.winRMDisconnectedForRebootMutex.Unlock()
   664  	if fake.WinRMDisconnectedForRebootStub != nil {
   665  		fake.WinRMDisconnectedForRebootStub()
   666  	}
   667  }
   668  
   669  func (fake *FakeConstructMessenger) WinRMDisconnectedForRebootCallCount() int {
   670  	fake.winRMDisconnectedForRebootMutex.RLock()
   671  	defer fake.winRMDisconnectedForRebootMutex.RUnlock()
   672  	return len(fake.winRMDisconnectedForRebootArgsForCall)
   673  }
   674  
   675  func (fake *FakeConstructMessenger) WinRMDisconnectedForRebootCalls(stub func()) {
   676  	fake.winRMDisconnectedForRebootMutex.Lock()
   677  	defer fake.winRMDisconnectedForRebootMutex.Unlock()
   678  	fake.WinRMDisconnectedForRebootStub = stub
   679  }
   680  
   681  func (fake *FakeConstructMessenger) Invocations() map[string][][]interface{} {
   682  	fake.invocationsMutex.RLock()
   683  	defer fake.invocationsMutex.RUnlock()
   684  	fake.createProvisionDirStartedMutex.RLock()
   685  	defer fake.createProvisionDirStartedMutex.RUnlock()
   686  	fake.createProvisionDirSucceededMutex.RLock()
   687  	defer fake.createProvisionDirSucceededMutex.RUnlock()
   688  	fake.enableWinRMStartedMutex.RLock()
   689  	defer fake.enableWinRMStartedMutex.RUnlock()
   690  	fake.enableWinRMSucceededMutex.RLock()
   691  	defer fake.enableWinRMSucceededMutex.RUnlock()
   692  	fake.executePostRebootScriptStartedMutex.RLock()
   693  	defer fake.executePostRebootScriptStartedMutex.RUnlock()
   694  	fake.executePostRebootScriptSucceededMutex.RLock()
   695  	defer fake.executePostRebootScriptSucceededMutex.RUnlock()
   696  	fake.executePostRebootWarningMutex.RLock()
   697  	defer fake.executePostRebootWarningMutex.RUnlock()
   698  	fake.executeSetupScriptStartedMutex.RLock()
   699  	defer fake.executeSetupScriptStartedMutex.RUnlock()
   700  	fake.executeSetupScriptSucceededMutex.RLock()
   701  	defer fake.executeSetupScriptSucceededMutex.RUnlock()
   702  	fake.extractArtifactsStartedMutex.RLock()
   703  	defer fake.extractArtifactsStartedMutex.RUnlock()
   704  	fake.extractArtifactsSucceededMutex.RLock()
   705  	defer fake.extractArtifactsSucceededMutex.RUnlock()
   706  	fake.logOutUsersStartedMutex.RLock()
   707  	defer fake.logOutUsersStartedMutex.RUnlock()
   708  	fake.logOutUsersSucceededMutex.RLock()
   709  	defer fake.logOutUsersSucceededMutex.RUnlock()
   710  	fake.rebootHasFinishedMutex.RLock()
   711  	defer fake.rebootHasFinishedMutex.RUnlock()
   712  	fake.rebootHasStartedMutex.RLock()
   713  	defer fake.rebootHasStartedMutex.RUnlock()
   714  	fake.shutdownCompletedMutex.RLock()
   715  	defer fake.shutdownCompletedMutex.RUnlock()
   716  	fake.uploadArtifactsStartedMutex.RLock()
   717  	defer fake.uploadArtifactsStartedMutex.RUnlock()
   718  	fake.uploadArtifactsSucceededMutex.RLock()
   719  	defer fake.uploadArtifactsSucceededMutex.RUnlock()
   720  	fake.uploadFileStartedMutex.RLock()
   721  	defer fake.uploadFileStartedMutex.RUnlock()
   722  	fake.uploadFileSucceededMutex.RLock()
   723  	defer fake.uploadFileSucceededMutex.RUnlock()
   724  	fake.validateVMConnectionStartedMutex.RLock()
   725  	defer fake.validateVMConnectionStartedMutex.RUnlock()
   726  	fake.validateVMConnectionSucceededMutex.RLock()
   727  	defer fake.validateVMConnectionSucceededMutex.RUnlock()
   728  	fake.waitingForShutdownMutex.RLock()
   729  	defer fake.waitingForShutdownMutex.RUnlock()
   730  	fake.winRMDisconnectedForRebootMutex.RLock()
   731  	defer fake.winRMDisconnectedForRebootMutex.RUnlock()
   732  	copiedInvocations := map[string][][]interface{}{}
   733  	for key, value := range fake.invocations {
   734  		copiedInvocations[key] = value
   735  	}
   736  	return copiedInvocations
   737  }
   738  
   739  func (fake *FakeConstructMessenger) recordInvocation(key string, args []interface{}) {
   740  	fake.invocationsMutex.Lock()
   741  	defer fake.invocationsMutex.Unlock()
   742  	if fake.invocations == nil {
   743  		fake.invocations = map[string][][]interface{}{}
   744  	}
   745  	if fake.invocations[key] == nil {
   746  		fake.invocations[key] = [][]interface{}{}
   747  	}
   748  	fake.invocations[key] = append(fake.invocations[key], args)
   749  }
   750  
   751  var _ construct.ConstructMessenger = new(FakeConstructMessenger)