github.com/IBM-Blockchain/fabric-operator@v1.0.4/pkg/offering/common/reconcilechecks/mocks/version.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package mocks
     3  
     4  import (
     5  	"sync"
     6  
     7  	"github.com/IBM-Blockchain/fabric-operator/pkg/offering/common/reconcilechecks"
     8  	"github.com/IBM-Blockchain/fabric-operator/pkg/offering/common/reconcilechecks/images"
     9  )
    10  
    11  type Version struct {
    12  	NormalizeStub        func(images.FabricVersionInstance) string
    13  	normalizeMutex       sync.RWMutex
    14  	normalizeArgsForCall []struct {
    15  		arg1 images.FabricVersionInstance
    16  	}
    17  	normalizeReturns struct {
    18  		result1 string
    19  	}
    20  	normalizeReturnsOnCall map[int]struct {
    21  		result1 string
    22  	}
    23  	ValidateStub        func(images.FabricVersionInstance) error
    24  	validateMutex       sync.RWMutex
    25  	validateArgsForCall []struct {
    26  		arg1 images.FabricVersionInstance
    27  	}
    28  	validateReturns struct {
    29  		result1 error
    30  	}
    31  	validateReturnsOnCall map[int]struct {
    32  		result1 error
    33  	}
    34  	invocations      map[string][][]interface{}
    35  	invocationsMutex sync.RWMutex
    36  }
    37  
    38  func (fake *Version) Normalize(arg1 images.FabricVersionInstance) string {
    39  	fake.normalizeMutex.Lock()
    40  	ret, specificReturn := fake.normalizeReturnsOnCall[len(fake.normalizeArgsForCall)]
    41  	fake.normalizeArgsForCall = append(fake.normalizeArgsForCall, struct {
    42  		arg1 images.FabricVersionInstance
    43  	}{arg1})
    44  	stub := fake.NormalizeStub
    45  	fakeReturns := fake.normalizeReturns
    46  	fake.recordInvocation("Normalize", []interface{}{arg1})
    47  	fake.normalizeMutex.Unlock()
    48  	if stub != nil {
    49  		return stub(arg1)
    50  	}
    51  	if specificReturn {
    52  		return ret.result1
    53  	}
    54  	return fakeReturns.result1
    55  }
    56  
    57  func (fake *Version) NormalizeCallCount() int {
    58  	fake.normalizeMutex.RLock()
    59  	defer fake.normalizeMutex.RUnlock()
    60  	return len(fake.normalizeArgsForCall)
    61  }
    62  
    63  func (fake *Version) NormalizeCalls(stub func(images.FabricVersionInstance) string) {
    64  	fake.normalizeMutex.Lock()
    65  	defer fake.normalizeMutex.Unlock()
    66  	fake.NormalizeStub = stub
    67  }
    68  
    69  func (fake *Version) NormalizeArgsForCall(i int) images.FabricVersionInstance {
    70  	fake.normalizeMutex.RLock()
    71  	defer fake.normalizeMutex.RUnlock()
    72  	argsForCall := fake.normalizeArgsForCall[i]
    73  	return argsForCall.arg1
    74  }
    75  
    76  func (fake *Version) NormalizeReturns(result1 string) {
    77  	fake.normalizeMutex.Lock()
    78  	defer fake.normalizeMutex.Unlock()
    79  	fake.NormalizeStub = nil
    80  	fake.normalizeReturns = struct {
    81  		result1 string
    82  	}{result1}
    83  }
    84  
    85  func (fake *Version) NormalizeReturnsOnCall(i int, result1 string) {
    86  	fake.normalizeMutex.Lock()
    87  	defer fake.normalizeMutex.Unlock()
    88  	fake.NormalizeStub = nil
    89  	if fake.normalizeReturnsOnCall == nil {
    90  		fake.normalizeReturnsOnCall = make(map[int]struct {
    91  			result1 string
    92  		})
    93  	}
    94  	fake.normalizeReturnsOnCall[i] = struct {
    95  		result1 string
    96  	}{result1}
    97  }
    98  
    99  func (fake *Version) Validate(arg1 images.FabricVersionInstance) error {
   100  	fake.validateMutex.Lock()
   101  	ret, specificReturn := fake.validateReturnsOnCall[len(fake.validateArgsForCall)]
   102  	fake.validateArgsForCall = append(fake.validateArgsForCall, struct {
   103  		arg1 images.FabricVersionInstance
   104  	}{arg1})
   105  	stub := fake.ValidateStub
   106  	fakeReturns := fake.validateReturns
   107  	fake.recordInvocation("Validate", []interface{}{arg1})
   108  	fake.validateMutex.Unlock()
   109  	if stub != nil {
   110  		return stub(arg1)
   111  	}
   112  	if specificReturn {
   113  		return ret.result1
   114  	}
   115  	return fakeReturns.result1
   116  }
   117  
   118  func (fake *Version) ValidateCallCount() int {
   119  	fake.validateMutex.RLock()
   120  	defer fake.validateMutex.RUnlock()
   121  	return len(fake.validateArgsForCall)
   122  }
   123  
   124  func (fake *Version) ValidateCalls(stub func(images.FabricVersionInstance) error) {
   125  	fake.validateMutex.Lock()
   126  	defer fake.validateMutex.Unlock()
   127  	fake.ValidateStub = stub
   128  }
   129  
   130  func (fake *Version) ValidateArgsForCall(i int) images.FabricVersionInstance {
   131  	fake.validateMutex.RLock()
   132  	defer fake.validateMutex.RUnlock()
   133  	argsForCall := fake.validateArgsForCall[i]
   134  	return argsForCall.arg1
   135  }
   136  
   137  func (fake *Version) ValidateReturns(result1 error) {
   138  	fake.validateMutex.Lock()
   139  	defer fake.validateMutex.Unlock()
   140  	fake.ValidateStub = nil
   141  	fake.validateReturns = struct {
   142  		result1 error
   143  	}{result1}
   144  }
   145  
   146  func (fake *Version) ValidateReturnsOnCall(i int, result1 error) {
   147  	fake.validateMutex.Lock()
   148  	defer fake.validateMutex.Unlock()
   149  	fake.ValidateStub = nil
   150  	if fake.validateReturnsOnCall == nil {
   151  		fake.validateReturnsOnCall = make(map[int]struct {
   152  			result1 error
   153  		})
   154  	}
   155  	fake.validateReturnsOnCall[i] = struct {
   156  		result1 error
   157  	}{result1}
   158  }
   159  
   160  func (fake *Version) Invocations() map[string][][]interface{} {
   161  	fake.invocationsMutex.RLock()
   162  	defer fake.invocationsMutex.RUnlock()
   163  	fake.normalizeMutex.RLock()
   164  	defer fake.normalizeMutex.RUnlock()
   165  	fake.validateMutex.RLock()
   166  	defer fake.validateMutex.RUnlock()
   167  	copiedInvocations := map[string][][]interface{}{}
   168  	for key, value := range fake.invocations {
   169  		copiedInvocations[key] = value
   170  	}
   171  	return copiedInvocations
   172  }
   173  
   174  func (fake *Version) recordInvocation(key string, args []interface{}) {
   175  	fake.invocationsMutex.Lock()
   176  	defer fake.invocationsMutex.Unlock()
   177  	if fake.invocations == nil {
   178  		fake.invocations = map[string][][]interface{}{}
   179  	}
   180  	if fake.invocations[key] == nil {
   181  		fake.invocations[key] = [][]interface{}{}
   182  	}
   183  	fake.invocations[key] = append(fake.invocations[key], args)
   184  }
   185  
   186  var _ reconcilechecks.Version = new(Version)