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

Clang Format some OEMCrypto Files

Browse Source 
Merge from Widevine repo of http://go/wvgerrit/23240

This CL runs clang format on some OEMCrypto test and mock files,
so it is easier to see what really changed in the next CL.

Change-Id: I0abf98fc8d312d5b94ad51c3ef2caae820b931de
This commit is contained in:
Fred Gylys-Colwell
2017-01-24 17:57:04 -08:00
parent 15e1f7dca2
commit a24acfa928
8 changed files with 482 additions and 664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
libwvdrmengine/oemcrypto/test/oec_session_util.cpp
View File

@@ -222,18 +222,17 @@ void Session::LoadTestKeys(const std::string& pst, bool new_mac_keys) {
&signature_[0], signature_.size(),
encrypted_license().mac_key_iv,
encrypted_license().mac_keys, num_keys_,
key_array_, pst_ptr, pst.length(),
NULL));
key_array_, pst_ptr, pst.length(), NULL));
// Update new generated keys.
memcpy(&mac_key_server_[0], license_.mac_keys, wvcdm::MAC_KEY_SIZE);
memcpy(&mac_key_client_[0], license_.mac_keys + wvcdm::MAC_KEY_SIZE,
wvcdm::MAC_KEY_SIZE);
} else {
ASSERT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(session_id(), message_ptr(), message_size_,
&signature_[0], signature_.size(), NULL, NULL,
num_keys_, key_array_, pst_ptr, pst.length(),
NULL));
ASSERT_EQ(
OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(session_id(), message_ptr(), message_size_,
&signature_[0], signature_.size(), NULL, NULL,
num_keys_, key_array_, pst_ptr, pst.length(), NULL));
}
VerifyTestKeys();
}
@@ -848,8 +847,8 @@ void Session::GenerateReport(const std::string& pst, bool expect_success,
vector<uint8_t> computed_signature(SHA_DIGEST_LENGTH);
unsigned int sig_len = SHA_DIGEST_LENGTH;
HMAC(EVP_sha1(), &mac_key_client_[0], mac_key_client_.size(),
&pst_report_buffer_[SHA_DIGEST_LENGTH],
length - SHA_DIGEST_LENGTH, &computed_signature[0], &sig_len);
&pst_report_buffer_[SHA_DIGEST_LENGTH], length - SHA_DIGEST_LENGTH,
&computed_signature[0], &sig_len);
EXPECT_EQ(0, memcmp(&computed_signature[0], pst_report().signature(),
SHA_DIGEST_LENGTH));
EXPECT_GE(kInactiveUnused, pst_report().status());

208
libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp
View File

@@ -970,12 +970,12 @@ TEST_F(OEMCryptoSessionTests, LoadKeyWithBadRange2) {
s.encrypted_license().mac_key_iv +
sizeof(s.encrypted_license().mac_key_iv));
OEMCryptoResult sts = OEMCrypto_LoadKeys(
s.session_id(), s.message_ptr(), s.message_size(), &s.signature()[0],
s.signature().size(),
&mac_key_iv[0], // bad.
s.encrypted_license().mac_keys, s.num_keys(), s.key_array(), NULL, 0,
NULL);
OEMCryptoResult sts =
OEMCrypto_LoadKeys(s.session_id(), s.message_ptr(), s.message_size(),
&s.signature()[0], s.signature().size(),
&mac_key_iv[0], // bad.
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), NULL, 0, NULL);
ASSERT_NE(OEMCrypto_SUCCESS, sts);
}
@@ -1143,6 +1143,7 @@ class SessionTestAlternateVerification : public OEMCryptoSessionTests,
OEMCryptoSessionTests::SetUp();
target_api_ = GetParam();
}
protected:
int target_api_;
};
@@ -1157,7 +1158,7 @@ TEST_P(SessionTestAlternateVerification, LoadKeys) {
if (target_api_ > 8 && target_api_ < 100) {
snprintf(buffer, 5, "kc%02d", target_api_);
}
for(int i=0; i < s.num_keys(); i++) {
for (int i = 0; i < s.num_keys(); i++) {
memcpy(s.license().keys[i].control.verification, buffer, 4);
}
ASSERT_NO_FATAL_FAILURE(s.EncryptAndSign());
@@ -1224,8 +1225,7 @@ TEST_F(OEMCryptoSessionTests, LoadKeyNoKeys) {
OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(s.session_id(), s.message_ptr(), s.message_size(),
&s.signature()[0], s.signature().size(), NULL, NULL,
kNoKeys, s.key_array(), NULL, 0,
NULL));
kNoKeys, s.key_array(), NULL, 0, NULL));
}
TEST_F(OEMCryptoSessionTests, LoadKeyNoKeyWithNonce) {
@@ -1240,8 +1240,7 @@ TEST_F(OEMCryptoSessionTests, LoadKeyNoKeyWithNonce) {
OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(s.session_id(), s.message_ptr(), s.message_size(),
&s.signature()[0], s.signature().size(), NULL, NULL,
kNoKeys, s.key_array(), NULL, 0,
NULL));
kNoKeys, s.key_array(), NULL, 0, NULL));
}
TEST_F(OEMCryptoSessionTests, QueryKeyControl) {
@@ -1305,8 +1304,7 @@ TEST_F(OEMCryptoSessionTests, CheckMinimumPatchLevel) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), NULL, 0,
NULL));
s.key_array(), NULL, 0, NULL));
if (patch_level < 0x3F) {
Session s;
ASSERT_NO_FATAL_FAILURE(s.open());
@@ -1321,8 +1319,7 @@ TEST_F(OEMCryptoSessionTests, CheckMinimumPatchLevel) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), NULL, 0,
NULL));
s.key_array(), NULL, 0, NULL));
}
if (patch_level > 0) {
Session s;
@@ -1338,8 +1335,7 @@ TEST_F(OEMCryptoSessionTests, CheckMinimumPatchLevel) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), NULL, 0,
NULL));
s.key_array(), NULL, 0, NULL));
}
}
@@ -4129,10 +4125,11 @@ TEST_F(GenericCryptoTest, KeyDurationEncrypt) {
session_.session_id(), &clear_buffer_[0], clear_buffer_.size(),
iv_, OEMCrypto_AES_CBC_128_NO_PADDING, &encrypted[0]));
ASSERT_NE(encrypted, expected_encrypted);
ASSERT_EQ(OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
ASSERT_EQ(
OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
}
TEST_F(GenericCryptoTest, KeyDurationDecrypt) {
@@ -4164,10 +4161,11 @@ TEST_F(GenericCryptoTest, KeyDurationDecrypt) {
session_.session_id(), &encrypted[0], encrypted.size(), iv_,
OEMCrypto_AES_CBC_128_NO_PADDING, &resultant[0]));
ASSERT_NE(clear_buffer_, resultant);
ASSERT_EQ(OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
ASSERT_EQ(
OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
}
TEST_F(GenericCryptoTest, KeyDurationSign) {
@@ -4201,10 +4199,11 @@ TEST_F(GenericCryptoTest, KeyDurationSign) {
clear_buffer_.size(), OEMCrypto_HMAC_SHA256,
&signature[0], &signature_length));
ASSERT_NE(expected_signature, signature);
ASSERT_EQ(OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
ASSERT_EQ(
OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
}
TEST_F(GenericCryptoTest, KeyDurationVerify) {
@@ -4233,10 +4232,11 @@ TEST_F(GenericCryptoTest, KeyDurationVerify) {
OEMCrypto_Generic_Verify(
session_.session_id(), &clear_buffer_[0], clear_buffer_.size(),
OEMCrypto_HMAC_SHA256, &signature[0], signature.size()));
ASSERT_EQ(OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
ASSERT_EQ(
OEMCrypto_ERROR_KEY_EXPIRED,
OEMCrypto_SelectKey(session_.session_id(),
session_.license().keys[key_index].key_id,
session_.license().keys[key_index].key_id_length));
}
const unsigned int kLongKeyId = 2;
@@ -4328,9 +4328,10 @@ class UsageTableTest : public GenericCryptoTest {
}
void DeactivatePST(const std::string& pst) {
ASSERT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_DeactivateUsageEntry(0,
reinterpret_cast<const uint8_t*>(pst.c_str()), pst.length()));
ASSERT_EQ(
OEMCrypto_SUCCESS,
OEMCrypto_DeactivateUsageEntry(
0, reinterpret_cast<const uint8_t*>(pst.c_str()), pst.length()));
}
void LoadOfflineLicense(Session& s, const std::string& pst) {
@@ -4344,8 +4345,7 @@ class UsageTableTest : public GenericCryptoTest {
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0,
s.pst_report().seconds_since_license_received(),
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -4407,10 +4407,8 @@ TEST_P(UsageTableTestWithMAC, OnlineLicense) {
EXPECT_EQ(kActive, s.pst_report().status());
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(s.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, s.pst_report().status());
@@ -4446,15 +4444,12 @@ TEST_P(UsageTableTestWithMAC, OnlineLicenseWithRefresh) {
EXPECT_EQ(kActive, s.pst_report().status());
// license received at LoadKeys, not at RefreshKeys.
EXPECT_NEAR(report_generated - loaded,
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
s.pst_report().seconds_since_license_received(), kTimeTolerance);
// First decrypt was just after LoadKeys.
EXPECT_NEAR(report_generated - loaded,
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
s.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
// Last decrypt just before report generated.
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
}
TEST_F(UsageTableTest, RepeatOnlineLicense) {
@@ -4482,8 +4477,7 @@ TEST_F(UsageTableTest, RepeatOnlineLicense) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), pst_ptr, pst.length(),
NULL));
s.key_array(), pst_ptr, pst.length(), NULL));
ASSERT_NO_FATAL_FAILURE(s2.close());
}
@@ -4830,12 +4824,12 @@ TEST_P(UsageTableTestWithMAC, DeleteEntryBadRange) {
TEST_P(UsageTableTestWithMAC, DeactivateBadPST) {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
std::string pst = "nonexistant pst";
OEMCryptoResult sts = OEMCrypto_DeactivateUsageEntry(0,
reinterpret_cast<const uint8_t*>(pst.c_str()), pst.length());
OEMCryptoResult sts = OEMCrypto_DeactivateUsageEntry(
0, reinterpret_cast<const uint8_t*>(pst.c_str()), pst.length());
EXPECT_EQ(OEMCrypto_ERROR_INVALID_CONTEXT, sts);
std::string null_pst = "";
sts = OEMCrypto_DeactivateUsageEntry(0,
reinterpret_cast<const uint8_t*>(null_pst.c_str()), null_pst.length());
sts = OEMCrypto_DeactivateUsageEntry(
0, reinterpret_cast<const uint8_t*>(null_pst.c_str()), null_pst.length());
EXPECT_EQ(OEMCrypto_ERROR_INVALID_CONTEXT, sts);
}
@@ -5009,17 +5003,16 @@ TEST_P(UsageTableTestWithMAC, GenericCryptoVerify) {
session_.GenerateReport(pst);
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
kTimeTolerance);
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
kTimeTolerance);
EXPECT_NEAR(0, session_.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(session_.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, session_.pst_report().status());
EXPECT_NEAR(
0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
sts = OEMCrypto_Generic_Verify(session_.session_id(), &clear_buffer_[0],
clear_buffer_.size(), OEMCrypto_HMAC_SHA256,
@@ -5057,15 +5050,12 @@ TEST_P(UsageTableTestWithMAC, OfflineLicenseRefresh) {
EXPECT_EQ(kActive, s.pst_report().status());
// license received at LoadKeys, not at RefreshKeys.
EXPECT_NEAR(report_generated - loaded,
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
s.pst_report().seconds_since_license_received(), kTimeTolerance);
// First decrypt was just after LoadKeys.
EXPECT_NEAR(report_generated - loaded,
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
s.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
// Last decrypt just before report generated.
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
}
TEST_P(UsageTableTestWithMAC, ReloadOfflineLicense) {
@@ -5082,19 +5072,15 @@ TEST_P(UsageTableTestWithMAC, ReloadOfflineLicense) {
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0,
s.pst_report().seconds_since_license_received(),
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.TestDecryptCTR());
s.GenerateReport(pst);
EXPECT_EQ(kActive, s.pst_report().status());
EXPECT_NEAR(0,
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -5113,8 +5099,7 @@ TEST_P(UsageTableTestWithMAC, ReloadOfflineLicenseWithRefresh) {
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0,
s.pst_report().seconds_since_license_received(),
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.TestDecryptCTR());
time_t decrypt_time = time(NULL);
@@ -5123,15 +5108,12 @@ TEST_P(UsageTableTestWithMAC, ReloadOfflineLicenseWithRefresh) {
EXPECT_EQ(kActive, s.pst_report().status());
// license received at first LoadKeys.
EXPECT_NEAR(report_generated - loaded,
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
s.pst_report().seconds_since_license_received(), kTimeTolerance);
// First decrypt was just after second LoadKeys.
EXPECT_NEAR(report_generated - decrypt_time,
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
s.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
EXPECT_NEAR(report_generated - decrypt_time,
s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
s.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
size_t kAllKeys = 1;
ASSERT_NO_FATAL_FAILURE(s.RefreshTestKeys(
kAllKeys, wvoec_mock::kControlNonceOrEntry, 0, OEMCrypto_SUCCESS));
@@ -5140,15 +5122,12 @@ TEST_P(UsageTableTestWithMAC, ReloadOfflineLicenseWithRefresh) {
EXPECT_EQ(kActive, s.pst_report().status());
// license received at LoadKeys, not at RefreshKeys.
EXPECT_NEAR(report_generated - loaded,
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
s.pst_report().seconds_since_license_received(), kTimeTolerance);
// First decrypt was just after LoadKeys.
EXPECT_NEAR(report_generated - decrypt_time,
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
s.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
// Last decrypt just before report generated.
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -5172,8 +5151,7 @@ TEST_P(UsageTableTestWithMAC, BadReloadOfflineLicense) {
&s2.signature()[0], s2.signature().size(),
s2.encrypted_license().mac_key_iv,
s2.encrypted_license().mac_keys, s.num_keys(),
s2.key_array(), pst_ptr, pst.length(),
NULL));
s2.key_array(), pst_ptr, pst.length(), NULL));
ASSERT_NO_FATAL_FAILURE(s2.close());
// Offline license with same mac keys should still be OK.
@@ -5199,8 +5177,7 @@ TEST_P(UsageTableTestWithMAC, OfflineBadNonce) {
s.session_id(), s.message_ptr(), s.message_size(), &s.signature()[0],
s.signature().size(), s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(), s.key_array(), pst_ptr,
pst.length(),
NULL);
pst.length(), NULL);
ASSERT_NE(OEMCrypto_SUCCESS, sts);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -5240,8 +5217,7 @@ TEST_P(UsageTableTestWithMAC, DeactivateOfflineLicense) {
s.TestDecryptCTR(false, OEMCrypto_ERROR_UNKNOWN_FAILURE));
s.GenerateReport(pst);
EXPECT_EQ(kInactiveUsed, s.pst_report().status());
EXPECT_NEAR(0,
s.pst_report().seconds_since_license_received(),
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
@@ -5256,8 +5232,7 @@ TEST_P(UsageTableTestWithMAC, DeactivateOfflineLicense) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), pst_ptr, pst.length(),
NULL));
s.key_array(), pst_ptr, pst.length(), NULL));
// But we can still generate a report.
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());
@@ -5281,8 +5256,7 @@ TEST_P(UsageTableTestWithMAC, BadRange) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), pst_ptr, pst.length(),
NULL));
s.key_array(), pst_ptr, pst.length(), NULL));
}
TEST_F(UsageTableTest, TimingTest) {
@@ -5356,30 +5330,23 @@ TEST_F(UsageTableTest, TimingTest) {
EXPECT_EQ(kInactiveUsed, s1.pst_report().status());
EXPECT_NEAR(report_generated1 - loaded1,
s1.pst_report().seconds_since_license_received(),
kTimeTolerance);
s1.pst_report().seconds_since_license_received(), kTimeTolerance);
EXPECT_NEAR(report_generated1 - first_decrypt1,
s1.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
s1.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
EXPECT_NEAR(report_generated1 - second_decrypt,
s1.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
s1.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
EXPECT_EQ(kActive, s2.pst_report().status());
EXPECT_NEAR(report_generated2 - loaded2,
s2.pst_report().seconds_since_license_received(),
kTimeTolerance);
s2.pst_report().seconds_since_license_received(), kTimeTolerance);
EXPECT_NEAR(report_generated2 - first_decrypt2,
s2.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
s2.pst_report().seconds_since_first_decrypt(), kTimeTolerance);
EXPECT_NEAR(report_generated2 - third_decrypt,
s2.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
s2.pst_report().seconds_since_last_decrypt(), kTimeTolerance);
EXPECT_EQ(kUnused, s3.pst_report().status());
EXPECT_NEAR(report_generated3 - loaded3,
s3.pst_report().seconds_since_license_received(),
kTimeTolerance);
s3.pst_report().seconds_since_license_received(), kTimeTolerance);
// We don't expect first or last decrypt for unused report.
}
@@ -5420,8 +5387,8 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(s.pst_report().seconds_since_license_received(),
kIdleInSeconds, kLicenseReceivedTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_license_received(), kIdleInSeconds,
kLicenseReceivedTimeTolerance);
cout << "Start simulated playback..." << endl;
time_t dot_time = kDotIntervalInSeconds;
@@ -5445,12 +5412,12 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
s.GenerateReport(pst);
EXPECT_NEAR(s.pst_report().seconds_since_license_received(),
playback_time + kIdleInSeconds, kLicenseReceivedTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt(),
playback_time, kUsageTableTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt(), playback_time,
kUsageTableTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_last_decrypt(), 0,
kUsageTableTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt() -
s.pst_report().seconds_since_last_decrypt(),
s.pst_report().seconds_since_last_decrypt(),
playback_time, kUsageTableTimeTolerance);
cout << "Wait another " << kIdleInSeconds
@@ -5472,8 +5439,8 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
kLicenseReceivedTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt(),
playback_time + kIdleInSeconds, kUsageTableTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_last_decrypt(),
kIdleInSeconds, kUsageTableTimeTolerance);
EXPECT_NEAR(s.pst_report().seconds_since_last_decrypt(), kIdleInSeconds,
kUsageTableTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(s.GenerateReport(pst));
@@ -5546,8 +5513,7 @@ TEST_F(UsageTableTest, PSTLargeBuffer) {
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), pst_ptr, pst.length(),
NULL));
s.key_array(), pst_ptr, pst.length(), NULL));
// But we can still generate a report.
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());