539 lines
25 KiB
C++
539 lines
25 KiB
C++
// 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");
|
|
|
|
// 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);
|
|
}
|
|
|
|
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_rsa_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_rsa_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
|