/*===========================================================================
  FILE:
  mock_gobi_sdk_wrapper.h,
  derived from
  gobi_sdk_wrapper.h, QCWWANCMAPI2k.h

  DESCRIPTION:
  QUALCOMM Wireless WAN Connection Manager API for Gobi 2000

  Copyright (C) 2009 QUALCOMM Incorporated. All rights reserved.
  QUALCOMM Proprietary/GTDR

  All data and information contained in or disclosed by this document is
  confidential and proprietary information of QUALCOMM Incorporated and all
  rights therein are expressly reserved.  By accepting this material the
  recipient agrees that this material and the information contained therein
  is held in confidence and in trust and will not be used, copied, reproduced
  in whole or in part, nor its contents revealed in any manner to others
  without the express written permission of QUALCOMM Incorporated.
  ==========================================================================*/

#ifndef GOBI_CROMO_PLUGIN_MOCK_GOBI_SDK_WRAPPER_H_
#define GOBI_CROMO_PLUGIN_MOCK_GOBI_SDK_WRAPPER_H_

#include <gtest/gtest.h>

namespace gobi {

// ErrorSdk overrides every QCWWAN API method in gobi::Sdk.  It
// returns an error for every SDK call (except for those that register
// callbacks---they always succeed without doing anything).  Depending
// on the setting of strict_, calls to the ErrorSdk will also make the
// current test fail.

class ErrorSdk : public gobi::Sdk {
 public:
  ErrorSdk() : Sdk(nullptr), strict_(false) {}

  virtual ULONG QCWWANEnumerateDevices(
      BYTE *                     pDevicesSize,
      BYTE *                     pDevices) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG QCWWANConnect(
      CHAR *                     pDeviceNode,
      CHAR *                     pDeviceKey) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG QCWWANDisconnect() {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG QCWWANGetConnectedDeviceID(
      ULONG                      deviceNodeSize,
      CHAR *                     pDeviceNode,
      ULONG                      deviceKeySize,
      CHAR *                     pDeviceKey) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSessionState(ULONG * pState) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSessionDuration(ULONGLONG * pDuration) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetDormancyState(ULONG * pState) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetAutoconnect(ULONG * pSetting) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetAutoconnect(ULONG setting) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetDefaultProfile(
      ULONG                      profileType,
      ULONG *                    pPDPType,
      ULONG *                    pIPAddress,
      ULONG *                    pPrimaryDNS,
      ULONG *                    pSecondaryDNS,
      ULONG *                    pAuthentication,
      CHAR *                     pName,
      CHAR *                     pAPNName,
      CHAR *                     pUsername,
      CHAR *                     pPassword) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetDefaultProfile(
      ULONG                      profileType,
      ULONG *                    pPDPType,
      ULONG *                    pIPAddress,
      ULONG *                    pPrimaryDNS,
      ULONG *                    pSecondaryDNS,
      ULONG *                    pAuthentication,
      BYTE                       nameSize,
      CHAR *                     pName,
      BYTE                       apnSize,
      CHAR *                     pAPNName,
      BYTE                       userSize,
      CHAR *                     pUsername) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG StartDataSession(
      ULONG *                    pTechnology,
      const CHAR *               pAPNName,
      ULONG *                    pAuthentication,
      const CHAR *               pUsername,
      const CHAR *               pPassword,
      ULONG *                    pSessionId,
      ULONG *                    pFailureReason) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG CancelStartDataSession() {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG StopDataSession(ULONG sessionId) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetIPAddress(ULONG * pIPAddress) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetConnectionRate(
      ULONG *                    pCurrentChannelTXRate,
      ULONG *                    pCurrentChannelRXRate,
      ULONG *                    pMaxChannelTXRate,
      ULONG *                    pMaxChannelRXRate) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetPacketStatus(
      ULONG *                    pTXPacketSuccesses,
      ULONG *                    pRXPacketSuccesses,
      ULONG *                    pTXPacketErrors,
      ULONG *                    pRXPacketErrors,
      ULONG *                    pTXPacketOverflows,
      ULONG *                    pRXPacketOverflows) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetByteTotals(
      ULONGLONG *                pTXTotalBytes,
      ULONGLONG *                pRXTotalBytes) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetMobileIP(ULONG mode) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetMobileIP(ULONG * pMode) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetActiveMobileIPProfile(
      CHAR *                     pSPC,
      BYTE                       index) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetActiveMobileIPProfile(BYTE * pIndex) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetMobileIPProfile(
      CHAR *                     pSPC,
      BYTE                       index,
      BYTE *                     pEnabled,
      ULONG *                    pAddress,
      ULONG *                    pPrimaryHA,
      ULONG *                    pSecondaryHA,
      BYTE *                     pRevTunneling,
      CHAR *                     pNAI,
      ULONG *                    pHASPI,
      ULONG *                    pAAASPI,
      CHAR *                     pMNHA,
      CHAR *                     pMNAAA) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetMobileIPProfile(
      BYTE                       index,
      BYTE *                     pEnabled,
      ULONG *                    pAddress,
      ULONG *                    pPrimaryHA,
      ULONG *                    pSecondaryHA,
      BYTE *                     pRevTunneling,
      BYTE                       naiSize,
      CHAR *                     pNAI,
      ULONG *                    pHASPI,
      ULONG *                    pAAASPI,
      ULONG *                    pHAState,
      ULONG *                    pAAAState) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetMobileIPParameters(
      CHAR *                     pSPC,
      ULONG *                    pMode,
      BYTE *                     pRetryLimit,
      BYTE *                     pRetryInterval,
      BYTE *                     pReRegPeriod,
      BYTE *                     pReRegTraffic,
      BYTE *                     pHAAuthenticator,
      BYTE *                     pHA2002bis) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetMobileIPParameters(
      ULONG *                    pMode,
      BYTE *                     pRetryLimit,
      BYTE *                     pRetryInterval,
      BYTE *                     pReRegPeriod,
      BYTE *                     pReRegTraffic,
      BYTE *                     pHAAuthenticator,
      BYTE *                     pHA2002bis) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetLastMobileIPError(ULONG * pError) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetANAAAAuthenticationStatus(ULONG * pStatus) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSignalStrengths(
      ULONG *                    pArraySizes,
      INT8 *                     pSignalStrengths,
      ULONG *                    pRadioInterfaces) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetRFInfo(
      BYTE *                     pInstanceSize,
      BYTE *                     pInstances) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG PerformNetworkScan(
      BYTE *                     pInstanceSize,
      BYTE *                     pInstances) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG InitiateNetworkRegistration(
      ULONG                      regType,
      WORD                       mcc,
      WORD                       mnc,
      ULONG                      rat) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG InitiateDomainAttach(ULONG action) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetServingNetwork(
      ULONG *                    pRegistrationState,
      ULONG *                    pRAN,
      BYTE *                     pRadioIfacesSize,
      BYTE *                     pRadioIfaces,
      ULONG *                    pRoaming,
      WORD *                     pMCC,
      WORD *                     pMNC,
      BYTE                       nameSize,
      CHAR *                     pName) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetServingNetworkCapabilities(
      BYTE *                     pDataCapsSize,
      BYTE *                     pDataCaps) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetDataBearerTechnology(ULONG * pDataBearer) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetHomeNetwork(
      WORD *                     pMCC,
      WORD *                     pMNC,
      BYTE                       nameSize,
      CHAR *                     pName,
      WORD *                     pSID,
      WORD *                     pNID) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetNetworkPreference(
      ULONG                      technologyPref,
      ULONG                      duration) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetNetworkPreference(
      ULONG *                    pTechnologyPref,
      ULONG *                    pDuration,
      ULONG *                    pPersistentTechnologyPref) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetCDMANetworkParameters(
      CHAR *                     pSPC,
      BYTE *                     pForceRev0,
      BYTE *                     pCustomSCP,
      ULONG *                    pProtocol,
      ULONG *                    pBroadcast,
      ULONG *                    pApplication,
      ULONG *                    pRoaming) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetCDMANetworkParameters(
      BYTE *                     pSCI,
      BYTE *                     pSCM,
      BYTE *                     pRegHomeSID,
      BYTE *                     pRegForeignSID,
      BYTE *                     pRegForeignNID,
      BYTE *                     pForceRev0,
      BYTE *                     pCustomSCP,
      ULONG *                    pProtocol,
      ULONG *                    pBroadcast,
      ULONG *                    pApplication,
      ULONG *                    pRoaming) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetACCOLC(BYTE * pACCOLC) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetACCOLC(
      CHAR *                     pSPC,
      BYTE                       accolc) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetDeviceCapabilities(
      ULONG *                    pMaxTXChannelRate,
      ULONG *                    pMaxRXChannelRate,
      ULONG *                    pDataServiceCapability,
      ULONG *                    pSimCapability,
      ULONG *                    pRadioIfacesSize,
      BYTE *                     pRadioIfaces) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetManufacturer(
      BYTE                       stringSize,
      CHAR *                     pString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetModelID(
      BYTE                       stringSize,
      CHAR *                     pString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetFirmwareRevision(
      BYTE                       stringSize,
      CHAR *                     pString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetFirmwareRevisions(
      BYTE                       amssSize,
      CHAR *                     pAMSSString,
      BYTE                       bootSize,
      CHAR *                     pBootString,
      BYTE                       priSize,
      CHAR *                     pPRIString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetFirmwareInfo(
      ULONG *                    pFirmwareID,
      ULONG *                    pTechnology,
      ULONG *                    pCarrier,
      ULONG *                    pRegion,
      ULONG *                    pGPSCapability) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetVoiceNumber(
      BYTE                       voiceNumberSize,
      CHAR *                     pVoiceNumber,
      BYTE                       minSize,
      CHAR *                     pMIN) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetIMSI(
      BYTE                       stringSize,
      CHAR *                     pString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSerialNumbers(
      BYTE                       esnSize,
      CHAR *                     pESNString,
      BYTE                       imeiSize,
      CHAR *                     pIMEIString,
      BYTE                       meidSize,
      CHAR *                     pMEIDString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetLock(
      ULONG                      state,
      CHAR *                     pCurrentPIN) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG QueryLock(ULONG * pState) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ChangeLockPIN(
      CHAR *                     pCurrentPIN,
      CHAR *                     pDesiredPIN) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetHardwareRevision(
      BYTE                       stringSize,
      CHAR *                     pString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetPRLVersion(WORD * pPRLVersion) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetERIFile(
      ULONG *                    pFileSize,
      BYTE *                     pFile) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ActivateAutomatic(const CHAR * pActivationCode) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ActivateManual(
      const CHAR *               pSPC,
      WORD                       sid,
      const CHAR *               pMDN,
      const CHAR *               pMIN,
      ULONG                      prlSize,
      BYTE *                     pPRL,
      const CHAR *               pMNHA,
      const CHAR *               pMNAAA) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ResetToFactoryDefaults(CHAR * pSPC) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetActivationState(ULONG * pActivationState) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetPower(ULONG powerMode) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetPower(ULONG * pPowerMode) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetOfflineReason(
      ULONG *                    pReasonMask,
      ULONG *                    pbPlatform) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetNetworkTime(
      ULONGLONG *                pTimeCount,
      ULONG *                    pTimeSource) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ValidateSPC(CHAR * pSPC) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG DeleteSMS(
      ULONG                      storageType,
      ULONG *                    pMessageIndex,
      ULONG *                    pMessageTag) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSMSList(
      ULONG                      storageType,
      ULONG *                    pRequestedTag,
      ULONG *                    pMessageListSize,
      BYTE *                     pMessageList) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSMS(
      ULONG                      storageType,
      ULONG                      messageIndex,
      ULONG *                    pMessageTag,
      ULONG *                    pMessageFormat,
      ULONG *                    pMessageSize,
      BYTE *                     pMessage) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ModifySMSStatus(
      ULONG                      storageType,
      ULONG                      messageIndex,
      ULONG                      messageTag) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SaveSMS(
      ULONG                      storageType,
      ULONG                      messageFormat,
      ULONG                      messageSize,
      BYTE *                     pMessage,
      ULONG *                    pMessageIndex) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SendSMS(
      ULONG                      messageFormat,
      ULONG                      messageSize,
      BYTE *                     pMessage,
      ULONG *                    pMessageFailureCode) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetSMSCAddress(
      BYTE                       addressSize,
      CHAR *                     pSMSCAddress,
      BYTE                       typeSize,
      CHAR *                     pSMSCType) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetSMSCAddress(
      CHAR *                     pSMSCAddress,
      CHAR *                     pSMSCType) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMSetPINProtection(
      ULONG                      id,
      ULONG                      bEnable,
      CHAR *                     pValue,
      ULONG *                    pVerifyRetriesLeft,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMVerifyPIN(
      ULONG                      id,
      CHAR *                     pValue,
      ULONG *                    pVerifyRetriesLeft,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMUnblockPIN(
      ULONG                      id,
      CHAR *                     pPUKValue,
      CHAR *                     pNewValue,
      ULONG *                    pVerifyRetriesLeft,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMChangePIN(
      ULONG                      id,
      CHAR *                     pOldValue,
      CHAR *                     pNewValue,
      ULONG *                    pVerifyRetriesLeft,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMGetPINStatus(
      ULONG                      id,
      ULONG *                    pStatus,
      ULONG *                    pVerifyRetriesLeft,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMGetICCID(
      BYTE                       stringSize,
      CHAR *                     pString) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }
  virtual ULONG UIMGetControlKeyStatus(
      ULONG                      id,
      ULONG *                    pStatus,
      ULONG *                    pVerifyRetriesLeft,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMSetControlKeyProtection(
      ULONG                      id,
      ULONG                      status,
      CHAR *                     pValue,
      ULONG *                    pVerifyRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG UIMUnblockControlKey(
      ULONG                      id,
      CHAR *                     pValue,
      ULONG *                    pUnblockRetriesLeft) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetPDSState(
      ULONG *                    pEnabled,
      ULONG *                    pTracking) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetPDSState(ULONG enable) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG PDSInjectTimeReference(
      ULONGLONG                  systemTime,
      USHORT                     systemDiscontinuities) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetPDSDefaults(
      ULONG *                    pOperation,
      BYTE *                     pTimeout,
      ULONG *                    pInterval,
      ULONG *                    pAccuracy) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetPDSDefaults(
      ULONG                      operation,
      BYTE                       timeout,
      ULONG                      interval,
      ULONG                      accuracy) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetXTRAAutomaticDownload(
      ULONG *                    pbEnabled,
      USHORT *                   pInterval) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetXTRAAutomaticDownload(
      ULONG                      bEnabled,
      USHORT                     interval) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetXTRANetwork(ULONG * pPreference) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetXTRANetwork(ULONG preference) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetXTRAValidity(
      USHORT *                   pGPSWeek,
      USHORT *                   pGPSWeekOffset,
      USHORT *                   pDuration) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG ForceXTRADownload() {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetAGPSConfig(
      ULONG *                    pServerAddress,
      ULONG *                    pServerPort) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG SetAGPSConfig(
      ULONG                      serverAddress,
      ULONG                      serverPort) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << __PRETTY_FUNCTION__;
    }
    return kGeneralError;
  }

  virtual ULONG GetServiceAutomaticTracking(ULONG * pbAuto) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "GetServiceAutomaticTracking";
    }
    return kGeneralError;
  }

  virtual ULONG SetServiceAutomaticTracking(ULONG bAuto) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "SetServiceAutomaticTracking";
    }
    return kGeneralError;
  }

  virtual ULONG GetPortAutomaticTracking(ULONG * pbAuto) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "GetPortAutomaticTracking";
    }
    return kGeneralError;
  }

  virtual ULONG SetPortAutomaticTracking(ULONG bAuto) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "SetPortAutomaticTracking";
    }
    return kGeneralError;
  }

  virtual ULONG ResetPDSData(
      ULONG *                    pGPSDataMask,
      ULONG *                    pCellDataMask) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "ResetPDSData";
    }
    return kGeneralError;
  }

  virtual ULONG CATSendTerminalResponse(
      ULONG                      refID,
      ULONG                      dataLen,
      BYTE *                     pData) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "CATSendTerminalResponse";
    }
    return kGeneralError;
  }

  virtual ULONG CATSendEnvelopeCommand(
      ULONG                      cmdID,
      ULONG                      dataLen,
      BYTE *                     pData) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "CATSendEnvelopeCommand";
    }
    return kGeneralError;
  }

  virtual ULONG GetSMSWake(
      ULONG *                    pbEnabled,
      ULONG *                    pWakeMask) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "GetSMSWake";
    }
    return kGeneralError;
  }

  virtual ULONG SetSMSWake(
      ULONG                      bEnable,
      ULONG                      wakeMask) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "SetSMSWake";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMStartSession(ULONG sessionType) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMStartSession";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMCancelSession() {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMCancelSession";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMGetSessionInfo(
      ULONG *                    pSessionState,
      ULONG *                    pSessionType,
      ULONG *                    pFailureReason,
      BYTE *                     pRetryCount,
      WORD *                     pSessionPause,
      WORD *                     pTimeRemaining) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMGetSessionInfo";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMGetPendingNIA(
      ULONG *                    pSessionType,
      USHORT *                   pSessionID) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMGetPendingNIA";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMSendSelection(
      ULONG                      selection,
      USHORT                     sessionID) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMSendSelection";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMGetFeatureSettings(
      ULONG *                    pbProvisioning,
      ULONG *                    pbPRLUpdate) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMGetFeatureSettings";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMSetProvisioningFeature(
      ULONG                      bProvisioning) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMSetProvisioningFeature";
    }
    return kGeneralError;
  }

  virtual ULONG OMADMSetPRLUpdateFeature(
      ULONG                      bPRLUpdate) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "OMADMSetPRLUpdateFeature";
    }
    return kGeneralError;
  }

  virtual ULONG UpgradeFirmware(CHAR * pDestinationPath) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "UpgradeFirmware";
    }
    return kGeneralError;
  }

  virtual ULONG GetImageInfo(
      CHAR *                     pPath,
      ULONG *                    pFirmwareID,
      ULONG *                    pTechnology,
      ULONG *                    pCarrier,
      ULONG *                    pRegion,
      ULONG *                    pGPSCapability) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "GetImageInfo";
    }
    return kGeneralError;
  }

  virtual ULONG GetImageStore(
      WORD                       pathSize,
      CHAR *                     pImageStorePath) {
    if (strict_) {
      ADD_FAILURE() << kBadCall << "GetImageStore";
    }
    return kGeneralError;
  }

  // By default, we don't want to care which callbacks have been
  // registered, so we return success and do not register errors in
  // these cases.

  virtual ULONG SetSessionStateCallback(tFNSessionState pCallback) {
    return 0;
  }

  virtual ULONG SetByteTotalsCallback(
      tFNByteTotals              pCallback,
      BYTE                       interval) {
    return 0;
  }

  virtual ULONG SetDataCapabilitiesCallback(
      tFNDataCapabilities        pCallback) {
    return 0;
  }

  virtual ULONG SetDataBearerCallback(tFNDataBearer pCallback) {
    return 0;
  }

  virtual ULONG SetDormancyStatusCallback(
      tFNDormancyStatus          pCallback) {
    return 0;
  }

  virtual ULONG SetMobileIPStatusCallback(
      tFNMobileIPStatus          pCallback) {
    return 0;
  }

  virtual ULONG SetActivationStatusCallback(
      tFNActivationStatus        pCallback) {
    return 0;
  }

  virtual ULONG SetPowerCallback(tFNPower pCallback) {
    return 0;
  }

  virtual ULONG SetRoamingIndicatorCallback(
      tFNRoamingIndicator        pCallback) {
    return 0;
  }

  virtual ULONG SetSignalStrengthCallback(
      tFNSignalStrength          pCallback,
      BYTE                       thresholdsSize,
      INT8 *                     pThresholds) {
    return 0;
  }

  virtual ULONG SetRFInfoCallback(tFNRFInfo pCallback) {
    return 0;
  }

  virtual ULONG SetLURejectCallback(tFNLUReject pCallback) {
    return 0;
  }

  virtual ULONG SetNewSMSCallback(tFNNewSMS pCallback) {
    return 0;
  }

  virtual ULONG SetNMEACallback(tFNNewNMEA pCallback) {
    return 0;
  }

  virtual ULONG SetPDSStateCallback(tFNPDSState pCallback) {
    return 0;
  }

  virtual ULONG SetCATEventCallback(
      tFNCATEvent                pCallback,
      ULONG                      eventMask,
      ULONG *                    pErrorMask) {
    return 0;
  }

  virtual ULONG SetOMADMAlertCallback(tFNOMADMAlert pCallback) {
    return 0;
  }

  virtual ULONG SetOMADMStateCallback(tFNOMADMState pCallback) {
    return 0;
  }

  void set_strict(bool value) {
    strict_ = value;
  }

 protected:
  bool strict_;
  static const char *kBadCall;
};

// Only expect one mock_gobi_sdk_wrapper.h per executable
const char *ErrorSdk::kBadCall = "Unexpected sdk call to: ";

// Just enough SDK to instantiate a modem object.
class BootstrapSdk : public ErrorSdk {
  virtual ULONG QCWWANConnect(
      CHAR *                     pDeviceNode,
      CHAR *                     pDeviceKey) {
    return 0;
  }

  virtual ULONG QCWWANDisconnect() {
    return 0;
  }

  virtual ULONG GetSerialNumbers(
      BYTE                       esnSize,
      CHAR *                     pESNString,
      BYTE                       imeiSize,
      CHAR *                     pIMEIString,
      BYTE                       meidSize,
      CHAR *                     pMEIDString) {
    strncpy(pESNString, "FFFFFF", esnSize);
    strncpy(pIMEIString, "980000000100000", imeiSize);
    strncpy(pMEIDString, "A1000000000000", meidSize);
    return 0;
  }
};

}  // namespace gobi

#endif  // GOBI_CROMO_PLUGIN_MOCK_GOBI_SDK_WRAPPER_H_