github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/compression/compressionfakes/fake_compression.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package compressionfakes
     3  
     4  import (
     5  	"io"
     6  	"sync"
     7  
     8  	"github.com/concourse/baggageclaim"
     9  	"github.com/pf-qiu/concourse/v6/atc/compression"
    10  )
    11  
    12  type FakeCompression struct {
    13  	EncodingStub        func() baggageclaim.Encoding
    14  	encodingMutex       sync.RWMutex
    15  	encodingArgsForCall []struct {
    16  	}
    17  	encodingReturns struct {
    18  		result1 baggageclaim.Encoding
    19  	}
    20  	encodingReturnsOnCall map[int]struct {
    21  		result1 baggageclaim.Encoding
    22  	}
    23  	NewReaderStub        func(io.ReadCloser) (io.ReadCloser, error)
    24  	newReaderMutex       sync.RWMutex
    25  	newReaderArgsForCall []struct {
    26  		arg1 io.ReadCloser
    27  	}
    28  	newReaderReturns struct {
    29  		result1 io.ReadCloser
    30  		result2 error
    31  	}
    32  	newReaderReturnsOnCall map[int]struct {
    33  		result1 io.ReadCloser
    34  		result2 error
    35  	}
    36  	invocations      map[string][][]interface{}
    37  	invocationsMutex sync.RWMutex
    38  }
    39  
    40  func (fake *FakeCompression) Encoding() baggageclaim.Encoding {
    41  	fake.encodingMutex.Lock()
    42  	ret, specificReturn := fake.encodingReturnsOnCall[len(fake.encodingArgsForCall)]
    43  	fake.encodingArgsForCall = append(fake.encodingArgsForCall, struct {
    44  	}{})
    45  	fake.recordInvocation("Encoding", []interface{}{})
    46  	fake.encodingMutex.Unlock()
    47  	if fake.EncodingStub != nil {
    48  		return fake.EncodingStub()
    49  	}
    50  	if specificReturn {
    51  		return ret.result1
    52  	}
    53  	fakeReturns := fake.encodingReturns
    54  	return fakeReturns.result1
    55  }
    56  
    57  func (fake *FakeCompression) EncodingCallCount() int {
    58  	fake.encodingMutex.RLock()
    59  	defer fake.encodingMutex.RUnlock()
    60  	return len(fake.encodingArgsForCall)
    61  }
    62  
    63  func (fake *FakeCompression) EncodingCalls(stub func() baggageclaim.Encoding) {
    64  	fake.encodingMutex.Lock()
    65  	defer fake.encodingMutex.Unlock()
    66  	fake.EncodingStub = stub
    67  }
    68  
    69  func (fake *FakeCompression) EncodingReturns(result1 baggageclaim.Encoding) {
    70  	fake.encodingMutex.Lock()
    71  	defer fake.encodingMutex.Unlock()
    72  	fake.EncodingStub = nil
    73  	fake.encodingReturns = struct {
    74  		result1 baggageclaim.Encoding
    75  	}{result1}
    76  }
    77  
    78  func (fake *FakeCompression) EncodingReturnsOnCall(i int, result1 baggageclaim.Encoding) {
    79  	fake.encodingMutex.Lock()
    80  	defer fake.encodingMutex.Unlock()
    81  	fake.EncodingStub = nil
    82  	if fake.encodingReturnsOnCall == nil {
    83  		fake.encodingReturnsOnCall = make(map[int]struct {
    84  			result1 baggageclaim.Encoding
    85  		})
    86  	}
    87  	fake.encodingReturnsOnCall[i] = struct {
    88  		result1 baggageclaim.Encoding
    89  	}{result1}
    90  }
    91  
    92  func (fake *FakeCompression) NewReader(arg1 io.ReadCloser) (io.ReadCloser, error) {
    93  	fake.newReaderMutex.Lock()
    94  	ret, specificReturn := fake.newReaderReturnsOnCall[len(fake.newReaderArgsForCall)]
    95  	fake.newReaderArgsForCall = append(fake.newReaderArgsForCall, struct {
    96  		arg1 io.ReadCloser
    97  	}{arg1})
    98  	fake.recordInvocation("NewReader", []interface{}{arg1})
    99  	fake.newReaderMutex.Unlock()
   100  	if fake.NewReaderStub != nil {
   101  		return fake.NewReaderStub(arg1)
   102  	}
   103  	if specificReturn {
   104  		return ret.result1, ret.result2
   105  	}
   106  	fakeReturns := fake.newReaderReturns
   107  	return fakeReturns.result1, fakeReturns.result2
   108  }
   109  
   110  func (fake *FakeCompression) NewReaderCallCount() int {
   111  	fake.newReaderMutex.RLock()
   112  	defer fake.newReaderMutex.RUnlock()
   113  	return len(fake.newReaderArgsForCall)
   114  }
   115  
   116  func (fake *FakeCompression) NewReaderCalls(stub func(io.ReadCloser) (io.ReadCloser, error)) {
   117  	fake.newReaderMutex.Lock()
   118  	defer fake.newReaderMutex.Unlock()
   119  	fake.NewReaderStub = stub
   120  }
   121  
   122  func (fake *FakeCompression) NewReaderArgsForCall(i int) io.ReadCloser {
   123  	fake.newReaderMutex.RLock()
   124  	defer fake.newReaderMutex.RUnlock()
   125  	argsForCall := fake.newReaderArgsForCall[i]
   126  	return argsForCall.arg1
   127  }
   128  
   129  func (fake *FakeCompression) NewReaderReturns(result1 io.ReadCloser, result2 error) {
   130  	fake.newReaderMutex.Lock()
   131  	defer fake.newReaderMutex.Unlock()
   132  	fake.NewReaderStub = nil
   133  	fake.newReaderReturns = struct {
   134  		result1 io.ReadCloser
   135  		result2 error
   136  	}{result1, result2}
   137  }
   138  
   139  func (fake *FakeCompression) NewReaderReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
   140  	fake.newReaderMutex.Lock()
   141  	defer fake.newReaderMutex.Unlock()
   142  	fake.NewReaderStub = nil
   143  	if fake.newReaderReturnsOnCall == nil {
   144  		fake.newReaderReturnsOnCall = make(map[int]struct {
   145  			result1 io.ReadCloser
   146  			result2 error
   147  		})
   148  	}
   149  	fake.newReaderReturnsOnCall[i] = struct {
   150  		result1 io.ReadCloser
   151  		result2 error
   152  	}{result1, result2}
   153  }
   154  
   155  func (fake *FakeCompression) Invocations() map[string][][]interface{} {
   156  	fake.invocationsMutex.RLock()
   157  	defer fake.invocationsMutex.RUnlock()
   158  	fake.encodingMutex.RLock()
   159  	defer fake.encodingMutex.RUnlock()
   160  	fake.newReaderMutex.RLock()
   161  	defer fake.newReaderMutex.RUnlock()
   162  	copiedInvocations := map[string][][]interface{}{}
   163  	for key, value := range fake.invocations {
   164  		copiedInvocations[key] = value
   165  	}
   166  	return copiedInvocations
   167  }
   168  
   169  func (fake *FakeCompression) recordInvocation(key string, args []interface{}) {
   170  	fake.invocationsMutex.Lock()
   171  	defer fake.invocationsMutex.Unlock()
   172  	if fake.invocations == nil {
   173  		fake.invocations = map[string][][]interface{}{}
   174  	}
   175  	if fake.invocations[key] == nil {
   176  		fake.invocations[key] = [][]interface{}{}
   177  	}
   178  	fake.invocations[key] = append(fake.invocations[key], args)
   179  }
   180  
   181  var _ compression.Compression = new(FakeCompression)