// Copyright 2014 The Chromium OS Authors. All rights reserved.
// 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 "trunks/tpm_generated.h"

#include <string>

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

namespace trunks {

class MockTpm : public Tpm {
 public:
  MockTpm();
  virtual ~MockTpm();

  MOCK_METHOD3(Startup,
      void(const TPM_SU& startup_type,
           AuthorizationDelegate* authorization_delegate,
           const 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,
           const 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,
           const 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,
           const 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,
           const GetTestResultResponse& callback));
  MOCK_METHOD3(GetTestResultSync,
      TPM_RC(TPM2B_MAX_BUFFER* out_data,
             TPM_RC* test_result,
             AuthorizationDelegate* authorization_delegate));
  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,
                        const StartAuthSessionResponse& callback) {
    // Too many args to mock, forward to *Short version.
    StartAuthSessionShort(tpm_key, bind, nonce_caller, encrypted_salt,
                          session_type, symmetric, auth_hash,
                          authorization_delegate, callback);
  }
  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,
           const StartAuthSessionResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return StartAuthSessionSyncShort(tpm_key, bind, nonce_caller,
                                     encrypted_salt, session_type, symmetric,
                                     auth_hash, session_handle, nonce_tpm,
                                     authorization_delegate);
  }
  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,
           const 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,
           const CreateResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return CreateSyncShort(parent_handle, in_sensitive, in_public, creation_pcr,
                           out_private, out_public, creation_data,
                           creation_hash, creation_ticket,
                           authorization_delegate);
  }
  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,
           const 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_METHOD6(LoadExternal,
      void(const TPMI_RH_HIERARCHY& hierarchy,
           const std::string& hierarchy_name,
           const TPM2B_SENSITIVE& in_private,
           const TPM2B_PUBLIC& in_public,
           AuthorizationDelegate* authorization_delegate,
           const LoadExternalResponse& callback));
  MOCK_METHOD7(LoadExternalSync,
      TPM_RC(const TPMI_RH_HIERARCHY& hierarchy,
             const std::string& hierarchy_name,
             const TPM2B_SENSITIVE& in_private,
             const TPM2B_PUBLIC& in_public,
             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,
           const 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,
           const 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,
           const MakeCredentialResponse& callback));
  MOCK_METHOD6(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,
             AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(Unseal,
      void(const TPMI_DH_OBJECT& item_handle,
           const std::string& item_handle_name,
           AuthorizationDelegate* authorization_delegate,
           const 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,
           const 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,
           const DuplicateResponse& callback));
  MOCK_METHOD9(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,
             AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD8(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,
           AuthorizationDelegate* authorization_delegate,
           const RewrapResponse& callback));
  MOCK_METHOD8(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,
             TPM2B_PRIVATE* out_duplicate,
             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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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_METHOD6(Hash,
      void(const TPMI_RH_HIERARCHY& hierarchy,
           const std::string& hierarchy_name,
           const TPM2B_MAX_BUFFER& data,
           const TPMI_ALG_HASH& hash_alg,
           AuthorizationDelegate* authorization_delegate,
           const HashResponse& callback));
  MOCK_METHOD7(HashSync,
      TPM_RC(const TPMI_RH_HIERARCHY& hierarchy,
             const std::string& hierarchy_name,
             const TPM2B_MAX_BUFFER& data,
             const TPMI_ALG_HASH& hash_alg,
             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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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_METHOD7(SequenceComplete,
      void(const TPMI_DH_OBJECT& sequence_handle,
           const std::string& sequence_handle_name,
           const TPMI_RH_HIERARCHY& hierarchy,
           const std::string& hierarchy_name,
           const TPM2B_MAX_BUFFER& buffer,
           AuthorizationDelegate* authorization_delegate,
           const SequenceCompleteResponse& callback));
  MOCK_METHOD8(SequenceCompleteSync,
      TPM_RC(const TPMI_DH_OBJECT& sequence_handle,
             const std::string& sequence_handle_name,
             const TPMI_RH_HIERARCHY& hierarchy,
             const std::string& hierarchy_name,
             const TPM2B_MAX_BUFFER& buffer,
             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,
           const 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,
           const 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,
           const CertifyCreationResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return CertifyCreationSyncShort(sign_handle, object_handle,
                                    qualifying_data, creation_hash, in_scheme,
                                    creation_ticket, certify_info, signature,
                                    authorization_delegate);
  }
  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,
           const 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,
           const GetSessionAuditDigestResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return GetSessionAuditDigestSyncShort(privacy_admin_handle, sign_handle,
                                          session_handle, qualifying_data,
                                          in_scheme, audit_info, signature,
                                          authorization_delegate);
  }
  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,
           const 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,
           const 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,
           const CommitResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return CommitSyncShort(sign_handle, param_size, p1, y2, param_size_out, k,
                           l, e, counter, authorization_delegate);
  }
  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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const PCR_ResetResponse& callback));
  MOCK_METHOD3(PCR_ResetSync,
      TPM_RC(const TPMI_DH_PCR& pcr_handle,
             const std::string& pcr_handle_name,
             AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD10(PolicySigned,
      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 TPM2B_NONCE& nonce_tpm,
           const TPM2B_DIGEST& cp_hash_a,
           const TPM2B_NONCE& policy_ref,
           const TPMT_SIGNATURE& auth,
           AuthorizationDelegate* authorization_delegate,
           const PolicySignedResponse& callback));
  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 TPMT_SIGNATURE& auth,
                          TPM2B_TIMEOUT* timeout,
                          TPMT_TK_AUTH* policy_ticket,
                          AuthorizationDelegate* authorization_delegate) {
    // Too many args to mock, forward to *Short version.
    return PolicySignedSyncShort(auth_object, policy_session, nonce_tpm,
                                 cp_hash_a, policy_ref, auth, timeout,
                                 policy_ticket, authorization_delegate);
  }
  MOCK_METHOD9(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 TPMT_SIGNATURE& auth,
             TPM2B_TIMEOUT* timeout,
             TPMT_TK_AUTH* policy_ticket,
             AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD9(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,
           AuthorizationDelegate* authorization_delegate,
           const PolicySecretResponse& callback));
  MOCK_METHOD10(PolicySecretSync,
      TPM_RC(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,
             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,
           const 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,
           const 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,
           const 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,
           const 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));
  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,
                const PolicyNVResponse& callback) {
    // Too many args to mock, forward to *Short version.
    PolicyNVShort(auth_handle, nv_index, policy_session, operand_b, offset,
                  operation, authorization_delegate, callback);
  }
  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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const CreatePrimaryResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return CreatePrimarySyncShort(primary_handle, in_public, creation_pcr,
                                  object_handle, out_public, creation_data,
                                  creation_hash, creation_ticket, name,
                                  authorization_delegate);
  }
  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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const ContextLoadResponse& callback));
  MOCK_METHOD3(ContextLoadSync,
      TPM_RC(const TPMS_CONTEXT& context,
             TPMI_DH_CONTEXT* loaded_handle,
             AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD4(FlushContext,
      void(const TPMI_DH_CONTEXT& flush_handle,
           const std::string& flush_handle_name,
           AuthorizationDelegate* authorization_delegate,
           const FlushContextResponse& callback));
  MOCK_METHOD3(FlushContextSync,
      TPM_RC(const TPMI_DH_CONTEXT& flush_handle,
             const std::string& flush_handle_name,
             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,
           const 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,
           const ReadClockResponse& callback));
  MOCK_METHOD3(ReadClockSync,
      TPM_RC(TPM_RC* return_code,
             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,
           const ClockSetResponse& callback));
  MOCK_METHOD5(ClockSetSync,
      TPM_RC(const TPMI_RH_PROVISION& auth,
             const std::string& auth_name,
             const UINT64& new_time,
             TPM_RC* return_code,
             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,
           const ClockRateAdjustResponse& callback));
  MOCK_METHOD5(ClockRateAdjustSync,
      TPM_RC(const TPMI_RH_PROVISION& auth,
             const std::string& auth_name,
             const TPM_CLOCK_ADJUST& rate_adjust,
             TPM_RC* return_code,
             AuthorizationDelegate* authorization_delegate));
  MOCK_METHOD5(GetCapability,
      void(const TPM_CAP& capability,
           const UINT32& property,
           const UINT32& property_count,
           AuthorizationDelegate* authorization_delegate,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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,
           const 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));
  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,
                  const NV_CertifyResponse& callback) {
    // Too many args to mock, forward to *Short version.
    NV_CertifyShort(sign_handle, auth_handle, nv_index, qualifying_data,
                    in_scheme, size, offset, authorization_delegate, callback);
  }
  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,
           const NV_CertifyResponse& callback));
  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) {
    // Too many args to mock, forward to *Short version.
    return NV_CertifySyncShort(sign_handle, auth_handle, nv_index,
                               qualifying_data, in_scheme, size, offset,
                               certify_info, signature, authorization_delegate);
  }
  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_