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