From ef00d84b05640f9e7858ea674dfd7086399f5822 Mon Sep 17 00:00:00 2001 From: Kongqun Yang Date: Wed, 25 Mar 2015 12:07:37 -0700 Subject: [PATCH] Fix cdm_extended_duration_test failures 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 --- .../cdm/test/cdm_extended_duration_test.cpp | 332 +++++++----------- 1 file changed, 132 insertions(+), 200 deletions(-) diff --git a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp index 9a00b325..ff5166f9 100644 --- a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp +++ b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp @@ -4,6 +4,7 @@ #include #include +#include #include #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(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(cert.size())); EXPECT_EQ(0, static_cast(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_);