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

Merge changes Ied664ce8,I90004025 into udc-dev am: 13368f4076

Browse Source 
Original change: https://googleplex-android-review.googlesource.com/c/platform/vendor/widevine/+/23088670

Change-Id: I6768d72e30a2ec12ca579d2555692d833146fb09
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Rahul Frias
2023-05-12 15:31:35 +00:00
committed by Automerger Merge Worker
parent fbaede0920 13368f4076
commit 023fd9d026
2 changed files with 163 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
libwvdrmengine/cdm/core/test/duration_use_case_test.cpp
View File

@@ -1533,9 +1533,11 @@ class CdmUseCase_RenewOnLicenseLoad : public RenewalTest {
timer_limits_.initial_renewal_duration_seconds =
renewal_delay_ + renewal_recovery_;
// Calculate the renewal cutoff:
renewal_cutoff_ = start_of_playback_ + renewal_delay_ + renewal_recovery_;
// Load the renewal just before the cutoff:
renewal_load_time_ =
start_of_playback_ + renewal_delay_ + renewal_recovery_ - 1;
renewal_load_time_ = renewal_cutoff_ - kFudge;
}
void SetUp() override {
@@ -1548,6 +1550,7 @@ class CdmUseCase_RenewOnLicenseLoad : public RenewalTest {
}
}
uint64_t renewal_cutoff_;
uint64_t renewal_delay_;
uint64_t renewal_load_time_;
uint64_t renewal_recovery_;
@@ -1561,9 +1564,8 @@ TEST_P(CdmUseCase_RenewOnLicenseLoad, Case1S) {
SleepUntilRenewalNeeded();
RequestRenewal(kRenewOnLicenseLoad);
const uint64_t start = 15; // time of first decrypt
const uint64_t load_renewal = 20;
const uint64_t stop = 45;
RenewAndContinue(start, load_renewal, stop, kRenewOnLicenseLoad);
RenewAndContinue(start, renewal_load_time_, stop, kRenewOnLicenseLoad);
}
// License loaded within rental duration window and playback continues.
@@ -1573,10 +1575,9 @@ TEST_P(CdmUseCase_RenewOnLicenseLoad, Case1M) {
LoadLicense();
SleepUntilRenewalNeeded();
RequestRenewal(kRenewOnLicenseLoad);
const uint64_t start = 20; // time of first decrypt
const uint64_t load_renewal = 20;
const uint64_t start = 25; // time of first decrypt
const uint64_t stop = 45; // end of decrypt
RenewAndContinue(start, load_renewal, stop, kRenewOnLicenseLoad);
RenewAndContinue(start, renewal_load_time_, stop, kRenewOnLicenseLoad);
}
// License loaded within rental duration window and playback continues.
@@ -1586,10 +1587,9 @@ TEST_P(CdmUseCase_RenewOnLicenseLoad, Case1L) {
LoadLicense();
SleepUntilRenewalNeeded();
RequestRenewal(kRenewOnLicenseLoad);
const uint64_t load_renewal = 20;
const uint64_t start = 25; // time of first decrypt
const uint64_t start = 35; // time of first decrypt
const uint64_t stop = 45; // end of decrypt
LoadRenewal(load_renewal, kRenewOnLicenseLoad);
LoadRenewal(renewal_load_time_, kRenewOnLicenseLoad);
AllowPlayback(start, stop);
}
@@ -1607,9 +1607,7 @@ TEST_P(CdmUseCase_RenewOnLicenseLoad, Case3S) {
LoadLicense();
const uint64_t start = 15; // time of first decrypt
// Allow playback within the initial renewal window.
const uint64_t cutoff =
start_of_playback_ + renewal_delay_ + renewal_recovery_;
TerminatePlayback(start, cutoff);
TerminatePlayback(start, renewal_cutoff_);
}
// License loaded within rental duration window but renewal not received.
@@ -1619,9 +1617,7 @@ TEST_P(CdmUseCase_RenewOnLicenseLoad, Case3M) {
LoadLicense();
const uint64_t start = 25; // time of first decrypt
// Allow playback within the initial renewal window.
const uint64_t cutoff =
start_of_playback_ + renewal_delay_ + renewal_recovery_;
TerminatePlayback(start, cutoff);
TerminatePlayback(start, renewal_cutoff_);
}
// License loaded within rental duration window but renewal not received.

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

@@ -11,6 +11,7 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "crypto_key.h"
#include "license.h"
#include "mock_clock.h"
#include "policy_engine.h"
@@ -50,17 +51,31 @@ int64_t GetLicenseRenewalDelay(int64_t license_duration) {
: 0;
}
class HdcpOnlyMockCryptoSession : public TestCryptoSession {
class MockCryptoSession : public CryptoSession {
public:
HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics)
: TestCryptoSession(metrics) {}
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: CryptoSession(crypto_metrics) {}
MOCK_METHOD(bool, IsOpen, (), (override));
MOCK_METHOD(const std::string&, request_id, (), (override));
MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (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*, bool&,
OEMCrypto_SignatureHashAlgorithm&),
(override));
MOCK_METHOD(CdmResponseType, LoadEntitledContentKeys,
(const std::vector<CryptoKey>& key_array), (override));
MOCK_METHOD(bool, GetResourceRatingTier, (uint32_t*), (override));
MOCK_METHOD(bool, GetWatermarkingSupport, (CdmWatermarkingSupport*),
(override));
MOCK_METHOD(bool, GetBuildInformation, (std::string*), (override));
MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
(HdcpCapability*, HdcpCapability*), (override));
CdmResponseType DoRealGetHdcpCapabilities(HdcpCapability* current,
HdcpCapability* max) {
return CryptoSession::GetHdcpCapabilities(current, max);
}
CdmSecurityLevel GetSecurityLevel() override { return kSecurityLevelL1; }
};
class MockCdmEventListener : public WvCdmEventListener {
@@ -98,13 +113,14 @@ using ::testing::UnorderedElementsAre;
class PolicyEngineTest : public WvCdmTestBase {
public:
PolicyEngineTest() : crypto_session_(&dummy_metrics_) {}
PolicyEngineTest()
: crypto_session_(new MockCryptoSession(&dummy_metrics_)) {}
protected:
void SetUp() override {
WvCdmTestBase::SetUp();
policy_engine_.reset(
new PolicyEngine(kSessionId, &mock_event_listener_, &crypto_session_));
policy_engine_.reset(new PolicyEngine(kSessionId, &mock_event_listener_,
crypto_session_.get()));
InjectMockClock();
license_.set_license_start_time(kLicenseStartTime);
@@ -133,11 +149,6 @@ class PolicyEngineTest : public WvCdmTestBase {
policy->set_renewal_delay_seconds(0);
policy->set_renewal_retry_interval_seconds(kLicenseRenewalRetryInterval);
policy->set_renew_with_usage(false);
ON_CALL(crypto_session_, GetHdcpCapabilities(_, _))
.WillByDefault(
Invoke(&crypto_session_,
&HdcpOnlyMockCryptoSession::DoRealGetHdcpCapabilities));
}
void InjectMockClock() {
@@ -181,7 +192,7 @@ class PolicyEngineTest : public WvCdmTestBase {
}
metrics::CryptoMetrics dummy_metrics_;
NiceMock<HdcpOnlyMockCryptoSession> crypto_session_;
std::unique_ptr<MockCryptoSession> crypto_session_;
StrictMock<MockCdmEventListener> mock_event_listener_;
MockClock* mock_clock_;
std::unique_ptr<PolicyEngine> policy_engine_;
@@ -189,6 +200,14 @@ class PolicyEngineTest : public WvCdmTestBase {
MockFunction<void(int i)> check_;
};
class PolicyEngineTestV16 : public PolicyEngineTest {
public:
PolicyEngineTestV16() {}
protected:
void SetUp() override { PolicyEngineTest::SetUp(); }
};
TEST_F(PolicyEngineTest, NoLicense) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
@@ -245,10 +264,10 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackSuccess_StreamingLicense_V15) {
// Current expectation: kLicenseStartTime + kLowDuration (license duration)
// Actual: kLicenseStart + kRentalDuration
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
.WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(
CdmResponseType(GET_HDCP_CAPABILITY_FAILED)))));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
policy_engine_->SetLicense(license_, false);
policy_engine_->BeginDecryption();
@@ -280,7 +299,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackFailed_RepeatedRenewFailures_V15) {
.WillOnce(Return(kLicenseStartTime + kLicenseDuration - 15))
.WillOnce(Return(kLicenseStartTime + kLicenseDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -342,7 +361,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackOk_RenewSuccessAfterExpiry_V15) {
.WillOnce(Return(new_license_start_time))
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 20));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -418,7 +437,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackOk_RenewSuccessAfterFailures_V15) {
.WillOnce(Return(kLicenseStartTime + license_renewal_delay + 67))
.WillOnce(Return(kLicenseStartTime + license_renewal_delay + 200));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -479,7 +498,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackOk_RenewedWithUsage_V15) {
.WillOnce(Return(kLicenseStartTime + 20))
.WillOnce(Return(kLicenseStartTime + 40));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -523,7 +542,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackOk_RenewedWithUsage_V15) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, MultipleKeysInLicense) {
TEST_F(PolicyEngineTestV16, MultipleKeysInLicense) {
const char kSigningKeyId[] = "signing_key";
license_.clear_key();
@@ -542,7 +561,7 @@ TEST_F(PolicyEngineTest, MultipleKeysInLicense) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -570,7 +589,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackOk_SoftEnforcePlaybackDuration_V15) {
.WillOnce(Return(kLicenseStartTime + kLicenseDuration - 5))
.WillOnce(Return(kLicenseStartTime + kLicenseDuration + 5));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -610,7 +629,7 @@ TEST_F(PolicyEngineTest,
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 5))
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -639,7 +658,7 @@ TEST_F(PolicyEngineTest,
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5))
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -663,7 +682,7 @@ TEST_F(PolicyEngineTest, DISABLED_PlaybackOk_RestoreWithoutPlaybackTimes_V15) {
.WillOnce(Return(kLicenseStartTime + 15))
.WillOnce(Return(kLicenseStartTime + 30));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -699,10 +718,10 @@ const KeySecurityLevelParams kKeySecurityTestVectors[] = {
};
class PolicyEngineKeySecurityLevelTest
: public PolicyEngineTest,
: public PolicyEngineTestV16,
public ::testing::WithParamInterface<const KeySecurityLevelParams*> {};
TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLevel) {
TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLeve) {
const KeySecurityLevelParams* param = GetParam();
license_.clear_key();
@@ -716,6 +735,11 @@ TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLevel) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime + 1));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
ExpectSessionKeysChange(kKeyStatusUsable, true);
EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _));
@@ -748,7 +772,7 @@ INSTANTIATE_TEST_SUITE_P(PolicyEngine, PolicyEngineKeySecurityLevelTest,
::testing::Range(&kKeySecurityTestVectors[0],
&kKeySecurityTestVectors[5]));
class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest {
class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTestV16 {
protected:
enum KeyFlag { kKeyFlagNull, kKeyFlagFalse, kKeyFlagTrue };
@@ -872,7 +896,7 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -933,7 +957,7 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -959,12 +983,12 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) {
kSignFalse, kVerifyTrue);
}
class PolicyEngineQueryTest : public PolicyEngineTest {
class PolicyEngineQueryTest : public PolicyEngineTestV16 {
protected:
void SetUp() override {
PolicyEngineTest::SetUp();
policy_engine_.reset(
new PolicyEngine(kSessionId, nullptr, &crypto_session_));
new PolicyEngine(kSessionId, nullptr, crypto_session_.get()));
InjectMockClock();
// Use a STREAMING license policy.
@@ -992,7 +1016,7 @@ TEST_F(PolicyEngineQueryTest, DISABLED_QuerySuccess_Offline_V15) {
.WillOnce(Return(kLicenseStartTime + 200))
.WillOnce(Return(kLicenseStartTime + 300));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1033,7 +1057,7 @@ TEST_F(PolicyEngineQueryTest, DISABLED_QuerySuccess_Renew_V15) {
.WillOnce(Return(kLicenseStartTime + license_renewal_delay +
kLicenseRenewalRetryInterval + 15));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1093,7 +1117,7 @@ TEST_F(PolicyEngineQueryTest,
.WillOnce(Return(kLicenseStartTime + license_renewal_delay +
kLicenseRenewalRetryInterval + 40));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1152,7 +1176,7 @@ TEST_F(PolicyEngineQueryTest,
// These test execise license policy when the license service and client
// both support OEMCrypto v16
TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense_V16) {
TEST_F(PolicyEngineTestV16, PlaybackSuccess_OfflineLicense) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime + 1))
.WillOnce(Return(kPlaybackStartTime))
@@ -1164,7 +1188,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense_V16) {
EXPECT_CALL(mock_event_listener_,
OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(NO_ERROR))));
@@ -1176,7 +1200,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
}
TEST_F(PolicyEngineTest, PlaybackFailed_CanPlayFalse_V16) {
TEST_F(PolicyEngineTestV16, PlaybackFailed_CanPlayFalse) {
License_Policy* policy = license_.mutable_policy();
policy->set_can_play(false);
@@ -1189,7 +1213,7 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanPlayFalse_V16) {
EXPECT_CALL(mock_event_listener_,
OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1203,8 +1227,8 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanPlayFalse_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest,
LicenseExpired_RentalDurationExpiredWithoutPlayback_V16) {
TEST_F(PolicyEngineTestV16,
LicenseExpired_RentalDurationExpiredWithoutPlayback) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_license_duration_seconds(kHighDuration);
@@ -1216,7 +1240,7 @@ TEST_F(PolicyEngineTest,
.WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
.WillOnce(Return(kLicenseStartTime + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1242,8 +1266,8 @@ TEST_F(PolicyEngineTest,
}
TEST_F(
PolicyEngineTest,
LicenseExpired_RentalDurationExpiredWithoutPlayback_SoftEnforceRentalDuration_V16) {
PolicyEngineTestV16,
LicenseExpired_RentalDurationExpiredWithoutPlayback_SoftEnforceRentalDuration) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_license_duration_seconds(kHighDuration);
@@ -1255,7 +1279,7 @@ TEST_F(
.WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
.WillOnce(Return(kLicenseStartTime + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1280,7 +1304,7 @@ TEST_F(
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackFails_RentalDurationPassedWithPlayback_V16) {
TEST_F(PolicyEngineTestV16, PlaybackFails_RentalDurationPassedWithPlayback) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_soft_enforce_rental_duration(false);
@@ -1292,7 +1316,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_RentalDurationPassedWithPlayback_V16) {
.WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
.WillOnce(Return(kLicenseStartTime + kLowDuration + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1317,9 +1341,8 @@ TEST_F(PolicyEngineTest, PlaybackFails_RentalDurationPassedWithPlayback_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(
PolicyEngineTest,
PlaybackOk_RentalDurationPassedWithPlayback_SoftEnforceRentalDuration_V16) {
TEST_F(PolicyEngineTestV16,
PlaybackOk_RentalDurationPassedWithPlayback_SoftEnforceRentalDuration) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_soft_enforce_rental_duration(true);
@@ -1331,7 +1354,7 @@ TEST_F(
.WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
.WillOnce(Return(kLicenseStartTime + kLowDuration + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1357,7 +1380,7 @@ TEST_F(
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired_V16) {
TEST_F(PolicyEngineTestV16, PlaybackFails_PlaybackDurationExpired) {
const int64_t playback_start_time = kLicenseStartTime + 10000;
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
@@ -1369,7 +1392,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired_V16) {
.WillOnce(Return(playback_start_time + kPlaybackDuration - 2))
.WillOnce(Return(playback_start_time + kPlaybackDuration + 2));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1396,8 +1419,8 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest,
PlaybackOk_PlaybackDurationExpired_SoftEnforcePlaybackDuration_V16) {
TEST_F(PolicyEngineTestV16,
PlaybackOk_PlaybackDurationExpired_SoftEnforcePlaybackDuration) {
int64_t playback_start_time = kLicenseStartTime + 10000;
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
@@ -1409,7 +1432,7 @@ TEST_F(PolicyEngineTest,
.WillOnce(Return(playback_start_time + kPlaybackDuration - 2))
.WillOnce(Return(playback_start_time + kPlaybackDuration + 2));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1437,7 +1460,7 @@ TEST_F(PolicyEngineTest,
// OEMCrypto v16. Rental and Playback durations are used for both streaming and
// offline. Verify that License duration expiry does not cause the license
// to expire.
TEST_F(PolicyEngineTest, LicenseOk_LicenseDurationExpiredWithoutPlayback_V16) {
TEST_F(PolicyEngineTestV16, LicenseOk_LicenseDurationExpiredWithoutPlayback) {
License_Policy* policy = license_.mutable_policy();
policy->set_license_duration_seconds(kLowDuration);
policy->set_soft_enforce_rental_duration(false);
@@ -1449,7 +1472,7 @@ TEST_F(PolicyEngineTest, LicenseOk_LicenseDurationExpiredWithoutPlayback_V16) {
.WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
.WillOnce(Return(kLicenseStartTime + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1473,7 +1496,7 @@ TEST_F(PolicyEngineTest, LicenseOk_LicenseDurationExpiredWithoutPlayback_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, LicenseOk_LicenseDurationExpiredWithPlayback_V16) {
TEST_F(PolicyEngineTestV16, LicenseOk_LicenseDurationExpiredWithPlayback) {
License_Policy* policy = license_.mutable_policy();
policy->set_license_duration_seconds(kLowDuration);
policy->set_soft_enforce_rental_duration(false);
@@ -1486,7 +1509,7 @@ TEST_F(PolicyEngineTest, LicenseOk_LicenseDurationExpiredWithPlayback_V16) {
.WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
.WillOnce(Return(kLicenseStartTime + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1513,7 +1536,7 @@ TEST_F(PolicyEngineTest, LicenseOk_LicenseDurationExpiredWithPlayback_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_V16) {
TEST_F(PolicyEngineTestV16, PlaybackFails_ExpiryBeforeRenewalDelay) {
License_Policy* policy = license_.mutable_policy();
policy->set_renewal_delay_seconds(kLicenseDuration + 10);
policy->set_can_renew(true);
@@ -1526,7 +1549,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_V16) {
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 1))
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1553,7 +1576,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, LicenseOk_RentalDuration0_V16) {
TEST_F(PolicyEngineTestV16, LicenseOk_RentalDuration0) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(UNLIMITED_DURATION);
policy->set_soft_enforce_rental_duration(false);
@@ -1565,7 +1588,7 @@ TEST_F(PolicyEngineTest, LicenseOk_RentalDuration0_V16) {
.WillOnce(Return(kLicenseStartTime + kRentalDuration + 10))
.WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1588,7 +1611,7 @@ TEST_F(PolicyEngineTest, LicenseOk_RentalDuration0_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0_V16) {
TEST_F(PolicyEngineTestV16, PlaybackOk_RentalDuration0) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(UNLIMITED_DURATION);
policy->set_soft_enforce_rental_duration(false);
@@ -1601,7 +1624,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0_V16) {
.WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1))
.WillOnce(Return(kLicenseStartTime + kLicenseDuration + 10));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1629,7 +1652,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDuration0_V16) {
TEST_F(PolicyEngineTestV16, PlaybackFails_PlaybackDuration0) {
License_Policy* policy = license_.mutable_policy();
policy->set_playback_duration_seconds(UNLIMITED_DURATION);
policy->set_soft_enforce_rental_duration(false);
@@ -1643,7 +1666,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDuration0_V16) {
.WillOnce(Return(kLicenseStartTime + kRentalDuration - 2))
.WillOnce(Return(kLicenseStartTime + kRentalDuration + 2));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1670,8 +1693,8 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDuration0_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest,
PlaybackOk_PlaybackDuration0_SoftEnforceRentalDuration_V16) {
TEST_F(PolicyEngineTestV16,
PlaybackOk_PlaybackDuration0_SoftEnforceRentalDuration) {
License_Policy* policy = license_.mutable_policy();
policy->set_playback_duration_seconds(UNLIMITED_DURATION);
policy->set_soft_enforce_rental_duration(true);
@@ -1685,7 +1708,7 @@ TEST_F(PolicyEngineTest,
.WillOnce(Return(kPlaybackStartTime + kRentalDuration - 2))
.WillOnce(Return(kPlaybackStartTime + kRentalDuration + 2));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1712,7 +1735,7 @@ TEST_F(PolicyEngineTest,
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0_V16) {
TEST_F(PolicyEngineTestV16, PlaybackOk_PlaybackAndRental0) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(UNLIMITED_DURATION);
policy->set_playback_duration_seconds(UNLIMITED_DURATION);
@@ -1728,7 +1751,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0_V16) {
.WillOnce(Return(kPlaybackStartTime + kRentalDuration - 2))
.WillOnce(Return(kPlaybackStartTime + kRentalDuration + 2));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1753,7 +1776,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime_V16) {
TEST_F(PolicyEngineTestV16, PlaybackOk_LicenseWithFutureStartTime) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -1764,7 +1787,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime_V16) {
.WillOnce(Return(kLicenseStartTime))
.WillOnce(Return(kPlaybackStartTime));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1789,7 +1812,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse_V16) {
TEST_F(PolicyEngineTestV16, PlaybackFailed_CanRenewFalse) {
License_Policy* policy = license_.mutable_policy();
const int64_t license_renewal_delay =
GetLicenseRenewalDelay(kPlaybackDuration);
@@ -1805,7 +1828,7 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse_V16) {
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 10))
.WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1833,7 +1856,7 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_V16) {
TEST_F(PolicyEngineTestV16, PlaybackOk_RenewSuccess) {
License_Policy* policy = license_.mutable_policy();
policy->set_can_renew(true);
int64_t license_renewal_delay = GetLicenseRenewalDelay(kPlaybackDuration);
@@ -1853,7 +1876,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_V16) {
.WillOnce(Return(kLicenseStartTime + license_renewal_delay +
kLicenseRenewalRetryInterval + 10));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1893,8 +1916,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_V16) {
}
// TODO(b/161992421): Rewrite after clarifying expected behavior
TEST_F(PolicyEngineTest,
DISABLED_PlaybackOk_RenewSuccess_WithFutureStartTime_V16) {
TEST_F(PolicyEngineTestV16,
DISABLED_PlaybackOk_RenewSuccess_WithFutureStartTime) {
License_Policy* policy = license_.mutable_policy();
policy->set_can_renew(true);
const int64_t license_renewal_delay =
@@ -1915,7 +1938,7 @@ TEST_F(PolicyEngineTest,
.WillOnce(Return(kLicenseStartTime + license_renewal_delay + 30))
.WillOnce(Return(kLicenseStartTime + license_renewal_delay + 60));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -1958,7 +1981,7 @@ TEST_F(PolicyEngineTest,
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated_V16) {
TEST_F(PolicyEngineTestV16, LicenseExpired_RenewFailedVersionNotUpdated) {
License_Policy* policy = license_.mutable_policy();
policy->set_can_renew(true);
int64_t license_renewal_delay = GetLicenseRenewalDelay(kPlaybackDuration);
@@ -1973,7 +1996,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated_V16) {
.WillOnce(Return(kLicenseStartTime + license_renewal_delay + 40))
.WillOnce(Return(kLicenseStartTime + kPlaybackDuration + 10));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2015,7 +2038,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated_V16) {
EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackSuccess_EntitlementLicense_V16) {
TEST_F(PolicyEngineTestV16, PlaybackSuccess_EntitlementLicense) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime + 1))
.WillOnce(Return(kPlaybackStartTime))
@@ -2027,7 +2050,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_EntitlementLicense_V16) {
EXPECT_CALL(mock_event_listener_,
OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(NO_ERROR))));
@@ -2049,7 +2072,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_EntitlementLicense_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseNotReceived_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseNotReceived) {
EXPECT_CALL(*mock_clock_, GetCurrentTime())
.WillOnce(Return(kLicenseStartTime));
@@ -2058,7 +2081,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseNotReceived_V16) {
EXPECT_EQ(0u, query_info.size());
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseStartTimeNotSet_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseStartTimeNotSet) {
license_.clear_license_start_time();
EXPECT_CALL(*mock_clock_, GetCurrentTime())
@@ -2071,7 +2094,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseStartTimeNotSet_V16) {
EXPECT_EQ(0u, query_info.size());
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2080,7 +2103,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_V16) {
.WillOnce(Return(kLicenseStartTime + 1))
.WillOnce(Return(kLicenseStartTime + 100));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2101,7 +2124,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2111,7 +2134,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun_V16) {
.WillOnce(Return(kLicenseStartTime + 100))
.WillOnce(Return(kLicenseStartTime + 200));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2144,7 +2167,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2156,7 +2179,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun_V16) {
.WillOnce(Return(kLicenseStartTime + 150))
.WillOnce(Return(kLicenseStartTime + 200));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2194,7 +2217,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialRentalDurationExpired_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialRentalDurationExpired) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_soft_enforce_rental_duration(false);
@@ -2221,7 +2244,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialRentalDurationExpired_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) {
LicenseIdentification* id = license_.mutable_id();
id->set_type(OFFLINE);
@@ -2237,7 +2260,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse_V16) {
.WillOnce(Return(kLicenseStartTime + 7))
.WillOnce(Return(kLicenseStartTime + 100));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2264,7 +2287,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_license_duration_seconds(kHighDuration);
@@ -2279,7 +2302,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired_V16) {
.WillOnce(Return(kLicenseStartTime + kLowDuration))
.WillOnce(Return(kLicenseStartTime + kLowDuration + 5));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2308,7 +2331,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) {
License_Policy* policy = license_.mutable_policy();
policy->set_playback_duration_seconds(kLowDuration);
policy->set_license_duration_seconds(kHighDuration);
@@ -2324,7 +2347,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired_V16) {
.WillOnce(Return(playback_start_time + 2 + kLowDuration))
.WillOnce(Return(playback_start_time + 5 + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2353,7 +2376,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired_V16) {
}
TEST_F(PolicyEngineQueryTest,
QuerySuccess_RentalDurationExpired_SoftEnforceRentalDuration_V16) {
QuerySuccess_RentalDurationExpired_SoftEnforceRentalDuration) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(kLowDuration);
policy->set_license_duration_seconds(kHighDuration);
@@ -2368,7 +2391,7 @@ TEST_F(PolicyEngineQueryTest,
.WillOnce(Return(kLicenseStartTime + 2 + kLowDuration))
.WillOnce(Return(kLicenseStartTime + 5 + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2400,7 +2423,7 @@ TEST_F(PolicyEngineQueryTest,
}
TEST_F(PolicyEngineQueryTest,
QuerySuccess_PlaybackDurationExpired_SoftEnforcePlaybackDuration_V16) {
QuerySuccess_PlaybackDurationExpired_SoftEnforcePlaybackDuration) {
License_Policy* policy = license_.mutable_policy();
policy->set_playback_duration_seconds(kLowDuration);
policy->set_license_duration_seconds(kHighDuration);
@@ -2415,7 +2438,7 @@ TEST_F(PolicyEngineQueryTest,
.WillOnce(Return(kPlaybackStartTime + 2 + kLowDuration))
.WillOnce(Return(kPlaybackStartTime + 5 + kLowDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2445,7 +2468,7 @@ TEST_F(PolicyEngineQueryTest,
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(UNLIMITED_DURATION);
policy->set_soft_enforce_rental_duration(false);
@@ -2461,7 +2484,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0_V16) {
.WillOnce(Return(kLicenseStartTime + kLowDuration))
.WillOnce(Return(kLicenseStartTime + kLowDuration + 5));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2491,7 +2514,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) {
License_Policy* policy = license_.mutable_policy();
policy->set_playback_duration_seconds(UNLIMITED_DURATION);
policy->set_license_duration_seconds(kHighDuration);
@@ -2510,7 +2533,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0_V16) {
.WillOnce(Return(kLicenseStartTime + kHighDuration + 2))
.WillOnce(Return(kLicenseStartTime + kHighDuration + 5));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2554,7 +2577,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0) {
License_Policy* policy = license_.mutable_policy();
policy->set_rental_duration_seconds(UNLIMITED_DURATION);
policy->set_playback_duration_seconds(UNLIMITED_DURATION);
@@ -2571,6 +2594,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0_V16) {
.WillOnce(Return(kLicenseStartTime + kLowDuration + 10))
.WillOnce(Return(kLicenseStartTime + kLowDuration + 10));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
policy_engine_->SetLicense(license_, false);
policy_engine_->BeginDecryption();
policy_engine_->OnTimerEvent();
@@ -2606,7 +2634,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime_V16) {
TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2619,7 +2647,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime_V16) {
.WillOnce(Return(kLicenseStartTime + 10))
.WillOnce(Return(kLicenseStartTime + 25));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2661,7 +2689,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime_V16) {
EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
}
TEST_F(PolicyEngineTest, SetLicenseForRelease_V16) {
TEST_F(PolicyEngineTestV16, SetLicenseForRelease) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2677,7 +2705,7 @@ TEST_F(PolicyEngineTest, SetLicenseForRelease_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense_V16) {
TEST_F(PolicyEngineTestV16, SetLicenseForReleaseAfterSetLicense) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2693,7 +2721,7 @@ TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense_V16) {
EXPECT_CALL(mock_event_listener_,
OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));
@@ -2712,7 +2740,7 @@ TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense_V16) {
EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
}
TEST_F(PolicyEngineTest, PlaybackOk_RestoreWithoutPlaybackTimes_V16) {
TEST_F(PolicyEngineTestV16, PlaybackOk_RestoreWithoutPlaybackTimes) {
License_Policy* policy = license_.mutable_policy();
policy->set_soft_enforce_rental_duration(false);
policy->set_soft_enforce_playback_duration(false);
@@ -2722,7 +2750,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RestoreWithoutPlaybackTimes_V16) {
.WillOnce(Return(kLicenseStartTime + 15))
.WillOnce(Return(kLicenseStartTime + 30));
EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
.WillRepeatedly(
DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
Return(CdmResponseType(GET_HDCP_CAPABILITY_FAILED))));