mock_tpm.h

// Copyright 2014 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef TRUNKS_MOCK_TPM_H_
#define TRUNKS_MOCK_TPM_H_

#include <string>
#include <vector>

#include <base/functional/callback.h>
#include <gmock/gmock.h>

#include "trunks/tpm_generated.h"

namespace trunks {

class MockTpm : public Tpm {
 public:
  explicit MockTpm(CommandTransceiver* transceiver = nullptr);
  ~MockTpm() override;

  MOCK_METHOD0(get_transceiver, CommandTransceiver*());
  MOCK_METHOD3(Startup,
               void(const TPM_SU& startup_type,
                    AuthorizationDelegate* authorization_delegate,
                    StartupResponse callback));
  MOCK_METHOD2(StartupSync,
               TPM_RC(const TPM_SU& startup_type,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(Shutdown,
               void(const TPM_SU& shutdown_type,
                    AuthorizationDelegate* authorization_delegate,
                    ShutdownResponse callback));
  MOCK_METHOD2(ShutdownSync,
               TPM_RC(const TPM_SU& shutdown_type,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(SelfTest,
               void(const TPMI_YES_NO& full_test,
                    AuthorizationDelegate* authorization_delegate,
                    SelfTestResponse callback));
  MOCK_METHOD2(SelfTestSync,
               TPM_RC(const TPMI_YES_NO& full_test,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(IncrementalSelfTest,
               void(const TPML_ALG& to_test,
                    AuthorizationDelegate* authorization_delegate,
                    IncrementalSelfTestResponse callback));
  MOCK_METHOD3(IncrementalSelfTestSync,
               TPM_RC(const TPML_ALG& to_test,
                      TPML_ALG* to_do_list,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD2(GetTestResult,
               void(AuthorizationDelegate* authorization_delegate,
                    GetTestResultResponse callback));
  MOCK_METHOD3(GetTestResultSync,
               TPM_RC(TPM2B_MAX_BUFFER* out_data,
                      TPM_RC* test_result,
                      AuthorizationDelegate* authorization_delegate));
  // Too many args to mock, forward to *Short version.
  void StartAuthSession(const TPMI_DH_OBJECT& tpm_key,
                        const std::string& tpm_key_name,
                        const TPMI_DH_ENTITY& bind,
                        const std::string& bind_name,
                        const TPM2B_NONCE& nonce_caller,
                        const TPM2B_ENCRYPTED_SECRET& encrypted_salt,
                        const TPM_SE& session_type,
                        const TPMT_SYM_DEF& symmetric,
                        const TPMI_ALG_HASH& auth_hash,
                        AuthorizationDelegate* authorization_delegate,
                        StartAuthSessionResponse callback) override;
  MOCK_METHOD9(StartAuthSessionShort,
               void(const TPMI_DH_OBJECT& tpm_key,
                    const TPMI_DH_ENTITY& bind,
                    const TPM2B_NONCE& nonce_caller,
                    const TPM2B_ENCRYPTED_SECRET& encrypted_salt,
                    const TPM_SE& session_type,
                    const TPMT_SYM_DEF& symmetric,
                    const TPMI_ALG_HASH& auth_hash,
                    AuthorizationDelegate* authorization_delegate,
                    StartAuthSessionResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC StartAuthSessionSync(
      const TPMI_DH_OBJECT& tpm_key,
      const std::string& tpm_key_name,
      const TPMI_DH_ENTITY& bind,
      const std::string& bind_name,
      const TPM2B_NONCE& nonce_caller,
      const TPM2B_ENCRYPTED_SECRET& encrypted_salt,
      const TPM_SE& session_type,
      const TPMT_SYM_DEF& symmetric,
      const TPMI_ALG_HASH& auth_hash,
      TPMI_SH_AUTH_SESSION* session_handle,
      TPM2B_NONCE* nonce_tpm,
      AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD10(StartAuthSessionSyncShort,
                TPM_RC(const TPMI_DH_OBJECT& tpm_key,
                       const TPMI_DH_ENTITY& bind,
                       const TPM2B_NONCE& nonce_caller,
                       const TPM2B_ENCRYPTED_SECRET& encrypted_salt,
                       const TPM_SE& session_type,
                       const TPMT_SYM_DEF& symmetric,
                       const TPMI_ALG_HASH& auth_hash,
                       TPMI_SH_AUTH_SESSION* session_handle,
                       TPM2B_NONCE* nonce_tpm,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(PolicyRestart,
               void(const TPMI_SH_POLICY& session_handle,
                    const std::string& session_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyRestartResponse callback));
  MOCK_METHOD3(PolicyRestartSync,
               TPM_RC(const TPMI_SH_POLICY& session_handle,
                      const std::string& session_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(Create,
               void(const TPMI_DH_OBJECT& parent_handle,
                    const std::string& parent_handle_name,
                    const TPM2B_SENSITIVE_CREATE& in_sensitive,
                    const TPM2B_PUBLIC& in_public,
                    const TPM2B_DATA& outside_info,
                    const TPML_PCR_SELECTION& creation_pcr,
                    AuthorizationDelegate* authorization_delegate,
                    CreateResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC CreateSync(const TPMI_DH_OBJECT& parent_handle,
                    const std::string& parent_handle_name,
                    const TPM2B_SENSITIVE_CREATE& in_sensitive,
                    const TPM2B_PUBLIC& in_public,
                    const TPM2B_DATA& outside_info,
                    const TPML_PCR_SELECTION& creation_pcr,
                    TPM2B_PRIVATE* out_private,
                    TPM2B_PUBLIC* out_public,
                    TPM2B_CREATION_DATA* creation_data,
                    TPM2B_DIGEST* creation_hash,
                    TPMT_TK_CREATION* creation_ticket,
                    AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD10(CreateSyncShort,
                TPM_RC(const TPMI_DH_OBJECT& parent_handle,
                       const TPM2B_SENSITIVE_CREATE& in_sensitive,
                       const TPM2B_PUBLIC& in_public,
                       const TPML_PCR_SELECTION& creation_pcr,
                       TPM2B_PRIVATE* out_private,
                       TPM2B_PUBLIC* out_public,
                       TPM2B_CREATION_DATA* creation_data,
                       TPM2B_DIGEST* creation_hash,
                       TPMT_TK_CREATION* creation_ticket,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(Load,
               void(const TPMI_DH_OBJECT& parent_handle,
                    const std::string& parent_handle_name,
                    const TPM2B_PRIVATE& in_private,
                    const TPM2B_PUBLIC& in_public,
                    AuthorizationDelegate* authorization_delegate,
                    LoadResponse callback));
  MOCK_METHOD7(LoadSync,
               TPM_RC(const TPMI_DH_OBJECT& parent_handle,
                      const std::string& parent_handle_name,
                      const TPM2B_PRIVATE& in_private,
                      const TPM2B_PUBLIC& in_public,
                      TPM_HANDLE* object_handle,
                      TPM2B_NAME* name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(LoadExternal,
               void(const TPM2B_SENSITIVE& in_private,
                    const TPM2B_PUBLIC& in_public,
                    const TPMI_RH_HIERARCHY& hierarchy,
                    AuthorizationDelegate* authorization_delegate,
                    LoadExternalResponse callback));
  MOCK_METHOD6(LoadExternalSync,
               TPM_RC(const TPM2B_SENSITIVE& in_private,
                      const TPM2B_PUBLIC& in_public,
                      const TPMI_RH_HIERARCHY& hierarchy,
                      TPM_HANDLE* object_handle,
                      TPM2B_NAME* name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(ReadPublic,
               void(const TPMI_DH_OBJECT& object_handle,
                    const std::string& object_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    ReadPublicResponse callback));
  MOCK_METHOD6(ReadPublicSync,
               TPM_RC(const TPMI_DH_OBJECT& object_handle,
                      const std::string& object_handle_name,
                      TPM2B_PUBLIC* out_public,
                      TPM2B_NAME* name,
                      TPM2B_NAME* qualified_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(ActivateCredential,
               void(const TPMI_DH_OBJECT& activate_handle,
                    const std::string& activate_handle_name,
                    const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_ID_OBJECT& credential_blob,
                    const TPM2B_ENCRYPTED_SECRET& secret,
                    AuthorizationDelegate* authorization_delegate,
                    ActivateCredentialResponse callback));
  MOCK_METHOD8(ActivateCredentialSync,
               TPM_RC(const TPMI_DH_OBJECT& activate_handle,
                      const std::string& activate_handle_name,
                      const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_ID_OBJECT& credential_blob,
                      const TPM2B_ENCRYPTED_SECRET& secret,
                      TPM2B_DIGEST* cert_info,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(MakeCredential,
               void(const TPMI_DH_OBJECT& handle,
                    const std::string& handle_name,
                    const TPM2B_DIGEST& credential,
                    const TPM2B_NAME& object_name,
                    AuthorizationDelegate* authorization_delegate,
                    MakeCredentialResponse callback));
  MOCK_METHOD7(MakeCredentialSync,
               TPM_RC(const TPMI_DH_OBJECT& handle,
                      const std::string& handle_name,
                      const TPM2B_DIGEST& credential,
                      const TPM2B_NAME& object_name,
                      TPM2B_ID_OBJECT* credential_blob,
                      TPM2B_ENCRYPTED_SECRET* secret,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(Unseal,
               void(const TPMI_DH_OBJECT& item_handle,
                    const std::string& item_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    UnsealResponse callback));
  MOCK_METHOD4(UnsealSync,
               TPM_RC(const TPMI_DH_OBJECT& item_handle,
                      const std::string& item_handle_name,
                      TPM2B_SENSITIVE_DATA* out_data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(ObjectChangeAuth,
               void(const TPMI_DH_OBJECT& object_handle,
                    const std::string& object_handle_name,
                    const TPMI_DH_OBJECT& parent_handle,
                    const std::string& parent_handle_name,
                    const TPM2B_AUTH& new_auth,
                    AuthorizationDelegate* authorization_delegate,
                    ObjectChangeAuthResponse callback));
  MOCK_METHOD7(ObjectChangeAuthSync,
               TPM_RC(const TPMI_DH_OBJECT& object_handle,
                      const std::string& object_handle_name,
                      const TPMI_DH_OBJECT& parent_handle,
                      const std::string& parent_handle_name,
                      const TPM2B_AUTH& new_auth,
                      TPM2B_PRIVATE* out_private,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(Duplicate,
               void(const TPMI_DH_OBJECT& object_handle,
                    const std::string& object_handle_name,
                    const TPMI_DH_OBJECT& new_parent_handle,
                    const std::string& new_parent_handle_name,
                    const TPM2B_DATA& encryption_key_in,
                    const TPMT_SYM_DEF_OBJECT& symmetric_alg,
                    AuthorizationDelegate* authorization_delegate,
                    DuplicateResponse callback));
  MOCK_METHOD10(DuplicateSync,
                TPM_RC(const TPMI_DH_OBJECT& object_handle,
                       const std::string& object_handle_name,
                       const TPMI_DH_OBJECT& new_parent_handle,
                       const std::string& new_parent_handle_name,
                       const TPM2B_DATA& encryption_key_in,
                       const TPMT_SYM_DEF_OBJECT& symmetric_alg,
                       TPM2B_DATA* encryption_key_out,
                       TPM2B_PRIVATE* duplicate,
                       TPM2B_ENCRYPTED_SECRET* out_sym_seed,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD9(Rewrap,
               void(const TPMI_DH_OBJECT& old_parent,
                    const std::string& old_parent_name,
                    const TPMI_DH_OBJECT& new_parent,
                    const std::string& new_parent_name,
                    const TPM2B_PRIVATE& in_duplicate,
                    const TPM2B_NAME& name,
                    const TPM2B_ENCRYPTED_SECRET& in_sym_seed,
                    AuthorizationDelegate* authorization_delegate,
                    RewrapResponse callback));
  MOCK_METHOD10(RewrapSync,
                TPM_RC(const TPMI_DH_OBJECT& old_parent,
                       const std::string& old_parent_name,
                       const TPMI_DH_OBJECT& new_parent,
                       const std::string& new_parent_name,
                       const TPM2B_PRIVATE& in_duplicate,
                       const TPM2B_NAME& name,
                       const TPM2B_ENCRYPTED_SECRET& in_sym_seed,
                       TPM2B_PRIVATE* out_duplicate,
                       TPM2B_ENCRYPTED_SECRET* out_sym_seed,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD9(Import,
               void(const TPMI_DH_OBJECT& parent_handle,
                    const std::string& parent_handle_name,
                    const TPM2B_DATA& encryption_key,
                    const TPM2B_PUBLIC& object_public,
                    const TPM2B_PRIVATE& duplicate,
                    const TPM2B_ENCRYPTED_SECRET& in_sym_seed,
                    const TPMT_SYM_DEF_OBJECT& symmetric_alg,
                    AuthorizationDelegate* authorization_delegate,
                    ImportResponse callback));
  MOCK_METHOD9(ImportSync,
               TPM_RC(const TPMI_DH_OBJECT& parent_handle,
                      const std::string& parent_handle_name,
                      const TPM2B_DATA& encryption_key,
                      const TPM2B_PUBLIC& object_public,
                      const TPM2B_PRIVATE& duplicate,
                      const TPM2B_ENCRYPTED_SECRET& in_sym_seed,
                      const TPMT_SYM_DEF_OBJECT& symmetric_alg,
                      TPM2B_PRIVATE* out_private,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(RSA_Encrypt,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_PUBLIC_KEY_RSA& message,
                    const TPMT_RSA_DECRYPT& in_scheme,
                    const TPM2B_DATA& label,
                    AuthorizationDelegate* authorization_delegate,
                    RSA_EncryptResponse callback));
  MOCK_METHOD7(RSA_EncryptSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_PUBLIC_KEY_RSA& message,
                      const TPMT_RSA_DECRYPT& in_scheme,
                      const TPM2B_DATA& label,
                      TPM2B_PUBLIC_KEY_RSA* out_data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(RSA_Decrypt,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_PUBLIC_KEY_RSA& cipher_text,
                    const TPMT_RSA_DECRYPT& in_scheme,
                    const TPM2B_DATA& label,
                    AuthorizationDelegate* authorization_delegate,
                    RSA_DecryptResponse callback));
  MOCK_METHOD7(RSA_DecryptSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_PUBLIC_KEY_RSA& cipher_text,
                      const TPMT_RSA_DECRYPT& in_scheme,
                      const TPM2B_DATA& label,
                      TPM2B_PUBLIC_KEY_RSA* message,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(ECDH_KeyGen,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    ECDH_KeyGenResponse callback));
  MOCK_METHOD5(ECDH_KeyGenSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      TPM2B_ECC_POINT* z_point,
                      TPM2B_ECC_POINT* pub_point,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(ECDH_ZGen,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_ECC_POINT& in_point,
                    AuthorizationDelegate* authorization_delegate,
                    ECDH_ZGenResponse callback));
  MOCK_METHOD5(ECDH_ZGenSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_ECC_POINT& in_point,
                      TPM2B_ECC_POINT* out_point,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(ECC_Parameters,
               void(const TPMI_ECC_CURVE& curve_id,
                    AuthorizationDelegate* authorization_delegate,
                    ECC_ParametersResponse callback));
  MOCK_METHOD3(ECC_ParametersSync,
               TPM_RC(const TPMI_ECC_CURVE& curve_id,
                      TPMS_ALGORITHM_DETAIL_ECC* parameters,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(ZGen_2Phase,
               void(const TPMI_DH_OBJECT& key_a,
                    const std::string& key_a_name,
                    const TPM2B_ECC_POINT& in_qs_b,
                    const TPM2B_ECC_POINT& in_qe_b,
                    const TPMI_ECC_KEY_EXCHANGE& in_scheme,
                    const UINT16& counter,
                    AuthorizationDelegate* authorization_delegate,
                    ZGen_2PhaseResponse callback));
  MOCK_METHOD9(ZGen_2PhaseSync,
               TPM_RC(const TPMI_DH_OBJECT& key_a,
                      const std::string& key_a_name,
                      const TPM2B_ECC_POINT& in_qs_b,
                      const TPM2B_ECC_POINT& in_qe_b,
                      const TPMI_ECC_KEY_EXCHANGE& in_scheme,
                      const UINT16& counter,
                      TPM2B_ECC_POINT* out_z1,
                      TPM2B_ECC_POINT* out_z2,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(EncryptDecrypt,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPMI_YES_NO& decrypt,
                    const TPMI_ALG_SYM_MODE& mode,
                    const TPM2B_IV& iv_in,
                    const TPM2B_MAX_BUFFER& in_data,
                    AuthorizationDelegate* authorization_delegate,
                    EncryptDecryptResponse callback));
  MOCK_METHOD9(EncryptDecryptSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPMI_YES_NO& decrypt,
                      const TPMI_ALG_SYM_MODE& mode,
                      const TPM2B_IV& iv_in,
                      const TPM2B_MAX_BUFFER& in_data,
                      TPM2B_MAX_BUFFER* out_data,
                      TPM2B_IV* iv_out,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(Hash,
               void(const TPM2B_MAX_BUFFER& data,
                    const TPMI_ALG_HASH& hash_alg,
                    const TPMI_RH_HIERARCHY& hierarchy,
                    AuthorizationDelegate* authorization_delegate,
                    HashResponse callback));
  MOCK_METHOD6(HashSync,
               TPM_RC(const TPM2B_MAX_BUFFER& data,
                      const TPMI_ALG_HASH& hash_alg,
                      const TPMI_RH_HIERARCHY& hierarchy,
                      TPM2B_DIGEST* out_hash,
                      TPMT_TK_HASHCHECK* validation,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(HMAC,
               void(const TPMI_DH_OBJECT& handle,
                    const std::string& handle_name,
                    const TPM2B_MAX_BUFFER& buffer,
                    const TPMI_ALG_HASH& hash_alg,
                    AuthorizationDelegate* authorization_delegate,
                    HMACResponse callback));
  MOCK_METHOD6(HMACSync,
               TPM_RC(const TPMI_DH_OBJECT& handle,
                      const std::string& handle_name,
                      const TPM2B_MAX_BUFFER& buffer,
                      const TPMI_ALG_HASH& hash_alg,
                      TPM2B_DIGEST* out_hmac,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(GetRandom,
               void(const UINT16& bytes_requested,
                    AuthorizationDelegate* authorization_delegate,
                    GetRandomResponse callback));
  MOCK_METHOD3(GetRandomSync,
               TPM_RC(const UINT16& bytes_requested,
                      TPM2B_DIGEST* random_bytes,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(StirRandom,
               void(const TPM2B_SENSITIVE_DATA& in_data,
                    AuthorizationDelegate* authorization_delegate,
                    StirRandomResponse callback));
  MOCK_METHOD2(StirRandomSync,
               TPM_RC(const TPM2B_SENSITIVE_DATA& in_data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(HMAC_Start,
               void(const TPMI_DH_OBJECT& handle,
                    const std::string& handle_name,
                    const TPM2B_AUTH& auth,
                    const TPMI_ALG_HASH& hash_alg,
                    AuthorizationDelegate* authorization_delegate,
                    HMAC_StartResponse callback));
  MOCK_METHOD6(HMAC_StartSync,
               TPM_RC(const TPMI_DH_OBJECT& handle,
                      const std::string& handle_name,
                      const TPM2B_AUTH& auth,
                      const TPMI_ALG_HASH& hash_alg,
                      TPMI_DH_OBJECT* sequence_handle,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(HashSequenceStart,
               void(const TPM2B_AUTH& auth,
                    const TPMI_ALG_HASH& hash_alg,
                    AuthorizationDelegate* authorization_delegate,
                    HashSequenceStartResponse callback));
  MOCK_METHOD4(HashSequenceStartSync,
               TPM_RC(const TPM2B_AUTH& auth,
                      const TPMI_ALG_HASH& hash_alg,
                      TPMI_DH_OBJECT* sequence_handle,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(SequenceUpdate,
               void(const TPMI_DH_OBJECT& sequence_handle,
                    const std::string& sequence_handle_name,
                    const TPM2B_MAX_BUFFER& buffer,
                    AuthorizationDelegate* authorization_delegate,
                    SequenceUpdateResponse callback));
  MOCK_METHOD4(SequenceUpdateSync,
               TPM_RC(const TPMI_DH_OBJECT& sequence_handle,
                      const std::string& sequence_handle_name,
                      const TPM2B_MAX_BUFFER& buffer,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(SequenceComplete,
               void(const TPMI_DH_OBJECT& sequence_handle,
                    const std::string& sequence_handle_name,
                    const TPM2B_MAX_BUFFER& buffer,
                    const TPMI_RH_HIERARCHY& hierarchy,
                    AuthorizationDelegate* authorization_delegate,
                    SequenceCompleteResponse callback));
  MOCK_METHOD7(SequenceCompleteSync,
               TPM_RC(const TPMI_DH_OBJECT& sequence_handle,
                      const std::string& sequence_handle_name,
                      const TPM2B_MAX_BUFFER& buffer,
                      const TPMI_RH_HIERARCHY& hierarchy,
                      TPM2B_DIGEST* result,
                      TPMT_TK_HASHCHECK* validation,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(EventSequenceComplete,
               void(const TPMI_DH_PCR& pcr_handle,
                    const std::string& pcr_handle_name,
                    const TPMI_DH_OBJECT& sequence_handle,
                    const std::string& sequence_handle_name,
                    const TPM2B_MAX_BUFFER& buffer,
                    AuthorizationDelegate* authorization_delegate,
                    EventSequenceCompleteResponse callback));
  MOCK_METHOD7(EventSequenceCompleteSync,
               TPM_RC(const TPMI_DH_PCR& pcr_handle,
                      const std::string& pcr_handle_name,
                      const TPMI_DH_OBJECT& sequence_handle,
                      const std::string& sequence_handle_name,
                      const TPM2B_MAX_BUFFER& buffer,
                      TPML_DIGEST_VALUES* results,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(Certify,
               void(const TPMI_DH_OBJECT& object_handle,
                    const std::string& object_handle_name,
                    const TPMI_DH_OBJECT& sign_handle,
                    const std::string& sign_handle_name,
                    const TPM2B_DATA& qualifying_data,
                    const TPMT_SIG_SCHEME& in_scheme,
                    AuthorizationDelegate* authorization_delegate,
                    CertifyResponse callback));
  MOCK_METHOD9(CertifySync,
               TPM_RC(const TPMI_DH_OBJECT& object_handle,
                      const std::string& object_handle_name,
                      const TPMI_DH_OBJECT& sign_handle,
                      const std::string& sign_handle_name,
                      const TPM2B_DATA& qualifying_data,
                      const TPMT_SIG_SCHEME& in_scheme,
                      TPM2B_ATTEST* certify_info,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD10(CertifyCreation,
                void(const TPMI_DH_OBJECT& sign_handle,
                     const std::string& sign_handle_name,
                     const TPMI_DH_OBJECT& object_handle,
                     const std::string& object_handle_name,
                     const TPM2B_DATA& qualifying_data,
                     const TPM2B_DIGEST& creation_hash,
                     const TPMT_SIG_SCHEME& in_scheme,
                     const TPMT_TK_CREATION& creation_ticket,
                     AuthorizationDelegate* authorization_delegate,
                     CertifyCreationResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC CertifyCreationSync(
      const TPMI_DH_OBJECT& sign_handle,
      const std::string& sign_handle_name,
      const TPMI_DH_OBJECT& object_handle,
      const std::string& object_handle_name,
      const TPM2B_DATA& qualifying_data,
      const TPM2B_DIGEST& creation_hash,
      const TPMT_SIG_SCHEME& in_scheme,
      const TPMT_TK_CREATION& creation_ticket,
      TPM2B_ATTEST* certify_info,
      TPMT_SIGNATURE* signature,
      AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD9(CertifyCreationSyncShort,
               TPM_RC(const TPMI_DH_OBJECT& sign_handle,
                      const TPMI_DH_OBJECT& object_handle,
                      const TPM2B_DATA& qualifying_data,
                      const TPM2B_DIGEST& creation_hash,
                      const TPMT_SIG_SCHEME& in_scheme,
                      const TPMT_TK_CREATION& creation_ticket,
                      TPM2B_ATTEST* certify_info,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(Quote,
               void(const TPMI_DH_OBJECT& sign_handle,
                    const std::string& sign_handle_name,
                    const TPM2B_DATA& qualifying_data,
                    const TPMT_SIG_SCHEME& in_scheme,
                    const TPML_PCR_SELECTION& pcrselect,
                    AuthorizationDelegate* authorization_delegate,
                    QuoteResponse callback));
  MOCK_METHOD8(QuoteSync,
               TPM_RC(const TPMI_DH_OBJECT& sign_handle,
                      const std::string& sign_handle_name,
                      const TPM2B_DATA& qualifying_data,
                      const TPMT_SIG_SCHEME& in_scheme,
                      const TPML_PCR_SELECTION& pcrselect,
                      TPM2B_ATTEST* quoted,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD10(GetSessionAuditDigest,
                void(const TPMI_RH_ENDORSEMENT& privacy_admin_handle,
                     const std::string& privacy_admin_handle_name,
                     const TPMI_DH_OBJECT& sign_handle,
                     const std::string& sign_handle_name,
                     const TPMI_SH_HMAC& session_handle,
                     const std::string& session_handle_name,
                     const TPM2B_DATA& qualifying_data,
                     const TPMT_SIG_SCHEME& in_scheme,
                     AuthorizationDelegate* authorization_delegate,
                     GetSessionAuditDigestResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC GetSessionAuditDigestSync(
      const TPMI_RH_ENDORSEMENT& privacy_admin_handle,
      const std::string& privacy_admin_handle_name,
      const TPMI_DH_OBJECT& sign_handle,
      const std::string& sign_handle_name,
      const TPMI_SH_HMAC& session_handle,
      const std::string& session_handle_name,
      const TPM2B_DATA& qualifying_data,
      const TPMT_SIG_SCHEME& in_scheme,
      TPM2B_ATTEST* audit_info,
      TPMT_SIGNATURE* signature,
      AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD8(GetSessionAuditDigestSyncShort,
               TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_admin_handle,
                      const TPMI_DH_OBJECT& sign_handle,
                      const TPMI_SH_HMAC& session_handle,
                      const TPM2B_DATA& qualifying_data,
                      const TPMT_SIG_SCHEME& in_scheme,
                      TPM2B_ATTEST* audit_info,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(GetCommandAuditDigest,
               void(const TPMI_RH_ENDORSEMENT& privacy_handle,
                    const std::string& privacy_handle_name,
                    const TPMI_DH_OBJECT& sign_handle,
                    const std::string& sign_handle_name,
                    const TPM2B_DATA& qualifying_data,
                    const TPMT_SIG_SCHEME& in_scheme,
                    AuthorizationDelegate* authorization_delegate,
                    GetCommandAuditDigestResponse callback));
  MOCK_METHOD9(GetCommandAuditDigestSync,
               TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_handle,
                      const std::string& privacy_handle_name,
                      const TPMI_DH_OBJECT& sign_handle,
                      const std::string& sign_handle_name,
                      const TPM2B_DATA& qualifying_data,
                      const TPMT_SIG_SCHEME& in_scheme,
                      TPM2B_ATTEST* audit_info,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(GetTime,
               void(const TPMI_RH_ENDORSEMENT& privacy_admin_handle,
                    const std::string& privacy_admin_handle_name,
                    const TPMI_DH_OBJECT& sign_handle,
                    const std::string& sign_handle_name,
                    const TPM2B_DATA& qualifying_data,
                    const TPMT_SIG_SCHEME& in_scheme,
                    AuthorizationDelegate* authorization_delegate,
                    GetTimeResponse callback));
  MOCK_METHOD9(GetTimeSync,
               TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_admin_handle,
                      const std::string& privacy_admin_handle_name,
                      const TPMI_DH_OBJECT& sign_handle,
                      const std::string& sign_handle_name,
                      const TPM2B_DATA& qualifying_data,
                      const TPMT_SIG_SCHEME& in_scheme,
                      TPM2B_ATTEST* time_info,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(Commit,
               void(const TPMI_DH_OBJECT& sign_handle,
                    const std::string& sign_handle_name,
                    const UINT32& param_size,
                    const TPM2B_ECC_POINT& p1,
                    const TPM2B_SENSITIVE_DATA& s2,
                    const TPM2B_ECC_PARAMETER& y2,
                    AuthorizationDelegate* authorization_delegate,
                    CommitResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC CommitSync(const TPMI_DH_OBJECT& sign_handle,
                    const std::string& sign_handle_name,
                    const UINT32& param_size,
                    const TPM2B_ECC_POINT& p1,
                    const TPM2B_SENSITIVE_DATA& s2,
                    const TPM2B_ECC_PARAMETER& y2,
                    UINT32* param_size_out,
                    TPM2B_ECC_POINT* k,
                    TPM2B_ECC_POINT* l,
                    TPM2B_ECC_POINT* e,
                    UINT16* counter,
                    AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD10(CommitSyncShort,
                TPM_RC(const TPMI_DH_OBJECT& sign_handle,
                       const UINT32& param_size,
                       const TPM2B_ECC_POINT& p1,
                       const TPM2B_ECC_PARAMETER& y2,
                       UINT32* param_size_out,
                       TPM2B_ECC_POINT* k,
                       TPM2B_ECC_POINT* l,
                       TPM2B_ECC_POINT* e,
                       UINT16* counter,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(EC_Ephemeral,
               void(const UINT32& param_size,
                    const TPMI_ECC_CURVE& curve_id,
                    AuthorizationDelegate* authorization_delegate,
                    EC_EphemeralResponse callback));
  MOCK_METHOD6(EC_EphemeralSync,
               TPM_RC(const UINT32& param_size,
                      const TPMI_ECC_CURVE& curve_id,
                      UINT32* param_size_out,
                      TPM2B_ECC_POINT* q,
                      UINT16* counter,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(VerifySignature,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_DIGEST& digest,
                    const TPMT_SIGNATURE& signature,
                    AuthorizationDelegate* authorization_delegate,
                    VerifySignatureResponse callback));
  MOCK_METHOD6(VerifySignatureSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_DIGEST& digest,
                      const TPMT_SIGNATURE& signature,
                      TPMT_TK_VERIFIED* validation,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(Sign,
               void(const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_DIGEST& digest,
                    const TPMT_SIG_SCHEME& in_scheme,
                    const TPMT_TK_HASHCHECK& validation,
                    AuthorizationDelegate* authorization_delegate,
                    SignResponse callback));
  MOCK_METHOD7(SignSync,
               TPM_RC(const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_DIGEST& digest,
                      const TPMT_SIG_SCHEME& in_scheme,
                      const TPMT_TK_HASHCHECK& validation,
                      TPMT_SIGNATURE* signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(SetCommandCodeAuditStatus,
               void(const TPMI_RH_PROVISION& auth,
                    const std::string& auth_name,
                    const TPMI_ALG_HASH& audit_alg,
                    const TPML_CC& set_list,
                    const TPML_CC& clear_list,
                    AuthorizationDelegate* authorization_delegate,
                    SetCommandCodeAuditStatusResponse callback));
  MOCK_METHOD6(SetCommandCodeAuditStatusSync,
               TPM_RC(const TPMI_RH_PROVISION& auth,
                      const std::string& auth_name,
                      const TPMI_ALG_HASH& audit_alg,
                      const TPML_CC& set_list,
                      const TPML_CC& clear_list,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PCR_Extend,
               void(const TPMI_DH_PCR& pcr_handle,
                    const std::string& pcr_handle_name,
                    const TPML_DIGEST_VALUES& digests,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_ExtendResponse callback));
  MOCK_METHOD4(PCR_ExtendSync,
               TPM_RC(const TPMI_DH_PCR& pcr_handle,
                      const std::string& pcr_handle_name,
                      const TPML_DIGEST_VALUES& digests,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PCR_Event,
               void(const TPMI_DH_PCR& pcr_handle,
                    const std::string& pcr_handle_name,
                    const TPM2B_EVENT& event_data,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_EventResponse callback));
  MOCK_METHOD5(PCR_EventSync,
               TPM_RC(const TPMI_DH_PCR& pcr_handle,
                      const std::string& pcr_handle_name,
                      const TPM2B_EVENT& event_data,
                      TPML_DIGEST_VALUES* digests,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(PCR_Read,
               void(const TPML_PCR_SELECTION& pcr_selection_in,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_ReadResponse callback));
  MOCK_METHOD5(PCR_ReadSync,
               TPM_RC(const TPML_PCR_SELECTION& pcr_selection_in,
                      UINT32* pcr_update_counter,
                      TPML_PCR_SELECTION* pcr_selection_out,
                      TPML_DIGEST* pcr_values,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PCR_Allocate,
               void(const TPMI_RH_PLATFORM& auth_handle,
                    const std::string& auth_handle_name,
                    const TPML_PCR_SELECTION& pcr_allocation,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_AllocateResponse callback));
  MOCK_METHOD8(PCR_AllocateSync,
               TPM_RC(const TPMI_RH_PLATFORM& auth_handle,
                      const std::string& auth_handle_name,
                      const TPML_PCR_SELECTION& pcr_allocation,
                      TPMI_YES_NO* allocation_success,
                      UINT32* max_pcr,
                      UINT32* size_needed,
                      UINT32* size_available,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(PCR_SetAuthPolicy,
               void(const TPMI_RH_PLATFORM& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_DH_PCR& pcr_num,
                    const std::string& pcr_num_name,
                    const TPM2B_DIGEST& auth_policy,
                    const TPMI_ALG_HASH& policy_digest,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_SetAuthPolicyResponse callback));
  MOCK_METHOD7(PCR_SetAuthPolicySync,
               TPM_RC(const TPMI_RH_PLATFORM& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_DH_PCR& pcr_num,
                      const std::string& pcr_num_name,
                      const TPM2B_DIGEST& auth_policy,
                      const TPMI_ALG_HASH& policy_digest,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PCR_SetAuthValue,
               void(const TPMI_DH_PCR& pcr_handle,
                    const std::string& pcr_handle_name,
                    const TPM2B_DIGEST& auth,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_SetAuthValueResponse callback));
  MOCK_METHOD4(PCR_SetAuthValueSync,
               TPM_RC(const TPMI_DH_PCR& pcr_handle,
                      const std::string& pcr_handle_name,
                      const TPM2B_DIGEST& auth,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(PCR_Reset,
               void(const TPMI_DH_PCR& pcr_handle,
                    const std::string& pcr_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    PCR_ResetResponse callback));
  MOCK_METHOD3(PCR_ResetSync,
               TPM_RC(const TPMI_DH_PCR& pcr_handle,
                      const std::string& pcr_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  // Too many args to mock, forward to *Short version.
  void PolicySigned(const TPMI_DH_OBJECT& auth_object,
                    const std::string& auth_object_name,
                    const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_NONCE& nonce_tpm,
                    const TPM2B_DIGEST& cp_hash_a,
                    const TPM2B_NONCE& policy_ref,
                    const INT32& expiration,
                    const TPMT_SIGNATURE& auth,
                    AuthorizationDelegate* authorization_delegate,
                    PolicySignedResponse callback) override;
  MOCK_METHOD9(PolicySignedShort,
               void(const TPMI_DH_OBJECT& auth_object,
                    const TPMI_SH_POLICY& policy_session,
                    const TPM2B_NONCE& nonce_tpm,
                    const TPM2B_DIGEST& cp_hash_a,
                    const TPM2B_NONCE& policy_ref,
                    const INT32& expiration,
                    const TPMT_SIGNATURE& auth,
                    AuthorizationDelegate* authorization_delegate,
                    PolicySignedResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC PolicySignedSync(
      const TPMI_DH_OBJECT& auth_object,
      const std::string& auth_object_name,
      const TPMI_SH_POLICY& policy_session,
      const std::string& policy_session_name,
      const TPM2B_NONCE& nonce_tpm,
      const TPM2B_DIGEST& cp_hash_a,
      const TPM2B_NONCE& policy_ref,
      const INT32& expiration,
      const TPMT_SIGNATURE& auth,
      TPM2B_TIMEOUT* timeout,
      TPMT_TK_AUTH* policy_ticket,
      AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD10(PolicySignedSyncShort,
                TPM_RC(const TPMI_DH_OBJECT& auth_object,
                       const TPMI_SH_POLICY& policy_session,
                       const TPM2B_NONCE& nonce_tpm,
                       const TPM2B_DIGEST& cp_hash_a,
                       const TPM2B_NONCE& policy_ref,
                       const INT32& expiration,
                       const TPMT_SIGNATURE& auth,
                       TPM2B_TIMEOUT* timeout,
                       TPMT_TK_AUTH* policy_ticket,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD9(PolicyFidoSigned,
               void(const TPMI_DH_OBJECT& auth_object,
                    const std::string& auth_object_name,
                    const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const std::string& auth_data,
                    const std::vector<FIDO_DATA_RANGE>& auth_data_descr,
                    const TPMT_SIGNATURE& auth,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyFidoSignedResponse callback));
  MOCK_METHOD8(PolicyFidoSignedSync,
               TPM_RC(const TPMI_DH_OBJECT& auth_object,
                      const std::string& auth_object_name,
                      const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const std::string& auth_data,
                      const std::vector<FIDO_DATA_RANGE>& auth_data_descr,
                      const TPMT_SIGNATURE& auth,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD10(PolicySecret,
                void(const TPMI_DH_ENTITY& auth_handle,
                     const std::string& auth_handle_name,
                     const TPMI_SH_POLICY& policy_session,
                     const std::string& policy_session_name,
                     const TPM2B_NONCE& nonce_tpm,
                     const TPM2B_DIGEST& cp_hash_a,
                     const TPM2B_NONCE& policy_ref,
                     const INT32& expiration,
                     AuthorizationDelegate* authorization_delegate,
                     PolicySecretResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC PolicySecretSync(
      const TPMI_DH_ENTITY& auth_handle,
      const std::string& auth_handle_name,
      const TPMI_SH_POLICY& policy_session,
      const std::string& policy_session_name,
      const TPM2B_NONCE& nonce_tpm,
      const TPM2B_DIGEST& cp_hash_a,
      const TPM2B_NONCE& policy_ref,
      const INT32& expiration,
      TPM2B_TIMEOUT* timeout,
      TPMT_TK_AUTH* policy_ticket,
      AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD9(PolicySecretSyncShort,
               TPM_RC(const TPMI_DH_ENTITY& auth_handle,
                      const TPMI_SH_POLICY& policy_session,
                      const TPM2B_NONCE& nonce_tpm,
                      const TPM2B_DIGEST& cp_hash_a,
                      const TPM2B_NONCE& policy_ref,
                      const INT32& expiration,
                      TPM2B_TIMEOUT* timeout,
                      TPMT_TK_AUTH* policy_ticket,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD9(PolicyTicket,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_TIMEOUT& timeout,
                    const TPM2B_DIGEST& cp_hash_a,
                    const TPM2B_NONCE& policy_ref,
                    const TPM2B_NAME& auth_name,
                    const TPMT_TK_AUTH& ticket,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyTicketResponse callback));
  MOCK_METHOD8(PolicyTicketSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_TIMEOUT& timeout,
                      const TPM2B_DIGEST& cp_hash_a,
                      const TPM2B_NONCE& policy_ref,
                      const TPM2B_NAME& auth_name,
                      const TPMT_TK_AUTH& ticket,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PolicyOR,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPML_DIGEST& p_hash_list,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyORResponse callback));
  MOCK_METHOD4(PolicyORSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPML_DIGEST& p_hash_list,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(PolicyPCR,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_DIGEST& pcr_digest,
                    const TPML_PCR_SELECTION& pcrs,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyPCRResponse callback));
  MOCK_METHOD5(PolicyPCRSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_DIGEST& pcr_digest,
                      const TPML_PCR_SELECTION& pcrs,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PolicyLocality,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPMA_LOCALITY& locality,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyLocalityResponse callback));
  MOCK_METHOD4(PolicyLocalitySync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPMA_LOCALITY& locality,
                      AuthorizationDelegate* authorization_delegate));
  // Too many args to mock, forward to *Short version.
  void PolicyNV(const TPMI_RH_NV_AUTH& auth_handle,
                const std::string& auth_handle_name,
                const TPMI_RH_NV_INDEX& nv_index,
                const std::string& nv_index_name,
                const TPMI_SH_POLICY& policy_session,
                const std::string& policy_session_name,
                const TPM2B_OPERAND& operand_b,
                const UINT16& offset,
                const TPM_EO& operation,
                AuthorizationDelegate* authorization_delegate,
                PolicyNVResponse callback) override;
  MOCK_METHOD8(PolicyNVShort,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const TPMI_SH_POLICY& policy_session,
                    const TPM2B_OPERAND& operand_b,
                    const UINT16& offset,
                    const TPM_EO& operation,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyNVResponse callback));
  MOCK_METHOD10(PolicyNVSync,
                TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                       const std::string& auth_handle_name,
                       const TPMI_RH_NV_INDEX& nv_index,
                       const std::string& nv_index_name,
                       const TPMI_SH_POLICY& policy_session,
                       const std::string& policy_session_name,
                       const TPM2B_OPERAND& operand_b,
                       const UINT16& offset,
                       const TPM_EO& operation,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(PolicyCounterTimer,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_OPERAND& operand_b,
                    const UINT16& offset,
                    const TPM_EO& operation,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyCounterTimerResponse callback));
  MOCK_METHOD6(PolicyCounterTimerSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_OPERAND& operand_b,
                      const UINT16& offset,
                      const TPM_EO& operation,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PolicyCommandCode,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM_CC& code,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyCommandCodeResponse callback));
  MOCK_METHOD4(PolicyCommandCodeSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM_CC& code,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(PolicyPhysicalPresence,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyPhysicalPresenceResponse callback));
  MOCK_METHOD3(PolicyPhysicalPresenceSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PolicyCpHash,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_DIGEST& cp_hash_a,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyCpHashResponse callback));
  MOCK_METHOD4(PolicyCpHashSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_DIGEST& cp_hash_a,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PolicyNameHash,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_DIGEST& name_hash,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyNameHashResponse callback));
  MOCK_METHOD4(PolicyNameHashSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_DIGEST& name_hash,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(PolicyDuplicationSelect,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_NAME& object_name,
                    const TPM2B_NAME& new_parent_name,
                    const TPMI_YES_NO& include_object,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyDuplicationSelectResponse callback));
  MOCK_METHOD6(PolicyDuplicationSelectSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_NAME& object_name,
                      const TPM2B_NAME& new_parent_name,
                      const TPMI_YES_NO& include_object,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(PolicyAuthorize,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPM2B_DIGEST& approved_policy,
                    const TPM2B_NONCE& policy_ref,
                    const TPM2B_NAME& key_sign,
                    const TPMT_TK_VERIFIED& check_ticket,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyAuthorizeResponse callback));
  MOCK_METHOD7(PolicyAuthorizeSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPM2B_DIGEST& approved_policy,
                      const TPM2B_NONCE& policy_ref,
                      const TPM2B_NAME& key_sign,
                      const TPMT_TK_VERIFIED& check_ticket,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(PolicyAuthValue,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyAuthValueResponse callback));
  MOCK_METHOD3(PolicyAuthValueSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(PolicyPassword,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyPasswordResponse callback));
  MOCK_METHOD3(PolicyPasswordSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(PolicyGetDigest,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyGetDigestResponse callback));
  MOCK_METHOD4(PolicyGetDigestSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      TPM2B_DIGEST* policy_digest,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(PolicyNvWritten,
               void(const TPMI_SH_POLICY& policy_session,
                    const std::string& policy_session_name,
                    const TPMI_YES_NO& written_set,
                    AuthorizationDelegate* authorization_delegate,
                    PolicyNvWrittenResponse callback));
  MOCK_METHOD4(PolicyNvWrittenSync,
               TPM_RC(const TPMI_SH_POLICY& policy_session,
                      const std::string& policy_session_name,
                      const TPMI_YES_NO& written_set,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(CreatePrimary,
               void(const TPMI_RH_HIERARCHY& primary_handle,
                    const std::string& primary_handle_name,
                    const TPM2B_SENSITIVE_CREATE& in_sensitive,
                    const TPM2B_PUBLIC& in_public,
                    const TPM2B_DATA& outside_info,
                    const TPML_PCR_SELECTION& creation_pcr,
                    AuthorizationDelegate* authorization_delegate,
                    CreatePrimaryResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC CreatePrimarySync(
      const TPMI_RH_HIERARCHY& primary_handle,
      const std::string& primary_handle_name,
      const TPM2B_SENSITIVE_CREATE& in_sensitive,
      const TPM2B_PUBLIC& in_public,
      const TPM2B_DATA& outside_info,
      const TPML_PCR_SELECTION& creation_pcr,
      TPM_HANDLE* object_handle,
      TPM2B_PUBLIC* out_public,
      TPM2B_CREATION_DATA* creation_data,
      TPM2B_DIGEST* creation_hash,
      TPMT_TK_CREATION* creation_ticket,
      TPM2B_NAME* name,
      AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD10(CreatePrimarySyncShort,
                TPM_RC(const TPMI_RH_HIERARCHY& primary_handle,
                       const TPM2B_PUBLIC& in_public,
                       const TPML_PCR_SELECTION& creation_pcr,
                       TPM_HANDLE* object_handle,
                       TPM2B_PUBLIC* out_public,
                       TPM2B_CREATION_DATA* creation_data,
                       TPM2B_DIGEST* creation_hash,
                       TPMT_TK_CREATION* creation_ticket,
                       TPM2B_NAME* name,
                       AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(HierarchyControl,
               void(const TPMI_RH_HIERARCHY& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_ENABLES& enable,
                    const TPMI_YES_NO& state,
                    AuthorizationDelegate* authorization_delegate,
                    HierarchyControlResponse callback));
  MOCK_METHOD5(HierarchyControlSync,
               TPM_RC(const TPMI_RH_HIERARCHY& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_ENABLES& enable,
                      const TPMI_YES_NO& state,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(SetPrimaryPolicy,
               void(const TPMI_RH_HIERARCHY& auth_handle,
                    const std::string& auth_handle_name,
                    const TPM2B_DIGEST& auth_policy,
                    const TPMI_ALG_HASH& hash_alg,
                    AuthorizationDelegate* authorization_delegate,
                    SetPrimaryPolicyResponse callback));
  MOCK_METHOD5(SetPrimaryPolicySync,
               TPM_RC(const TPMI_RH_HIERARCHY& auth_handle,
                      const std::string& auth_handle_name,
                      const TPM2B_DIGEST& auth_policy,
                      const TPMI_ALG_HASH& hash_alg,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(ChangePPS,
               void(const TPMI_RH_PLATFORM& auth_handle,
                    const std::string& auth_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    ChangePPSResponse callback));
  MOCK_METHOD3(ChangePPSSync,
               TPM_RC(const TPMI_RH_PLATFORM& auth_handle,
                      const std::string& auth_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(ChangeEPS,
               void(const TPMI_RH_PLATFORM& auth_handle,
                    const std::string& auth_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    ChangeEPSResponse callback));
  MOCK_METHOD3(ChangeEPSSync,
               TPM_RC(const TPMI_RH_PLATFORM& auth_handle,
                      const std::string& auth_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(Clear,
               void(const TPMI_RH_CLEAR& auth_handle,
                    const std::string& auth_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    ClearResponse callback));
  MOCK_METHOD3(ClearSync,
               TPM_RC(const TPMI_RH_CLEAR& auth_handle,
                      const std::string& auth_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(ClearControl,
               void(const TPMI_RH_CLEAR& auth,
                    const std::string& auth_name,
                    const TPMI_YES_NO& disable,
                    AuthorizationDelegate* authorization_delegate,
                    ClearControlResponse callback));
  MOCK_METHOD4(ClearControlSync,
               TPM_RC(const TPMI_RH_CLEAR& auth,
                      const std::string& auth_name,
                      const TPMI_YES_NO& disable,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(HierarchyChangeAuth,
               void(const TPMI_RH_HIERARCHY_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPM2B_AUTH& new_auth,
                    AuthorizationDelegate* authorization_delegate,
                    HierarchyChangeAuthResponse callback));
  MOCK_METHOD4(HierarchyChangeAuthSync,
               TPM_RC(const TPMI_RH_HIERARCHY_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPM2B_AUTH& new_auth,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(DictionaryAttackLockReset,
               void(const TPMI_RH_LOCKOUT& lock_handle,
                    const std::string& lock_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    DictionaryAttackLockResetResponse callback));
  MOCK_METHOD3(DictionaryAttackLockResetSync,
               TPM_RC(const TPMI_RH_LOCKOUT& lock_handle,
                      const std::string& lock_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(DictionaryAttackParameters,
               void(const TPMI_RH_LOCKOUT& lock_handle,
                    const std::string& lock_handle_name,
                    const UINT32& new_max_tries,
                    const UINT32& new_recovery_time,
                    const UINT32& lockout_recovery,
                    AuthorizationDelegate* authorization_delegate,
                    DictionaryAttackParametersResponse callback));
  MOCK_METHOD6(DictionaryAttackParametersSync,
               TPM_RC(const TPMI_RH_LOCKOUT& lock_handle,
                      const std::string& lock_handle_name,
                      const UINT32& new_max_tries,
                      const UINT32& new_recovery_time,
                      const UINT32& lockout_recovery,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(PP_Commands,
               void(const TPMI_RH_PLATFORM& auth,
                    const std::string& auth_name,
                    const TPML_CC& set_list,
                    const TPML_CC& clear_list,
                    AuthorizationDelegate* authorization_delegate,
                    PP_CommandsResponse callback));
  MOCK_METHOD5(PP_CommandsSync,
               TPM_RC(const TPMI_RH_PLATFORM& auth,
                      const std::string& auth_name,
                      const TPML_CC& set_list,
                      const TPML_CC& clear_list,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(SetAlgorithmSet,
               void(const TPMI_RH_PLATFORM& auth_handle,
                    const std::string& auth_handle_name,
                    const UINT32& algorithm_set,
                    AuthorizationDelegate* authorization_delegate,
                    SetAlgorithmSetResponse callback));
  MOCK_METHOD4(SetAlgorithmSetSync,
               TPM_RC(const TPMI_RH_PLATFORM& auth_handle,
                      const std::string& auth_handle_name,
                      const UINT32& algorithm_set,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(FieldUpgradeStart,
               void(const TPMI_RH_PLATFORM& authorization,
                    const std::string& authorization_name,
                    const TPMI_DH_OBJECT& key_handle,
                    const std::string& key_handle_name,
                    const TPM2B_DIGEST& fu_digest,
                    const TPMT_SIGNATURE& manifest_signature,
                    AuthorizationDelegate* authorization_delegate,
                    FieldUpgradeStartResponse callback));
  MOCK_METHOD7(FieldUpgradeStartSync,
               TPM_RC(const TPMI_RH_PLATFORM& authorization,
                      const std::string& authorization_name,
                      const TPMI_DH_OBJECT& key_handle,
                      const std::string& key_handle_name,
                      const TPM2B_DIGEST& fu_digest,
                      const TPMT_SIGNATURE& manifest_signature,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(FieldUpgradeData,
               void(const TPM2B_MAX_BUFFER& fu_data,
                    AuthorizationDelegate* authorization_delegate,
                    FieldUpgradeDataResponse callback));
  MOCK_METHOD4(FieldUpgradeDataSync,
               TPM_RC(const TPM2B_MAX_BUFFER& fu_data,
                      TPMT_HA* next_digest,
                      TPMT_HA* first_digest,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(FirmwareRead,
               void(const UINT32& sequence_number,
                    AuthorizationDelegate* authorization_delegate,
                    FirmwareReadResponse callback));
  MOCK_METHOD3(FirmwareReadSync,
               TPM_RC(const UINT32& sequence_number,
                      TPM2B_MAX_BUFFER* fu_data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(ContextSave,
               void(const TPMI_DH_CONTEXT& save_handle,
                    const std::string& save_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    ContextSaveResponse callback));
  MOCK_METHOD4(ContextSaveSync,
               TPM_RC(const TPMI_DH_CONTEXT& save_handle,
                      const std::string& save_handle_name,
                      TPMS_CONTEXT* context,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(ContextLoad,
               void(const TPMS_CONTEXT& context,
                    AuthorizationDelegate* authorization_delegate,
                    ContextLoadResponse callback));
  MOCK_METHOD3(ContextLoadSync,
               TPM_RC(const TPMS_CONTEXT& context,
                      TPMI_DH_CONTEXT* loaded_handle,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(FlushContext,
               void(const TPMI_DH_CONTEXT& flush_handle,
                    AuthorizationDelegate* authorization_delegate,
                    FlushContextResponse callback));
  MOCK_METHOD2(FlushContextSync,
               TPM_RC(const TPMI_DH_CONTEXT& flush_handle,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(EvictControl,
               void(const TPMI_RH_PROVISION& auth,
                    const std::string& auth_name,
                    const TPMI_DH_OBJECT& object_handle,
                    const std::string& object_handle_name,
                    const TPMI_DH_PERSISTENT& persistent_handle,
                    AuthorizationDelegate* authorization_delegate,
                    EvictControlResponse callback));
  MOCK_METHOD6(EvictControlSync,
               TPM_RC(const TPMI_RH_PROVISION& auth,
                      const std::string& auth_name,
                      const TPMI_DH_OBJECT& object_handle,
                      const std::string& object_handle_name,
                      const TPMI_DH_PERSISTENT& persistent_handle,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD2(ReadClock,
               void(AuthorizationDelegate* authorization_delegate,
                    ReadClockResponse callback));
  MOCK_METHOD2(ReadClockSync,
               TPM_RC(TPMS_TIME_INFO* current_time,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(ClockSet,
               void(const TPMI_RH_PROVISION& auth,
                    const std::string& auth_name,
                    const UINT64& new_time,
                    AuthorizationDelegate* authorization_delegate,
                    ClockSetResponse callback));
  MOCK_METHOD4(ClockSetSync,
               TPM_RC(const TPMI_RH_PROVISION& auth,
                      const std::string& auth_name,
                      const UINT64& new_time,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(ClockRateAdjust,
               void(const TPMI_RH_PROVISION& auth,
                    const std::string& auth_name,
                    const TPM_CLOCK_ADJUST& rate_adjust,
                    AuthorizationDelegate* authorization_delegate,
                    ClockRateAdjustResponse callback));
  MOCK_METHOD4(ClockRateAdjustSync,
               TPM_RC(const TPMI_RH_PROVISION& auth,
                      const std::string& auth_name,
                      const TPM_CLOCK_ADJUST& rate_adjust,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(GetCapability,
               void(const TPM_CAP& capability,
                    const UINT32& property,
                    const UINT32& property_count,
                    AuthorizationDelegate* authorization_delegate,
                    GetCapabilityResponse callback));
  MOCK_METHOD6(GetCapabilitySync,
               TPM_RC(const TPM_CAP& capability,
                      const UINT32& property,
                      const UINT32& property_count,
                      TPMI_YES_NO* more_data,
                      TPMS_CAPABILITY_DATA* capability_data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD3(TestParms,
               void(const TPMT_PUBLIC_PARMS& parameters,
                    AuthorizationDelegate* authorization_delegate,
                    TestParmsResponse callback));
  MOCK_METHOD2(TestParmsSync,
               TPM_RC(const TPMT_PUBLIC_PARMS& parameters,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(NV_DefineSpace,
               void(const TPMI_RH_PROVISION& auth_handle,
                    const std::string& auth_handle_name,
                    const TPM2B_AUTH& auth,
                    const TPM2B_NV_PUBLIC& public_info,
                    AuthorizationDelegate* authorization_delegate,
                    NV_DefineSpaceResponse callback));
  MOCK_METHOD5(NV_DefineSpaceSync,
               TPM_RC(const TPMI_RH_PROVISION& auth_handle,
                      const std::string& auth_handle_name,
                      const TPM2B_AUTH& auth,
                      const TPM2B_NV_PUBLIC& public_info,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(NV_UndefineSpace,
               void(const TPMI_RH_PROVISION& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_UndefineSpaceResponse callback));
  MOCK_METHOD5(NV_UndefineSpaceSync,
               TPM_RC(const TPMI_RH_PROVISION& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(NV_UndefineSpaceSpecial,
               void(const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    const TPMI_RH_PLATFORM& platform,
                    const std::string& platform_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_UndefineSpaceSpecialResponse callback));
  MOCK_METHOD5(NV_UndefineSpaceSpecialSync,
               TPM_RC(const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      const TPMI_RH_PLATFORM& platform,
                      const std::string& platform_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(NV_ReadPublic,
               void(const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_ReadPublicResponse callback));
  MOCK_METHOD5(NV_ReadPublicSync,
               TPM_RC(const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      TPM2B_NV_PUBLIC* nv_public,
                      TPM2B_NAME* nv_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(NV_Write,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    const TPM2B_MAX_NV_BUFFER& data,
                    const UINT16& offset,
                    AuthorizationDelegate* authorization_delegate,
                    NV_WriteResponse callback));
  MOCK_METHOD7(NV_WriteSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      const TPM2B_MAX_NV_BUFFER& data,
                      const UINT16& offset,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(NV_Increment,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_IncrementResponse callback));
  MOCK_METHOD5(NV_IncrementSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(NV_Extend,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    const TPM2B_MAX_NV_BUFFER& data,
                    AuthorizationDelegate* authorization_delegate,
                    NV_ExtendResponse callback));
  MOCK_METHOD6(NV_ExtendSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      const TPM2B_MAX_NV_BUFFER& data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD7(NV_SetBits,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    const UINT64& bits,
                    AuthorizationDelegate* authorization_delegate,
                    NV_SetBitsResponse callback));
  MOCK_METHOD6(NV_SetBitsSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      const UINT64& bits,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(NV_WriteLock,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_WriteLockResponse callback));
  MOCK_METHOD5(NV_WriteLockSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(NV_GlobalWriteLock,
               void(const TPMI_RH_PROVISION& auth_handle,
                    const std::string& auth_handle_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_GlobalWriteLockResponse callback));
  MOCK_METHOD3(NV_GlobalWriteLockSync,
               TPM_RC(const TPMI_RH_PROVISION& auth_handle,
                      const std::string& auth_handle_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(NV_Read,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    const UINT16& size,
                    const UINT16& offset,
                    AuthorizationDelegate* authorization_delegate,
                    NV_ReadResponse callback));
  MOCK_METHOD8(NV_ReadSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      const UINT16& size,
                      const UINT16& offset,
                      TPM2B_MAX_NV_BUFFER* data,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD6(NV_ReadLock,
               void(const TPMI_RH_NV_AUTH& auth_handle,
                    const std::string& auth_handle_name,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    AuthorizationDelegate* authorization_delegate,
                    NV_ReadLockResponse callback));
  MOCK_METHOD5(NV_ReadLockSync,
               TPM_RC(const TPMI_RH_NV_AUTH& auth_handle,
                      const std::string& auth_handle_name,
                      const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(NV_ChangeAuth,
               void(const TPMI_RH_NV_INDEX& nv_index,
                    const std::string& nv_index_name,
                    const TPM2B_AUTH& new_auth,
                    AuthorizationDelegate* authorization_delegate,
                    NV_ChangeAuthResponse callback));
  MOCK_METHOD4(NV_ChangeAuthSync,
               TPM_RC(const TPMI_RH_NV_INDEX& nv_index,
                      const std::string& nv_index_name,
                      const TPM2B_AUTH& new_auth,
                      AuthorizationDelegate* authorization_delegate));
  // Too many args to mock, forward to *Short version.
  void NV_Certify(const TPMI_DH_OBJECT& sign_handle,
                  const std::string& sign_handle_name,
                  const TPMI_RH_NV_AUTH& auth_handle,
                  const std::string& auth_handle_name,
                  const TPMI_RH_NV_INDEX& nv_index,
                  const std::string& nv_index_name,
                  const TPM2B_DATA& qualifying_data,
                  const TPMT_SIG_SCHEME& in_scheme,
                  const UINT16& size,
                  const UINT16& offset,
                  AuthorizationDelegate* authorization_delegate,
                  NV_CertifyResponse callback) override;
  MOCK_METHOD9(NV_CertifyShort,
               void(const TPMI_DH_OBJECT& sign_handle,
                    const TPMI_RH_NV_AUTH& auth_handle,
                    const TPMI_RH_NV_INDEX& nv_index,
                    const TPM2B_DATA& qualifying_data,
                    const TPMT_SIG_SCHEME& in_scheme,
                    const UINT16& size,
                    const UINT16& offset,
                    AuthorizationDelegate* authorization_delegate,
                    NV_CertifyResponse callback));
  // Too many args to mock, forward to *Short version.
  TPM_RC NV_CertifySync(const TPMI_DH_OBJECT& sign_handle,
                        const std::string& sign_handle_name,
                        const TPMI_RH_NV_AUTH& auth_handle,
                        const std::string& auth_handle_name,
                        const TPMI_RH_NV_INDEX& nv_index,
                        const std::string& nv_index_name,
                        const TPM2B_DATA& qualifying_data,
                        const TPMT_SIG_SCHEME& in_scheme,
                        const UINT16& size,
                        const UINT16& offset,
                        TPM2B_ATTEST* certify_info,
                        TPMT_SIGNATURE* signature,
                        AuthorizationDelegate* authorization_delegate) override;
  MOCK_METHOD10(NV_CertifySyncShort,
                TPM_RC(const TPMI_DH_OBJECT& sign_handle,
                       const TPMI_RH_NV_AUTH& auth_handle,
                       const TPMI_RH_NV_INDEX& nv_index,
                       const TPM2B_DATA& qualifying_data,
                       const TPMT_SIG_SCHEME& in_scheme,
                       const UINT16& size,
                       const UINT16& offset,
                       TPM2B_ATTEST* certify_info,
                       TPMT_SIGNATURE* signature,
                       AuthorizationDelegate* authorization_delegate));
};

}  // namespace trunks

#endif  // TRUNKS_MOCK_TPM_H_