github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/internal/pkg/identity/mocks/signer_serializer.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package mocks
     3  
     4  import (
     5  	"sync"
     6  
     7  	"github.com/hechain20/hechain/internal/pkg/identity"
     8  )
     9  
    10  type SignerSerializer struct {
    11  	SerializeStub        func() ([]byte, error)
    12  	serializeMutex       sync.RWMutex
    13  	serializeArgsForCall []struct {
    14  	}
    15  	serializeReturns struct {
    16  		result1 []byte
    17  		result2 error
    18  	}
    19  	serializeReturnsOnCall map[int]struct {
    20  		result1 []byte
    21  		result2 error
    22  	}
    23  	SignStub        func([]byte) ([]byte, error)
    24  	signMutex       sync.RWMutex
    25  	signArgsForCall []struct {
    26  		arg1 []byte
    27  	}
    28  	signReturns struct {
    29  		result1 []byte
    30  		result2 error
    31  	}
    32  	signReturnsOnCall map[int]struct {
    33  		result1 []byte
    34  		result2 error
    35  	}
    36  	invocations      map[string][][]interface{}
    37  	invocationsMutex sync.RWMutex
    38  }
    39  
    40  func (fake *SignerSerializer) Serialize() ([]byte, error) {
    41  	fake.serializeMutex.Lock()
    42  	ret, specificReturn := fake.serializeReturnsOnCall[len(fake.serializeArgsForCall)]
    43  	fake.serializeArgsForCall = append(fake.serializeArgsForCall, struct {
    44  	}{})
    45  	fake.recordInvocation("Serialize", []interface{}{})
    46  	fake.serializeMutex.Unlock()
    47  	if fake.SerializeStub != nil {
    48  		return fake.SerializeStub()
    49  	}
    50  	if specificReturn {
    51  		return ret.result1, ret.result2
    52  	}
    53  	fakeReturns := fake.serializeReturns
    54  	return fakeReturns.result1, fakeReturns.result2
    55  }
    56  
    57  func (fake *SignerSerializer) SerializeCallCount() int {
    58  	fake.serializeMutex.RLock()
    59  	defer fake.serializeMutex.RUnlock()
    60  	return len(fake.serializeArgsForCall)
    61  }
    62  
    63  func (fake *SignerSerializer) SerializeCalls(stub func() ([]byte, error)) {
    64  	fake.serializeMutex.Lock()
    65  	defer fake.serializeMutex.Unlock()
    66  	fake.SerializeStub = stub
    67  }
    68  
    69  func (fake *SignerSerializer) SerializeReturns(result1 []byte, result2 error) {
    70  	fake.serializeMutex.Lock()
    71  	defer fake.serializeMutex.Unlock()
    72  	fake.SerializeStub = nil
    73  	fake.serializeReturns = struct {
    74  		result1 []byte
    75  		result2 error
    76  	}{result1, result2}
    77  }
    78  
    79  func (fake *SignerSerializer) SerializeReturnsOnCall(i int, result1 []byte, result2 error) {
    80  	fake.serializeMutex.Lock()
    81  	defer fake.serializeMutex.Unlock()
    82  	fake.SerializeStub = nil
    83  	if fake.serializeReturnsOnCall == nil {
    84  		fake.serializeReturnsOnCall = make(map[int]struct {
    85  			result1 []byte
    86  			result2 error
    87  		})
    88  	}
    89  	fake.serializeReturnsOnCall[i] = struct {
    90  		result1 []byte
    91  		result2 error
    92  	}{result1, result2}
    93  }
    94  
    95  func (fake *SignerSerializer) Sign(arg1 []byte) ([]byte, error) {
    96  	var arg1Copy []byte
    97  	if arg1 != nil {
    98  		arg1Copy = make([]byte, len(arg1))
    99  		copy(arg1Copy, arg1)
   100  	}
   101  	fake.signMutex.Lock()
   102  	ret, specificReturn := fake.signReturnsOnCall[len(fake.signArgsForCall)]
   103  	fake.signArgsForCall = append(fake.signArgsForCall, struct {
   104  		arg1 []byte
   105  	}{arg1Copy})
   106  	fake.recordInvocation("Sign", []interface{}{arg1Copy})
   107  	fake.signMutex.Unlock()
   108  	if fake.SignStub != nil {
   109  		return fake.SignStub(arg1)
   110  	}
   111  	if specificReturn {
   112  		return ret.result1, ret.result2
   113  	}
   114  	fakeReturns := fake.signReturns
   115  	return fakeReturns.result1, fakeReturns.result2
   116  }
   117  
   118  func (fake *SignerSerializer) SignCallCount() int {
   119  	fake.signMutex.RLock()
   120  	defer fake.signMutex.RUnlock()
   121  	return len(fake.signArgsForCall)
   122  }
   123  
   124  func (fake *SignerSerializer) SignCalls(stub func([]byte) ([]byte, error)) {
   125  	fake.signMutex.Lock()
   126  	defer fake.signMutex.Unlock()
   127  	fake.SignStub = stub
   128  }
   129  
   130  func (fake *SignerSerializer) SignArgsForCall(i int) []byte {
   131  	fake.signMutex.RLock()
   132  	defer fake.signMutex.RUnlock()
   133  	argsForCall := fake.signArgsForCall[i]
   134  	return argsForCall.arg1
   135  }
   136  
   137  func (fake *SignerSerializer) SignReturns(result1 []byte, result2 error) {
   138  	fake.signMutex.Lock()
   139  	defer fake.signMutex.Unlock()
   140  	fake.SignStub = nil
   141  	fake.signReturns = struct {
   142  		result1 []byte
   143  		result2 error
   144  	}{result1, result2}
   145  }
   146  
   147  func (fake *SignerSerializer) SignReturnsOnCall(i int, result1 []byte, result2 error) {
   148  	fake.signMutex.Lock()
   149  	defer fake.signMutex.Unlock()
   150  	fake.SignStub = nil
   151  	if fake.signReturnsOnCall == nil {
   152  		fake.signReturnsOnCall = make(map[int]struct {
   153  			result1 []byte
   154  			result2 error
   155  		})
   156  	}
   157  	fake.signReturnsOnCall[i] = struct {
   158  		result1 []byte
   159  		result2 error
   160  	}{result1, result2}
   161  }
   162  
   163  func (fake *SignerSerializer) Invocations() map[string][][]interface{} {
   164  	fake.invocationsMutex.RLock()
   165  	defer fake.invocationsMutex.RUnlock()
   166  	fake.serializeMutex.RLock()
   167  	defer fake.serializeMutex.RUnlock()
   168  	fake.signMutex.RLock()
   169  	defer fake.signMutex.RUnlock()
   170  	copiedInvocations := map[string][][]interface{}{}
   171  	for key, value := range fake.invocations {
   172  		copiedInvocations[key] = value
   173  	}
   174  	return copiedInvocations
   175  }
   176  
   177  func (fake *SignerSerializer) recordInvocation(key string, args []interface{}) {
   178  	fake.invocationsMutex.Lock()
   179  	defer fake.invocationsMutex.Unlock()
   180  	if fake.invocations == nil {
   181  		fake.invocations = map[string][][]interface{}{}
   182  	}
   183  	if fake.invocations[key] == nil {
   184  		fake.invocations[key] = [][]interface{}{}
   185  	}
   186  	fake.invocations[key] = append(fake.invocations[key], args)
   187  }
   188  
   189  var _ identity.SignerSerializer = new(SignerSerializer)