github.com/lzy4123/fabric@v2.1.1+incompatible/internal/peer/lifecycle/chaincode/mock/platform_registry.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package mock
     3  
     4  import (
     5  	"sync"
     6  )
     7  
     8  type PlatformRegistry struct {
     9  	GetDeploymentPayloadStub        func(string, string) ([]byte, error)
    10  	getDeploymentPayloadMutex       sync.RWMutex
    11  	getDeploymentPayloadArgsForCall []struct {
    12  		arg1 string
    13  		arg2 string
    14  	}
    15  	getDeploymentPayloadReturns struct {
    16  		result1 []byte
    17  		result2 error
    18  	}
    19  	getDeploymentPayloadReturnsOnCall map[int]struct {
    20  		result1 []byte
    21  		result2 error
    22  	}
    23  	NormalizePathStub        func(string, string) (string, error)
    24  	normalizePathMutex       sync.RWMutex
    25  	normalizePathArgsForCall []struct {
    26  		arg1 string
    27  		arg2 string
    28  	}
    29  	normalizePathReturns struct {
    30  		result1 string
    31  		result2 error
    32  	}
    33  	normalizePathReturnsOnCall map[int]struct {
    34  		result1 string
    35  		result2 error
    36  	}
    37  	invocations      map[string][][]interface{}
    38  	invocationsMutex sync.RWMutex
    39  }
    40  
    41  func (fake *PlatformRegistry) GetDeploymentPayload(arg1 string, arg2 string) ([]byte, error) {
    42  	fake.getDeploymentPayloadMutex.Lock()
    43  	ret, specificReturn := fake.getDeploymentPayloadReturnsOnCall[len(fake.getDeploymentPayloadArgsForCall)]
    44  	fake.getDeploymentPayloadArgsForCall = append(fake.getDeploymentPayloadArgsForCall, struct {
    45  		arg1 string
    46  		arg2 string
    47  	}{arg1, arg2})
    48  	fake.recordInvocation("GetDeploymentPayload", []interface{}{arg1, arg2})
    49  	fake.getDeploymentPayloadMutex.Unlock()
    50  	if fake.GetDeploymentPayloadStub != nil {
    51  		return fake.GetDeploymentPayloadStub(arg1, arg2)
    52  	}
    53  	if specificReturn {
    54  		return ret.result1, ret.result2
    55  	}
    56  	fakeReturns := fake.getDeploymentPayloadReturns
    57  	return fakeReturns.result1, fakeReturns.result2
    58  }
    59  
    60  func (fake *PlatformRegistry) GetDeploymentPayloadCallCount() int {
    61  	fake.getDeploymentPayloadMutex.RLock()
    62  	defer fake.getDeploymentPayloadMutex.RUnlock()
    63  	return len(fake.getDeploymentPayloadArgsForCall)
    64  }
    65  
    66  func (fake *PlatformRegistry) GetDeploymentPayloadCalls(stub func(string, string) ([]byte, error)) {
    67  	fake.getDeploymentPayloadMutex.Lock()
    68  	defer fake.getDeploymentPayloadMutex.Unlock()
    69  	fake.GetDeploymentPayloadStub = stub
    70  }
    71  
    72  func (fake *PlatformRegistry) GetDeploymentPayloadArgsForCall(i int) (string, string) {
    73  	fake.getDeploymentPayloadMutex.RLock()
    74  	defer fake.getDeploymentPayloadMutex.RUnlock()
    75  	argsForCall := fake.getDeploymentPayloadArgsForCall[i]
    76  	return argsForCall.arg1, argsForCall.arg2
    77  }
    78  
    79  func (fake *PlatformRegistry) GetDeploymentPayloadReturns(result1 []byte, result2 error) {
    80  	fake.getDeploymentPayloadMutex.Lock()
    81  	defer fake.getDeploymentPayloadMutex.Unlock()
    82  	fake.GetDeploymentPayloadStub = nil
    83  	fake.getDeploymentPayloadReturns = struct {
    84  		result1 []byte
    85  		result2 error
    86  	}{result1, result2}
    87  }
    88  
    89  func (fake *PlatformRegistry) GetDeploymentPayloadReturnsOnCall(i int, result1 []byte, result2 error) {
    90  	fake.getDeploymentPayloadMutex.Lock()
    91  	defer fake.getDeploymentPayloadMutex.Unlock()
    92  	fake.GetDeploymentPayloadStub = nil
    93  	if fake.getDeploymentPayloadReturnsOnCall == nil {
    94  		fake.getDeploymentPayloadReturnsOnCall = make(map[int]struct {
    95  			result1 []byte
    96  			result2 error
    97  		})
    98  	}
    99  	fake.getDeploymentPayloadReturnsOnCall[i] = struct {
   100  		result1 []byte
   101  		result2 error
   102  	}{result1, result2}
   103  }
   104  
   105  func (fake *PlatformRegistry) NormalizePath(arg1 string, arg2 string) (string, error) {
   106  	fake.normalizePathMutex.Lock()
   107  	ret, specificReturn := fake.normalizePathReturnsOnCall[len(fake.normalizePathArgsForCall)]
   108  	fake.normalizePathArgsForCall = append(fake.normalizePathArgsForCall, struct {
   109  		arg1 string
   110  		arg2 string
   111  	}{arg1, arg2})
   112  	fake.recordInvocation("NormalizePath", []interface{}{arg1, arg2})
   113  	fake.normalizePathMutex.Unlock()
   114  	if fake.NormalizePathStub != nil {
   115  		return fake.NormalizePathStub(arg1, arg2)
   116  	}
   117  	if specificReturn {
   118  		return ret.result1, ret.result2
   119  	}
   120  	fakeReturns := fake.normalizePathReturns
   121  	return fakeReturns.result1, fakeReturns.result2
   122  }
   123  
   124  func (fake *PlatformRegistry) NormalizePathCallCount() int {
   125  	fake.normalizePathMutex.RLock()
   126  	defer fake.normalizePathMutex.RUnlock()
   127  	return len(fake.normalizePathArgsForCall)
   128  }
   129  
   130  func (fake *PlatformRegistry) NormalizePathCalls(stub func(string, string) (string, error)) {
   131  	fake.normalizePathMutex.Lock()
   132  	defer fake.normalizePathMutex.Unlock()
   133  	fake.NormalizePathStub = stub
   134  }
   135  
   136  func (fake *PlatformRegistry) NormalizePathArgsForCall(i int) (string, string) {
   137  	fake.normalizePathMutex.RLock()
   138  	defer fake.normalizePathMutex.RUnlock()
   139  	argsForCall := fake.normalizePathArgsForCall[i]
   140  	return argsForCall.arg1, argsForCall.arg2
   141  }
   142  
   143  func (fake *PlatformRegistry) NormalizePathReturns(result1 string, result2 error) {
   144  	fake.normalizePathMutex.Lock()
   145  	defer fake.normalizePathMutex.Unlock()
   146  	fake.NormalizePathStub = nil
   147  	fake.normalizePathReturns = struct {
   148  		result1 string
   149  		result2 error
   150  	}{result1, result2}
   151  }
   152  
   153  func (fake *PlatformRegistry) NormalizePathReturnsOnCall(i int, result1 string, result2 error) {
   154  	fake.normalizePathMutex.Lock()
   155  	defer fake.normalizePathMutex.Unlock()
   156  	fake.NormalizePathStub = nil
   157  	if fake.normalizePathReturnsOnCall == nil {
   158  		fake.normalizePathReturnsOnCall = make(map[int]struct {
   159  			result1 string
   160  			result2 error
   161  		})
   162  	}
   163  	fake.normalizePathReturnsOnCall[i] = struct {
   164  		result1 string
   165  		result2 error
   166  	}{result1, result2}
   167  }
   168  
   169  func (fake *PlatformRegistry) Invocations() map[string][][]interface{} {
   170  	fake.invocationsMutex.RLock()
   171  	defer fake.invocationsMutex.RUnlock()
   172  	fake.getDeploymentPayloadMutex.RLock()
   173  	defer fake.getDeploymentPayloadMutex.RUnlock()
   174  	fake.normalizePathMutex.RLock()
   175  	defer fake.normalizePathMutex.RUnlock()
   176  	copiedInvocations := map[string][][]interface{}{}
   177  	for key, value := range fake.invocations {
   178  		copiedInvocations[key] = value
   179  	}
   180  	return copiedInvocations
   181  }
   182  
   183  func (fake *PlatformRegistry) recordInvocation(key string, args []interface{}) {
   184  	fake.invocationsMutex.Lock()
   185  	defer fake.invocationsMutex.Unlock()
   186  	if fake.invocations == nil {
   187  		fake.invocations = map[string][][]interface{}{}
   188  	}
   189  	if fake.invocations[key] == nil {
   190  		fake.invocations[key] = [][]interface{}{}
   191  	}
   192  	fake.invocations[key] = append(fake.invocations[key], args)
   193  }