widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upgrade MOCK_METHOD to googletest 1.10

Browse Source 
(This is a merge of http://go/wvgerrit/139989.)

Googletest added a new, more powerful MOCK_METHOD() macro in 1.10. This
patch updates all our usage of the old MOCK_METHOD family to the new
macro. Full details can be found at
https://github.com/google/googletest/blob/release-1.10.0/googlemock/docs/cook_book.md#creating-mock-classes
but in brief, the new MOCK_METHOD() replaces the entire old MOCK_METHOD
family and has the following advantages:

1) No need to count parameters or update the macro name when changing
   parameters.
2) No need for a different macro for const methods.
3) The ability to specify override, noexcept, and other function
   qualifiers.
4) The macro order is now the same as C++ method definition order:
   Return Type -> Name -> Arguments -> Qualifiers

In addition to upgrading all our usage sites to the new macro, the
addition of the override qualifier to our MOCK_METHODs helped uncover
several cases where we were using MOCK_METHOD to override methods that
didn't exist. This is a great example of why the override qualifier is
so useful. These places have been updated, by removing the invalid and
unused mock method.

Bug: 207693687
Test: build_and_run_all_unit_tests
Change-Id: Iaad4a22c7f72bb48b1356fe01a41eb0a2f555244
This commit is contained in:
John "Juce" Bruce
2021-12-06 12:04:40 -08:00
committed by John Bruce
parent e5822def1d
commit 5606e7dae3
14 changed files with 318 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp
View File

@@ -31,24 +31,25 @@ namespace wvcdm {
class MockCdmClientPropertySet : public CdmClientPropertySet {
public:
MOCK_CONST_METHOD0(security_level, const std::string&());
MOCK_CONST_METHOD0(use_privacy_mode, bool());
MOCK_CONST_METHOD0(service_certificate, const std::string&());
MOCK_METHOD1(set_service_certificate, void(const std::string&));
MOCK_CONST_METHOD0(is_session_sharing_enabled, bool());
MOCK_CONST_METHOD0(session_sharing_id, uint32_t());
MOCK_METHOD1(set_session_sharing_id, void(uint32_t));
MOCK_CONST_METHOD0(use_atsc_mode, bool());
MOCK_METHOD1(set_use_atsc_mode, void(bool));
MOCK_CONST_METHOD0(app_id, const std::string&());
MOCK_METHOD(const std::string&, security_level, (), (const, override));
MOCK_METHOD(bool, use_privacy_mode, (), (const, override));
MOCK_METHOD(const std::string&, service_certificate, (), (const, override));
MOCK_METHOD(void, set_service_certificate, (const std::string&), (override));
MOCK_METHOD(bool, is_session_sharing_enabled, (), (const, override));
MOCK_METHOD(uint32_t, session_sharing_id, (), (const, override));
MOCK_METHOD(void, set_session_sharing_id, (uint32_t), (override));
MOCK_METHOD(bool, use_atsc_mode, (), (const, override));
MOCK_METHOD(const std::string&, app_id, (), (const, override));
};
class MockWvCdmEventListener : public WvCdmEventListener {
MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId&));
MOCK_METHOD3(OnSessionKeysChange,
void(const CdmSessionId&, const CdmKeyStatusMap&,
bool has_new_usable_key));
MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId&, int64_t));
MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId&), (override));
MOCK_METHOD(void, OnSessionKeysChange,
(const CdmSessionId&, const CdmKeyStatusMap&,
bool has_new_usable_key),
(override));
MOCK_METHOD(void, OnExpirationUpdate, (const CdmSessionId&, int64_t),
(override));
};
class MockCdmEngineImpl : public CdmEngine {
@@ -56,50 +57,58 @@ class MockCdmEngineImpl : public CdmEngine {
MockCdmEngineImpl(FileSystem* file_system,
std::shared_ptr<EngineMetrics> metrics)
: CdmEngine(file_system, metrics) {}
MOCK_METHOD4(OpenSession,
CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*,
const CdmSessionId&, WvCdmEventListener*));
MOCK_METHOD4(OpenSession,
CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*,
WvCdmEventListener*, CdmSessionId*));
MOCK_METHOD1(CloseSession, CdmResponseType(const CdmSessionId&));
MOCK_METHOD3(OpenKeySetSession,
CdmResponseType(const CdmKeySetId&, CdmClientPropertySet*,
WvCdmEventListener*));
MOCK_METHOD6(GenerateKeyRequest,
CdmResponseType(const CdmSessionId&, const CdmKeySetId&,
const InitializationData&, const CdmLicenseType,
CdmAppParameterMap&, CdmKeyRequest*));
MOCK_METHOD4(AddKey,
CdmResponseType(const CdmSessionId&, const CdmKeyResponse&,
CdmLicenseType*, CdmKeySetId*));
MOCK_METHOD2(RestoreKey,
CdmResponseType(const CdmSessionId&, const CdmKeySetId&));
MOCK_METHOD1(RemoveKeys, CdmResponseType(const CdmSessionId&));
MOCK_METHOD2(QueryKeyStatus,
CdmResponseType(const CdmSessionId&, CdmQueryMap*));
MOCK_METHOD6(GetProvisioningRequest,
CdmResponseType(CdmCertificateType, const std::string&,
const std::string&, SecurityLevel,
CdmProvisioningRequest*, std::string*));
MOCK_METHOD4(HandleProvisioningResponse,
CdmResponseType(const CdmProvisioningResponse&, SecurityLevel,
std::string*, std::string*));
MOCK_METHOD1(Unprovision, CdmResponseType(CdmSecurityLevel));
MOCK_METHOD4(ListUsageIds,
CdmResponseType(const std::string&, CdmSecurityLevel,
std::vector<std::string>*,
std::vector<std::string>*));
MOCK_METHOD1(RemoveAllUsageInfo, CdmResponseType(const std::string&));
MOCK_METHOD2(RemoveAllUsageInfo,
CdmResponseType(const std::string&, CdmSecurityLevel));
MOCK_METHOD2(RemoveUsageInfo,
CdmResponseType(const std::string&, const CdmSecureStopId&));
MOCK_METHOD1(ReleaseUsageInfo,
CdmResponseType(const CdmUsageInfoReleaseMessage&));
MOCK_METHOD2(DecryptV16, CdmResponseType(const CdmSessionId&,
const CdmDecryptionParametersV16&));
MOCK_METHOD2(FindSessionForKey, bool(const KeyId&, CdmSessionId*));
MOCK_METHOD(CdmResponseType, OpenSession,
(const CdmKeySystem&, CdmClientPropertySet*, const CdmSessionId&,
WvCdmEventListener*),
(override));
MOCK_METHOD(CdmResponseType, OpenSession,
(const CdmKeySystem&, CdmClientPropertySet*, WvCdmEventListener*,
CdmSessionId*),
(override));
MOCK_METHOD(CdmResponseType, CloseSession, (const CdmSessionId&), (override));
MOCK_METHOD(CdmResponseType, OpenKeySetSession,
(const CdmKeySetId&, CdmClientPropertySet*, WvCdmEventListener*),
(override));
MOCK_METHOD(CdmResponseType, GenerateKeyRequest,
(const CdmSessionId&, const CdmKeySetId&,
const InitializationData&, const CdmLicenseType,
CdmAppParameterMap&, CdmKeyRequest*),
(override));
MOCK_METHOD(CdmResponseType, AddKey,
(const CdmSessionId&, const CdmKeyResponse&, CdmLicenseType*,
CdmKeySetId*),
(override));
MOCK_METHOD(CdmResponseType, RestoreKey,
(const CdmSessionId&, const CdmKeySetId&), (override));
MOCK_METHOD(CdmResponseType, RemoveKeys, (const CdmSessionId&), (override));
MOCK_METHOD(CdmResponseType, QueryKeyStatus,
(const CdmSessionId&, CdmQueryMap*), (override));
MOCK_METHOD(CdmResponseType, GetProvisioningRequest,
(CdmCertificateType, const std::string&, const std::string&,
SecurityLevel, CdmProvisioningRequest*, std::string*),
(override));
MOCK_METHOD(CdmResponseType, HandleProvisioningResponse,
(const CdmProvisioningResponse&, SecurityLevel, std::string*,
std::string*),
(override));
MOCK_METHOD(CdmResponseType, Unprovision, (CdmSecurityLevel), (override));
MOCK_METHOD(CdmResponseType, ListUsageIds,
(const std::string&, CdmSecurityLevel, std::vector<std::string>*,
std::vector<std::string>*),
(override));
MOCK_METHOD(CdmResponseType, RemoveAllUsageInfo, (const std::string&),
(override));
MOCK_METHOD(CdmResponseType, RemoveAllUsageInfo,
(const std::string&, CdmSecurityLevel), (override));
MOCK_METHOD(CdmResponseType, RemoveUsageInfo,
(const std::string&, const CdmSecureStopId&), (override));
MOCK_METHOD(CdmResponseType, ReleaseUsageInfo,
(const CdmUsageInfoReleaseMessage&), (override));
MOCK_METHOD(CdmResponseType, DecryptV16,
(const CdmSessionId&, const CdmDecryptionParametersV16&),
(override));
MOCK_METHOD(bool, FindSessionForKey, (const KeyId&, CdmSessionId*),
(override));
};
class WvCdmEngineMetricsImplTest : public ::testing::Test {

46
libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
View File

@@ -115,21 +115,21 @@ class MockDeviceFiles : public DeviceFiles {
public:
MockDeviceFiles() : DeviceFiles(nullptr) {}
MOCK_METHOD1(Init, bool(CdmSecurityLevel));
MOCK_METHOD5(RetrieveCertificate,
DeviceFiles::CertificateState(bool, std::string*,
CryptoWrappedKey*, std::string*,
uint32_t*));
MOCK_METHOD1(HasCertificate, bool(bool));
MOCK_METHOD(bool, Init, (CdmSecurityLevel), (override));
MOCK_METHOD(DeviceFiles::CertificateState, RetrieveCertificate,
(bool, std::string*, CryptoWrappedKey*, std::string*, uint32_t*),
(override));
MOCK_METHOD(bool, HasCertificate, (bool), (override));
};
class MockUsageTableHeader : public UsageTableHeader {
public:
MockUsageTableHeader() : UsageTableHeader() {}
MOCK_METHOD3(UpdateEntry, CdmResponseType(uint32_t usage_entry_number,
CryptoSession* crypto_session,
CdmUsageEntry* usage_entry));
MOCK_METHOD(CdmResponseType, UpdateEntry,
(uint32_t usage_entry_number, CryptoSession* crypto_session,
CdmUsageEntry* usage_entry),
(override));
};
class MockCryptoSession : public TestCryptoSession {
@@ -141,17 +141,16 @@ class MockCryptoSession : public TestCryptoSession {
.WillByDefault(
Invoke(this, &MockCryptoSession::BaseHasUsageInfoSupport));
}
MOCK_METHOD1(GetClientToken, bool(std::string*));
MOCK_METHOD1(GetProvisioningToken, CdmResponseType(std::string*));
MOCK_METHOD0(GetPreProvisionTokenType, CdmClientTokenType());
MOCK_METHOD0(GetSecurityLevel, CdmSecurityLevel());
MOCK_METHOD0(Open, CdmResponseType());
MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
MOCK_METHOD1(LoadCertificatePrivateKey,
CdmResponseType(const CryptoWrappedKey&));
MOCK_METHOD0(DeleteAllUsageReports, CdmResponseType());
MOCK_METHOD1(HasUsageInfoSupport, bool(bool*));
MOCK_METHOD0(GetUsageTableHeader, UsageTableHeader*());
MOCK_METHOD(CdmResponseType, GetProvisioningToken, (std::string*),
(override));
MOCK_METHOD(CdmClientTokenType, GetPreProvisionTokenType, (), (override));
MOCK_METHOD(CdmSecurityLevel, GetSecurityLevel, (), (override));
MOCK_METHOD(CdmResponseType, Open, (), (override));
MOCK_METHOD(CdmResponseType, Open, (SecurityLevel), (override));
MOCK_METHOD(CdmResponseType, LoadCertificatePrivateKey,
(const CryptoWrappedKey&), (override));
MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
MOCK_METHOD(UsageTableHeader*, GetUsageTableHeader, (), (override));
bool BaseHasUsageInfoSupport(bool* has_support) {
return CryptoSession::HasUsageInfoSupport(has_support);
@@ -170,9 +169,10 @@ class MockCdmLicense : public CdmLicense {
public:
MockCdmLicense(const CdmSessionId& session_id) : CdmLicense(session_id) {}
MOCK_METHOD4(Init,
bool(bool, const std::string&, CryptoSession*, PolicyEngine*));
MOCK_METHOD0(provider_session_token, std::string());
MOCK_METHOD(bool, Init,
(bool, const std::string&, CryptoSession*, PolicyEngine*),
(override));
MOCK_METHOD(std::string, provider_session_token, (), (override));
};
} // namespace

25
libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
View File

@@ -59,20 +59,21 @@ class MockCryptoSession : public TestCryptoSession {
public:
MockCryptoSession(metrics::CryptoMetrics* metrics)
: TestCryptoSession(metrics) {}
MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
MOCK_METHOD(CdmResponseType, Open, (SecurityLevel), (override));
// Usage Table Header.
MOCK_METHOD2(CreateUsageTableHeader,
CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
MOCK_METHOD2(LoadUsageTableHeader,
CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
MOCK_METHOD3(ShrinkUsageTableHeader,
CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
(SecurityLevel, CdmUsageTableHeader*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
(SecurityLevel, const CdmUsageTableHeader&), (override));
MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
(SecurityLevel, uint32_t, CdmUsageTableHeader*), (override));
// Usage Entry.
MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
MOCK_METHOD2(UpdateUsageEntry,
CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
(override));
MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
(CdmUsageTableHeader*, CdmUsageEntry*), (override));
MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
};
class TestStubCryptoSessionFactory : public CryptoSessionFactory {

18
libwvdrmengine/cdm/core/test/device_files_unittest.cpp
View File

@@ -3747,8 +3747,8 @@ class MockFile : public File {
MockFile() {}
~MockFile() override {}
MOCK_METHOD2(Read, ssize_t(char*, size_t));
MOCK_METHOD2(Write, ssize_t(const char*, size_t));
MOCK_METHOD(ssize_t, Read, (char*, size_t), (override));
MOCK_METHOD(ssize_t, Write, (const char*, size_t), (override));
};
class MockFileSystem : public FileSystem {
@@ -3756,13 +3756,13 @@ class MockFileSystem : public FileSystem {
MockFileSystem() {}
~MockFileSystem() override {}
MOCK_METHOD2(Open, std::unique_ptr<File>(const std::string&, int flags));
MOCK_METHOD0(IsFactoryReset, bool());
MOCK_METHOD1(Exists, bool(const std::string&));
MOCK_METHOD1(Remove, bool(const std::string&));
MOCK_METHOD1(FileSize, ssize_t(const std::string&));
MOCK_METHOD2(List, bool(const std::string&, std::vector<std::string>*));
MOCK_METHOD(std::unique_ptr<File>, Open, (const std::string&, int flags),
(override));
MOCK_METHOD(bool, Exists, (const std::string&), (override));
MOCK_METHOD(bool, Remove, (const std::string&), (override));
MOCK_METHOD(ssize_t, FileSize, (const std::string&), (override));
MOCK_METHOD(bool, List, (const std::string&, std::vector<std::string>*),
(override));
};
} // namespace

46
libwvdrmengine/cdm/core/test/license_unittest.cpp
View File

@@ -139,36 +139,30 @@ class MockCryptoSession : public TestCryptoSession {
public:
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: TestCryptoSession(crypto_metrics) {}
MOCK_METHOD0(IsOpen, bool());
MOCK_METHOD0(request_id, const std::string&());
MOCK_METHOD1(HasUsageInfoSupport, bool(bool*));
MOCK_METHOD2(GetHdcpCapabilities,
CdmResponseType(HdcpCapability*, HdcpCapability*));
MOCK_METHOD1(GetSupportedCertificateTypes, bool(SupportedCertificateTypes*));
MOCK_METHOD1(GetApiVersion, bool(uint32_t*));
MOCK_METHOD1(GenerateNonce, CdmResponseType(uint32_t*));
MOCK_METHOD3(PrepareAndSignLicenseRequest,
CdmResponseType(const std::string&, std::string*, std::string*));
MOCK_METHOD1(LoadEntitledContentKeys,
CdmResponseType(const std::vector<CryptoKey>& key_array));
MOCK_METHOD1(GetResourceRatingTier, bool(uint32_t*));
MOCK_METHOD(bool, IsOpen, (), (override));
MOCK_METHOD(const std::string&, request_id, (), (override));
MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
(HdcpCapability*, HdcpCapability*), (override));
MOCK_METHOD(bool, GetSupportedCertificateTypes, (SupportedCertificateTypes*),
(override));
MOCK_METHOD(bool, GetApiVersion, (uint32_t*), (override));
MOCK_METHOD(CdmResponseType, GenerateNonce, (uint32_t*), (override));
MOCK_METHOD(CdmResponseType, PrepareAndSignLicenseRequest,
(const std::string&, std::string*, std::string*), (override));
MOCK_METHOD(CdmResponseType, LoadEntitledContentKeys,
(const std::vector<CryptoKey>& key_array), (override));
MOCK_METHOD(bool, GetResourceRatingTier, (uint32_t*), (override));
};
class MockPolicyEngine : public PolicyEngine {
public:
MockPolicyEngine(CryptoSession* crypto)
: PolicyEngine("mock_session_id", nullptr, crypto) {}
MOCK_METHOD1(
SetEntitledLicenseKeys,
void(const std::vector<video_widevine::WidevinePsshData_EntitledKey>&));
};
class MockInitializationData : public InitializationData {
public:
MockInitializationData(const std::string& type, const CdmInitData& data)
: InitializationData(type, data) {}
MOCK_METHOD0(is_supported, bool());
MOCK_METHOD0(is_cenc, bool());
MOCK_METHOD(
void, SetEntitledLicenseKeys,
(const std::vector<video_widevine::WidevinePsshData_EntitledKey>&),
(override));
};
} // namespace
@@ -216,7 +210,7 @@ class CdmLicenseTest : public WvCdmTestBase {
WvCdmTestBase::SetUp();
clock_ = new MockClock();
crypto_session_ = new MockCryptoSession(&crypto_metrics_);
init_data_ = new MockInitializationData(CENC_INIT_DATA_FORMAT, pssh_);
init_data_ = new InitializationData(CENC_INIT_DATA_FORMAT, pssh_);
policy_engine_ = new MockPolicyEngine(crypto_session_);
ON_CALL(*crypto_session_, GetSupportedCertificateTypes(NotNull()))
@@ -241,7 +235,7 @@ class CdmLicenseTest : public WvCdmTestBase {
MockClock* clock_;
metrics::CryptoMetrics crypto_metrics_;
MockCryptoSession* crypto_session_;
MockInitializationData* init_data_;
InitializationData* init_data_;
MockPolicyEngine* policy_engine_;
std::string pssh_;
};

2
libwvdrmengine/cdm/core/test/mock_clock.h
View File

@@ -12,7 +12,7 @@ namespace wvcdm {
class MockClock : public Clock {
public:
MOCK_METHOD0(GetCurrentTime, int64_t());
MOCK_METHOD(int64_t, GetCurrentTime, (), (override));
};
// Frozen clock will always return the same value for the current time.

7
libwvdrmengine/cdm/core/test/ota_keybox_provisioner_test.cpp
View File

@@ -52,9 +52,10 @@ class MockCryptoSession : public CryptoSession {
bool IsOpen() override { return is_open_; }
void SetIsOpen(bool is_open) { is_open_ = is_open; }
MOCK_METHOD2(PrepareOtaProvisioningRequest,
CdmResponseType(bool, std::string*));
MOCK_METHOD2(LoadOtaProvisioning, CdmResponseType(bool, const std::string&));
MOCK_METHOD(CdmResponseType, PrepareOtaProvisioningRequest,
(bool, std::string*), (override));
MOCK_METHOD(CdmResponseType, LoadOtaProvisioning, (bool, const std::string&),
(override));
// Client ID
uint8_t GetSecurityPatchLevel() override { return 0x00; }

19
libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp
View File

@@ -70,18 +70,21 @@ class HdcpOnlyMockCryptoSession : public TestCryptoSession {
HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: TestCryptoSession(crypto_metrics) {}
MOCK_METHOD2(GetHdcpCapabilities,
CdmResponseType(HdcpCapability*, HdcpCapability*));
MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
(HdcpCapability*, HdcpCapability*), (override));
};
class MockCdmEventListener : public WvCdmEventListener {
public:
MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status,
bool has_new_usable_key));
MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
int64_t new_expiry_time_seconds));
MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
(override));
MOCK_METHOD(void, OnSessionKeysChange,
(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
(override));
MOCK_METHOD(void, OnExpirationUpdate,
(const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
(override));
};
} // namespace

19
libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
View File

@@ -55,8 +55,8 @@ class HdcpOnlyMockCryptoSession : public TestCryptoSession {
HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics)
: TestCryptoSession(metrics) {}
MOCK_METHOD2(GetHdcpCapabilities,
CdmResponseType(HdcpCapability*, HdcpCapability*));
MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
(HdcpCapability*, HdcpCapability*), (override));
CdmResponseType DoRealGetHdcpCapabilities(HdcpCapability* current,
HdcpCapability* max) {
return CryptoSession::GetHdcpCapabilities(current, max);
@@ -65,12 +65,15 @@ class HdcpOnlyMockCryptoSession : public TestCryptoSession {
class MockCdmEventListener : public WvCdmEventListener {
public:
MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status,
bool has_new_usable_key));
MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
int64_t new_expiry_time_seconds));
MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
(override));
MOCK_METHOD(void, OnSessionKeysChange,
(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
(override));
MOCK_METHOD(void, OnExpirationUpdate,
(const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
(override));
};
} // namespace

112
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -379,9 +379,10 @@ class MockDeviceFiles : public DeviceFiles {
public:
MockDeviceFiles() : DeviceFiles(&file_system_) { Init(kSecurityLevelL1); }
MOCK_METHOD3(RetrieveLicense,
bool(const std::string&, DeviceFiles::CdmLicenseData*,
DeviceFiles::ResponseType*));
MOCK_METHOD(bool, RetrieveLicense,
(const std::string&, DeviceFiles::CdmLicenseData*,
DeviceFiles::ResponseType*),
(override));
// Used for calling the non-mocked method.
bool RealRetrieveLicense(const std::string& key_set_id,
DeviceFiles::CdmLicenseData* license_data,
@@ -389,34 +390,41 @@ class MockDeviceFiles : public DeviceFiles {
return DeviceFiles::RetrieveLicense(key_set_id, license_data, response);
}
MOCK_METHOD3(RetrieveUsageTableInfo,
bool(CdmUsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
bool* lru_upgrade));
MOCK_METHOD2(StoreUsageTableInfo,
bool(const CdmUsageTableHeader&,
const std::vector<CdmUsageEntryInfo>&));
MOCK_METHOD2(DeleteUsageInfo, bool(const std::string&, const std::string&));
MOCK_METHOD2(DeleteMultipleUsageInfoByKeySetIds,
bool(const std::string&, const std::vector<std::string>&));
MOCK_METHOD9(RetrieveUsageInfoByKeySetId,
bool(const std::string&, const std::string&, std::string*,
CdmKeyMessage*, CdmKeyResponse*, CdmUsageEntry*, uint32_t*,
std::string*, CryptoWrappedKey*));
MOCK_METHOD2(StoreLicense, bool(const CdmLicenseData&, ResponseType*));
MOCK_METHOD1(DeleteLicense, bool(const std::string&));
MOCK_METHOD0(DeleteAllLicenses, bool());
MOCK_METHOD0(DeleteAllUsageInfo, bool());
MOCK_METHOD0(DeleteUsageTableInfo, bool());
MOCK_METHOD9(StoreUsageInfo,
bool(const std::string&, const CdmKeyMessage&,
const CdmKeyResponse&, const std::string&,
const std::string&, const CdmUsageEntry&, uint32_t,
const std::string&, const CryptoWrappedKey&));
MOCK_METHOD2(RetrieveUsageInfo,
bool(const std::string&, std::vector<CdmUsageData>*));
MOCK_METHOD1(ListLicenses, bool(std::vector<std::string>* key_set_ids));
MOCK_METHOD1(ListUsageInfoFiles,
bool(std::vector<std::string>* usage_info_files));
MOCK_METHOD(bool, RetrieveUsageTableInfo,
(CdmUsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
bool* lru_upgrade),
(override));
MOCK_METHOD(bool, StoreUsageTableInfo,
(const CdmUsageTableHeader&,
const std::vector<CdmUsageEntryInfo>&),
(override));
MOCK_METHOD(bool, DeleteUsageInfo, (const std::string&, const std::string&),
(override));
MOCK_METHOD(bool, DeleteMultipleUsageInfoByKeySetIds,
(const std::string&, const std::vector<std::string>&),
(override));
MOCK_METHOD(bool, RetrieveUsageInfoByKeySetId,
(const std::string&, const std::string&, std::string*,
CdmKeyMessage*, CdmKeyResponse*, CdmUsageEntry*, uint32_t*,
std::string*, CryptoWrappedKey*),
(override));
MOCK_METHOD(bool, StoreLicense, (const CdmLicenseData&, ResponseType*),
(override));
MOCK_METHOD(bool, DeleteLicense, (const std::string&), (override));
MOCK_METHOD(bool, DeleteAllLicenses, (), (override));
MOCK_METHOD(bool, DeleteAllUsageInfo, (), (override));
MOCK_METHOD(bool, DeleteUsageTableInfo, (), (override));
MOCK_METHOD(bool, StoreUsageInfo,
(const std::string&, const CdmKeyMessage&, const CdmKeyResponse&,
const std::string&, const std::string&, const CdmUsageEntry&,
uint32_t, const std::string&, const CryptoWrappedKey&),
(override));
MOCK_METHOD(bool, RetrieveUsageInfo,
(const std::string&, std::vector<CdmUsageData>*), (override));
MOCK_METHOD(bool, ListLicenses, (std::vector<std::string> * key_set_ids),
(override));
MOCK_METHOD(bool, ListUsageInfoFiles,
(std::vector<std::string> * usage_info_files), (override));
private:
FileSystem file_system_;
@@ -426,22 +434,23 @@ class MockCryptoSession : public TestCryptoSession {
public:
MockCryptoSession(metrics::CryptoMetrics* metrics)
: TestCryptoSession(metrics) {}
MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
MOCK_METHOD(CdmResponseType, Open, (SecurityLevel), (override));
// Usage Table Header.
MOCK_METHOD2(CreateUsageTableHeader,
CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
MOCK_METHOD2(LoadUsageTableHeader,
CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
MOCK_METHOD3(ShrinkUsageTableHeader,
CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
(SecurityLevel, CdmUsageTableHeader*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
(SecurityLevel, const CdmUsageTableHeader&), (override));
MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
(SecurityLevel, uint32_t, CdmUsageTableHeader*), (override));
// Usage Entry.
MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
MOCK_METHOD2(UpdateUsageEntry,
CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
MOCK_METHOD2(GetNumberOfOpenSessions,
CdmResponseType(SecurityLevel, size_t*));
MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
(override));
MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
(CdmUsageTableHeader*, CdmUsageEntry*), (override));
MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
MOCK_METHOD(CdmResponseType, GetNumberOfOpenSessions,
(SecurityLevel, size_t*), (override));
// Fake method for testing. Having an EXPECT_CALL causes complexities
// for getting table capacity during initialization.
@@ -470,12 +479,13 @@ class MockCryptoSession : public TestCryptoSession {
class MockUsageTableHeader : public UsageTableHeader {
public:
MockUsageTableHeader() : UsageTableHeader() {}
MOCK_METHOD4(InvalidateEntryInternal,
CdmResponseType(uint32_t, bool, DeviceFiles*,
metrics::CryptoMetrics*));
MOCK_METHOD6(AddEntry, CdmResponseType(CryptoSession*, bool,
const CdmKeySetId&, const std::string&,
const CdmKeyResponse&, uint32_t*));
MOCK_METHOD(CdmResponseType, InvalidateEntryInternal,
(uint32_t, bool, DeviceFiles*, metrics::CryptoMetrics*),
(override));
MOCK_METHOD(CdmResponseType, AddEntry,
(CryptoSession*, bool, const CdmKeySetId&, const std::string&,
const CdmKeyResponse&, uint32_t*),
(override));
CdmResponseType SuperAddEntry(CryptoSession* crypto_session,
bool persistent_license,

15
libwvdrmengine/cdm/test/cdm_feature_test.cpp
View File

@@ -197,12 +197,15 @@ using video_widevine::SignedProvisioningMessage;
class TestWvCdmEventListener : public WvCdmEventListener {
public:
TestWvCdmEventListener() : WvCdmEventListener() {}
MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status,
bool has_new_usable_key));
MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
int64_t new_expiry_time_seconds));
MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
(override));
MOCK_METHOD(void, OnSessionKeysChange,
(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
(override));
MOCK_METHOD(void, OnExpirationUpdate,
(const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
(override));
};
class TestKeyVerifier {

15
libwvdrmengine/cdm/test/request_license_test.cpp
View File

@@ -1599,12 +1599,15 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
class TestWvCdmEventListener : public WvCdmEventListener {
public:
TestWvCdmEventListener() : WvCdmEventListener() {}
MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status,
bool has_new_usable_key));
MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
int64_t new_expiry_time_seconds));
MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
(override));
MOCK_METHOD(void, OnSessionKeysChange,
(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
(override));
MOCK_METHOD(void, OnExpirationUpdate,
(const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
(override));
};
class DecryptCallbackTester {