widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
47fc031576ffd1211fa893caaba42394e0714ff2
android/libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp
Alex Dale 47fc031576 Include DRM key type to SessionMetrics. 
[ Merge of http://go/wvgerrit/111903 ]

CDM metrics has been updated to include the DRM key type.  The CDM
session records the key type when the wrapped DRM key is successfully
loaded into an OEMCrypto session.

Now that the API refers to a general DRM key rather than an RSA key,
the timer metric for loading the DRM key has been renamed on the client
to reflect this.

Test: Metric unit tests
Bug: 140813486
Change-Id: I9069f13ac7c979cc8556e08591e1cf8f623d0a84
2021-02-16 10:30:30 -08:00

541 lines
25 KiB
C++
Raw Blame History

// Copyright 2017 Google Inc. All Rights Reserved.
//
// Unit tests for the metrics collections,
// EngineMetrics, SessionMetrics and CryptoMetrics.
#include "metrics_collections.h"
#include <sstream>
#include "device_files.h"
#include "gmock/gmock.h"
#include "google/protobuf/text_format.h"
#include "gtest/gtest.h"
#include "log.h"
#include "string_conversions.h"
#include "wv_cdm_types.h"
#include "wv_metrics.pb.h"
using drm_metrics::WvCdmMetrics;
namespace {
const char kSessionId1[] = "session_id_1";
const char kSessionId2[] = "session_id_2";
} // anonymous namespace
namespace wvcdm {
namespace metrics {
// TODO(blueeyes): Improve this implementation by supporting full message
// API In CDM. That allows us to use MessageDifferencer.
class EngineMetricsTest : public ::testing::Test {
};
TEST_F(EngineMetricsTest, AllEngineMetrics) {
EngineMetrics engine_metrics;
// Set some values in all of the engine metrics.
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED,
kLicenseTypeRelease);
engine_metrics.cdm_engine_close_session_.Increment(NO_ERROR);
engine_metrics.cdm_engine_decrypt_.Record(1.0, NO_ERROR,
metrics::Pow2Bucket(8));
engine_metrics.cdm_engine_find_session_for_key_.Increment(false);
engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR,
kLicenseTypeRelease);
engine_metrics.cdm_engine_get_provisioning_request_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR,
UNKNOWN_ERROR);
engine_metrics.cdm_engine_handle_provisioning_response_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_open_key_set_session_.Increment(NO_ERROR);
engine_metrics.cdm_engine_open_session_.Increment(NO_ERROR);
engine_metrics.cdm_engine_query_key_status_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_release_all_usage_info_.Increment(NO_ERROR);
engine_metrics.cdm_engine_release_usage_info_.Increment(NO_ERROR);
engine_metrics.cdm_engine_remove_keys_.Increment(NO_ERROR);
engine_metrics.cdm_engine_restore_key_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_unprovision_.Increment(NO_ERROR, kSecurityLevelL1);
engine_metrics.SetAppPackageName("test package name");
engine_metrics.cdm_engine_cdm_version_.Record("test cdm version");
engine_metrics.cdm_engine_creation_time_millis_.Record(100);
engine_metrics.cdm_engine_get_secure_stop_ids_.Increment(UNKNOWN_ERROR);
engine_metrics.cdm_engine_remove_all_usage_info_.Increment(UNKNOWN_ERROR);
engine_metrics.cdm_engine_remove_usage_info_.Increment(UNKNOWN_ERROR);
// Also set and serialize the oemcrypto dynamic adapter metrics.
OemCryptoDynamicAdapterMetrics adapter_metrics;
adapter_metrics.SetInitializationMode(OEMCrypto_INITIALIZED_FORCING_L3);
adapter_metrics.SetL1ApiVersion(2);
adapter_metrics.SetL1MinApiVersion(1);
WvCdmMetrics actual;
engine_metrics.Serialize(&actual);
adapter_metrics.Serialize(actual.mutable_engine_metrics());
EXPECT_EQ(0, actual.session_metrics_size());
ASSERT_TRUE(actual.has_engine_metrics());
EXPECT_GT(actual.engine_metrics().cdm_engine_add_key_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_decrypt_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_find_session_for_key_size(), 0);
EXPECT_GT(
actual.engine_metrics()
.cdm_engine_generate_key_request_time_us_size(), 0);
EXPECT_GT(
actual.engine_metrics()
.cdm_engine_get_provisioning_request_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_get_usage_info_time_us_size(),
0);
EXPECT_GT(
actual.engine_metrics()
.cdm_engine_handle_provisioning_response_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_open_key_set_session_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_open_session_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_query_key_status_time_us_size(),
0);
EXPECT_GT(actual.engine_metrics().cdm_engine_release_all_usage_info_size(),
0);
EXPECT_GT(actual.engine_metrics().cdm_engine_release_usage_info_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_remove_keys_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_restore_key_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_unprovision_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_get_secure_stop_ids_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_remove_all_usage_info_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_remove_usage_info_size(), 0);
EXPECT_EQ("test package name",
actual.engine_metrics().app_package_name().string_value());
EXPECT_EQ("test cdm version",
actual.engine_metrics().cdm_engine_cdm_version().string_value());
EXPECT_EQ(100,
actual.engine_metrics()
.cdm_engine_creation_time_millis().int_value());
}
TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
EngineMetrics engine_metrics;
// Set some values in some of the engine metrics and some crypto metrics.
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED,
kLicenseTypeRelease);
engine_metrics.cdm_engine_close_session_.Increment(UNKNOWN_ERROR);
CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics();
crypto_metrics->crypto_session_get_device_unique_id_.Increment(NO_ERROR);
crypto_metrics->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(0, actual_metrics.session_metrics_size());
// Spot check some metrics.
ASSERT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
EXPECT_EQ(2, actual_metrics.engine_metrics()
.cdm_engine_add_key_time_us(0)
.attributes().error_code());
ASSERT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_close_session_size());
EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics()
.cdm_engine_close_session(0)
.attributes().error_code());
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_get_device_unique_id_size());
EXPECT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_get_device_unique_id(0)
.count());
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_get_device_unique_id(0)
.attributes().error_code());
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_generic_decrypt_time_us_size());
EXPECT_EQ(2.0, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_generic_decrypt_time_us(0)
.mean());
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics()
.crypto_session_generic_decrypt_time_us(0)
.attributes().error_code());
}
TEST_F(EngineMetricsTest, EmptyEngineMetrics) {
EngineMetrics engine_metrics;
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
// Empty engine metics will still produce an engine metrics record.
EXPECT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(0, actual_metrics.session_metrics_size());
}
TEST_F(EngineMetricsTest, EngineMetricsWithSessions) {
EngineMetrics engine_metrics;
// Set a values in an engine metric and in a crypto metric.
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED,
kLicenseTypeRelease);
engine_metrics.GetCryptoMetrics()
->crypto_session_load_certificate_private_key_.Record(2.0, NO_ERROR);
// Create two sessions and record some metrics.
std::shared_ptr<SessionMetrics> session_metrics_1 =
engine_metrics.AddSession();
session_metrics_1->SetSessionId(kSessionId1);
std::shared_ptr<SessionMetrics> session_metrics_2 =
engine_metrics.AddSession();
session_metrics_2->SetSessionId(kSessionId2);
// Record a CryptoMetrics metric in the session.
session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
// Spot check some metrics.
ASSERT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
EXPECT_EQ(2, actual_metrics.session_metrics_size());
EXPECT_EQ(kSessionId1,
actual_metrics.session_metrics(0).session_id().string_value());
EXPECT_EQ(kSessionId2,
actual_metrics.session_metrics(1).session_id().string_value());
EXPECT_EQ(1, actual_metrics.session_metrics(1).crypto_metrics()
.crypto_session_generic_decrypt_time_us_size());
}
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessions) {
EngineMetrics engine_metrics;
// Create one more session than the max allowed closed sessions.
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
session_metrics.push_back(engine_metrics.AddSession());
session_metrics.back()->SetSessionId(std::to_string(i));
}
// Mark sessions as completed.
for (auto it = session_metrics.begin(); it != session_metrics.end(); it++) {
(*it)->SetCompleted();
}
engine_metrics.ConsolidateSessions();
// Consolidate the metrics now. These should now be consolidated down to
// kMaxCompletedSessions.
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_EQ(kMaxCompletedSessions, actual_metrics.session_metrics_size());
}
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoClosedSessions) {
EngineMetrics engine_metrics;
// Create one more session than the max allowed closed sessions.
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
session_metrics.push_back(engine_metrics.AddSession());
session_metrics.back()->SetSessionId(std::to_string(i));
}
// Consolidate sessions will do nothing since no sessions are closed.
engine_metrics.ConsolidateSessions();
// Serializing now will include all sessions since none are closed.
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_EQ(kMaxCompletedSessions + 1, actual_metrics.session_metrics_size());
}
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoSessions) {
EngineMetrics engine_metrics;
// Consolidate sessions will do nothing since there are no sessions
engine_metrics.ConsolidateSessions();
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
ASSERT_EQ(0, actual_metrics.session_metrics_size());
}
class SessionMetricsTest : public ::testing::Test {
};
TEST_F(SessionMetricsTest, AllSessionMetrics) {
SessionMetrics session_metrics;
session_metrics.SetSessionId(kSessionId1);
session_metrics.cdm_session_life_span_.Record(1.0);
session_metrics.cdm_session_renew_key_.Record(1.0, NO_ERROR);
session_metrics.cdm_session_restore_offline_session_.Increment(
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
session_metrics.cdm_session_restore_usage_session_.Increment(
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
session_metrics.cdm_session_license_request_latency_ms_.Record(
2.0, kKeyRequestTypeInitial);
session_metrics.oemcrypto_build_info_.Record("test build info");
session_metrics.license_sdk_version_.Record("test license sdk version");
session_metrics.license_service_version_.Record("test license service version");
session_metrics.drm_certificate_key_type_.Record(1);
// Record a CryptoMetrics metric in the session.
session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics::SessionMetrics actual;
session_metrics.Serialize(&actual);
EXPECT_STREQ(kSessionId1, actual.session_id().string_value().c_str());
EXPECT_EQ(1.0, actual.cdm_session_life_span_ms().double_value());
EXPECT_GT(actual.cdm_session_renew_key_time_us_size(), 0);
EXPECT_GT(actual.cdm_session_restore_offline_session_size(), 0);
EXPECT_GT(actual.cdm_session_restore_usage_session_size(), 0);
EXPECT_GT(actual.cdm_session_license_request_latency_ms_size(), 0);
EXPECT_STREQ("test build info",
actual.oemcrypto_build_info().string_value().c_str());
EXPECT_STREQ("test license sdk version",
actual.license_sdk_version().string_value().c_str());
EXPECT_STREQ("test license service version",
actual.license_service_version().string_value().c_str());
EXPECT_GT(
actual.crypto_metrics().crypto_session_generic_decrypt_time_us_size(), 0);
EXPECT_EQ(1, actual.drm_certificate_key_type().int_value());
}
TEST_F(SessionMetricsTest, EmptySessionMetrics) {
SessionMetrics session_metrics;
WvCdmMetrics::SessionMetrics actual_metrics;
session_metrics.Serialize(&actual_metrics);
EXPECT_TRUE(actual_metrics.has_crypto_metrics());
EXPECT_FALSE(actual_metrics.has_session_id());
EXPECT_FALSE(actual_metrics.has_cdm_session_life_span_ms());
EXPECT_EQ(0, actual_metrics.cdm_session_renew_key_time_us_size());
EXPECT_EQ(0, actual_metrics.cdm_session_restore_offline_session_size());
EXPECT_EQ(0, actual_metrics.cdm_session_restore_usage_session_size());
}
class CryptoMetricsTest : public ::testing::Test {
};
TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
CryptoMetrics crypto_metrics;
// Crypto session metrics.
crypto_metrics.crypto_session_delete_all_usage_reports_.Increment(NO_ERROR);
crypto_metrics.crypto_session_delete_multiple_usage_information_
.Increment(NO_ERROR);
crypto_metrics.crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics.crypto_session_generic_encrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics.crypto_session_generic_sign_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_generic_verify_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_get_device_unique_id_.Increment(NO_ERROR);
crypto_metrics.crypto_session_get_token_.Increment(NO_ERROR);
crypto_metrics.crypto_session_life_span_.Record(1.0);
crypto_metrics.crypto_session_load_certificate_private_key_
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault);
crypto_metrics.crypto_session_update_usage_information_
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_usage_information_support_.Record(true);
crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2);
// Usage table header metrics.
crypto_metrics.usage_table_header_initial_size_.Record(200);
crypto_metrics.usage_table_header_add_entry_.Increment(UNKNOWN_ERROR);
crypto_metrics.usage_table_header_delete_entry_.Increment(UNKNOWN_ERROR);
crypto_metrics.usage_table_header_update_entry_.Record(2.0, UNKNOWN_ERROR);
crypto_metrics.usage_table_header_load_entry_.Increment(UNKNOWN_ERROR);
// Usage table LRU metrics.
crypto_metrics.usage_table_header_lru_usage_info_count_.Record(150);
crypto_metrics.usage_table_header_lru_offline_license_count_.Record(50);
crypto_metrics.usage_table_header_lru_evicted_entry_staleness_.Record(259200);
crypto_metrics.usage_table_header_lru_evicted_entry_type_.Record(
kStorageUsageInfo);
// Oem crypto metrics.
crypto_metrics.oemcrypto_api_version_.Record(123);
crypto_metrics.oemcrypto_close_session_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_copy_buffer_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_deactivate_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_decrypt_cenc_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_delete_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_delete_usage_table_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_derive_keys_from_session_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_force_delete_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_derived_keys_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_nonce_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_rsa_signature_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generate_signature_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_decrypt_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_encrypt_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_sign_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_verify_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_get_device_id_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_get_key_data_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_max_number_of_sessions_.Record(7);
crypto_metrics.oemcrypto_number_of_open_sessions_.Record(5);
crypto_metrics.oemcrypto_get_oem_public_certificate_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_provisioning_method_.Record(OEMCrypto_Keybox);
crypto_metrics.oemcrypto_get_random_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_initialize_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_is_anti_rollback_hw_present_.Record(true);
crypto_metrics.oemcrypto_is_keybox_valid_.Record(true);
crypto_metrics.oemcrypto_load_device_drm_key_.Record(
1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_refresh_keys_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_report_usage_.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_security_patch_level_.Record(123);
crypto_metrics.oemcrypto_select_key_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_update_usage_table_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_create_usage_table_header_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_usage_table_header_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_shrink_usage_table_header_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_create_new_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_move_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_create_old_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_copy_old_usage_entry_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_set_sandbox_.Record("sandbox");
crypto_metrics.oemcrypto_set_decrypt_hash_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_resource_rating_tier_.Record(123);
crypto_metrics.oemcrypto_minor_api_version_.Record(234);
crypto_metrics.oemcrypto_maximum_usage_table_header_size_.Record(321);
WvCdmMetrics::CryptoMetrics actual;
crypto_metrics.Serialize(&actual);
// Crypto session metrics.
EXPECT_GT(actual.crypto_session_delete_all_usage_reports_size(), 0);
EXPECT_GT(actual.crypto_session_delete_multiple_usage_information_size(), 0);
EXPECT_GT(actual.crypto_session_generic_decrypt_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_generic_encrypt_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_generic_sign_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_generic_verify_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_get_device_unique_id_size(), 0);
EXPECT_GT(actual.crypto_session_get_token_size(), 0);
EXPECT_EQ(1.0, actual.crypto_session_life_span().double_value());
EXPECT_GT(actual.crypto_session_load_certificate_private_key_time_us_size(),
0);
EXPECT_GT(actual.crypto_session_open_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_update_usage_information_time_us_size(), 0);
EXPECT_EQ(true,
actual.crypto_session_usage_information_support().int_value());
EXPECT_EQ(kSecurityLevelL2,
actual.crypto_session_security_level().int_value());
// Usage table header metrics.
EXPECT_EQ(200, actual.usage_table_header_initial_size().int_value());
EXPECT_GT(actual.usage_table_header_add_entry_size(), 0);
EXPECT_GT(actual.usage_table_header_delete_entry_size(), 0);
EXPECT_GT(actual.usage_table_header_update_entry_time_us_size(), 0);
EXPECT_GT(actual.usage_table_header_load_entry_size(), 0);
// Usage table LRU metrics.
EXPECT_EQ(150, actual.usage_table_header_lru_usage_info_count().int_value());
EXPECT_EQ(50,
actual.usage_table_header_lru_offline_license_count().int_value());
EXPECT_EQ(
259200,
actual.usage_table_header_lru_evicted_entry_staleness_s().int_value());
EXPECT_EQ(kStorageUsageInfo,
actual.usage_table_header_lru_evicted_entry_type().int_value());
// Oem crypto metrics.
EXPECT_EQ(123, actual.oemcrypto_api_version().int_value());
EXPECT_GT(actual.oemcrypto_close_session_size(), 0);
EXPECT_GT(actual.oemcrypto_copy_buffer_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_deactivate_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_decrypt_cenc_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_delete_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_delete_usage_table_size(), 0);
EXPECT_GT(actual.oemcrypto_derive_keys_from_session_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_force_delete_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_derived_keys_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_nonce_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_rsa_signature_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_signature_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_decrypt_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_encrypt_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_sign_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_verify_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_get_device_id_size(), 0);
EXPECT_GT(actual.oemcrypto_get_key_data_time_us_size(), 0);
EXPECT_EQ(7, actual.oemcrypto_max_number_of_sessions().int_value());
EXPECT_EQ(5, actual.oemcrypto_number_of_open_sessions().int_value());
EXPECT_GT(actual.oemcrypto_get_oem_public_certificate_size(), 0);
EXPECT_EQ(OEMCrypto_Keybox,
actual.oemcrypto_provisioning_method().int_value());
EXPECT_GT(actual.oemcrypto_get_random_size(), 0);
EXPECT_GT(actual.oemcrypto_initialize_time_us_size(), 0);
EXPECT_EQ(true, actual.oemcrypto_is_anti_rollback_hw_present().int_value());
EXPECT_EQ(true, actual.oemcrypto_is_keybox_valid().int_value());
EXPECT_GT(actual.oemcrypto_load_device_drm_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_load_keys_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_refresh_keys_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_report_usage_size(), 0);
EXPECT_GT(actual.oemcrypto_rewrap_device_rsa_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_rewrap_device_rsa_key_30_time_us_size(), 0);
EXPECT_EQ(123, actual.oemcrypto_security_patch_level().int_value());
EXPECT_GT(actual.oemcrypto_select_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_update_usage_table_size(), 0);
EXPECT_GT(actual.oemcrypto_create_usage_table_header_size(), 0);
EXPECT_GT(actual.oemcrypto_load_usage_table_header_size(), 0);
EXPECT_GT(actual.oemcrypto_shrink_usage_table_header_size(), 0);
EXPECT_GT(actual.oemcrypto_create_new_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_load_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_move_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_create_old_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_copy_old_usage_entry_size(), 0);
EXPECT_EQ("sandbox", actual.oemcrypto_set_sandbox().string_value());
EXPECT_GT(actual.oemcrypto_set_decrypt_hash_size(), 0);
EXPECT_EQ(123, actual.oemcrypto_resource_rating_tier().int_value());
EXPECT_EQ(234, actual.oemcrypto_minor_api_version().int_value());
EXPECT_EQ(321,
actual.oemcrypto_maximum_usage_table_header_size().int_value());
}
} // namespace metrics
} // namespace wvcdm
Reference in New Issue View Git Blame Copy Permalink