github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/exec/execfakes/fake_get_delegate.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package execfakes
     3  
     4  import (
     5  	"context"
     6  	"io"
     7  	"sync"
     8  
     9  	"code.cloudfoundry.org/lager"
    10  	"github.com/pf-qiu/concourse/v6/atc"
    11  	"github.com/pf-qiu/concourse/v6/atc/exec"
    12  	"github.com/pf-qiu/concourse/v6/atc/runtime"
    13  	"github.com/pf-qiu/concourse/v6/atc/worker"
    14  	"github.com/pf-qiu/concourse/v6/tracing"
    15  	"go.opentelemetry.io/otel/api/trace"
    16  )
    17  
    18  type FakeGetDelegate struct {
    19  	ErroredStub        func(lager.Logger, string)
    20  	erroredMutex       sync.RWMutex
    21  	erroredArgsForCall []struct {
    22  		arg1 lager.Logger
    23  		arg2 string
    24  	}
    25  	FetchImageStub        func(context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) (worker.ImageSpec, error)
    26  	fetchImageMutex       sync.RWMutex
    27  	fetchImageArgsForCall []struct {
    28  		arg1 context.Context
    29  		arg2 atc.ImageResource
    30  		arg3 atc.VersionedResourceTypes
    31  		arg4 bool
    32  	}
    33  	fetchImageReturns struct {
    34  		result1 worker.ImageSpec
    35  		result2 error
    36  	}
    37  	fetchImageReturnsOnCall map[int]struct {
    38  		result1 worker.ImageSpec
    39  		result2 error
    40  	}
    41  	FinishedStub        func(lager.Logger, exec.ExitStatus, runtime.VersionResult)
    42  	finishedMutex       sync.RWMutex
    43  	finishedArgsForCall []struct {
    44  		arg1 lager.Logger
    45  		arg2 exec.ExitStatus
    46  		arg3 runtime.VersionResult
    47  	}
    48  	InitializingStub        func(lager.Logger)
    49  	initializingMutex       sync.RWMutex
    50  	initializingArgsForCall []struct {
    51  		arg1 lager.Logger
    52  	}
    53  	SelectedWorkerStub        func(lager.Logger, string)
    54  	selectedWorkerMutex       sync.RWMutex
    55  	selectedWorkerArgsForCall []struct {
    56  		arg1 lager.Logger
    57  		arg2 string
    58  	}
    59  	StartSpanStub        func(context.Context, string, tracing.Attrs) (context.Context, trace.Span)
    60  	startSpanMutex       sync.RWMutex
    61  	startSpanArgsForCall []struct {
    62  		arg1 context.Context
    63  		arg2 string
    64  		arg3 tracing.Attrs
    65  	}
    66  	startSpanReturns struct {
    67  		result1 context.Context
    68  		result2 trace.Span
    69  	}
    70  	startSpanReturnsOnCall map[int]struct {
    71  		result1 context.Context
    72  		result2 trace.Span
    73  	}
    74  	StartingStub        func(lager.Logger)
    75  	startingMutex       sync.RWMutex
    76  	startingArgsForCall []struct {
    77  		arg1 lager.Logger
    78  	}
    79  	StderrStub        func() io.Writer
    80  	stderrMutex       sync.RWMutex
    81  	stderrArgsForCall []struct {
    82  	}
    83  	stderrReturns struct {
    84  		result1 io.Writer
    85  	}
    86  	stderrReturnsOnCall map[int]struct {
    87  		result1 io.Writer
    88  	}
    89  	StdoutStub        func() io.Writer
    90  	stdoutMutex       sync.RWMutex
    91  	stdoutArgsForCall []struct {
    92  	}
    93  	stdoutReturns struct {
    94  		result1 io.Writer
    95  	}
    96  	stdoutReturnsOnCall map[int]struct {
    97  		result1 io.Writer
    98  	}
    99  	UpdateVersionStub        func(lager.Logger, atc.GetPlan, runtime.VersionResult)
   100  	updateVersionMutex       sync.RWMutex
   101  	updateVersionArgsForCall []struct {
   102  		arg1 lager.Logger
   103  		arg2 atc.GetPlan
   104  		arg3 runtime.VersionResult
   105  	}
   106  	invocations      map[string][][]interface{}
   107  	invocationsMutex sync.RWMutex
   108  }
   109  
   110  func (fake *FakeGetDelegate) Errored(arg1 lager.Logger, arg2 string) {
   111  	fake.erroredMutex.Lock()
   112  	fake.erroredArgsForCall = append(fake.erroredArgsForCall, struct {
   113  		arg1 lager.Logger
   114  		arg2 string
   115  	}{arg1, arg2})
   116  	fake.recordInvocation("Errored", []interface{}{arg1, arg2})
   117  	fake.erroredMutex.Unlock()
   118  	if fake.ErroredStub != nil {
   119  		fake.ErroredStub(arg1, arg2)
   120  	}
   121  }
   122  
   123  func (fake *FakeGetDelegate) ErroredCallCount() int {
   124  	fake.erroredMutex.RLock()
   125  	defer fake.erroredMutex.RUnlock()
   126  	return len(fake.erroredArgsForCall)
   127  }
   128  
   129  func (fake *FakeGetDelegate) ErroredCalls(stub func(lager.Logger, string)) {
   130  	fake.erroredMutex.Lock()
   131  	defer fake.erroredMutex.Unlock()
   132  	fake.ErroredStub = stub
   133  }
   134  
   135  func (fake *FakeGetDelegate) ErroredArgsForCall(i int) (lager.Logger, string) {
   136  	fake.erroredMutex.RLock()
   137  	defer fake.erroredMutex.RUnlock()
   138  	argsForCall := fake.erroredArgsForCall[i]
   139  	return argsForCall.arg1, argsForCall.arg2
   140  }
   141  
   142  func (fake *FakeGetDelegate) FetchImage(arg1 context.Context, arg2 atc.ImageResource, arg3 atc.VersionedResourceTypes, arg4 bool) (worker.ImageSpec, error) {
   143  	fake.fetchImageMutex.Lock()
   144  	ret, specificReturn := fake.fetchImageReturnsOnCall[len(fake.fetchImageArgsForCall)]
   145  	fake.fetchImageArgsForCall = append(fake.fetchImageArgsForCall, struct {
   146  		arg1 context.Context
   147  		arg2 atc.ImageResource
   148  		arg3 atc.VersionedResourceTypes
   149  		arg4 bool
   150  	}{arg1, arg2, arg3, arg4})
   151  	fake.recordInvocation("FetchImage", []interface{}{arg1, arg2, arg3, arg4})
   152  	fake.fetchImageMutex.Unlock()
   153  	if fake.FetchImageStub != nil {
   154  		return fake.FetchImageStub(arg1, arg2, arg3, arg4)
   155  	}
   156  	if specificReturn {
   157  		return ret.result1, ret.result2
   158  	}
   159  	fakeReturns := fake.fetchImageReturns
   160  	return fakeReturns.result1, fakeReturns.result2
   161  }
   162  
   163  func (fake *FakeGetDelegate) FetchImageCallCount() int {
   164  	fake.fetchImageMutex.RLock()
   165  	defer fake.fetchImageMutex.RUnlock()
   166  	return len(fake.fetchImageArgsForCall)
   167  }
   168  
   169  func (fake *FakeGetDelegate) FetchImageCalls(stub func(context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) (worker.ImageSpec, error)) {
   170  	fake.fetchImageMutex.Lock()
   171  	defer fake.fetchImageMutex.Unlock()
   172  	fake.FetchImageStub = stub
   173  }
   174  
   175  func (fake *FakeGetDelegate) FetchImageArgsForCall(i int) (context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) {
   176  	fake.fetchImageMutex.RLock()
   177  	defer fake.fetchImageMutex.RUnlock()
   178  	argsForCall := fake.fetchImageArgsForCall[i]
   179  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
   180  }
   181  
   182  func (fake *FakeGetDelegate) FetchImageReturns(result1 worker.ImageSpec, result2 error) {
   183  	fake.fetchImageMutex.Lock()
   184  	defer fake.fetchImageMutex.Unlock()
   185  	fake.FetchImageStub = nil
   186  	fake.fetchImageReturns = struct {
   187  		result1 worker.ImageSpec
   188  		result2 error
   189  	}{result1, result2}
   190  }
   191  
   192  func (fake *FakeGetDelegate) FetchImageReturnsOnCall(i int, result1 worker.ImageSpec, result2 error) {
   193  	fake.fetchImageMutex.Lock()
   194  	defer fake.fetchImageMutex.Unlock()
   195  	fake.FetchImageStub = nil
   196  	if fake.fetchImageReturnsOnCall == nil {
   197  		fake.fetchImageReturnsOnCall = make(map[int]struct {
   198  			result1 worker.ImageSpec
   199  			result2 error
   200  		})
   201  	}
   202  	fake.fetchImageReturnsOnCall[i] = struct {
   203  		result1 worker.ImageSpec
   204  		result2 error
   205  	}{result1, result2}
   206  }
   207  
   208  func (fake *FakeGetDelegate) Finished(arg1 lager.Logger, arg2 exec.ExitStatus, arg3 runtime.VersionResult) {
   209  	fake.finishedMutex.Lock()
   210  	fake.finishedArgsForCall = append(fake.finishedArgsForCall, struct {
   211  		arg1 lager.Logger
   212  		arg2 exec.ExitStatus
   213  		arg3 runtime.VersionResult
   214  	}{arg1, arg2, arg3})
   215  	fake.recordInvocation("Finished", []interface{}{arg1, arg2, arg3})
   216  	fake.finishedMutex.Unlock()
   217  	if fake.FinishedStub != nil {
   218  		fake.FinishedStub(arg1, arg2, arg3)
   219  	}
   220  }
   221  
   222  func (fake *FakeGetDelegate) FinishedCallCount() int {
   223  	fake.finishedMutex.RLock()
   224  	defer fake.finishedMutex.RUnlock()
   225  	return len(fake.finishedArgsForCall)
   226  }
   227  
   228  func (fake *FakeGetDelegate) FinishedCalls(stub func(lager.Logger, exec.ExitStatus, runtime.VersionResult)) {
   229  	fake.finishedMutex.Lock()
   230  	defer fake.finishedMutex.Unlock()
   231  	fake.FinishedStub = stub
   232  }
   233  
   234  func (fake *FakeGetDelegate) FinishedArgsForCall(i int) (lager.Logger, exec.ExitStatus, runtime.VersionResult) {
   235  	fake.finishedMutex.RLock()
   236  	defer fake.finishedMutex.RUnlock()
   237  	argsForCall := fake.finishedArgsForCall[i]
   238  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
   239  }
   240  
   241  func (fake *FakeGetDelegate) Initializing(arg1 lager.Logger) {
   242  	fake.initializingMutex.Lock()
   243  	fake.initializingArgsForCall = append(fake.initializingArgsForCall, struct {
   244  		arg1 lager.Logger
   245  	}{arg1})
   246  	fake.recordInvocation("Initializing", []interface{}{arg1})
   247  	fake.initializingMutex.Unlock()
   248  	if fake.InitializingStub != nil {
   249  		fake.InitializingStub(arg1)
   250  	}
   251  }
   252  
   253  func (fake *FakeGetDelegate) InitializingCallCount() int {
   254  	fake.initializingMutex.RLock()
   255  	defer fake.initializingMutex.RUnlock()
   256  	return len(fake.initializingArgsForCall)
   257  }
   258  
   259  func (fake *FakeGetDelegate) InitializingCalls(stub func(lager.Logger)) {
   260  	fake.initializingMutex.Lock()
   261  	defer fake.initializingMutex.Unlock()
   262  	fake.InitializingStub = stub
   263  }
   264  
   265  func (fake *FakeGetDelegate) InitializingArgsForCall(i int) lager.Logger {
   266  	fake.initializingMutex.RLock()
   267  	defer fake.initializingMutex.RUnlock()
   268  	argsForCall := fake.initializingArgsForCall[i]
   269  	return argsForCall.arg1
   270  }
   271  
   272  func (fake *FakeGetDelegate) SelectedWorker(arg1 lager.Logger, arg2 string) {
   273  	fake.selectedWorkerMutex.Lock()
   274  	fake.selectedWorkerArgsForCall = append(fake.selectedWorkerArgsForCall, struct {
   275  		arg1 lager.Logger
   276  		arg2 string
   277  	}{arg1, arg2})
   278  	fake.recordInvocation("SelectedWorker", []interface{}{arg1, arg2})
   279  	fake.selectedWorkerMutex.Unlock()
   280  	if fake.SelectedWorkerStub != nil {
   281  		fake.SelectedWorkerStub(arg1, arg2)
   282  	}
   283  }
   284  
   285  func (fake *FakeGetDelegate) SelectedWorkerCallCount() int {
   286  	fake.selectedWorkerMutex.RLock()
   287  	defer fake.selectedWorkerMutex.RUnlock()
   288  	return len(fake.selectedWorkerArgsForCall)
   289  }
   290  
   291  func (fake *FakeGetDelegate) SelectedWorkerCalls(stub func(lager.Logger, string)) {
   292  	fake.selectedWorkerMutex.Lock()
   293  	defer fake.selectedWorkerMutex.Unlock()
   294  	fake.SelectedWorkerStub = stub
   295  }
   296  
   297  func (fake *FakeGetDelegate) SelectedWorkerArgsForCall(i int) (lager.Logger, string) {
   298  	fake.selectedWorkerMutex.RLock()
   299  	defer fake.selectedWorkerMutex.RUnlock()
   300  	argsForCall := fake.selectedWorkerArgsForCall[i]
   301  	return argsForCall.arg1, argsForCall.arg2
   302  }
   303  
   304  func (fake *FakeGetDelegate) StartSpan(arg1 context.Context, arg2 string, arg3 tracing.Attrs) (context.Context, trace.Span) {
   305  	fake.startSpanMutex.Lock()
   306  	ret, specificReturn := fake.startSpanReturnsOnCall[len(fake.startSpanArgsForCall)]
   307  	fake.startSpanArgsForCall = append(fake.startSpanArgsForCall, struct {
   308  		arg1 context.Context
   309  		arg2 string
   310  		arg3 tracing.Attrs
   311  	}{arg1, arg2, arg3})
   312  	fake.recordInvocation("StartSpan", []interface{}{arg1, arg2, arg3})
   313  	fake.startSpanMutex.Unlock()
   314  	if fake.StartSpanStub != nil {
   315  		return fake.StartSpanStub(arg1, arg2, arg3)
   316  	}
   317  	if specificReturn {
   318  		return ret.result1, ret.result2
   319  	}
   320  	fakeReturns := fake.startSpanReturns
   321  	return fakeReturns.result1, fakeReturns.result2
   322  }
   323  
   324  func (fake *FakeGetDelegate) StartSpanCallCount() int {
   325  	fake.startSpanMutex.RLock()
   326  	defer fake.startSpanMutex.RUnlock()
   327  	return len(fake.startSpanArgsForCall)
   328  }
   329  
   330  func (fake *FakeGetDelegate) StartSpanCalls(stub func(context.Context, string, tracing.Attrs) (context.Context, trace.Span)) {
   331  	fake.startSpanMutex.Lock()
   332  	defer fake.startSpanMutex.Unlock()
   333  	fake.StartSpanStub = stub
   334  }
   335  
   336  func (fake *FakeGetDelegate) StartSpanArgsForCall(i int) (context.Context, string, tracing.Attrs) {
   337  	fake.startSpanMutex.RLock()
   338  	defer fake.startSpanMutex.RUnlock()
   339  	argsForCall := fake.startSpanArgsForCall[i]
   340  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
   341  }
   342  
   343  func (fake *FakeGetDelegate) StartSpanReturns(result1 context.Context, result2 trace.Span) {
   344  	fake.startSpanMutex.Lock()
   345  	defer fake.startSpanMutex.Unlock()
   346  	fake.StartSpanStub = nil
   347  	fake.startSpanReturns = struct {
   348  		result1 context.Context
   349  		result2 trace.Span
   350  	}{result1, result2}
   351  }
   352  
   353  func (fake *FakeGetDelegate) StartSpanReturnsOnCall(i int, result1 context.Context, result2 trace.Span) {
   354  	fake.startSpanMutex.Lock()
   355  	defer fake.startSpanMutex.Unlock()
   356  	fake.StartSpanStub = nil
   357  	if fake.startSpanReturnsOnCall == nil {
   358  		fake.startSpanReturnsOnCall = make(map[int]struct {
   359  			result1 context.Context
   360  			result2 trace.Span
   361  		})
   362  	}
   363  	fake.startSpanReturnsOnCall[i] = struct {
   364  		result1 context.Context
   365  		result2 trace.Span
   366  	}{result1, result2}
   367  }
   368  
   369  func (fake *FakeGetDelegate) Starting(arg1 lager.Logger) {
   370  	fake.startingMutex.Lock()
   371  	fake.startingArgsForCall = append(fake.startingArgsForCall, struct {
   372  		arg1 lager.Logger
   373  	}{arg1})
   374  	fake.recordInvocation("Starting", []interface{}{arg1})
   375  	fake.startingMutex.Unlock()
   376  	if fake.StartingStub != nil {
   377  		fake.StartingStub(arg1)
   378  	}
   379  }
   380  
   381  func (fake *FakeGetDelegate) StartingCallCount() int {
   382  	fake.startingMutex.RLock()
   383  	defer fake.startingMutex.RUnlock()
   384  	return len(fake.startingArgsForCall)
   385  }
   386  
   387  func (fake *FakeGetDelegate) StartingCalls(stub func(lager.Logger)) {
   388  	fake.startingMutex.Lock()
   389  	defer fake.startingMutex.Unlock()
   390  	fake.StartingStub = stub
   391  }
   392  
   393  func (fake *FakeGetDelegate) StartingArgsForCall(i int) lager.Logger {
   394  	fake.startingMutex.RLock()
   395  	defer fake.startingMutex.RUnlock()
   396  	argsForCall := fake.startingArgsForCall[i]
   397  	return argsForCall.arg1
   398  }
   399  
   400  func (fake *FakeGetDelegate) Stderr() io.Writer {
   401  	fake.stderrMutex.Lock()
   402  	ret, specificReturn := fake.stderrReturnsOnCall[len(fake.stderrArgsForCall)]
   403  	fake.stderrArgsForCall = append(fake.stderrArgsForCall, struct {
   404  	}{})
   405  	fake.recordInvocation("Stderr", []interface{}{})
   406  	fake.stderrMutex.Unlock()
   407  	if fake.StderrStub != nil {
   408  		return fake.StderrStub()
   409  	}
   410  	if specificReturn {
   411  		return ret.result1
   412  	}
   413  	fakeReturns := fake.stderrReturns
   414  	return fakeReturns.result1
   415  }
   416  
   417  func (fake *FakeGetDelegate) StderrCallCount() int {
   418  	fake.stderrMutex.RLock()
   419  	defer fake.stderrMutex.RUnlock()
   420  	return len(fake.stderrArgsForCall)
   421  }
   422  
   423  func (fake *FakeGetDelegate) StderrCalls(stub func() io.Writer) {
   424  	fake.stderrMutex.Lock()
   425  	defer fake.stderrMutex.Unlock()
   426  	fake.StderrStub = stub
   427  }
   428  
   429  func (fake *FakeGetDelegate) StderrReturns(result1 io.Writer) {
   430  	fake.stderrMutex.Lock()
   431  	defer fake.stderrMutex.Unlock()
   432  	fake.StderrStub = nil
   433  	fake.stderrReturns = struct {
   434  		result1 io.Writer
   435  	}{result1}
   436  }
   437  
   438  func (fake *FakeGetDelegate) StderrReturnsOnCall(i int, result1 io.Writer) {
   439  	fake.stderrMutex.Lock()
   440  	defer fake.stderrMutex.Unlock()
   441  	fake.StderrStub = nil
   442  	if fake.stderrReturnsOnCall == nil {
   443  		fake.stderrReturnsOnCall = make(map[int]struct {
   444  			result1 io.Writer
   445  		})
   446  	}
   447  	fake.stderrReturnsOnCall[i] = struct {
   448  		result1 io.Writer
   449  	}{result1}
   450  }
   451  
   452  func (fake *FakeGetDelegate) Stdout() io.Writer {
   453  	fake.stdoutMutex.Lock()
   454  	ret, specificReturn := fake.stdoutReturnsOnCall[len(fake.stdoutArgsForCall)]
   455  	fake.stdoutArgsForCall = append(fake.stdoutArgsForCall, struct {
   456  	}{})
   457  	fake.recordInvocation("Stdout", []interface{}{})
   458  	fake.stdoutMutex.Unlock()
   459  	if fake.StdoutStub != nil {
   460  		return fake.StdoutStub()
   461  	}
   462  	if specificReturn {
   463  		return ret.result1
   464  	}
   465  	fakeReturns := fake.stdoutReturns
   466  	return fakeReturns.result1
   467  }
   468  
   469  func (fake *FakeGetDelegate) StdoutCallCount() int {
   470  	fake.stdoutMutex.RLock()
   471  	defer fake.stdoutMutex.RUnlock()
   472  	return len(fake.stdoutArgsForCall)
   473  }
   474  
   475  func (fake *FakeGetDelegate) StdoutCalls(stub func() io.Writer) {
   476  	fake.stdoutMutex.Lock()
   477  	defer fake.stdoutMutex.Unlock()
   478  	fake.StdoutStub = stub
   479  }
   480  
   481  func (fake *FakeGetDelegate) StdoutReturns(result1 io.Writer) {
   482  	fake.stdoutMutex.Lock()
   483  	defer fake.stdoutMutex.Unlock()
   484  	fake.StdoutStub = nil
   485  	fake.stdoutReturns = struct {
   486  		result1 io.Writer
   487  	}{result1}
   488  }
   489  
   490  func (fake *FakeGetDelegate) StdoutReturnsOnCall(i int, result1 io.Writer) {
   491  	fake.stdoutMutex.Lock()
   492  	defer fake.stdoutMutex.Unlock()
   493  	fake.StdoutStub = nil
   494  	if fake.stdoutReturnsOnCall == nil {
   495  		fake.stdoutReturnsOnCall = make(map[int]struct {
   496  			result1 io.Writer
   497  		})
   498  	}
   499  	fake.stdoutReturnsOnCall[i] = struct {
   500  		result1 io.Writer
   501  	}{result1}
   502  }
   503  
   504  func (fake *FakeGetDelegate) UpdateVersion(arg1 lager.Logger, arg2 atc.GetPlan, arg3 runtime.VersionResult) {
   505  	fake.updateVersionMutex.Lock()
   506  	fake.updateVersionArgsForCall = append(fake.updateVersionArgsForCall, struct {
   507  		arg1 lager.Logger
   508  		arg2 atc.GetPlan
   509  		arg3 runtime.VersionResult
   510  	}{arg1, arg2, arg3})
   511  	fake.recordInvocation("UpdateVersion", []interface{}{arg1, arg2, arg3})
   512  	fake.updateVersionMutex.Unlock()
   513  	if fake.UpdateVersionStub != nil {
   514  		fake.UpdateVersionStub(arg1, arg2, arg3)
   515  	}
   516  }
   517  
   518  func (fake *FakeGetDelegate) UpdateVersionCallCount() int {
   519  	fake.updateVersionMutex.RLock()
   520  	defer fake.updateVersionMutex.RUnlock()
   521  	return len(fake.updateVersionArgsForCall)
   522  }
   523  
   524  func (fake *FakeGetDelegate) UpdateVersionCalls(stub func(lager.Logger, atc.GetPlan, runtime.VersionResult)) {
   525  	fake.updateVersionMutex.Lock()
   526  	defer fake.updateVersionMutex.Unlock()
   527  	fake.UpdateVersionStub = stub
   528  }
   529  
   530  func (fake *FakeGetDelegate) UpdateVersionArgsForCall(i int) (lager.Logger, atc.GetPlan, runtime.VersionResult) {
   531  	fake.updateVersionMutex.RLock()
   532  	defer fake.updateVersionMutex.RUnlock()
   533  	argsForCall := fake.updateVersionArgsForCall[i]
   534  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
   535  }
   536  
   537  func (fake *FakeGetDelegate) Invocations() map[string][][]interface{} {
   538  	fake.invocationsMutex.RLock()
   539  	defer fake.invocationsMutex.RUnlock()
   540  	fake.erroredMutex.RLock()
   541  	defer fake.erroredMutex.RUnlock()
   542  	fake.fetchImageMutex.RLock()
   543  	defer fake.fetchImageMutex.RUnlock()
   544  	fake.finishedMutex.RLock()
   545  	defer fake.finishedMutex.RUnlock()
   546  	fake.initializingMutex.RLock()
   547  	defer fake.initializingMutex.RUnlock()
   548  	fake.selectedWorkerMutex.RLock()
   549  	defer fake.selectedWorkerMutex.RUnlock()
   550  	fake.startSpanMutex.RLock()
   551  	defer fake.startSpanMutex.RUnlock()
   552  	fake.startingMutex.RLock()
   553  	defer fake.startingMutex.RUnlock()
   554  	fake.stderrMutex.RLock()
   555  	defer fake.stderrMutex.RUnlock()
   556  	fake.stdoutMutex.RLock()
   557  	defer fake.stdoutMutex.RUnlock()
   558  	fake.updateVersionMutex.RLock()
   559  	defer fake.updateVersionMutex.RUnlock()
   560  	copiedInvocations := map[string][][]interface{}{}
   561  	for key, value := range fake.invocations {
   562  		copiedInvocations[key] = value
   563  	}
   564  	return copiedInvocations
   565  }
   566  
   567  func (fake *FakeGetDelegate) recordInvocation(key string, args []interface{}) {
   568  	fake.invocationsMutex.Lock()
   569  	defer fake.invocationsMutex.Unlock()
   570  	if fake.invocations == nil {
   571  		fake.invocations = map[string][][]interface{}{}
   572  	}
   573  	if fake.invocations[key] == nil {
   574  		fake.invocations[key] = [][]interface{}{}
   575  	}
   576  	fake.invocations[key] = append(fake.invocations[key], args)
   577  }
   578  
   579  var _ exec.GetDelegate = new(FakeGetDelegate)