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

Fix cdm_extended_duration_test failures

Browse Source 
Remove renewal related expectations from WvCdmStreamingPstTest.

Also clean up the code in cdm_extended_duration_test.cpp.

Bug: 19534907

Merged from Widevine CDM repo:
https://widevine-internal-review.googlesource.com/#/c/13842/

Change-Id: I89f9aafd80c8867af541b29bc8a6778f53a8b7e6
This commit is contained in:
Kongqun Yang
2015-03-25 12:07:37 -07:00
parent 8ea1ab7f5e
commit ef00d84b05
1 changed files with 132 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

332
libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
View File

@@ -4,6 +4,7 @@
#include <getopt.h>
#include <sstream>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "clock.h"
@@ -30,7 +31,7 @@ const int kHttpBadRequest = 400;
const int kHttpInternalServerError = 500;
const uint32_t kMinute = 60;
const uint32_t kClockTolerance = 5;
const uint32_t kClockTolerance = 10;
const uint32_t kTwoMinutes = 120;
const uint32_t kMaxUsageTableSize = 50;
@@ -177,8 +178,17 @@ std::string kOfflineClip2PstInitData = wvcdm::a2bs_hex(
"08011a0d7769646576696e655f74657374220d6f" // pssh data
"66666c696e655f636c697032");
bool StringToInt64(const std::string& input, int64_t* output) {
std::istringstream ss(input);
return ss >> *output;
}
} // namespace
using ::testing::Contains;
using ::testing::Pair;
using ::testing::StrNe;
namespace wvcdm {
// Protobuf generated classes
using video_widevine_server::sdk::LicenseIdentification;
@@ -207,8 +217,8 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
void set_app_id(const std::string& app_id) { app_id_ = app_id; }
void set_security_level(const std::string& security_level) {
if (!security_level.compare(QUERY_VALUE_SECURITY_LEVEL_L1) ||
!security_level.compare(QUERY_VALUE_SECURITY_LEVEL_L3)) {
if (security_level == QUERY_VALUE_SECURITY_LEVEL_L1 ||
security_level == QUERY_VALUE_SECURITY_LEVEL_L3) {
security_level_ = security_level;
}
}
@@ -256,7 +266,7 @@ class WvCdmExtendedDurationTest : public testing::Test {
void GetOfflineConfiguration(std::string* key_id, std::string* client_auth) {
ConfigTestEnv config(g_license_server_id, false);
if (g_key_id.compare(a2bs_hex(g_config->key_id())) == 0)
key_id->assign(wvcdm::a2bs_hex(config.key_id()));
key_id->assign(a2bs_hex(config.key_id()));
else
key_id->assign(g_key_id);
@@ -268,13 +278,13 @@ class WvCdmExtendedDurationTest : public testing::Test {
void GenerateKeyRequest(const std::string& init_data,
CdmLicenseType license_type) {
wvcdm::CdmAppParameterMap app_parameters;
CdmAppParameterMap app_parameters;
std::string server_url;
CdmKeyRequestType key_request_type;
EXPECT_EQ(wvcdm::KEY_MESSAGE, decryptor_.GenerateKeyRequest(
session_id_, key_set_id_, "video/mp4",
init_data, license_type, app_parameters,
NULL, &key_msg_, &key_request_type, &server_url));
EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
session_id_, key_set_id_, "video/mp4", init_data,
license_type, app_parameters, NULL, &key_msg_,
&key_request_type, &server_url));
EXPECT_EQ(kKeyRequestTypeInitial, key_request_type);
EXPECT_EQ(0u, server_url.size());
}
@@ -284,13 +294,12 @@ class WvCdmExtendedDurationTest : public testing::Test {
// TODO application makes a license request, CDM will renew the license
// when appropriate.
std::string init_data;
wvcdm::CdmAppParameterMap app_parameters;
CdmAppParameterMap app_parameters;
CdmKeyRequestType key_request_type;
EXPECT_EQ(
wvcdm::KEY_MESSAGE,
decryptor_.GenerateKeyRequest(
session_id_, key_set_id_, "video/mp4", init_data, license_type,
app_parameters, NULL, &key_msg_, &key_request_type, server_url));
EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
session_id_, key_set_id_, "video/mp4", init_data,
license_type, app_parameters, NULL, &key_msg_,
&key_request_type, server_url));
EXPECT_EQ(kKeyRequestTypeRenewal, key_request_type);
// TODO(edwinwong, rfrias): Add tests cases for when license server url
// is empty on renewal. Need appropriate key id at the server.
@@ -300,14 +309,13 @@ class WvCdmExtendedDurationTest : public testing::Test {
void GenerateKeyRelease(CdmKeySetId key_set_id) {
CdmSessionId session_id;
CdmInitData init_data;
wvcdm::CdmAppParameterMap app_parameters;
CdmAppParameterMap app_parameters;
std::string server_url;
CdmKeyRequestType key_request_type;
EXPECT_EQ(wvcdm::KEY_MESSAGE,
decryptor_.GenerateKeyRequest(session_id, key_set_id, "video/mp4",
init_data, kLicenseTypeRelease,
app_parameters, NULL, &key_msg_,
&key_request_type, &server_url));
EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
session_id, key_set_id, "video/mp4", init_data,
kLicenseTypeRelease, app_parameters, NULL,
&key_msg_, &key_request_type, &server_url));
EXPECT_EQ(kKeyRequestTypeRelease, key_request_type);
}
@@ -398,11 +406,9 @@ class WvCdmExtendedDurationTest : public testing::Test {
if (is_renewal) {
// TODO application makes a license request, CDM will renew the license
// when appropriate
EXPECT_EQ(decryptor_.AddKey(session_id_, resp, &key_set_id_),
wvcdm::KEY_ADDED);
EXPECT_EQ(KEY_ADDED, decryptor_.AddKey(session_id_, resp, &key_set_id_));
} else {
EXPECT_EQ(decryptor_.AddKey(session_id_, resp, &key_set_id_),
wvcdm::KEY_ADDED);
EXPECT_EQ(KEY_ADDED, decryptor_.AddKey(session_id_, resp, &key_set_id_));
}
}
@@ -431,15 +437,15 @@ class WvCdmExtendedDurationTest : public testing::Test {
status = decryptor_.GetProvisioningRequest(
cert_type, cert_authority, &key_msg_, &provisioning_server_url);
EXPECT_EQ(wvcdm::NO_ERROR, status);
EXPECT_EQ(NO_ERROR, status);
if (NO_ERROR != status) return;
EXPECT_EQ(provisioning_server_url, g_config->provisioning_server_url());
std::string response =
GetCertRequestResponse(g_config->provisioning_server_url());
EXPECT_NE(0, static_cast<int>(response.size()));
EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(
response, &cert, &wrapped_key));
EXPECT_EQ(NO_ERROR, decryptor_.HandleProvisioningResponse(response, &cert,
&wrapped_key));
EXPECT_EQ(0, static_cast<int>(cert.size()));
EXPECT_EQ(0, static_cast<int>(wrapped_key.size()));
decryptor_.CloseSession(session_id_);
@@ -487,29 +493,21 @@ class WvCdmExtendedDurationTest : public testing::Test {
EXPECT_FALSE(content_id.has_webm_id());
EXPECT_TRUE(content_id.has_license());
const ::video_widevine_server::sdk::
LicenseRequest_ContentIdentification_ExistingLicense& existing_license =
content_id.license();
const LicenseRequest_ContentIdentification::ExistingLicense&
existing_license = content_id.license();
const LicenseIdentification& id = existing_license.license_id();
EXPECT_TRUE(std::equal(id.request_id().begin(), id.request_id().end(),
license_id_.request_id().begin()));
EXPECT_TRUE(std::equal(id.session_id().begin(), id.session_id().end(),
license_id_.session_id().begin()));
EXPECT_TRUE(std::equal(id.purchase_id().begin(), id.purchase_id().end(),
license_id_.purchase_id().begin()));
EXPECT_EQ(license_id_.request_id(), id.request_id());
EXPECT_EQ(license_id_.session_id(), id.session_id());
EXPECT_EQ(license_id_.purchase_id(), id.purchase_id());
EXPECT_EQ(license_id_.type(), id.type());
EXPECT_EQ(license_id_.version(), id.version());
EXPECT_EQ(has_provider_session_token, !id.provider_session_token().empty());
EXPECT_LT(expected_seconds_since_started - kClockTolerance,
existing_license.seconds_since_started());
EXPECT_LT(existing_license.seconds_since_started(),
expected_seconds_since_started + kClockTolerance);
EXPECT_LT(expected_seconds_since_last_played - kClockTolerance,
existing_license.seconds_since_last_played());
EXPECT_LT(existing_license.seconds_since_last_played(),
expected_seconds_since_last_played + kClockTolerance);
EXPECT_NEAR(existing_license.seconds_since_started(),
expected_seconds_since_started, kClockTolerance);
EXPECT_NEAR(existing_license.seconds_since_last_played(),
expected_seconds_since_last_played, kClockTolerance);
EXPECT_TRUE(existing_license.session_usage_table_entry().empty());
EXPECT_EQ(::video_widevine_server::sdk::LicenseRequest_RequestType_RENEWAL,
@@ -542,29 +540,21 @@ class WvCdmExtendedDurationTest : public testing::Test {
EXPECT_FALSE(content_id.has_webm_id());
EXPECT_TRUE(content_id.has_license());
const ::video_widevine_server::sdk::
LicenseRequest_ContentIdentification_ExistingLicense& existing_license =
content_id.license();
const LicenseRequest_ContentIdentification::ExistingLicense&
existing_license = content_id.license();
const LicenseIdentification& id = existing_license.license_id();
EXPECT_TRUE(std::equal(id.request_id().begin(), id.request_id().end(),
license_id_.request_id().begin()));
EXPECT_TRUE(std::equal(id.session_id().begin(), id.session_id().end(),
license_id_.session_id().begin()));
EXPECT_TRUE(std::equal(id.purchase_id().begin(), id.purchase_id().end(),
license_id_.purchase_id().begin()));
EXPECT_EQ(license_id_.request_id(), id.request_id());
EXPECT_EQ(license_id_.session_id(), id.session_id());
EXPECT_EQ(license_id_.purchase_id(), id.purchase_id());
EXPECT_EQ(license_id_.type(), id.type());
EXPECT_EQ(license_id_.version(), id.version());
EXPECT_TRUE(!id.provider_session_token().empty());
EXPECT_LT(expected_seconds_since_first_playback - kClockTolerance,
existing_license.seconds_since_started());
EXPECT_LT(existing_license.seconds_since_started(),
expected_seconds_since_first_playback + kClockTolerance);
EXPECT_LT(expected_seconds_since_last_playback - kClockTolerance,
existing_license.seconds_since_last_played());
EXPECT_LT(existing_license.seconds_since_last_played(),
expected_seconds_since_last_playback + kClockTolerance);
EXPECT_NEAR(existing_license.seconds_since_started(),
expected_seconds_since_first_playback, kClockTolerance);
EXPECT_NEAR(existing_license.seconds_since_last_played(),
expected_seconds_since_last_playback, kClockTolerance);
EXPECT_TRUE(!existing_license.session_usage_table_entry().empty());
// Verify usage report
@@ -593,18 +583,13 @@ class WvCdmExtendedDurationTest : public testing::Test {
seconds_since_first_decrypt = 0;
seconds_since_last_decrypt = 0;
}
EXPECT_LT(expected_seconds_since_license_received - kClockTolerance,
seconds_since_license_received);
EXPECT_LT(seconds_since_license_received,
expected_seconds_since_license_received + kClockTolerance);
EXPECT_LT(expected_seconds_since_first_playback - kClockTolerance,
seconds_since_first_decrypt);
EXPECT_LT(seconds_since_first_decrypt,
expected_seconds_since_first_playback + kClockTolerance);
EXPECT_LT(expected_seconds_since_last_playback - kClockTolerance,
seconds_since_last_decrypt);
EXPECT_LT(seconds_since_last_decrypt,
expected_seconds_since_last_playback + kClockTolerance);
EXPECT_NEAR(seconds_since_license_received,
expected_seconds_since_license_received, kClockTolerance);
EXPECT_NEAR(seconds_since_first_decrypt,
expected_seconds_since_first_playback, kClockTolerance);
EXPECT_NEAR(seconds_since_last_decrypt,
expected_seconds_since_last_playback, kClockTolerance);
EXPECT_EQ(::video_widevine_server::sdk::LicenseRequest_RequestType_RELEASE,
license_renewal.type());
@@ -614,70 +599,52 @@ class WvCdmExtendedDurationTest : public testing::Test {
EXPECT_TRUE(license_renewal.has_key_control_nonce());
}
void QueryKeyStatus(bool streaming, int64_t* license_duration_remaining,
void QueryKeyStatus(bool streaming, bool expect_renewal,
int64_t* license_duration_remaining,
int64_t* playback_duration_remaining) {
CdmQueryMap query_info;
CdmQueryMap::iterator itr;
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.QueryKeyStatus(session_id_, &query_info));
EXPECT_EQ(NO_ERROR, decryptor_.QueryKeyStatus(session_id_, &query_info));
itr = query_info.find(wvcdm::QUERY_KEY_LICENSE_TYPE);
ASSERT_TRUE(itr != query_info.end());
if (streaming) {
EXPECT_EQ(wvcdm::QUERY_VALUE_STREAMING, itr->second);
} else {
EXPECT_EQ(wvcdm::QUERY_VALUE_OFFLINE, itr->second);
EXPECT_THAT(query_info, Contains(Pair(QUERY_KEY_LICENSE_TYPE,
streaming ? QUERY_VALUE_STREAMING
: QUERY_VALUE_OFFLINE)));
EXPECT_THAT(query_info,
Contains(Pair(QUERY_KEY_PLAY_ALLOWED, QUERY_VALUE_TRUE)));
EXPECT_THAT(query_info, Contains(Pair(QUERY_KEY_PERSIST_ALLOWED,
streaming ? QUERY_VALUE_FALSE
: QUERY_VALUE_TRUE)));
if (expect_renewal) {
EXPECT_THAT(query_info,
Contains(Pair(QUERY_KEY_RENEW_ALLOWED, QUERY_VALUE_TRUE)));
EXPECT_THAT(query_info,
Contains(Pair(QUERY_KEY_RENEWAL_SERVER_URL, StrNe(""))));
}
itr = query_info.find(wvcdm::QUERY_KEY_PLAY_ALLOWED);
ASSERT_TRUE(itr != query_info.end());
EXPECT_EQ(wvcdm::QUERY_VALUE_TRUE, itr->second);
itr = query_info.find(wvcdm::QUERY_KEY_PERSIST_ALLOWED);
ASSERT_TRUE(itr != query_info.end());
if (streaming) {
EXPECT_EQ(wvcdm::QUERY_VALUE_FALSE, itr->second);
} else {
EXPECT_EQ(wvcdm::QUERY_VALUE_TRUE, itr->second);
}
itr = query_info.find(wvcdm::QUERY_KEY_RENEW_ALLOWED);
ASSERT_TRUE(itr != query_info.end());
EXPECT_EQ(wvcdm::QUERY_VALUE_TRUE, itr->second);
std::istringstream ss;
itr = query_info.find(wvcdm::QUERY_KEY_LICENSE_DURATION_REMAINING);
ASSERT_TRUE(itr != query_info.end());
ss.str(itr->second);
ASSERT_TRUE(ss >> *license_duration_remaining);
EXPECT_LT(0, *license_duration_remaining);
itr = query_info.find(wvcdm::QUERY_KEY_PLAYBACK_DURATION_REMAINING);
ASSERT_TRUE(itr != query_info.end());
ss.clear();
ss.str(itr->second);
ASSERT_TRUE(ss >> *playback_duration_remaining);
EXPECT_LT(0, *playback_duration_remaining);
itr = query_info.find(wvcdm::QUERY_KEY_RENEWAL_SERVER_URL);
ASSERT_TRUE(itr != query_info.end());
EXPECT_LT(0u, itr->second.size());
std::string key = QUERY_KEY_LICENSE_DURATION_REMAINING;
ASSERT_THAT(query_info, Contains(Pair(key,StrNe(""))));
EXPECT_TRUE(StringToInt64(query_info[key], license_duration_remaining));
key = QUERY_KEY_PLAYBACK_DURATION_REMAINING;
ASSERT_THAT(query_info, Contains(Pair(key,StrNe(""))));
EXPECT_TRUE(StringToInt64(query_info[key], playback_duration_remaining));
}
std::string GetSecurityLevel(TestWvCdmClientPropertySet* property_set) {
decryptor_.OpenSession(g_key_system, property_set, NULL, &session_id_);
CdmQueryMap query_info;
EXPECT_EQ(wvcdm::NO_ERROR,
EXPECT_EQ(NO_ERROR,
decryptor_.QuerySessionStatus(session_id_, &query_info));
CdmQueryMap::iterator itr =
query_info.find(wvcdm::QUERY_KEY_SECURITY_LEVEL);
CdmQueryMap::iterator itr = query_info.find(QUERY_KEY_SECURITY_LEVEL);
EXPECT_TRUE(itr != query_info.end());
decryptor_.CloseSession(session_id_);
return itr->second;
}
CdmSecurityLevel GetDefaultSecurityLevel() {
std::string level = GetSecurityLevel(NULL).c_str();
std::string level = GetSecurityLevel(NULL);
CdmSecurityLevel security_level = kSecurityLevelUninitialized;
if (level.compare(wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1) == 0) {
if (level == QUERY_VALUE_SECURITY_LEVEL_L1) {
security_level = kSecurityLevelL1;
} else if (level.compare(wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3) == 0) {
} else if (level == QUERY_VALUE_SECURITY_LEVEL_L3) {
security_level = kSecurityLevelL3;
} else {
EXPECT_TRUE(false);
@@ -685,7 +652,7 @@ class WvCdmExtendedDurationTest : public testing::Test {
return security_level;
}
wvcdm::WvContentDecryptionModule decryptor_;
WvContentDecryptionModule decryptor_;
CdmKeyMessage key_msg_;
CdmKeyResponse key_response_;
CdmSessionId session_id_;
@@ -728,8 +695,8 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) {
EXPECT_FALSE(client_id.has_provider_client_token());
EXPECT_FALSE(client_id.has_license_counter());
const ::video_widevine_server::sdk::ClientIdentification_ClientCapabilities&
client_capabilities = client_id.client_capabilities();
const ClientIdentification::ClientCapabilities& client_capabilities =
client_id.client_capabilities();
EXPECT_FALSE(client_capabilities.has_client_token());
EXPECT_TRUE(client_capabilities.has_session_token());
EXPECT_FALSE(client_capabilities.video_resolution_constraints());
@@ -743,8 +710,8 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) {
EXPECT_FALSE(content_id.has_webm_id());
EXPECT_FALSE(content_id.has_license());
const ::video_widevine_server::sdk::LicenseRequest_ContentIdentification_CENC&
cenc_id = content_id.cenc_id();
const LicenseRequest_ContentIdentification::CENC& cenc_id =
content_id.cenc_id();
EXPECT_TRUE(std::equal(cenc_id.pssh(0).begin(), cenc_id.pssh(0).end(),
g_key_id.begin() + 32));
EXPECT_EQ(video_widevine_server::sdk::STREAMING, cenc_id.license_type());
@@ -811,17 +778,13 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRenewalTest) {
EXPECT_FALSE(content_id.has_webm_id());
EXPECT_TRUE(content_id.has_license());
const ::video_widevine_server::sdk::
LicenseRequest_ContentIdentification_ExistingLicense& existing_license =
content_id.license();
const LicenseRequest_ContentIdentification::ExistingLicense&
existing_license = content_id.license();
const LicenseIdentification& id = existing_license.license_id();
EXPECT_TRUE(std::equal(id.request_id().begin(), id.request_id().end(),
license_id.request_id().begin()));
EXPECT_TRUE(std::equal(id.session_id().begin(), id.session_id().end(),
license_id.session_id().begin()));
EXPECT_TRUE(std::equal(id.purchase_id().begin(), id.purchase_id().end(),
license_id.purchase_id().begin()));
EXPECT_EQ(license_id.request_id(), id.request_id());
EXPECT_EQ(license_id.session_id(), id.session_id());
EXPECT_EQ(license_id.purchase_id(), id.purchase_id());
EXPECT_EQ(license_id.type(), id.type());
EXPECT_EQ(license_id.version(), id.version());
EXPECT_TRUE(id.provider_session_token().empty());
@@ -903,7 +866,7 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
int64_t initial_license_duration_remaining = 0;
int64_t initial_playback_duration_remaining = 0;
QueryKeyStatus(true, &initial_license_duration_remaining,
QueryKeyStatus(true, true, &initial_license_duration_remaining,
&initial_playback_duration_remaining);
sleep(kMinute);
@@ -927,9 +890,7 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
decryption_parameters));
EXPECT_TRUE(std::equal((data + i)->decrypt_data.begin(),
(data + i)->decrypt_data.end(),
decrypt_buffer.begin()));
EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
}
sleep(kMinute);
@@ -950,16 +911,13 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
// Query and validate usage information
int64_t license_duration_remaining = 0;
int64_t playback_duration_remaining = 0;
QueryKeyStatus(true, &license_duration_remaining,
QueryKeyStatus(true, true, &license_duration_remaining,
&playback_duration_remaining);
int64_t delta =
initial_license_duration_remaining - license_duration_remaining;
EXPECT_LT(expected_seconds_since_license_received - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_license_received + kClockTolerance);
delta = initial_playback_duration_remaining - playback_duration_remaining;
EXPECT_LT(expected_seconds_since_initial_playback - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_initial_playback + kClockTolerance);
EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
expected_seconds_since_license_received, kClockTolerance);
EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
expected_seconds_since_initial_playback, kClockTolerance);
decryptor_.CloseSession(session_id_);
}
@@ -982,7 +940,7 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
int64_t initial_license_duration_remaining = 0;
int64_t initial_playback_duration_remaining = 0;
QueryKeyStatus(true, &initial_license_duration_remaining,
QueryKeyStatus(true, false, &initial_license_duration_remaining,
&initial_playback_duration_remaining);
sleep(kMinute);
@@ -1006,9 +964,7 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
decryption_parameters));
EXPECT_TRUE(std::equal((data + i)->decrypt_data.begin(),
(data + i)->decrypt_data.end(),
decrypt_buffer.begin()));
EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
}
sleep(kMinute);
@@ -1017,28 +973,16 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
expected_seconds_since_last_playback = kMinute;
}
// Create renewal request and validate
std::string license_server;
GenerateRenewalRequest(kLicenseTypeStreaming, &license_server);
EXPECT_TRUE(!license_server.empty());
EXPECT_TRUE(!key_msg_.empty());
ValidateRenewalRequest(expected_seconds_since_initial_playback,
expected_seconds_since_last_playback, true);
// Query and validate usage information
int64_t license_duration_remaining = 0;
int64_t playback_duration_remaining = 0;
QueryKeyStatus(true, &license_duration_remaining,
QueryKeyStatus(true, false, &license_duration_remaining,
&playback_duration_remaining);
int64_t delta =
initial_license_duration_remaining - license_duration_remaining;
EXPECT_LT(expected_seconds_since_license_received - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_license_received + kClockTolerance);
delta = initial_playback_duration_remaining - playback_duration_remaining;
EXPECT_LT(expected_seconds_since_initial_playback - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_initial_playback + kClockTolerance);
EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
expected_seconds_since_license_received, kClockTolerance);
EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
expected_seconds_since_initial_playback, kClockTolerance);
decryptor_.CloseSession(session_id_);
}
@@ -1061,7 +1005,7 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
int64_t initial_license_duration_remaining = 0;
int64_t initial_playback_duration_remaining = 0;
QueryKeyStatus(true, &initial_license_duration_remaining,
QueryKeyStatus(true, false, &initial_license_duration_remaining,
&initial_playback_duration_remaining);
sleep(kMinute);
@@ -1085,9 +1029,7 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
decryption_parameters));
EXPECT_TRUE(std::equal((data + i)->decrypt_data.begin(),
(data + i)->decrypt_data.end(),
decrypt_buffer.begin()));
EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
}
sleep(kMinute);
@@ -1099,16 +1041,13 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
// Query and validate usage information
int64_t license_duration_remaining = 0;
int64_t playback_duration_remaining = 0;
QueryKeyStatus(true, &license_duration_remaining,
QueryKeyStatus(true, false, &license_duration_remaining,
&playback_duration_remaining);
int64_t delta =
initial_license_duration_remaining - license_duration_remaining;
EXPECT_LT(expected_seconds_since_license_received - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_license_received + kClockTolerance);
delta = initial_playback_duration_remaining - playback_duration_remaining;
EXPECT_LT(expected_seconds_since_initial_playback - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_initial_playback + kClockTolerance);
EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
expected_seconds_since_license_received, kClockTolerance);
EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
expected_seconds_since_initial_playback, kClockTolerance);
decryptor_.CloseSession(session_id_);
@@ -1165,7 +1104,7 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
int64_t initial_license_duration_remaining = 0;
int64_t initial_playback_duration_remaining = 0;
QueryKeyStatus(false, &initial_license_duration_remaining,
QueryKeyStatus(false, true, &initial_license_duration_remaining,
&initial_playback_duration_remaining);
decryptor_.CloseSession(session_id_);
@@ -1178,21 +1117,19 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
for (size_t i = 0; i < GetParam(); ++i) {
session_id_.clear();
decryptor_.OpenSession(g_key_system, NULL, NULL, &session_id_);
EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
// Query and validate usage information
int64_t license_duration_remaining = 0;
int64_t playback_duration_remaining = 0;
QueryKeyStatus(false, &license_duration_remaining,
QueryKeyStatus(false, true, &license_duration_remaining,
&playback_duration_remaining);
int64_t delta =
initial_license_duration_remaining - license_duration_remaining;
EXPECT_LT(expected_seconds_since_license_received - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_license_received + kClockTolerance);
delta = initial_playback_duration_remaining - playback_duration_remaining;
EXPECT_LT(expected_seconds_since_initial_playback - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_initial_playback + kClockTolerance);
EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
expected_seconds_since_license_received, kClockTolerance);
EXPECT_NEAR(
initial_playback_duration_remaining - playback_duration_remaining,
expected_seconds_since_initial_playback, kClockTolerance);
// Decrypt data
SubSampleInfo* data = &kEncryptedOfflineClip2SubSample;
@@ -1209,9 +1146,7 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
decryption_parameters));
EXPECT_TRUE(std::equal((data + i)->decrypt_data.begin(),
(data + i)->decrypt_data.end(),
decrypt_buffer.begin()));
EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
}
sleep(10);
@@ -1225,21 +1160,18 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
session_id_.clear();
decryptor_.OpenSession(g_key_system, NULL, NULL, &session_id_);
EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
// Query and validate usage information
int64_t license_duration_remaining = 0;
int64_t playback_duration_remaining = 0;
QueryKeyStatus(false, &license_duration_remaining,
QueryKeyStatus(false, true, &license_duration_remaining,
&playback_duration_remaining);
int64_t delta =
initial_license_duration_remaining - license_duration_remaining;
EXPECT_LT(expected_seconds_since_license_received - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_license_received + kClockTolerance);
delta = initial_playback_duration_remaining - playback_duration_remaining;
EXPECT_LT(expected_seconds_since_initial_playback - kClockTolerance, delta);
EXPECT_LT(delta, expected_seconds_since_initial_playback + kClockTolerance);
EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
expected_seconds_since_license_received, kClockTolerance);
EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
expected_seconds_since_initial_playback, kClockTolerance);
decryptor_.CloseSession(session_id_);