github.com/osdi23p228/fabric@v0.0.0-20221218062954-77808885f5db/common/ledger/testutil/fakes/signing_identity.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package fakes 3 4 import ( 5 "sync" 6 "time" 7 8 mspa "github.com/hyperledger/fabric-protos-go/msp" 9 "github.com/osdi23p228/fabric/msp" 10 ) 11 12 type SigningIdentity struct { 13 AnonymousStub func() bool 14 anonymousMutex sync.RWMutex 15 anonymousArgsForCall []struct { 16 } 17 anonymousReturns struct { 18 result1 bool 19 } 20 anonymousReturnsOnCall map[int]struct { 21 result1 bool 22 } 23 ExpiresAtStub func() time.Time 24 expiresAtMutex sync.RWMutex 25 expiresAtArgsForCall []struct { 26 } 27 expiresAtReturns struct { 28 result1 time.Time 29 } 30 expiresAtReturnsOnCall map[int]struct { 31 result1 time.Time 32 } 33 GetIdentifierStub func() *msp.IdentityIdentifier 34 getIdentifierMutex sync.RWMutex 35 getIdentifierArgsForCall []struct { 36 } 37 getIdentifierReturns struct { 38 result1 *msp.IdentityIdentifier 39 } 40 getIdentifierReturnsOnCall map[int]struct { 41 result1 *msp.IdentityIdentifier 42 } 43 GetMSPIdentifierStub func() string 44 getMSPIdentifierMutex sync.RWMutex 45 getMSPIdentifierArgsForCall []struct { 46 } 47 getMSPIdentifierReturns struct { 48 result1 string 49 } 50 getMSPIdentifierReturnsOnCall map[int]struct { 51 result1 string 52 } 53 GetOrganizationalUnitsStub func() []*msp.OUIdentifier 54 getOrganizationalUnitsMutex sync.RWMutex 55 getOrganizationalUnitsArgsForCall []struct { 56 } 57 getOrganizationalUnitsReturns struct { 58 result1 []*msp.OUIdentifier 59 } 60 getOrganizationalUnitsReturnsOnCall map[int]struct { 61 result1 []*msp.OUIdentifier 62 } 63 GetPublicVersionStub func() msp.Identity 64 getPublicVersionMutex sync.RWMutex 65 getPublicVersionArgsForCall []struct { 66 } 67 getPublicVersionReturns struct { 68 result1 msp.Identity 69 } 70 getPublicVersionReturnsOnCall map[int]struct { 71 result1 msp.Identity 72 } 73 SatisfiesPrincipalStub func(*mspa.MSPPrincipal) error 74 satisfiesPrincipalMutex sync.RWMutex 75 satisfiesPrincipalArgsForCall []struct { 76 arg1 *mspa.MSPPrincipal 77 } 78 satisfiesPrincipalReturns struct { 79 result1 error 80 } 81 satisfiesPrincipalReturnsOnCall map[int]struct { 82 result1 error 83 } 84 SerializeStub func() ([]byte, error) 85 serializeMutex sync.RWMutex 86 serializeArgsForCall []struct { 87 } 88 serializeReturns struct { 89 result1 []byte 90 result2 error 91 } 92 serializeReturnsOnCall map[int]struct { 93 result1 []byte 94 result2 error 95 } 96 SignStub func([]byte) ([]byte, error) 97 signMutex sync.RWMutex 98 signArgsForCall []struct { 99 arg1 []byte 100 } 101 signReturns struct { 102 result1 []byte 103 result2 error 104 } 105 signReturnsOnCall map[int]struct { 106 result1 []byte 107 result2 error 108 } 109 ValidateStub func() error 110 validateMutex sync.RWMutex 111 validateArgsForCall []struct { 112 } 113 validateReturns struct { 114 result1 error 115 } 116 validateReturnsOnCall map[int]struct { 117 result1 error 118 } 119 VerifyStub func([]byte, []byte) error 120 verifyMutex sync.RWMutex 121 verifyArgsForCall []struct { 122 arg1 []byte 123 arg2 []byte 124 } 125 verifyReturns struct { 126 result1 error 127 } 128 verifyReturnsOnCall map[int]struct { 129 result1 error 130 } 131 invocations map[string][][]interface{} 132 invocationsMutex sync.RWMutex 133 } 134 135 func (fake *SigningIdentity) Anonymous() bool { 136 fake.anonymousMutex.Lock() 137 ret, specificReturn := fake.anonymousReturnsOnCall[len(fake.anonymousArgsForCall)] 138 fake.anonymousArgsForCall = append(fake.anonymousArgsForCall, struct { 139 }{}) 140 fake.recordInvocation("Anonymous", []interface{}{}) 141 fake.anonymousMutex.Unlock() 142 if fake.AnonymousStub != nil { 143 return fake.AnonymousStub() 144 } 145 if specificReturn { 146 return ret.result1 147 } 148 fakeReturns := fake.anonymousReturns 149 return fakeReturns.result1 150 } 151 152 func (fake *SigningIdentity) AnonymousCallCount() int { 153 fake.anonymousMutex.RLock() 154 defer fake.anonymousMutex.RUnlock() 155 return len(fake.anonymousArgsForCall) 156 } 157 158 func (fake *SigningIdentity) AnonymousCalls(stub func() bool) { 159 fake.anonymousMutex.Lock() 160 defer fake.anonymousMutex.Unlock() 161 fake.AnonymousStub = stub 162 } 163 164 func (fake *SigningIdentity) AnonymousReturns(result1 bool) { 165 fake.anonymousMutex.Lock() 166 defer fake.anonymousMutex.Unlock() 167 fake.AnonymousStub = nil 168 fake.anonymousReturns = struct { 169 result1 bool 170 }{result1} 171 } 172 173 func (fake *SigningIdentity) AnonymousReturnsOnCall(i int, result1 bool) { 174 fake.anonymousMutex.Lock() 175 defer fake.anonymousMutex.Unlock() 176 fake.AnonymousStub = nil 177 if fake.anonymousReturnsOnCall == nil { 178 fake.anonymousReturnsOnCall = make(map[int]struct { 179 result1 bool 180 }) 181 } 182 fake.anonymousReturnsOnCall[i] = struct { 183 result1 bool 184 }{result1} 185 } 186 187 func (fake *SigningIdentity) ExpiresAt() time.Time { 188 fake.expiresAtMutex.Lock() 189 ret, specificReturn := fake.expiresAtReturnsOnCall[len(fake.expiresAtArgsForCall)] 190 fake.expiresAtArgsForCall = append(fake.expiresAtArgsForCall, struct { 191 }{}) 192 fake.recordInvocation("ExpiresAt", []interface{}{}) 193 fake.expiresAtMutex.Unlock() 194 if fake.ExpiresAtStub != nil { 195 return fake.ExpiresAtStub() 196 } 197 if specificReturn { 198 return ret.result1 199 } 200 fakeReturns := fake.expiresAtReturns 201 return fakeReturns.result1 202 } 203 204 func (fake *SigningIdentity) ExpiresAtCallCount() int { 205 fake.expiresAtMutex.RLock() 206 defer fake.expiresAtMutex.RUnlock() 207 return len(fake.expiresAtArgsForCall) 208 } 209 210 func (fake *SigningIdentity) ExpiresAtCalls(stub func() time.Time) { 211 fake.expiresAtMutex.Lock() 212 defer fake.expiresAtMutex.Unlock() 213 fake.ExpiresAtStub = stub 214 } 215 216 func (fake *SigningIdentity) ExpiresAtReturns(result1 time.Time) { 217 fake.expiresAtMutex.Lock() 218 defer fake.expiresAtMutex.Unlock() 219 fake.ExpiresAtStub = nil 220 fake.expiresAtReturns = struct { 221 result1 time.Time 222 }{result1} 223 } 224 225 func (fake *SigningIdentity) ExpiresAtReturnsOnCall(i int, result1 time.Time) { 226 fake.expiresAtMutex.Lock() 227 defer fake.expiresAtMutex.Unlock() 228 fake.ExpiresAtStub = nil 229 if fake.expiresAtReturnsOnCall == nil { 230 fake.expiresAtReturnsOnCall = make(map[int]struct { 231 result1 time.Time 232 }) 233 } 234 fake.expiresAtReturnsOnCall[i] = struct { 235 result1 time.Time 236 }{result1} 237 } 238 239 func (fake *SigningIdentity) GetIdentifier() *msp.IdentityIdentifier { 240 fake.getIdentifierMutex.Lock() 241 ret, specificReturn := fake.getIdentifierReturnsOnCall[len(fake.getIdentifierArgsForCall)] 242 fake.getIdentifierArgsForCall = append(fake.getIdentifierArgsForCall, struct { 243 }{}) 244 fake.recordInvocation("GetIdentifier", []interface{}{}) 245 fake.getIdentifierMutex.Unlock() 246 if fake.GetIdentifierStub != nil { 247 return fake.GetIdentifierStub() 248 } 249 if specificReturn { 250 return ret.result1 251 } 252 fakeReturns := fake.getIdentifierReturns 253 return fakeReturns.result1 254 } 255 256 func (fake *SigningIdentity) GetIdentifierCallCount() int { 257 fake.getIdentifierMutex.RLock() 258 defer fake.getIdentifierMutex.RUnlock() 259 return len(fake.getIdentifierArgsForCall) 260 } 261 262 func (fake *SigningIdentity) GetIdentifierCalls(stub func() *msp.IdentityIdentifier) { 263 fake.getIdentifierMutex.Lock() 264 defer fake.getIdentifierMutex.Unlock() 265 fake.GetIdentifierStub = stub 266 } 267 268 func (fake *SigningIdentity) GetIdentifierReturns(result1 *msp.IdentityIdentifier) { 269 fake.getIdentifierMutex.Lock() 270 defer fake.getIdentifierMutex.Unlock() 271 fake.GetIdentifierStub = nil 272 fake.getIdentifierReturns = struct { 273 result1 *msp.IdentityIdentifier 274 }{result1} 275 } 276 277 func (fake *SigningIdentity) GetIdentifierReturnsOnCall(i int, result1 *msp.IdentityIdentifier) { 278 fake.getIdentifierMutex.Lock() 279 defer fake.getIdentifierMutex.Unlock() 280 fake.GetIdentifierStub = nil 281 if fake.getIdentifierReturnsOnCall == nil { 282 fake.getIdentifierReturnsOnCall = make(map[int]struct { 283 result1 *msp.IdentityIdentifier 284 }) 285 } 286 fake.getIdentifierReturnsOnCall[i] = struct { 287 result1 *msp.IdentityIdentifier 288 }{result1} 289 } 290 291 func (fake *SigningIdentity) GetMSPIdentifier() string { 292 fake.getMSPIdentifierMutex.Lock() 293 ret, specificReturn := fake.getMSPIdentifierReturnsOnCall[len(fake.getMSPIdentifierArgsForCall)] 294 fake.getMSPIdentifierArgsForCall = append(fake.getMSPIdentifierArgsForCall, struct { 295 }{}) 296 fake.recordInvocation("GetMSPIdentifier", []interface{}{}) 297 fake.getMSPIdentifierMutex.Unlock() 298 if fake.GetMSPIdentifierStub != nil { 299 return fake.GetMSPIdentifierStub() 300 } 301 if specificReturn { 302 return ret.result1 303 } 304 fakeReturns := fake.getMSPIdentifierReturns 305 return fakeReturns.result1 306 } 307 308 func (fake *SigningIdentity) GetMSPIdentifierCallCount() int { 309 fake.getMSPIdentifierMutex.RLock() 310 defer fake.getMSPIdentifierMutex.RUnlock() 311 return len(fake.getMSPIdentifierArgsForCall) 312 } 313 314 func (fake *SigningIdentity) GetMSPIdentifierCalls(stub func() string) { 315 fake.getMSPIdentifierMutex.Lock() 316 defer fake.getMSPIdentifierMutex.Unlock() 317 fake.GetMSPIdentifierStub = stub 318 } 319 320 func (fake *SigningIdentity) GetMSPIdentifierReturns(result1 string) { 321 fake.getMSPIdentifierMutex.Lock() 322 defer fake.getMSPIdentifierMutex.Unlock() 323 fake.GetMSPIdentifierStub = nil 324 fake.getMSPIdentifierReturns = struct { 325 result1 string 326 }{result1} 327 } 328 329 func (fake *SigningIdentity) GetMSPIdentifierReturnsOnCall(i int, result1 string) { 330 fake.getMSPIdentifierMutex.Lock() 331 defer fake.getMSPIdentifierMutex.Unlock() 332 fake.GetMSPIdentifierStub = nil 333 if fake.getMSPIdentifierReturnsOnCall == nil { 334 fake.getMSPIdentifierReturnsOnCall = make(map[int]struct { 335 result1 string 336 }) 337 } 338 fake.getMSPIdentifierReturnsOnCall[i] = struct { 339 result1 string 340 }{result1} 341 } 342 343 func (fake *SigningIdentity) GetOrganizationalUnits() []*msp.OUIdentifier { 344 fake.getOrganizationalUnitsMutex.Lock() 345 ret, specificReturn := fake.getOrganizationalUnitsReturnsOnCall[len(fake.getOrganizationalUnitsArgsForCall)] 346 fake.getOrganizationalUnitsArgsForCall = append(fake.getOrganizationalUnitsArgsForCall, struct { 347 }{}) 348 fake.recordInvocation("GetOrganizationalUnits", []interface{}{}) 349 fake.getOrganizationalUnitsMutex.Unlock() 350 if fake.GetOrganizationalUnitsStub != nil { 351 return fake.GetOrganizationalUnitsStub() 352 } 353 if specificReturn { 354 return ret.result1 355 } 356 fakeReturns := fake.getOrganizationalUnitsReturns 357 return fakeReturns.result1 358 } 359 360 func (fake *SigningIdentity) GetOrganizationalUnitsCallCount() int { 361 fake.getOrganizationalUnitsMutex.RLock() 362 defer fake.getOrganizationalUnitsMutex.RUnlock() 363 return len(fake.getOrganizationalUnitsArgsForCall) 364 } 365 366 func (fake *SigningIdentity) GetOrganizationalUnitsCalls(stub func() []*msp.OUIdentifier) { 367 fake.getOrganizationalUnitsMutex.Lock() 368 defer fake.getOrganizationalUnitsMutex.Unlock() 369 fake.GetOrganizationalUnitsStub = stub 370 } 371 372 func (fake *SigningIdentity) GetOrganizationalUnitsReturns(result1 []*msp.OUIdentifier) { 373 fake.getOrganizationalUnitsMutex.Lock() 374 defer fake.getOrganizationalUnitsMutex.Unlock() 375 fake.GetOrganizationalUnitsStub = nil 376 fake.getOrganizationalUnitsReturns = struct { 377 result1 []*msp.OUIdentifier 378 }{result1} 379 } 380 381 func (fake *SigningIdentity) GetOrganizationalUnitsReturnsOnCall(i int, result1 []*msp.OUIdentifier) { 382 fake.getOrganizationalUnitsMutex.Lock() 383 defer fake.getOrganizationalUnitsMutex.Unlock() 384 fake.GetOrganizationalUnitsStub = nil 385 if fake.getOrganizationalUnitsReturnsOnCall == nil { 386 fake.getOrganizationalUnitsReturnsOnCall = make(map[int]struct { 387 result1 []*msp.OUIdentifier 388 }) 389 } 390 fake.getOrganizationalUnitsReturnsOnCall[i] = struct { 391 result1 []*msp.OUIdentifier 392 }{result1} 393 } 394 395 func (fake *SigningIdentity) GetPublicVersion() msp.Identity { 396 fake.getPublicVersionMutex.Lock() 397 ret, specificReturn := fake.getPublicVersionReturnsOnCall[len(fake.getPublicVersionArgsForCall)] 398 fake.getPublicVersionArgsForCall = append(fake.getPublicVersionArgsForCall, struct { 399 }{}) 400 fake.recordInvocation("GetPublicVersion", []interface{}{}) 401 fake.getPublicVersionMutex.Unlock() 402 if fake.GetPublicVersionStub != nil { 403 return fake.GetPublicVersionStub() 404 } 405 if specificReturn { 406 return ret.result1 407 } 408 fakeReturns := fake.getPublicVersionReturns 409 return fakeReturns.result1 410 } 411 412 func (fake *SigningIdentity) GetPublicVersionCallCount() int { 413 fake.getPublicVersionMutex.RLock() 414 defer fake.getPublicVersionMutex.RUnlock() 415 return len(fake.getPublicVersionArgsForCall) 416 } 417 418 func (fake *SigningIdentity) GetPublicVersionCalls(stub func() msp.Identity) { 419 fake.getPublicVersionMutex.Lock() 420 defer fake.getPublicVersionMutex.Unlock() 421 fake.GetPublicVersionStub = stub 422 } 423 424 func (fake *SigningIdentity) GetPublicVersionReturns(result1 msp.Identity) { 425 fake.getPublicVersionMutex.Lock() 426 defer fake.getPublicVersionMutex.Unlock() 427 fake.GetPublicVersionStub = nil 428 fake.getPublicVersionReturns = struct { 429 result1 msp.Identity 430 }{result1} 431 } 432 433 func (fake *SigningIdentity) GetPublicVersionReturnsOnCall(i int, result1 msp.Identity) { 434 fake.getPublicVersionMutex.Lock() 435 defer fake.getPublicVersionMutex.Unlock() 436 fake.GetPublicVersionStub = nil 437 if fake.getPublicVersionReturnsOnCall == nil { 438 fake.getPublicVersionReturnsOnCall = make(map[int]struct { 439 result1 msp.Identity 440 }) 441 } 442 fake.getPublicVersionReturnsOnCall[i] = struct { 443 result1 msp.Identity 444 }{result1} 445 } 446 447 func (fake *SigningIdentity) SatisfiesPrincipal(arg1 *mspa.MSPPrincipal) error { 448 fake.satisfiesPrincipalMutex.Lock() 449 ret, specificReturn := fake.satisfiesPrincipalReturnsOnCall[len(fake.satisfiesPrincipalArgsForCall)] 450 fake.satisfiesPrincipalArgsForCall = append(fake.satisfiesPrincipalArgsForCall, struct { 451 arg1 *mspa.MSPPrincipal 452 }{arg1}) 453 fake.recordInvocation("SatisfiesPrincipal", []interface{}{arg1}) 454 fake.satisfiesPrincipalMutex.Unlock() 455 if fake.SatisfiesPrincipalStub != nil { 456 return fake.SatisfiesPrincipalStub(arg1) 457 } 458 if specificReturn { 459 return ret.result1 460 } 461 fakeReturns := fake.satisfiesPrincipalReturns 462 return fakeReturns.result1 463 } 464 465 func (fake *SigningIdentity) SatisfiesPrincipalCallCount() int { 466 fake.satisfiesPrincipalMutex.RLock() 467 defer fake.satisfiesPrincipalMutex.RUnlock() 468 return len(fake.satisfiesPrincipalArgsForCall) 469 } 470 471 func (fake *SigningIdentity) SatisfiesPrincipalCalls(stub func(*mspa.MSPPrincipal) error) { 472 fake.satisfiesPrincipalMutex.Lock() 473 defer fake.satisfiesPrincipalMutex.Unlock() 474 fake.SatisfiesPrincipalStub = stub 475 } 476 477 func (fake *SigningIdentity) SatisfiesPrincipalArgsForCall(i int) *mspa.MSPPrincipal { 478 fake.satisfiesPrincipalMutex.RLock() 479 defer fake.satisfiesPrincipalMutex.RUnlock() 480 argsForCall := fake.satisfiesPrincipalArgsForCall[i] 481 return argsForCall.arg1 482 } 483 484 func (fake *SigningIdentity) SatisfiesPrincipalReturns(result1 error) { 485 fake.satisfiesPrincipalMutex.Lock() 486 defer fake.satisfiesPrincipalMutex.Unlock() 487 fake.SatisfiesPrincipalStub = nil 488 fake.satisfiesPrincipalReturns = struct { 489 result1 error 490 }{result1} 491 } 492 493 func (fake *SigningIdentity) SatisfiesPrincipalReturnsOnCall(i int, result1 error) { 494 fake.satisfiesPrincipalMutex.Lock() 495 defer fake.satisfiesPrincipalMutex.Unlock() 496 fake.SatisfiesPrincipalStub = nil 497 if fake.satisfiesPrincipalReturnsOnCall == nil { 498 fake.satisfiesPrincipalReturnsOnCall = make(map[int]struct { 499 result1 error 500 }) 501 } 502 fake.satisfiesPrincipalReturnsOnCall[i] = struct { 503 result1 error 504 }{result1} 505 } 506 507 func (fake *SigningIdentity) Serialize() ([]byte, error) { 508 fake.serializeMutex.Lock() 509 ret, specificReturn := fake.serializeReturnsOnCall[len(fake.serializeArgsForCall)] 510 fake.serializeArgsForCall = append(fake.serializeArgsForCall, struct { 511 }{}) 512 fake.recordInvocation("Serialize", []interface{}{}) 513 fake.serializeMutex.Unlock() 514 if fake.SerializeStub != nil { 515 return fake.SerializeStub() 516 } 517 if specificReturn { 518 return ret.result1, ret.result2 519 } 520 fakeReturns := fake.serializeReturns 521 return fakeReturns.result1, fakeReturns.result2 522 } 523 524 func (fake *SigningIdentity) SerializeCallCount() int { 525 fake.serializeMutex.RLock() 526 defer fake.serializeMutex.RUnlock() 527 return len(fake.serializeArgsForCall) 528 } 529 530 func (fake *SigningIdentity) SerializeCalls(stub func() ([]byte, error)) { 531 fake.serializeMutex.Lock() 532 defer fake.serializeMutex.Unlock() 533 fake.SerializeStub = stub 534 } 535 536 func (fake *SigningIdentity) SerializeReturns(result1 []byte, result2 error) { 537 fake.serializeMutex.Lock() 538 defer fake.serializeMutex.Unlock() 539 fake.SerializeStub = nil 540 fake.serializeReturns = struct { 541 result1 []byte 542 result2 error 543 }{result1, result2} 544 } 545 546 func (fake *SigningIdentity) SerializeReturnsOnCall(i int, result1 []byte, result2 error) { 547 fake.serializeMutex.Lock() 548 defer fake.serializeMutex.Unlock() 549 fake.SerializeStub = nil 550 if fake.serializeReturnsOnCall == nil { 551 fake.serializeReturnsOnCall = make(map[int]struct { 552 result1 []byte 553 result2 error 554 }) 555 } 556 fake.serializeReturnsOnCall[i] = struct { 557 result1 []byte 558 result2 error 559 }{result1, result2} 560 } 561 562 func (fake *SigningIdentity) Sign(arg1 []byte) ([]byte, error) { 563 var arg1Copy []byte 564 if arg1 != nil { 565 arg1Copy = make([]byte, len(arg1)) 566 copy(arg1Copy, arg1) 567 } 568 fake.signMutex.Lock() 569 ret, specificReturn := fake.signReturnsOnCall[len(fake.signArgsForCall)] 570 fake.signArgsForCall = append(fake.signArgsForCall, struct { 571 arg1 []byte 572 }{arg1Copy}) 573 fake.recordInvocation("Sign", []interface{}{arg1Copy}) 574 fake.signMutex.Unlock() 575 if fake.SignStub != nil { 576 return fake.SignStub(arg1) 577 } 578 if specificReturn { 579 return ret.result1, ret.result2 580 } 581 fakeReturns := fake.signReturns 582 return fakeReturns.result1, fakeReturns.result2 583 } 584 585 func (fake *SigningIdentity) SignCallCount() int { 586 fake.signMutex.RLock() 587 defer fake.signMutex.RUnlock() 588 return len(fake.signArgsForCall) 589 } 590 591 func (fake *SigningIdentity) SignCalls(stub func([]byte) ([]byte, error)) { 592 fake.signMutex.Lock() 593 defer fake.signMutex.Unlock() 594 fake.SignStub = stub 595 } 596 597 func (fake *SigningIdentity) SignArgsForCall(i int) []byte { 598 fake.signMutex.RLock() 599 defer fake.signMutex.RUnlock() 600 argsForCall := fake.signArgsForCall[i] 601 return argsForCall.arg1 602 } 603 604 func (fake *SigningIdentity) SignReturns(result1 []byte, result2 error) { 605 fake.signMutex.Lock() 606 defer fake.signMutex.Unlock() 607 fake.SignStub = nil 608 fake.signReturns = struct { 609 result1 []byte 610 result2 error 611 }{result1, result2} 612 } 613 614 func (fake *SigningIdentity) SignReturnsOnCall(i int, result1 []byte, result2 error) { 615 fake.signMutex.Lock() 616 defer fake.signMutex.Unlock() 617 fake.SignStub = nil 618 if fake.signReturnsOnCall == nil { 619 fake.signReturnsOnCall = make(map[int]struct { 620 result1 []byte 621 result2 error 622 }) 623 } 624 fake.signReturnsOnCall[i] = struct { 625 result1 []byte 626 result2 error 627 }{result1, result2} 628 } 629 630 func (fake *SigningIdentity) Validate() error { 631 fake.validateMutex.Lock() 632 ret, specificReturn := fake.validateReturnsOnCall[len(fake.validateArgsForCall)] 633 fake.validateArgsForCall = append(fake.validateArgsForCall, struct { 634 }{}) 635 fake.recordInvocation("Validate", []interface{}{}) 636 fake.validateMutex.Unlock() 637 if fake.ValidateStub != nil { 638 return fake.ValidateStub() 639 } 640 if specificReturn { 641 return ret.result1 642 } 643 fakeReturns := fake.validateReturns 644 return fakeReturns.result1 645 } 646 647 func (fake *SigningIdentity) ValidateCallCount() int { 648 fake.validateMutex.RLock() 649 defer fake.validateMutex.RUnlock() 650 return len(fake.validateArgsForCall) 651 } 652 653 func (fake *SigningIdentity) ValidateCalls(stub func() error) { 654 fake.validateMutex.Lock() 655 defer fake.validateMutex.Unlock() 656 fake.ValidateStub = stub 657 } 658 659 func (fake *SigningIdentity) ValidateReturns(result1 error) { 660 fake.validateMutex.Lock() 661 defer fake.validateMutex.Unlock() 662 fake.ValidateStub = nil 663 fake.validateReturns = struct { 664 result1 error 665 }{result1} 666 } 667 668 func (fake *SigningIdentity) ValidateReturnsOnCall(i int, result1 error) { 669 fake.validateMutex.Lock() 670 defer fake.validateMutex.Unlock() 671 fake.ValidateStub = nil 672 if fake.validateReturnsOnCall == nil { 673 fake.validateReturnsOnCall = make(map[int]struct { 674 result1 error 675 }) 676 } 677 fake.validateReturnsOnCall[i] = struct { 678 result1 error 679 }{result1} 680 } 681 682 func (fake *SigningIdentity) Verify(arg1 []byte, arg2 []byte) error { 683 var arg1Copy []byte 684 if arg1 != nil { 685 arg1Copy = make([]byte, len(arg1)) 686 copy(arg1Copy, arg1) 687 } 688 var arg2Copy []byte 689 if arg2 != nil { 690 arg2Copy = make([]byte, len(arg2)) 691 copy(arg2Copy, arg2) 692 } 693 fake.verifyMutex.Lock() 694 ret, specificReturn := fake.verifyReturnsOnCall[len(fake.verifyArgsForCall)] 695 fake.verifyArgsForCall = append(fake.verifyArgsForCall, struct { 696 arg1 []byte 697 arg2 []byte 698 }{arg1Copy, arg2Copy}) 699 fake.recordInvocation("Verify", []interface{}{arg1Copy, arg2Copy}) 700 fake.verifyMutex.Unlock() 701 if fake.VerifyStub != nil { 702 return fake.VerifyStub(arg1, arg2) 703 } 704 if specificReturn { 705 return ret.result1 706 } 707 fakeReturns := fake.verifyReturns 708 return fakeReturns.result1 709 } 710 711 func (fake *SigningIdentity) VerifyCallCount() int { 712 fake.verifyMutex.RLock() 713 defer fake.verifyMutex.RUnlock() 714 return len(fake.verifyArgsForCall) 715 } 716 717 func (fake *SigningIdentity) VerifyCalls(stub func([]byte, []byte) error) { 718 fake.verifyMutex.Lock() 719 defer fake.verifyMutex.Unlock() 720 fake.VerifyStub = stub 721 } 722 723 func (fake *SigningIdentity) VerifyArgsForCall(i int) ([]byte, []byte) { 724 fake.verifyMutex.RLock() 725 defer fake.verifyMutex.RUnlock() 726 argsForCall := fake.verifyArgsForCall[i] 727 return argsForCall.arg1, argsForCall.arg2 728 } 729 730 func (fake *SigningIdentity) VerifyReturns(result1 error) { 731 fake.verifyMutex.Lock() 732 defer fake.verifyMutex.Unlock() 733 fake.VerifyStub = nil 734 fake.verifyReturns = struct { 735 result1 error 736 }{result1} 737 } 738 739 func (fake *SigningIdentity) VerifyReturnsOnCall(i int, result1 error) { 740 fake.verifyMutex.Lock() 741 defer fake.verifyMutex.Unlock() 742 fake.VerifyStub = nil 743 if fake.verifyReturnsOnCall == nil { 744 fake.verifyReturnsOnCall = make(map[int]struct { 745 result1 error 746 }) 747 } 748 fake.verifyReturnsOnCall[i] = struct { 749 result1 error 750 }{result1} 751 } 752 753 func (fake *SigningIdentity) Invocations() map[string][][]interface{} { 754 fake.invocationsMutex.RLock() 755 defer fake.invocationsMutex.RUnlock() 756 fake.anonymousMutex.RLock() 757 defer fake.anonymousMutex.RUnlock() 758 fake.expiresAtMutex.RLock() 759 defer fake.expiresAtMutex.RUnlock() 760 fake.getIdentifierMutex.RLock() 761 defer fake.getIdentifierMutex.RUnlock() 762 fake.getMSPIdentifierMutex.RLock() 763 defer fake.getMSPIdentifierMutex.RUnlock() 764 fake.getOrganizationalUnitsMutex.RLock() 765 defer fake.getOrganizationalUnitsMutex.RUnlock() 766 fake.getPublicVersionMutex.RLock() 767 defer fake.getPublicVersionMutex.RUnlock() 768 fake.satisfiesPrincipalMutex.RLock() 769 defer fake.satisfiesPrincipalMutex.RUnlock() 770 fake.serializeMutex.RLock() 771 defer fake.serializeMutex.RUnlock() 772 fake.signMutex.RLock() 773 defer fake.signMutex.RUnlock() 774 fake.validateMutex.RLock() 775 defer fake.validateMutex.RUnlock() 776 fake.verifyMutex.RLock() 777 defer fake.verifyMutex.RUnlock() 778 copiedInvocations := map[string][][]interface{}{} 779 for key, value := range fake.invocations { 780 copiedInvocations[key] = value 781 } 782 return copiedInvocations 783 } 784 785 func (fake *SigningIdentity) recordInvocation(key string, args []interface{}) { 786 fake.invocationsMutex.Lock() 787 defer fake.invocationsMutex.Unlock() 788 if fake.invocations == nil { 789 fake.invocations = map[string][][]interface{}{} 790 } 791 if fake.invocations[key] == nil { 792 fake.invocations[key] = [][]interface{}{} 793 } 794 fake.invocations[key] = append(fake.invocations[key], args) 795 }