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