From 2e22e2321e23daa19a675e90129d878692e4bb95 Mon Sep 17 00:00:00 2001 From: Rahul Frias Date: Wed, 16 Oct 2019 16:48:50 -0700 Subject: [PATCH] clang-format core/test files [ Merge of http://go/wvgerrit/88006 ] Certain test files have yet to be formatted since we introduced clang-formatting. Test: android unit/integration tests Bug: 134365840 Change-Id: I2d30ad367d76a9dfbf389614e1b31ed39fa17c72 --- .../cdm/core/test/buffer_reader_test.cpp | 4 +- .../cdm_engine_metrics_decorator_unittest.cpp | 355 ++++++++--------- .../cdm/core/test/cdm_engine_test.cpp | 49 +-- .../cdm/core/test/cdm_session_unittest.cpp | 59 ++- .../cdm/core/test/config_test_env.cpp | 20 +- .../cdm/core/test/crypto_session_unittest.cpp | 8 +- .../cdm/core/test/device_files_unittest.cpp | 32 +- .../cdm/core/test/generic_crypto_unittest.cpp | 16 +- libwvdrmengine/cdm/core/test/http_socket.cpp | 34 +- .../cdm/core/test/http_socket_test.cpp | 2 +- .../test/initialization_data_unittest.cpp | 1 - .../cdm/core/test/license_keys_unittest.cpp | 255 ++++++------ .../cdm/core/test/license_unittest.cpp | 115 +++--- .../policy_engine_constraints_unittest.cpp | 164 ++++---- .../cdm/core/test/policy_engine_unittest.cpp | 370 +++++++----------- libwvdrmengine/cdm/core/test/test_base.cpp | 33 +- libwvdrmengine/cdm/core/test/url_request.cpp | 2 +- .../core/test/usage_table_header_unittest.cpp | 203 +++++----- 18 files changed, 776 insertions(+), 946 deletions(-) diff --git a/libwvdrmengine/cdm/core/test/buffer_reader_test.cpp b/libwvdrmengine/cdm/core/test/buffer_reader_test.cpp index 60968415..4ebd0e10 100644 --- a/libwvdrmengine/cdm/core/test/buffer_reader_test.cpp +++ b/libwvdrmengine/cdm/core/test/buffer_reader_test.cpp @@ -2,9 +2,9 @@ // source code may only be used and distributed under the Widevine Master // License Agreement. -#include #include #include +#include #include "buffer_reader.h" @@ -836,4 +836,4 @@ TEST_F(BufferReaderTest, SkipBytesTooLarge) { ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data))); ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0)); } -} // namespace +} // namespace wvcdm diff --git a/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp index 1d3c3f2c..0ddfe811 100644 --- a/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp @@ -29,10 +29,8 @@ using ::wvcdm::metrics::EngineMetrics; namespace wvcdm { - class MockCdmClientPropertySet : public CdmClientPropertySet { public: - MOCK_CONST_METHOD0(security_level, const std::string&()); MOCK_CONST_METHOD0(use_privacy_mode, bool()); MOCK_CONST_METHOD0(service_certificate, const std::string&()); @@ -57,12 +55,12 @@ class MockCdmEngineImpl : public CdmEngine { std::shared_ptr metrics, const std::string& spoid) : CdmEngine(file_system, metrics, spoid) {} - MOCK_METHOD4(OpenSession, CdmResponseType( - const CdmKeySystem&, CdmClientPropertySet*, - const CdmSessionId&, WvCdmEventListener*)); - MOCK_METHOD4(OpenSession, CdmResponseType( - const CdmKeySystem&, CdmClientPropertySet*, - WvCdmEventListener*, CdmSessionId*)); + MOCK_METHOD4(OpenSession, + CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*, + const CdmSessionId&, WvCdmEventListener*)); + MOCK_METHOD4(OpenSession, + CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*, + WvCdmEventListener*, CdmSessionId*)); MOCK_METHOD1(CloseSession, CdmResponseType(const CdmSessionId&)); MOCK_METHOD3(OpenKeySetSession, CdmResponseType(const CdmKeySetId&, CdmClientPropertySet*, @@ -71,28 +69,31 @@ class MockCdmEngineImpl : public CdmEngine { CdmResponseType(const CdmSessionId&, const CdmKeySetId&, const InitializationData&, const CdmLicenseType, CdmAppParameterMap&, CdmKeyRequest*)); - MOCK_METHOD4(AddKey, CdmResponseType( - const CdmSessionId&, const CdmKeyResponse&, - CdmLicenseType*, CdmKeySetId*)); - MOCK_METHOD2(RestoreKey, CdmResponseType(const CdmSessionId&, - const CdmKeySetId&)); + MOCK_METHOD4(AddKey, + CdmResponseType(const CdmSessionId&, const CdmKeyResponse&, + CdmLicenseType*, CdmKeySetId*)); + MOCK_METHOD2(RestoreKey, + CdmResponseType(const CdmSessionId&, const CdmKeySetId&)); MOCK_METHOD1(RemoveKeys, CdmResponseType(const CdmSessionId&)); - MOCK_METHOD2(QueryKeyStatus, CdmResponseType(const CdmSessionId&, - CdmQueryMap*)); - MOCK_METHOD5(GetProvisioningRequest, CdmResponseType( - CdmCertificateType, const std::string&, const std::string&, - CdmProvisioningRequest*, std::string*)); - MOCK_METHOD3(HandleProvisioningResponse, CdmResponseType( - const CdmProvisioningResponse&, std::string*, std::string*)); + MOCK_METHOD2(QueryKeyStatus, + CdmResponseType(const CdmSessionId&, CdmQueryMap*)); + MOCK_METHOD5(GetProvisioningRequest, + CdmResponseType(CdmCertificateType, const std::string&, + const std::string&, CdmProvisioningRequest*, + std::string*)); + MOCK_METHOD3(HandleProvisioningResponse, + CdmResponseType(const CdmProvisioningResponse&, std::string*, + std::string*)); MOCK_METHOD1(Unprovision, CdmResponseType(CdmSecurityLevel)); - MOCK_METHOD4(ListUsageIds, CdmResponseType( - const std::string&, CdmSecurityLevel, - std::vector*, std::vector*)); + MOCK_METHOD4(ListUsageIds, + CdmResponseType(const std::string&, CdmSecurityLevel, + std::vector*, + std::vector*)); MOCK_METHOD1(RemoveAllUsageInfo, CdmResponseType(const std::string&)); - MOCK_METHOD2(RemoveAllUsageInfo, CdmResponseType(const std::string&, - CdmSecurityLevel)); - MOCK_METHOD2(RemoveUsageInfo, CdmResponseType(const std::string&, - const CdmSecureStopId&)); + MOCK_METHOD2(RemoveAllUsageInfo, + CdmResponseType(const std::string&, CdmSecurityLevel)); + MOCK_METHOD2(RemoveUsageInfo, + CdmResponseType(const std::string&, const CdmSecureStopId&)); MOCK_METHOD1(ReleaseUsageInfo, CdmResponseType(const CdmUsageInfoReleaseMessage&)); MOCK_METHOD2(Decrypt, CdmResponseType(const CdmSessionId&, @@ -108,7 +109,6 @@ class WvCdmEngineMetricsImplTest : public ::testing::Test { test_cdm_metrics_engine_.reset( new CdmEngineMetricsImpl>( file_system_.get(), engine_metrics)); - } protected: @@ -121,10 +121,10 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload1) { MockCdmClientPropertySet property_set; MockWvCdmEventListener event_listener; - EXPECT_CALL(*test_cdm_metrics_engine_, - OpenSession( - StrEq("foo"), Eq(&property_set), - Matcher(Eq("bar")), Eq(&event_listener))) + EXPECT_CALL( + *test_cdm_metrics_engine_, + OpenSession(StrEq("foo"), Eq(&property_set), + Matcher(Eq("bar")), Eq(&event_listener))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -134,9 +134,10 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload1) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_open_session_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_open_session(0).attributes().error_code()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_open_session(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload2) { @@ -145,9 +146,8 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload2) { CdmSessionId session_id; EXPECT_CALL(*test_cdm_metrics_engine_, - OpenSession( - StrEq("foo"), Eq(&property_set), - Eq(&event_listener), Matcher(Eq(&session_id)))) + OpenSession(StrEq("foo"), Eq(&property_set), Eq(&event_listener), + Matcher(Eq(&session_id)))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -157,9 +157,10 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload2) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_open_session_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_open_session(0).attributes().error_code()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_open_session(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, CloseSession) { @@ -175,30 +176,32 @@ TEST_F(WvCdmEngineMetricsImplTest, CloseSession) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_close_session_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_close_session(0).attributes().error_code()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_close_session(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, OpenKeySetSession) { MockCdmClientPropertySet property_set; MockWvCdmEventListener event_listener; - EXPECT_CALL(*test_cdm_metrics_engine_, + EXPECT_CALL( + *test_cdm_metrics_engine_, OpenKeySetSession(Eq("bar"), Eq(&property_set), Eq(&event_listener))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); - ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->OpenKeySetSession("bar", &property_set, - &event_listener)); + ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->OpenKeySetSession( + "bar", &property_set, &event_listener)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( 1, metrics_proto.engine_metrics().cdm_engine_open_key_set_session_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_open_key_set_session(0).attributes().error_code()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_open_key_set_session(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, GenerateKeyRequest) { @@ -206,25 +209,26 @@ TEST_F(WvCdmEngineMetricsImplTest, GenerateKeyRequest) { CdmAppParameterMap app_parameters; CdmKeyRequest key_request; - EXPECT_CALL(*test_cdm_metrics_engine_, + EXPECT_CALL( + *test_cdm_metrics_engine_, GenerateKeyRequest(Eq("foo"), Eq("bar"), _, Eq(kLicenseTypeStreaming), Eq(app_parameters), Eq(&key_request))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->GenerateKeyRequest( - "foo", "bar", initialization_data, - kLicenseTypeStreaming, app_parameters, &key_request)); + "foo", "bar", initialization_data, kLicenseTypeStreaming, + app_parameters, &key_request)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_generate_key_request_time_us_size()); + ASSERT_EQ(1, metrics_proto.engine_metrics() + .cdm_engine_generate_key_request_time_us_size()); EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() .cdm_engine_generate_key_request_time_us(0) - .attributes().error_code()); + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, AddKey) { @@ -232,49 +236,44 @@ TEST_F(WvCdmEngineMetricsImplTest, AddKey) { CdmKeySetId key_set_id; EXPECT_CALL(*test_cdm_metrics_engine_, - AddKey(Eq("fake session id"), Eq("fake response"), Eq(&license_type), - Eq(&key_set_id))) + AddKey(Eq("fake session id"), Eq("fake response"), + Eq(&license_type), Eq(&key_set_id))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->AddKey( - "fake session id", "fake response", - &license_type, &key_set_id)); + test_cdm_metrics_engine_->AddKey("fake session id", "fake response", + &license_type, &key_set_id)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_add_key_time_us_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_add_key_time_us(0) - .attributes().error_code()); + ASSERT_EQ(1, + metrics_proto.engine_metrics().cdm_engine_add_key_time_us_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_add_key_time_us(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, RestoreKey) { EXPECT_CALL(*test_cdm_metrics_engine_, - RestoreKey(Eq("fake session id"), Eq("fake key set id"))) + RestoreKey(Eq("fake session id"), Eq("fake key set id"))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); - ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->RestoreKey( - "fake session id", "fake key set id")); + ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->RestoreKey( + "fake session id", "fake key set id")); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_restore_key_time_us_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_restore_key_time_us(0) - .attributes().error_code()); + 1, metrics_proto.engine_metrics().cdm_engine_restore_key_time_us_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_restore_key_time_us(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, RemoveKeys) { - EXPECT_CALL(*test_cdm_metrics_engine_, - RemoveKeys(Eq("fake session id"))) + EXPECT_CALL(*test_cdm_metrics_engine_, RemoveKeys(Eq("fake session id"))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -282,34 +281,30 @@ TEST_F(WvCdmEngineMetricsImplTest, RemoveKeys) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_remove_keys_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_remove_keys(0) - .attributes().error_code()); + ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_remove_keys_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_remove_keys(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, QueryKeyStatus) { CdmQueryMap query_response; EXPECT_CALL(*test_cdm_metrics_engine_, - QueryKeyStatus(Eq("fake session id"), Eq(&query_response))) + QueryKeyStatus(Eq("fake session id"), Eq(&query_response))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); - ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->QueryKeyStatus("fake session id", - &query_response)); + ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->QueryKeyStatus( + "fake session id", &query_response)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_query_key_status_time_us_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_query_key_status_time_us(0) - .attributes().error_code()); + ASSERT_EQ(1, metrics_proto.engine_metrics() + .cdm_engine_query_key_status_time_us_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_query_key_status_time_us(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, GetProvisioningRequest) { @@ -317,10 +312,10 @@ TEST_F(WvCdmEngineMetricsImplTest, GetProvisioningRequest) { std::string default_url; EXPECT_CALL(*test_cdm_metrics_engine_, - GetProvisioningRequest(Eq(kCertificateX509), - Eq("fake certificate authority"), - Eq("fake service certificate"), - Eq(&request), Eq(&default_url))) + GetProvisioningRequest(Eq(kCertificateX509), + Eq("fake certificate authority"), + Eq("fake service certificate"), + Eq(&request), Eq(&default_url))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -330,13 +325,13 @@ TEST_F(WvCdmEngineMetricsImplTest, GetProvisioningRequest) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_get_provisioning_request_time_us_size()); + ASSERT_EQ(1, metrics_proto.engine_metrics() + .cdm_engine_get_provisioning_request_time_us_size()); EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() .cdm_engine_get_provisioning_request_time_us(0) - .attributes().error_code()); + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, HandleProvisioningResponse) { @@ -345,8 +340,8 @@ TEST_F(WvCdmEngineMetricsImplTest, HandleProvisioningResponse) { std::string wrapped_key; EXPECT_CALL(*test_cdm_metrics_engine_, - HandleProvisioningResponse(Eq("fake provisioning response"), - Eq(&cert), Eq(&wrapped_key))) + HandleProvisioningResponse(Eq("fake provisioning response"), + Eq(&cert), Eq(&wrapped_key))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -355,18 +350,17 @@ TEST_F(WvCdmEngineMetricsImplTest, HandleProvisioningResponse) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_handle_provisioning_response_time_us_size()); + ASSERT_EQ(1, metrics_proto.engine_metrics() + .cdm_engine_handle_provisioning_response_time_us_size()); EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() .cdm_engine_handle_provisioning_response_time_us(0) - .attributes().error_code()); + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, Unprovision) { - EXPECT_CALL(*test_cdm_metrics_engine_, - Unprovision(Eq(kSecurityLevelL2))) + EXPECT_CALL(*test_cdm_metrics_engine_, Unprovision(Eq(kSecurityLevelL2))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -374,18 +368,15 @@ TEST_F(WvCdmEngineMetricsImplTest, Unprovision) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_unprovision_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_unprovision(0) - .attributes().error_code()); + ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_unprovision_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_unprovision(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload1) { - EXPECT_CALL(*test_cdm_metrics_engine_, - RemoveAllUsageInfo(Eq("fake app id"))) + EXPECT_CALL(*test_cdm_metrics_engine_, RemoveAllUsageInfo(Eq("fake app id"))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -394,58 +385,54 @@ TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload1) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_remove_all_usage_info_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_remove_all_usage_info(0) - .attributes().error_code()); + 1, + metrics_proto.engine_metrics().cdm_engine_remove_all_usage_info_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_remove_all_usage_info(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload2) { EXPECT_CALL(*test_cdm_metrics_engine_, - RemoveAllUsageInfo(Eq("fake app id"), Eq(kSecurityLevelL2))) + RemoveAllUsageInfo(Eq("fake app id"), Eq(kSecurityLevelL2))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); - ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->RemoveAllUsageInfo("fake app id", - kSecurityLevelL2)); + ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->RemoveAllUsageInfo( + "fake app id", kSecurityLevelL2)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_remove_all_usage_info_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_remove_all_usage_info(0) - .attributes().error_code()); + 1, + metrics_proto.engine_metrics().cdm_engine_remove_all_usage_info_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_remove_all_usage_info(0) + .attributes() + .error_code()); } - TEST_F(WvCdmEngineMetricsImplTest, RemoveUsageInfo) { EXPECT_CALL(*test_cdm_metrics_engine_, - RemoveUsageInfo(Eq("fake app id"), Eq("fake secure stop id"))) + RemoveUsageInfo(Eq("fake app id"), Eq("fake secure stop id"))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); - ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->RemoveUsageInfo("fake app id", - "fake secure stop id")); + ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->RemoveUsageInfo( + "fake app id", "fake secure stop id")); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_remove_usage_info_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_remove_usage_info(0) - .attributes().error_code()); + ASSERT_EQ(1, + metrics_proto.engine_metrics().cdm_engine_remove_usage_info_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_remove_usage_info(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, ReleaseUsageInfo) { EXPECT_CALL(*test_cdm_metrics_engine_, - ReleaseUsageInfo(Eq("fake release message"))) + ReleaseUsageInfo(Eq("fake release message"))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); ASSERT_EQ(wvcdm::UNKNOWN_ERROR, @@ -454,12 +441,11 @@ TEST_F(WvCdmEngineMetricsImplTest, ReleaseUsageInfo) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_release_usage_info_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_release_usage_info(0) - .attributes().error_code()); + 1, metrics_proto.engine_metrics().cdm_engine_release_usage_info_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_release_usage_info(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, ListUsageIds) { @@ -467,44 +453,42 @@ TEST_F(WvCdmEngineMetricsImplTest, ListUsageIds) { std::vector provider_session_tokens; EXPECT_CALL(*test_cdm_metrics_engine_, - ListUsageIds(Eq("fake app id"), Eq(kSecurityLevelL2), - Eq(&ksids), Eq(&provider_session_tokens))) + ListUsageIds(Eq("fake app id"), Eq(kSecurityLevelL2), Eq(&ksids), + Eq(&provider_session_tokens))) .WillOnce(Return(wvcdm::UNKNOWN_ERROR)); - ASSERT_EQ(wvcdm::UNKNOWN_ERROR, - test_cdm_metrics_engine_->ListUsageIds( - "fake app id", kSecurityLevelL2, &ksids, - &provider_session_tokens)); + ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->ListUsageIds( + "fake app id", kSecurityLevelL2, &ksids, + &provider_session_tokens)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_get_secure_stop_ids_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_get_secure_stop_ids(0) - .attributes().error_code()); + 1, metrics_proto.engine_metrics().cdm_engine_get_secure_stop_ids_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_get_secure_stop_ids(0) + .attributes() + .error_code()); } TEST_F(WvCdmEngineMetricsImplTest, FindSessionForKey) { CdmSessionId session_id; EXPECT_CALL(*test_cdm_metrics_engine_, - FindSessionForKey(Eq("fake key id"), Eq(&session_id))) + FindSessionForKey(Eq("fake key id"), Eq(&session_id))) .WillOnce(Return(true)); - ASSERT_TRUE(test_cdm_metrics_engine_->FindSessionForKey("fake key id", - &session_id)); + ASSERT_TRUE( + test_cdm_metrics_engine_->FindSessionForKey("fake key id", &session_id)); drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_find_session_for_key_size()); + 1, metrics_proto.engine_metrics().cdm_engine_find_session_for_key_size()); EXPECT_TRUE(metrics_proto.engine_metrics() - .cdm_engine_find_session_for_key(0) - .attributes().error_code_bool()); + .cdm_engine_find_session_for_key(0) + .attributes() + .error_code_bool()); } TEST_F(WvCdmEngineMetricsImplTest, Decrypt) { @@ -517,13 +501,12 @@ TEST_F(WvCdmEngineMetricsImplTest, Decrypt) { drm_metrics::WvCdmMetrics metrics_proto; test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto); - ASSERT_EQ( - 1, metrics_proto.engine_metrics() - .cdm_engine_decrypt_time_us_size()); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, - metrics_proto.engine_metrics() - .cdm_engine_decrypt_time_us(0) - .attributes().error_code()); + ASSERT_EQ(1, + metrics_proto.engine_metrics().cdm_engine_decrypt_time_us_size()); + EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics() + .cdm_engine_decrypt_time_us(0) + .attributes() + .error_code()); } } // namespace wvcdm diff --git a/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp b/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp index 5dd9bc31..4873eef9 100644 --- a/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp +++ b/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp @@ -11,15 +11,15 @@ #include +#include "OEMCryptoCENC.h" #include "cdm_engine.h" #include "config_test_env.h" #include "device_files.h" -#include "initialization_data.h" #include "file_store.h" +#include "initialization_data.h" #include "license_request.h" #include "log.h" #include "metrics.pb.h" -#include "OEMCryptoCENC.h" #include "properties.h" #include "string_conversions.h" #include "test_base.h" @@ -181,8 +181,8 @@ class WvCdmEngineTest : public WvCdmEnginePreProvTest { CdmKeyRequest key_request; CdmResponseType result = cdm_engine_.GenerateKeyRequest( - session_id_, key_set_id, init_data, license_type, - app_parameters, &key_request); + session_id_, key_set_id, init_data, license_type, app_parameters, + &key_request); EXPECT_EQ(KEY_MESSAGE, result); key_msg_ = key_request.message; @@ -261,16 +261,14 @@ class WvCdmEngineTest : public WvCdmEnginePreProvTest { EXPECT_EQ(KEY_ADDED, status); EXPECT_EQ(expected_license_type, license_type); - VerifyLicenseRequestLatency(kKeyRequestTypeInitial, - *dummy_engine_metrics_); + VerifyLicenseRequestLatency(kKeyRequestTypeInitial, *dummy_engine_metrics_); } void VerifyRenewalKeyResponse(const std::string& server_url, const std::string& client_auth) { std::string resp = GetKeyRequestResponse(server_url, client_auth); EXPECT_EQ(KEY_ADDED, cdm_engine_.RenewKey(session_id_, resp)); - VerifyLicenseRequestLatency(kKeyRequestTypeRenewal, - *dummy_engine_metrics_); + VerifyLicenseRequestLatency(kKeyRequestTypeRenewal, *dummy_engine_metrics_); } void VerifyLicenseRequestLatency( @@ -342,14 +340,10 @@ TEST_F(WvCdmEngineTest, SetLicensingServiceInvalidCertificate) { TEST_F(WvCdmEnginePreProvTestStaging, ProvisioningTest) { Provision(); } -TEST_F(WvCdmEnginePreProvTestUatBinary, ProvisioningTest) { - Provision(); -} +TEST_F(WvCdmEnginePreProvTestUatBinary, ProvisioningTest) { Provision(); } // Test that provisioning works. -TEST_F(WvCdmEngineTest, ProvisioningTest) { - Provision(); -} +TEST_F(WvCdmEngineTest, ProvisioningTest) { Provision(); } // Test that provisioning works, even if device is already provisioned. TEST_F(WvCdmEngineTest, ReprovisioningTest) { @@ -418,7 +412,6 @@ TEST_F(WvCdmEngineTest, LicenseRenewal) { } TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) { - CdmSessionId session_id; uint32_t frame_number; std::string hash; @@ -428,13 +421,14 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) { const std::string test_frame_number_string = std::to_string(test_frame_number); const std::string test_invalid_hash = "an invalid hash"; - std::vector binary_hash{ 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0xFF }; + std::vector binary_hash{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0xFF}; const std::string test_valid_decoded_hash(binary_hash.begin(), binary_hash.end()); const std::string test_valid_hash = b2a_hex(binary_hash); const std::string test_invalid_hash_string = "sample hash string"; const std::string test_valid_hash_string = test_session_id + kComma + - test_frame_number_string + kComma + test_valid_hash; + test_frame_number_string + kComma + + test_valid_hash; // invalid parameters EXPECT_EQ(PARAMETER_NULL, @@ -444,9 +438,8 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) { CdmEngine::ParseDecryptHashString(test_valid_hash_string, &session_id, nullptr, &hash)); EXPECT_EQ(PARAMETER_NULL, - CdmEngine::ParseDecryptHashString(test_valid_hash_string, - &session_id, &frame_number, - nullptr)); + CdmEngine::ParseDecryptHashString( + test_valid_hash_string, &session_id, &frame_number, nullptr)); // Too few or too many parameters EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT, @@ -500,33 +493,31 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) { EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT, CdmEngine::ParseDecryptHashString(hash_data, &session_id, &frame_number, &hash)); - hash_data = test_session_id + kComma + test_frame_number_string + kComma + - kComma; + hash_data = + test_session_id + kComma + test_frame_number_string + kComma + kComma; EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT, CdmEngine::ParseDecryptHashString(hash_data, &session_id, &frame_number, &hash)); // Invalid parameters (frame number, hash) - hash_data = test_session_id + kComma + test_session_id + kComma + - test_valid_hash; + hash_data = + test_session_id + kComma + test_session_id + kComma + test_valid_hash; EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT, CdmEngine::ParseDecryptHashString(hash_data, &session_id, &frame_number, &hash)); hash_data = test_session_id + kComma + test_frame_number_string + kComma + - test_invalid_hash; + test_invalid_hash; EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT, CdmEngine::ParseDecryptHashString(hash_data, &session_id, &frame_number, &hash)); // valid data EXPECT_EQ(NO_ERROR, - CdmEngine::ParseDecryptHashString(test_valid_hash_string, - &session_id, &frame_number, - &hash)); + CdmEngine::ParseDecryptHashString( + test_valid_hash_string, &session_id, &frame_number, &hash)); EXPECT_EQ(test_session_id, session_id); EXPECT_EQ(test_frame_number, frame_number); EXPECT_EQ(test_valid_decoded_hash, hash); } - } // namespace wvcdm diff --git a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp index ada49f9f..b7613d5c 100644 --- a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp @@ -25,8 +25,8 @@ using ::testing::Invoke; using ::testing::NiceMock; using ::testing::NotNull; using ::testing::Return; -using ::testing::SetArgPointee; using ::testing::Sequence; +using ::testing::SetArgPointee; using ::testing::StrEq; namespace wvcdm { @@ -114,8 +114,8 @@ class MockDeviceFiles : public DeviceFiles { MockDeviceFiles() : DeviceFiles(nullptr) {} MOCK_METHOD1(Init, bool(CdmSecurityLevel)); - MOCK_METHOD4(RetrieveCertificate, bool(std::string*, std::string*, - std::string*, uint32_t*)); + MOCK_METHOD4(RetrieveCertificate, + bool(std::string*, std::string*, std::string*, uint32_t*)); }; class MockUsageTableHeader : public UsageTableHeader { @@ -161,12 +161,11 @@ class MockPolicyEngine : public PolicyEngine { class MockCdmLicense : public CdmLicense { public: - MockCdmLicense(const CdmSessionId& session_id) - : CdmLicense(session_id) {} + MockCdmLicense(const CdmSessionId& session_id) : CdmLicense(session_id) {} - MOCK_METHOD7(Init, bool(const std::string&, CdmClientTokenType, - const std::string&, bool, const std::string&, - CryptoSession*, PolicyEngine*)); + MOCK_METHOD7(Init, + bool(const std::string&, CdmClientTokenType, const std::string&, + bool, const std::string&, CryptoSession*, PolicyEngine*)); MOCK_METHOD0(provider_session_token, std::string()); }; @@ -216,8 +215,8 @@ TEST_F(CdmSessionTest, InitWithBuiltInCertificate) { .WillOnce(Return(level)); EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType()) .WillOnce(Return(kClientTokenDrmCert)); - EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(), - NotNull(), _)) + EXPECT_CALL(*file_handle_, + RetrieveCertificate(NotNull(), NotNull(), NotNull(), _)) .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey), Return(true))); EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey))) @@ -225,9 +224,8 @@ TEST_F(CdmSessionTest, InitWithBuiltInCertificate) { .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true)); EXPECT_CALL(*license_parser_, - Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), - false, Eq(kEmptyString), Eq(crypto_session_), - Eq(policy_engine_))) + Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), false, + Eq(kEmptyString), Eq(crypto_session_), Eq(policy_engine_))) .WillOnce(Return(true)); ASSERT_EQ(NO_ERROR, cdm_session_->Init(nullptr)); @@ -245,17 +243,16 @@ TEST_F(CdmSessionTest, InitWithCertificate) { EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType()) .WillOnce(Return(kClientTokenKeybox)); EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true)); - EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(), - NotNull(), _)) + EXPECT_CALL(*file_handle_, + RetrieveCertificate(NotNull(), NotNull(), NotNull(), _)) .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey), Return(true))); EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey))) .InSequence(crypto_session_seq) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*license_parser_, - Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), - false, Eq(kEmptyString), Eq(crypto_session_), - Eq(policy_engine_))) + Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), false, + Eq(kEmptyString), Eq(crypto_session_), Eq(policy_engine_))) .WillOnce(Return(true)); ASSERT_EQ(NO_ERROR, cdm_session_->Init(nullptr)); @@ -273,8 +270,8 @@ TEST_F(CdmSessionTest, ReInitFail) { EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType()) .WillOnce(Return(kClientTokenKeybox)); EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true)); - EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(), - NotNull(), _)) + EXPECT_CALL(*file_handle_, + RetrieveCertificate(NotNull(), NotNull(), NotNull(), _)) .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey), Return(true))); EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey))) @@ -308,8 +305,8 @@ TEST_F(CdmSessionTest, InitNeedsProvisioning) { EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType()) .WillOnce(Return(kClientTokenKeybox)); EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true)); - EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(), - NotNull(), _)) + EXPECT_CALL(*file_handle_, + RetrieveCertificate(NotNull(), NotNull(), NotNull(), _)) .WillOnce(Return(false)); ASSERT_EQ(NEED_PROVISIONING, cdm_session_->Init(nullptr)); @@ -328,8 +325,8 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) { EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType()) .WillOnce(Return(kClientTokenKeybox)); EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true)); - EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(), - NotNull(), _)) + EXPECT_CALL(*file_handle_, + RetrieveCertificate(NotNull(), NotNull(), NotNull(), _)) .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey), Return(true))); EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey))) @@ -338,15 +335,14 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) { EXPECT_CALL(*crypto_session_, GetUsageTableHeader()) .WillOnce(Return(&usage_table_header_)); EXPECT_CALL(*license_parser_, - Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), - false, Eq(kEmptyString), Eq(crypto_session_), - Eq(policy_engine_))) + Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), false, + Eq(kEmptyString), Eq(crypto_session_), Eq(policy_engine_))) .WillOnce(Return(true)); // Set up mocks and expectations for the UpdateUsageEntryInformation call. EXPECT_CALL(*crypto_session_, GetUsageSupportType(_)) - .WillRepeatedly(DoAll( - SetArgPointee<0>(kUsageEntrySupport), Return(NO_ERROR))); + .WillRepeatedly( + DoAll(SetArgPointee<0>(kUsageEntrySupport), Return(NO_ERROR))); EXPECT_CALL(*license_parser_, provider_session_token()) .WillRepeatedly(Return("Mock provider session token")); EXPECT_CALL(usage_table_header_, UpdateEntry(NotNull(), NotNull())) @@ -362,8 +358,9 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) { cdm_session_->GetMetrics()->Serialize(&metrics); std::string serialized_metrics; ASSERT_TRUE(metrics.SerializeToString(&serialized_metrics)); - EXPECT_GT(metrics.crypto_metrics() - .usage_table_header_update_entry_time_us().size(), 0) + EXPECT_GT( + metrics.crypto_metrics().usage_table_header_update_entry_time_us().size(), + 0) << "Missing update usage entry metric. Metrics: " << wvcdm::b2a_hex(serialized_metrics); } diff --git a/libwvdrmengine/cdm/core/test/config_test_env.cpp b/libwvdrmengine/cdm/core/test/config_test_env.cpp index 7fb9034d..8aced7ac 100644 --- a/libwvdrmengine/cdm/core/test/config_test_env.cpp +++ b/libwvdrmengine/cdm/core/test/config_test_env.cpp @@ -53,9 +53,9 @@ const std::string kCpProductionProvisioningServiceCertificate = // Staging Provisioning Server const std::string kCpStagingProvisioningServerUrl = - "https://staging-www.sandbox.googleapis.com/" - "certificateprovisioning/v1/devicecertificates/create" - "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE"; + "https://staging-www.sandbox.googleapis.com/" + "certificateprovisioning/v1/devicecertificates/create" + "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE"; // NOTE: This is currently the same as the Production Provisioning Service Cert. // NOTE: Provider ID = widevine.com const std::string kCpStagingProvisioningServiceCertificate = @@ -123,8 +123,7 @@ const std::string kCpProductionServiceCertificate = // Testing should be directed to this server. The only exception // is when testing against a new server feature that is not yet // deployed to this server (which would be directed to staging). -const std::string kCpUatLicenseServer = - "https://proxy.uat.widevine.com/proxy"; +const std::string kCpUatLicenseServer = "https://proxy.uat.widevine.com/proxy"; // NOTE: Provider ID = staging.google.com const std::string kCpUatServiceCertificate = "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F9900522" @@ -218,7 +217,7 @@ const CdmInitData kCpStagingSrmOuputProtectionRequired = "0000001d" // pssh data size // pssh data: "08011a0d7769646576696e655f746573" - "74220a74656172735f73726d32"; // "tears_srm2" + "74220a74656172735f73726d32"; // "tears_srm2" const CdmInitData kCpStagingSrmOuputProtectionRequested = "0000003d" // blob size "70737368" // "pssh" @@ -227,7 +226,7 @@ const CdmInitData kCpStagingSrmOuputProtectionRequested = "0000001d" // pssh data size // pssh data: "08011a0d7769646576696e655f746573" - "74220a74656172735f73726d32"; // "tears_srm1" + "74220a74656172735f73726d32"; // "tears_srm1" const CdmInitData kEmptyData; // Google Play license server data @@ -263,7 +262,8 @@ const ConfigTestEnv::LicenseServerConfiguration license_servers[] = { {kContentProtectionUatServer, kCpUatLicenseServer, kCpUatServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId, - // TODO(rfrias): replace when b/62880305 is addressed. For now use production + // TODO(rfrias): replace when b/62880305 is addressed. For now use + // production kCpProductionProvisioningServerUrl, kCpProductionProvisioningServiceCertificate}, @@ -306,7 +306,7 @@ ConfigTestEnv::ConfigTestEnv(ServerConfigurationId server_id, bool streaming, } } -ConfigTestEnv& ConfigTestEnv::operator=(const ConfigTestEnv &other) { +ConfigTestEnv& ConfigTestEnv::operator=(const ConfigTestEnv& other) { this->server_id_ = other.server_id_; this->client_auth_ = other.client_auth_; this->key_id_ = other.key_id_; @@ -343,7 +343,7 @@ const CdmInitData ConfigTestEnv::GetInitData(ContentId content_id) { case kContentIdStagingSrmOuputProtectionRequired: return wvcdm::a2bs_hex(kCpStagingSrmOuputProtectionRequired); default: - return kEmptyData; + return kEmptyData; } } diff --git a/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp b/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp index af4b9165..4cf703db 100644 --- a/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp @@ -12,9 +12,9 @@ #include "key_session.h" #include "license_protocol.pb.h" #include "log.h" -#include "platform.h" #include "metrics.pb.h" #include "metrics_collections.h" +#include "platform.h" #include "test_base.h" #include "test_printers.h" #include "wv_cdm_types.h" @@ -249,7 +249,7 @@ class CryptoSessionForTest : public TestCryptoSession, public WvCdmTestBase { void SetUp() {} - KeySession *key_session() { return key_session_.get(); } + KeySession* key_session() { return key_session_.get(); } private: static metrics::SessionMetrics metrics_; @@ -258,7 +258,7 @@ class CryptoSessionForTest : public TestCryptoSession, public WvCdmTestBase { metrics::SessionMetrics CryptoSessionForTest::metrics_; TEST(CryptoSessionTest, CanExtractSystemIdFromOemCertificate) { - std::string oem_cert(reinterpret_cast(kOemCert), + std::string oem_cert(reinterpret_cast(kOemCert), sizeof(kOemCert)); uint32_t system_id; ASSERT_TRUE( @@ -274,7 +274,7 @@ class CryptoSessionMetricsTest : public WvCdmTestBase { size_t key_data_len = sizeof(key_data); sts = OEMCrypto_GetKeyData(key_data, &key_data_len, kLevelDefault); if (sts != OEMCrypto_SUCCESS) return 0; - uint32_t *data = reinterpret_cast(key_data); + uint32_t* data = reinterpret_cast(key_data); uint32_t system_id = htonl(data[1]); return system_id; } diff --git a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp index ea1819b3..263785f1 100644 --- a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp @@ -2064,9 +2064,9 @@ class DeviceFilesSecurityLevelTest : public DeviceFilesTest, public ::testing::WithParamInterface {}; -class DeviceFilesUsageInfoListTest - : public DeviceFilesTest, - public ::testing::WithParamInterface {}; +class DeviceFilesUsageInfoListTest : public DeviceFilesTest, + public ::testing::WithParamInterface { +}; class DeviceFilesUsageInfoTest : public DeviceFilesTest, public ::testing::WithParamInterface {}; @@ -2210,9 +2210,8 @@ TEST_F(DeviceCertificateTest, DISABLED_ReadCertificate) { std::string certificate, wrapped_private_key; std::string serial_number; uint32_t system_id = 0; - ASSERT_TRUE( - device_files.RetrieveCertificate(&certificate, &wrapped_private_key, - &serial_number, &system_id)); + ASSERT_TRUE(device_files.RetrieveCertificate( + &certificate, &wrapped_private_key, &serial_number, &system_id)); EXPECT_EQ(kTestCertificate, b2a_hex(certificate)); EXPECT_EQ(kTestWrappedPrivateKey, b2a_hex(wrapped_private_key)); } @@ -2658,8 +2657,8 @@ TEST_F(DeviceFilesUsageInfoTest, ListUsageIds) { std::vector key_set_ids; std::vector provider_session_tokens; - EXPECT_TRUE(device_files.ListUsageIds( - app_id, &key_set_ids, &provider_session_tokens)); + EXPECT_TRUE(device_files.ListUsageIds(app_id, &key_set_ids, + &provider_session_tokens)); EXPECT_EQ(key_set_ids.size(), provider_session_tokens.size()); if (index >= 0) { @@ -2668,9 +2667,8 @@ TEST_F(DeviceFilesUsageInfoTest, ListUsageIds) { for (int j = 0; !found && j <= index; ++j) { if (app_id == kUsageInfoTestData[j].app_id && kUsageInfoTestData[j].usage_data.provider_session_token == - provider_session_tokens[i] && - kUsageInfoTestData[j].usage_data.key_set_id == - key_set_ids[i]) { + provider_session_tokens[i] && + kUsageInfoTestData[j].usage_data.key_set_id == key_set_ids[i]) { found = true; } } @@ -2855,8 +2853,7 @@ TEST_P(DeviceFilesUsageInfoTest, ListKeySetIds) { bool found = false; for (int j = 0; !found && j <= index; ++j) { if (app_id == kUsageInfoTestData[j].app_id && - kUsageInfoTestData[j].usage_data.key_set_id == - key_set_ids[i]) { + kUsageInfoTestData[j].usage_data.key_set_id == key_set_ids[i]) { found = true; } } @@ -2908,7 +2905,7 @@ TEST_P(DeviceFilesUsageInfoTest, ListProviderSessionTokenIds) { for (int j = 0; !found && j <= index; ++j) { if (app_id == kUsageInfoTestData[j].app_id && kUsageInfoTestData[j].usage_data.provider_session_token == - provider_session_tokens[i]) { + provider_session_tokens[i]) { found = true; } } @@ -3168,7 +3165,7 @@ TEST_P(DeviceFilesUsageTableTest, Store) { entry_data.push_back(kUsageEntriesTestData[i].key_set_id); entry_data.push_back(kUsageEntriesTestData[i].usage_info_file_name); entry_data_length += kUsageEntriesTestData[i].key_set_id.size() + - kUsageEntriesTestData[i].usage_info_file_name.size(); + kUsageEntriesTestData[i].usage_info_file_name.size(); } entry_data.push_back(kUsageTableInfoTestData[index].usage_table_header); entry_data_length += kUsageTableInfoTestData[index].usage_table_header.size(); @@ -3223,9 +3220,8 @@ TEST_P(DeviceFilesUsageTableTest, Read) { usage_entry_info[i].storage_type); EXPECT_EQ(kUsageEntriesTestData[i].key_set_id, usage_entry_info[i].key_set_id); - EXPECT_EQ( - kUsageEntriesTestData[i].usage_info_file_name, - usage_entry_info[i].usage_info_file_name); + EXPECT_EQ(kUsageEntriesTestData[i].usage_info_file_name, + usage_entry_info[i].usage_info_file_name); } } diff --git a/libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp b/libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp index 2a51ab9e..d0fe19bb 100644 --- a/libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp @@ -95,9 +95,7 @@ class WvGenericCryptoTest : public WvCdmTestBase { std::string iv_; }; -TEST_F(WvGenericCryptoTest, LoadSpecialKeys) { - holder_.SignAndLoadLicense(); -} +TEST_F(WvGenericCryptoTest, LoadSpecialKeys) { holder_.SignAndLoadLicense(); } TEST_F(WvGenericCryptoTest, GenericEncryptGood) { CdmResponseType cdm_sts; @@ -220,9 +218,9 @@ TEST_F(WvGenericCryptoTest, GenericVerifyKeyNotAllowed) { std::string signature = SignHMAC(in_buffer_, siggy_key_); holder_.SignAndLoadLicense(); - cdm_sts = cdm_engine_.GenericVerify(holder_.session_id(), in_buffer_, key_id, - wvcdm::kSigningAlgorithmHmacSha256, - signature); + cdm_sts = + cdm_engine_.GenericVerify(holder_.session_id(), in_buffer_, key_id, + wvcdm::kSigningAlgorithmHmacSha256, signature); EXPECT_EQ(UNKNOWN_ERROR, cdm_sts); } @@ -231,9 +229,9 @@ TEST_F(WvGenericCryptoTest, GenericVerifyBadSignautre) { std::string signature(MAC_KEY_SIZE, 's'); holder_.SignAndLoadLicense(); - cdm_sts = cdm_engine_.GenericVerify( - holder_.session_id(), in_buffer_, vou_id_, - wvcdm::kSigningAlgorithmHmacSha256, signature); + cdm_sts = + cdm_engine_.GenericVerify(holder_.session_id(), in_buffer_, vou_id_, + wvcdm::kSigningAlgorithmHmacSha256, signature); // OEMCrypto error is OEMCrypto_ERROR_SIGNATURE_FAILURE EXPECT_EQ(UNKNOWN_ERROR, cdm_sts); } diff --git a/libwvdrmengine/cdm/core/test/http_socket.cpp b/libwvdrmengine/cdm/core/test/http_socket.cpp index 74d1a6be..38610791 100644 --- a/libwvdrmengine/cdm/core/test/http_socket.cpp +++ b/libwvdrmengine/cdm/core/test/http_socket.cpp @@ -4,22 +4,22 @@ #include "http_socket.h" -#include #include #include #include #include +#include #ifdef _WIN32 -# include "winsock2.h" -# include "ws2tcpip.h" -# define ERROR_ASYNC_COMPLETE WSAEWOULDBLOCK +# include "winsock2.h" +# include "ws2tcpip.h" +# define ERROR_ASYNC_COMPLETE WSAEWOULDBLOCK #else -# include -# include -# include -# include -# define ERROR_ASYNC_COMPLETE EINPROGRESS +# include +# include +# include +# include +# define ERROR_ASYNC_COMPLETE EINPROGRESS #endif #include @@ -60,16 +60,15 @@ SSL_CTX* InitSslContext() { return ctx; } -static int LogBoringSslError( - const char* message, size_t length, void* /* user_data */) { +static int LogBoringSslError(const char* message, size_t length, + void* /* user_data */) { LOGE(" BoringSSL Error: %s", message); return length; } bool IsRetryableSslError(int ssl_error) { - return ssl_error != SSL_ERROR_ZERO_RETURN && - ssl_error != SSL_ERROR_SYSCALL && - ssl_error != SSL_ERROR_SSL; + return ssl_error != SSL_ERROR_ZERO_RETURN && ssl_error != SSL_ERROR_SYSCALL && + ssl_error != SSL_ERROR_SSL; } #if 0 @@ -262,8 +261,8 @@ bool HttpSocket::Connect(int timeout_in_ms) { hints.ai_flags = AI_NUMERICSERV | AI_ADDRCONFIG; struct addrinfo* addr_info = nullptr; - int ret = getaddrinfo(domain_name_.c_str(), port_.c_str(), &hints, - &addr_info); + int ret = + getaddrinfo(domain_name_.c_str(), port_.c_str(), &hints, &addr_info); if (ret != 0) { LOGE("getaddrinfo failed, errno = %d", ret); return false; @@ -308,7 +307,8 @@ bool HttpSocket::Connect(int timeout_in_ms) { } else { if (GetError() != ERROR_ASYNC_COMPLETE) { // failed right away. - LOGE("cannot connect to %s, errno = %d", domain_name_.c_str(), GetError()); + LOGE("cannot connect to %s, errno = %d", domain_name_.c_str(), + GetError()); CloseSocket(); return false; } else { diff --git a/libwvdrmengine/cdm/core/test/http_socket_test.cpp b/libwvdrmengine/cdm/core/test/http_socket_test.cpp index f4f99601..72a0d043 100644 --- a/libwvdrmengine/cdm/core/test/http_socket_test.cpp +++ b/libwvdrmengine/cdm/core/test/http_socket_test.cpp @@ -25,7 +25,7 @@ std::string gTestData("Hello"); // Arbitrary buffer size and timeout settings. const int kHttpBufferSize = 4096; const int kTimeout = 3000; -} +} // namespace class HttpSocketTest : public testing::Test { public: diff --git a/libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp b/libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp index 3af92cbf..b30d2c7b 100644 --- a/libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp @@ -501,7 +501,6 @@ class HlsParseTest : public ::testing::TestWithParam {}; class HlsTest : public ::testing::Test {}; - TEST_F(InitializationDataTest, BadType) { InitializationData init_data("bad", kWidevinePssh); EXPECT_TRUE(init_data.IsEmpty()); diff --git a/libwvdrmengine/cdm/core/test/license_keys_unittest.cpp b/libwvdrmengine/cdm/core/test/license_keys_unittest.cpp index b2e66d99..5c08bd11 100644 --- a/libwvdrmengine/cdm/core/test/license_keys_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/license_keys_unittest.cpp @@ -64,20 +64,15 @@ static const KeyId ck_NO_HDCP_dual_res = "ck_NO_HDCP_dual_res"; // protobuf generated classes. using video_widevine::License; using video_widevine::LicenseIdentification; -using video_widevine::STREAMING; using video_widevine::OFFLINE; +using video_widevine::STREAMING; using KeyContainer = ::video_widevine::License::KeyContainer; using VideoResolutionConstraint = KeyContainer::VideoResolutionConstraint; class LicenseKeysTest : public ::testing::Test { protected: - - enum KeyFlag { - kKeyFlagNull, - kKeyFlagFalse, - kKeyFlagTrue - }; + enum KeyFlag { kKeyFlagNull, kKeyFlagFalse, kKeyFlagTrue }; static const KeyFlag kEncryptNull = kKeyFlagNull; static const KeyFlag kEncryptFalse = kKeyFlagFalse; @@ -122,14 +117,15 @@ class LicenseKeysTest : public ::testing::Test { pro->set_hdcp(hdcp_value); } if (set_constraints) { - for (std::vector::iterator - it = constraints->begin(); it != constraints->end(); ++it) { + for (std::vector::iterator it = + constraints->begin(); + it != constraints->end(); ++it) { VideoResolutionConstraint* constraint = key->add_video_resolution_constraints(); constraint->set_min_resolution_pixels(it->min_resolution_pixels()); constraint->set_max_resolution_pixels(it->max_resolution_pixels()); - constraint->mutable_required_protection()-> - set_hdcp(it->required_protection().hdcp()); + constraint->mutable_required_protection()->set_hdcp( + it->required_protection().hdcp()); } } key->set_id(key_id); @@ -149,10 +145,12 @@ class LicenseKeysTest : public ::testing::Test { ->set_type(KeyContainer::ENTITLEMENT); } - virtual void AddOperatorSessionKey( - const KeyId& key_id, bool set_perms = false, - KeyFlag encrypt = kKeyFlagNull, KeyFlag decrypt = kKeyFlagNull, - KeyFlag sign = kKeyFlagNull, KeyFlag verify = kKeyFlagNull) { + virtual void AddOperatorSessionKey(const KeyId& key_id, + bool set_perms = false, + KeyFlag encrypt = kKeyFlagNull, + KeyFlag decrypt = kKeyFlagNull, + KeyFlag sign = kKeyFlagNull, + KeyFlag verify = kKeyFlagNull) { KeyContainer* non_content_key = license_.add_key(); non_content_key->set_type(KeyContainer::OPERATOR_SESSION); non_content_key->set_id(key_id); @@ -192,9 +190,9 @@ class LicenseKeysTest : public ::testing::Test { EXPECT_FALSE(key_usage.generic_verify); } - virtual void ExpectAllowedUsageOperator( - const CdmKeyAllowedUsage& key_usage, KeyFlag encrypt, KeyFlag decrypt, - KeyFlag sign, KeyFlag verify) { + virtual void ExpectAllowedUsageOperator(const CdmKeyAllowedUsage& key_usage, + KeyFlag encrypt, KeyFlag decrypt, + KeyFlag sign, KeyFlag verify) { EXPECT_FALSE(key_usage.decrypt_to_secure_buffer); EXPECT_FALSE(key_usage.decrypt_to_clear_buffer); EXPECT_EQ(key_usage.generic_encrypt, encrypt == kKeyFlagTrue); @@ -203,9 +201,7 @@ class LicenseKeysTest : public ::testing::Test { EXPECT_EQ(key_usage.generic_verify, verify == kKeyFlagTrue); } - virtual int NumContentKeys() { - return content_key_count_; - } + virtual int NumContentKeys() { return content_key_count_; } virtual void StageContentKeys() { content_key_count_ = 0; @@ -223,20 +219,20 @@ class LicenseKeysTest : public ::testing::Test { } virtual void StageOperatorSessionKeys() { - AddOperatorSessionKey(osk_decrypt, true, - kEncryptNull, kDecryptTrue, kSignNull, kVerifyNull); - AddOperatorSessionKey(osk_encrypt, true, - kEncryptTrue, kDecryptNull, kSignNull, kVerifyNull); - AddOperatorSessionKey(osk_sign, true, - kEncryptNull, kDecryptNull, kSignTrue, kVerifyNull); - AddOperatorSessionKey(osk_verify, true, - kEncryptNull, kDecryptNull, kSignNull, kVerifyTrue); - AddOperatorSessionKey(osk_encrypt_decrypt, true, - kEncryptTrue, kDecryptTrue, kSignNull, kVerifyNull); - AddOperatorSessionKey(osk_sign_verify, true, - kEncryptNull, kDecryptNull, kSignTrue, kVerifyTrue); - AddOperatorSessionKey(osk_all, true, - kEncryptTrue, kDecryptTrue, kSignTrue, kVerifyTrue); + AddOperatorSessionKey(osk_decrypt, true, kEncryptNull, kDecryptTrue, + kSignNull, kVerifyNull); + AddOperatorSessionKey(osk_encrypt, true, kEncryptTrue, kDecryptNull, + kSignNull, kVerifyNull); + AddOperatorSessionKey(osk_sign, true, kEncryptNull, kDecryptNull, kSignTrue, + kVerifyNull); + AddOperatorSessionKey(osk_verify, true, kEncryptNull, kDecryptNull, + kSignNull, kVerifyTrue); + AddOperatorSessionKey(osk_encrypt_decrypt, true, kEncryptTrue, kDecryptTrue, + kSignNull, kVerifyNull); + AddOperatorSessionKey(osk_sign_verify, true, kEncryptNull, kDecryptNull, + kSignTrue, kVerifyTrue); + AddOperatorSessionKey(osk_all, true, kEncryptTrue, kDecryptTrue, kSignTrue, + kVerifyTrue); license_keys_->SetFromLicense(license_); } @@ -310,10 +306,10 @@ class LicenseKeysTest : public ::testing::Test { constraints.clear(); AddConstraint(constraints, key_hi_res_min, key_hi_res_max); - AddContentKey( - ck_HDCP_NO_OUTPUT_hi_res, true, KeyContainer::SW_SECURE_CRYPTO, true, - KeyContainer::OutputProtection::HDCP_NO_DIGITAL_OUTPUT, true, - &constraints); + AddContentKey(ck_HDCP_NO_OUTPUT_hi_res, true, + KeyContainer::SW_SECURE_CRYPTO, true, + KeyContainer::OutputProtection::HDCP_NO_DIGITAL_OUTPUT, true, + &constraints); content_key_count_++; constraints.clear(); @@ -372,15 +368,12 @@ class LicenseKeysTest : public ::testing::Test { } } - size_t content_key_count_; std::unique_ptr license_keys_; License license_; }; -TEST_F(LicenseKeysTest, Empty) { - EXPECT_TRUE(license_keys_->Empty()); -} +TEST_F(LicenseKeysTest, Empty) { EXPECT_TRUE(license_keys_->Empty()); } TEST_F(LicenseKeysTest, NotEmpty) { const KeyId c_key = "content_key"; @@ -474,15 +467,15 @@ TEST_F(LicenseKeysTest, CanDecrypt) { EXPECT_FALSE(license_keys_->CanDecryptContent(e_key)); bool new_usable_keys = false; bool any_change = false; - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); EXPECT_TRUE(license_keys_->CanDecryptContent(c_key)); EXPECT_FALSE(license_keys_->CanDecryptContent(os_key)); - any_change = license_keys_->ApplyStatusChange(kKeyStatusExpired, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusExpired, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_FALSE(license_keys_->CanDecryptContent(c_key)); @@ -538,13 +531,13 @@ TEST_F(LicenseKeysTest, AllowedUsageContent) { CdmKeyAllowedUsage u_hw_decode; EXPECT_TRUE(license_keys_->GetAllowedUsage(ck_hw_decode, &u_hw_decode)); - ExpectAllowedUsageContent(u_hw_decode, kContentSecureTrue, - kContentClearFalse, kHardwareSecureDecode); + ExpectAllowedUsageContent(u_hw_decode, kContentSecureTrue, kContentClearFalse, + kHardwareSecureDecode); CdmKeyAllowedUsage u_hw_secure; EXPECT_TRUE(license_keys_->GetAllowedUsage(ck_hw_secure, &u_hw_secure)); - ExpectAllowedUsageContent(u_hw_secure, kContentSecureTrue, - kContentClearFalse, kHardwareSecureAll); + ExpectAllowedUsageContent(u_hw_secure, kContentSecureTrue, kContentClearFalse, + kHardwareSecureAll); } TEST_F(LicenseKeysTest, AllowedUsageOperatorSession) { @@ -570,8 +563,8 @@ TEST_F(LicenseKeysTest, AllowedUsageOperatorSession) { kVerifyTrue); CdmKeyAllowedUsage u_encrypt_decrypt; - EXPECT_TRUE(license_keys_->GetAllowedUsage(osk_encrypt_decrypt, - &u_encrypt_decrypt)); + EXPECT_TRUE( + license_keys_->GetAllowedUsage(osk_encrypt_decrypt, &u_encrypt_decrypt)); ExpectAllowedUsageOperator(u_encrypt_decrypt, kEncryptTrue, kDecryptTrue, kSignFalse, kVerifyFalse); @@ -609,8 +602,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) { ExpectKeyStatusesEqual(key_status_map, kKeyStatusInternalError); // change to pending - any_change = license_keys_->ApplyStatusChange(kKeyStatusPending, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusPending, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto)); @@ -622,7 +615,7 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) { // change to usable in future any_change = license_keys_->ApplyStatusChange(kKeyStatusUsableInFuture, - &new_usable_keys); + &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto)); @@ -633,8 +626,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) { ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsableInFuture); // change to usable - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); EXPECT_TRUE(license_keys_->CanDecryptContent(ck_sw_crypto)); @@ -645,8 +638,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) { ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsable); // change to usable (again) - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_FALSE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_TRUE(license_keys_->CanDecryptContent(ck_sw_crypto)); @@ -657,8 +650,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) { ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsable); // change to expired - any_change = license_keys_->ApplyStatusChange(kKeyStatusExpired, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusExpired, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto)); @@ -675,8 +668,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { CdmKeyStatusMap key_status_map; StageHdcpKeys(); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); EXPECT_TRUE(license_keys_->CanDecryptContent(ck_sw_crypto_NO_HDCP)); @@ -702,8 +695,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { EXPECT_TRUE(license_keys_->MeetsConstraints(ck_hw_secure_HDCP_NO_OUTPUT)); license_keys_->ApplyConstraints(100, HDCP_NONE); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); @@ -750,8 +743,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { kKeyStatusOutputNotAllowed); license_keys_->ApplyConstraints(100, HDCP_V1); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_FALSE(any_change); EXPECT_FALSE(new_usable_keys); @@ -798,8 +791,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { kKeyStatusOutputNotAllowed); license_keys_->ApplyConstraints(100, HDCP_V2_1); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -846,8 +839,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { kKeyStatusOutputNotAllowed); license_keys_->ApplyConstraints(100, HDCP_V2_2); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -894,8 +887,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { kKeyStatusOutputNotAllowed); license_keys_->ApplyConstraints(100, HDCP_V2_3); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -942,8 +935,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { kKeyStatusOutputNotAllowed); license_keys_->ApplyConstraints(100, HDCP_NO_DIGITAL_OUTPUT); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -982,8 +975,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) { kKeyStatusUsable); license_keys_->ApplyConstraints(100, HDCP_NONE); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); @@ -1037,8 +1030,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { StageConstraintKeys(); // No constraints set by device - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); EXPECT_TRUE(license_keys_->CanDecryptContent(ck_NO_HDCP_lo_res)); @@ -1057,8 +1050,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { // Low-res device, no HDCP support license_keys_->ApplyConstraints(dev_lo_res, HDCP_NONE); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); @@ -1098,8 +1091,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { // Hi-res device, HDCP_V1 support license_keys_->ApplyConstraints(dev_hi_res, HDCP_V1); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -1139,8 +1132,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { // Lo-res device, HDCP V2.2 support license_keys_->ApplyConstraints(dev_lo_res, HDCP_V2_2); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -1178,8 +1171,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { // Hi-res device, Maximal HDCP support license_keys_->ApplyConstraints(dev_hi_res, HDCP_NO_DIGITAL_OUTPUT); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -1217,8 +1210,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { // Lo-res device, no HDCP support license_keys_->ApplyConstraints(dev_lo_res, HDCP_NONE); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_TRUE(new_usable_keys); @@ -1239,10 +1232,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { EXPECT_TRUE(license_keys_->MeetsConstraints(ck_NO_HDCP_dual_res)); license_keys_->ExtractKeyStatuses(&key_status_map); - ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP, - kKeyStatusUsable); - ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP, - kKeyStatusUsable); + ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP, kKeyStatusUsable); + ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP, kKeyStatusUsable); ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_HDCP_V2_1, kKeyStatusOutputNotAllowed); ExpectKeyStatusEqual(key_status_map, ck_hw_secure_HDCP_V2_1, @@ -1262,8 +1253,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { // Too-high-res -- all keys rejected license_keys_->ApplyConstraints(dev_top_res, HDCP_NONE); - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); @@ -1282,10 +1273,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) { EXPECT_FALSE(license_keys_->MeetsConstraints(ck_NO_HDCP_dual_res)); license_keys_->ExtractKeyStatuses(&key_status_map); - ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP, - kKeyStatusUsable); - ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP, - kKeyStatusUsable); + ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP, kKeyStatusUsable); + ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP, kKeyStatusUsable); ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_HDCP_V2_1, kKeyStatusOutputNotAllowed); ExpectKeyStatusEqual(key_status_map, ck_hw_secure_HDCP_V2_1, @@ -1315,11 +1304,11 @@ struct KeySecurityLevelParams { }; KeySecurityLevelParams key_security_level_test_vectors[] = { - { kSecurityLevelUninitialized, false, false, false, false, false, false}, - { kSecurityLevelL1, true, true, true, true, true, true}, - { kSecurityLevelL2, true, true, true, true, false, false}, - { kSecurityLevelL3, true, true, true, false, false, false}, - { kSecurityLevelUnknown, false, false, false, false, false, false}, + {kSecurityLevelUninitialized, false, false, false, false, false, false}, + {kSecurityLevelL1, true, true, true, true, true, true}, + {kSecurityLevelL2, true, true, true, true, false, false}, + {kSecurityLevelL3, true, true, true, false, false, false}, + {kSecurityLevelUnknown, false, false, false, false, false, false}, }; class LicenseKeysSecurityLevelConstraintsTest @@ -1340,8 +1329,8 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) { ExpectKeyStatusesEqual(key_status_map, kKeyStatusInternalError); // change to pending - any_change = license_keys_->ApplyStatusChange(kKeyStatusPending, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusPending, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto)); @@ -1370,8 +1359,8 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) { ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsableInFuture); // change to usable - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_EQ(config->expect_usable_keys, new_usable_keys); EXPECT_EQ(config->expect_can_use_sw_crypto_key, @@ -1388,25 +1377,25 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) { license_keys_->ExtractKeyStatuses(&key_status_map); EXPECT_EQ(content_key_count_, key_status_map.size()); - EXPECT_EQ(config->expect_can_use_sw_crypto_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_sw_crypto_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_sw_crypto]); - EXPECT_EQ(config->expect_can_use_sw_decode_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_sw_decode_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_sw_decode]); - EXPECT_EQ(config->expect_can_use_hw_crypto_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_hw_crypto_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_hw_crypto]); - EXPECT_EQ(config->expect_can_use_hw_decode_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_hw_decode_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_hw_decode]); - EXPECT_EQ(config->expect_can_use_hw_secure_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_hw_secure_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_hw_secure]); // change to usable (again) - any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys); EXPECT_FALSE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_EQ(config->expect_can_use_sw_crypto_key, @@ -1422,25 +1411,25 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) { license_keys_->ExtractKeyStatuses(&key_status_map); EXPECT_EQ(content_key_count_, key_status_map.size()); - EXPECT_EQ(config->expect_can_use_sw_crypto_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_sw_crypto_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_sw_crypto]); - EXPECT_EQ(config->expect_can_use_sw_decode_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_sw_decode_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_sw_decode]); - EXPECT_EQ(config->expect_can_use_hw_crypto_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_hw_crypto_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_hw_crypto]); - EXPECT_EQ(config->expect_can_use_hw_decode_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_hw_decode_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_hw_decode]); - EXPECT_EQ(config->expect_can_use_hw_secure_key - ? kKeyStatusUsable : kKeyStatusOutputNotAllowed, + EXPECT_EQ(config->expect_can_use_hw_secure_key ? kKeyStatusUsable + : kKeyStatusOutputNotAllowed, key_status_map[ck_hw_secure]); // change to expired - any_change = license_keys_->ApplyStatusChange(kKeyStatusExpired, - &new_usable_keys); + any_change = + license_keys_->ApplyStatusChange(kKeyStatusExpired, &new_usable_keys); EXPECT_TRUE(any_change); EXPECT_FALSE(new_usable_keys); EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto)); diff --git a/libwvdrmengine/cdm/core/test/license_unittest.cpp b/libwvdrmengine/cdm/core/test/license_unittest.cpp index b780c0e6..c87d3373 100644 --- a/libwvdrmengine/cdm/core/test/license_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/license_unittest.cpp @@ -114,10 +114,7 @@ const std::string kLicenseRequestSignature = a2bs_hex( "9BEDB6CF3D8713F9E11675DF1F5DB9038DBBECAB9D1683F8722CAF6E18EC8C04AEE5"); const CryptoSession::SupportedCertificateTypes kDefaultSupportedCertTypes = { - true, - true, - true - }; + true, true, true}; const std::string kFakeEntitlementKeyId = a2bs_hex("2a538231c616c67143032a645f9c545d"); @@ -125,9 +122,9 @@ const std::string kFakeEntitledKeyId = a2bs_hex("f93c7a81e62d4e9a988ff20bca60f52d"); const std::string kFakeUnpaddedKey = a2bs_hex("b2047e7fab08b3a4dac76b7b82e8cd4d"); -const std::string kFakePaddedKey = - a2bs_hex("42f804e9ce0fa693692e1c4ffaeb0e14" - "10101010101010101010101010101010"); +const std::string kFakePaddedKey = a2bs_hex( + "42f804e9ce0fa693692e1c4ffaeb0e14" + "10101010101010101010101010101010"); const std::string kFakeKeyTooLong = a2bs_hex("d4bc8605d662878a46adb2adb6bf3c0b30a54a0c2f"); const std::string kFakeKeyTooShort = a2bs_hex("06e247e7f924208011"); @@ -136,7 +133,7 @@ const std::string kFakeIv = a2bs_hex("3d515a3ee0be1687080ac59da9e0d69a"); class MockCryptoSession : public TestCryptoSession { public: MockCryptoSession(metrics::CryptoMetrics* crypto_metrics) - : TestCryptoSession(crypto_metrics) { } + : TestCryptoSession(crypto_metrics) {} MOCK_METHOD0(IsOpen, bool()); MOCK_METHOD0(request_id, const std::string&()); MOCK_METHOD1(UsageInformationSupport, bool(bool*)); @@ -156,7 +153,8 @@ class MockPolicyEngine : public PolicyEngine { public: MockPolicyEngine(CryptoSession* crypto) : PolicyEngine("mock_session_id", nullptr, crypto) {} - MOCK_METHOD1(SetEntitledLicenseKeys, + MOCK_METHOD1( + SetEntitledLicenseKeys, void(const std::vector&)); }; @@ -176,11 +174,11 @@ class MockInitializationData : public InitializationData { } // namespace // Protobuf generated classes -using video_widevine::LicenseRequest_ContentIdentification; using video_widevine::ClientIdentification; using video_widevine::License; using video_widevine::License_KeyContainer; using video_widevine::LicenseRequest; +using video_widevine::LicenseRequest_ContentIdentification; using video_widevine::SignedMessage; using video_widevine::WidevinePsshData_EntitledKey; @@ -311,8 +309,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) { CryptoSession::HdcpCapability max_hdcp_version = HDCP_V2_1; uint32_t crypto_session_api_version = 9; - EXPECT_CALL(*crypto_session_, IsOpen()) - .WillOnce(Return(true)); + EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true)); EXPECT_CALL(*crypto_session_, request_id()) .WillOnce(ReturnRef(kCryptoRequestId)); EXPECT_CALL(*crypto_session_, UsageInformationSupport(NotNull())) @@ -334,16 +331,17 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) { DoAll(SetArgPointee<2>(kLicenseRequestSignature), Return(NO_ERROR))); CreateCdmLicense(); - EXPECT_TRUE(cdm_license_->Init( - kToken, kClientTokenDrmCert, kEmptyString, true, - kDefaultServiceCertificate, crypto_session_, policy_engine_)); + EXPECT_TRUE(cdm_license_->Init(kToken, kClientTokenDrmCert, kEmptyString, + true, kDefaultServiceCertificate, + crypto_session_, policy_engine_)); CdmAppParameterMap app_parameters; CdmKeyMessage signed_request; std::string server_url; - EXPECT_EQ(cdm_license_->PrepareKeyRequest( - *init_data_, kLicenseTypeStreaming, app_parameters, - &signed_request, &server_url), KEY_MESSAGE); + EXPECT_EQ(cdm_license_->PrepareKeyRequest(*init_data_, kLicenseTypeStreaming, + app_parameters, &signed_request, + &server_url), + KEY_MESSAGE); EXPECT_TRUE(!signed_request.empty()); @@ -363,16 +361,16 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) { // Verify Client Identification const ClientIdentification& client_id = license_request.client_id(); - EXPECT_EQ(video_widevine:: - ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE, - client_id.type()); + EXPECT_EQ( + video_widevine::ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE, + client_id.type()); EXPECT_TRUE(std::equal(client_id.token().begin(), client_id.token().end(), kToken.begin())); EXPECT_LT(0, client_id.client_info_size()); for (int i = 0; i < client_id.client_info_size(); ++i) { - const ::video_widevine::ClientIdentification_NameValue& - name_value = client_id.client_info(i); + const ::video_widevine::ClientIdentification_NameValue& name_value = + client_id.client_info(i); EXPECT_TRUE(!name_value.name().empty()); EXPECT_TRUE(!name_value.value().empty()); } @@ -419,8 +417,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) { EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_NEW, license_request.type()); EXPECT_EQ(kLicenseStartTime, license_request.request_time()); - EXPECT_EQ(video_widevine::VERSION_2_1, - license_request.protocol_version()); + EXPECT_EQ(video_widevine::VERSION_2_1, license_request.protocol_version()); EXPECT_EQ(kNonce, license_request.key_control_nonce()); } @@ -431,8 +428,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) { uint32_t crypto_session_api_version = 15; uint32_t resource_rating_tier = RESOURCE_RATING_TIER_LOW; - EXPECT_CALL(*crypto_session_, IsOpen()) - .WillOnce(Return(true)); + EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true)); EXPECT_CALL(*crypto_session_, request_id()) .WillOnce(ReturnRef(kCryptoRequestId)); EXPECT_CALL(*crypto_session_, UsageInformationSupport(NotNull())) @@ -447,8 +443,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) { .WillRepeatedly( DoAll(SetArgPointee<0>(crypto_session_api_version), Return(true))); EXPECT_CALL(*crypto_session_, GetResourceRatingTier(NotNull())) - .WillOnce( - DoAll(SetArgPointee<0>(resource_rating_tier), Return(true))); + .WillOnce(DoAll(SetArgPointee<0>(resource_rating_tier), Return(true))); EXPECT_CALL(*clock_, GetCurrentTime()).WillOnce(Return(kLicenseStartTime)); EXPECT_CALL(*crypto_session_, GenerateNonce(NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kNonce), Return(NO_ERROR))); @@ -457,16 +452,17 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) { DoAll(SetArgPointee<2>(kLicenseRequestSignature), Return(NO_ERROR))); CreateCdmLicense(); - EXPECT_TRUE(cdm_license_->Init( - kToken, kClientTokenDrmCert, kEmptyString, true, - kDefaultServiceCertificate, crypto_session_, policy_engine_)); + EXPECT_TRUE(cdm_license_->Init(kToken, kClientTokenDrmCert, kEmptyString, + true, kDefaultServiceCertificate, + crypto_session_, policy_engine_)); CdmAppParameterMap app_parameters; CdmKeyMessage signed_request; std::string server_url; - EXPECT_EQ(cdm_license_->PrepareKeyRequest( - *init_data_, kLicenseTypeStreaming, app_parameters, - &signed_request, &server_url), KEY_MESSAGE); + EXPECT_EQ(cdm_license_->PrepareKeyRequest(*init_data_, kLicenseTypeStreaming, + app_parameters, &signed_request, + &server_url), + KEY_MESSAGE); EXPECT_TRUE(!signed_request.empty()); @@ -486,16 +482,16 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) { // Verify Client Identification const ClientIdentification& client_id = license_request.client_id(); - EXPECT_EQ(video_widevine:: - ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE, - client_id.type()); + EXPECT_EQ( + video_widevine::ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE, + client_id.type()); EXPECT_TRUE(std::equal(client_id.token().begin(), client_id.token().end(), kToken.begin())); EXPECT_LT(0, client_id.client_info_size()); for (int i = 0; i < client_id.client_info_size(); ++i) { - const ::video_widevine::ClientIdentification_NameValue& - name_value = client_id.client_info(i); + const ::video_widevine::ClientIdentification_NameValue& name_value = + client_id.client_info(i); EXPECT_TRUE(!name_value.name().empty()); EXPECT_TRUE(!name_value.value().empty()); } @@ -521,8 +517,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) { ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048, video_widevine:: ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072)); - EXPECT_EQ(resource_rating_tier, - client_capabilities.resource_rating_tier()); + EXPECT_EQ(resource_rating_tier, client_capabilities.resource_rating_tier()); // Verify Content Identification const LicenseRequest_ContentIdentification& content_id = @@ -543,17 +538,14 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) { EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_NEW, license_request.type()); EXPECT_EQ(kLicenseStartTime, license_request.request_time()); - EXPECT_EQ(video_widevine::VERSION_2_1, - license_request.protocol_version()); + EXPECT_EQ(video_widevine::VERSION_2_1, license_request.protocol_version()); EXPECT_EQ(kNonce, license_request.key_control_nonce()); } struct EntitledKeyVariant { EntitledKeyVariant(const char* name, const std::string& key, bool should_succeed) - : name(name), - key(key), - should_succeed(should_succeed) {} + : name(name), key(key), should_succeed(should_succeed) {} const std::string name; const std::string key; const bool should_succeed; @@ -586,26 +578,22 @@ TEST_P(CdmLicenseEntitledKeyTest, LoadsEntitledKeys) { padded_key.set_iv(kFakeIv); // Set the expected downstream calls - EXPECT_CALL(*crypto_session_, IsOpen()) - .WillOnce(Return(true)); + EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true)); if (variant.should_succeed) { EXPECT_CALL(*crypto_session_, LoadEntitledContentKeys(_)) - .WillOnce(Return(KEY_ADDED)); - EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_)) - .Times(1); + .WillOnce(Return(KEY_ADDED)); + EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_)).Times(1); } else { - EXPECT_CALL(*crypto_session_, LoadEntitledContentKeys(_)) - .Times(0); - EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_)) - .Times(0); + EXPECT_CALL(*crypto_session_, LoadEntitledContentKeys(_)).Times(0); + EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_)).Times(0); } // Set up the CdmLicense with the mocks and fake entitlement key CreateCdmLicense(); - EXPECT_TRUE(cdm_license_->Init( - kToken, kClientTokenDrmCert, kEmptyString, true, - kDefaultServiceCertificate, crypto_session_, policy_engine_)); + EXPECT_TRUE(cdm_license_->Init(kToken, kClientTokenDrmCert, kEmptyString, + true, kDefaultServiceCertificate, + crypto_session_, policy_engine_)); cdm_license_->set_entitlement_keys(entitlement_license); // Call the function under test and check its return value @@ -620,11 +608,10 @@ TEST_P(CdmLicenseEntitledKeyTest, LoadsEntitledKeys) { INSTANTIATE_TEST_CASE_P( EntitledKeyTests, CdmLicenseEntitledKeyTest, - Values( - EntitledKeyVariant("UnpaddedKey", kFakeUnpaddedKey, true), - EntitledKeyVariant("PaddedKey", kFakePaddedKey, true), - EntitledKeyVariant("KeyTooLong", kFakeKeyTooLong, true), - EntitledKeyVariant("KeyTooShort", kFakeKeyTooShort, false)), + Values(EntitledKeyVariant("UnpaddedKey", kFakeUnpaddedKey, true), + EntitledKeyVariant("PaddedKey", kFakePaddedKey, true), + EntitledKeyVariant("KeyTooLong", kFakeKeyTooLong, true), + EntitledKeyVariant("KeyTooShort", kFakeKeyTooShort, false)), PrintToStringParamName()); } // namespace wvcdm diff --git a/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp b/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp index 853b1b30..83296e16 100644 --- a/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp @@ -10,8 +10,8 @@ #include "crypto_session.h" #include "license.h" #include "metrics_collections.h" -#include "policy_engine.h" #include "mock_clock.h" +#include "policy_engine.h" #include "test_base.h" #include "test_printers.h" #include "wv_cdm_event_listener.h" @@ -27,12 +27,12 @@ namespace wvcdm { using License = ::video_widevine::License; using KeyContainer = ::video_widevine::License::KeyContainer; using OutputProtection = - ::video_widevine::License::KeyContainer::OutputProtection; + ::video_widevine::License::KeyContainer::OutputProtection; using VideoResolutionConstraint = - ::video_widevine::License::KeyContainer::VideoResolutionConstraint; + ::video_widevine::License::KeyContainer::VideoResolutionConstraint; using KeyList = ::google::protobuf::RepeatedPtrField; using ConstraintList = - ::google::protobuf::RepeatedPtrField; + ::google::protobuf::RepeatedPtrField; using namespace testing; @@ -55,8 +55,8 @@ const uint32_t kTargetRes1 = (kMinRes1 + kMaxRes1) / 2; const uint32_t kTargetRes2 = (kMinRes2 + kMaxRes2) / 2; const uint32_t kTargetRes3 = kMaxRes2 + 1000; -const int64_t kRentalDuration = 604800; // 7 days -const int64_t kPlaybackDuration = 172800; // 48 hours +const int64_t kRentalDuration = 604800; // 7 days +const int64_t kPlaybackDuration = 172800; // 48 hours const int64_t kStreamingLicenseDuration = 300; const OutputProtection::HDCP kHdcpV2 = OutputProtection::HDCP_V2; @@ -68,7 +68,7 @@ const int64_t kHdcpInterval = 10; class HdcpOnlyMockCryptoSession : public TestCryptoSession { public: HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* crypto_metrics) - : TestCryptoSession(crypto_metrics) { } + : TestCryptoSession(crypto_metrics) {} MOCK_METHOD2(GetHdcpCapabilities, CdmResponseType(HdcpCapability*, HdcpCapability*)); @@ -88,17 +88,15 @@ class MockCdmEventListener : public WvCdmEventListener { class PolicyEngineConstraintsTest : public WvCdmTestBase { public: - PolicyEngineConstraintsTest() : - crypto_session_(&dummy_metrics_) { - } + PolicyEngineConstraintsTest() : crypto_session_(&dummy_metrics_) {} protected: void SetUp() override { WvCdmTestBase::SetUp(); current_time_ = 0; - policy_engine_.reset(new PolicyEngine(kSessionId, &mock_event_listener_, - &crypto_session_)); + policy_engine_.reset( + new PolicyEngine(kSessionId, &mock_event_listener_, &crypto_session_)); InjectMockClock(); SetupLicense(); @@ -194,11 +192,11 @@ class PolicyEngineConstraintsTest : public WvCdmTestBase { bool expected_has_new_usable_key) { EXPECT_CALL(mock_event_listener_, OnSessionKeysChange( - kSessionId, UnorderedElementsAre( - Pair(kKeyId1, expected_key_status), - Pair(kKeyId2, expected_key_status), - Pair(kKeyId3, expected_key_status), - Pair(kKeyId4, expected_key_status)), + kSessionId, + UnorderedElementsAre(Pair(kKeyId1, expected_key_status), + Pair(kKeyId2, expected_key_status), + Pair(kKeyId3, expected_key_status), + Pair(kKeyId4, expected_key_status)), expected_has_new_usable_key)); } @@ -207,14 +205,13 @@ class PolicyEngineConstraintsTest : public WvCdmTestBase { const KeyId& k3, CdmKeyStatus expected_3, const KeyId& k4, CdmKeyStatus expected_4, bool expected_has_new_usable_key) { - EXPECT_CALL(mock_event_listener_, - OnSessionKeysChange( - kSessionId, UnorderedElementsAre( - Pair(k1, expected_1), - Pair(k2, expected_2), - Pair(k3, expected_3), - Pair(k4, expected_4)), - expected_has_new_usable_key)); + EXPECT_CALL( + mock_event_listener_, + OnSessionKeysChange( + kSessionId, + UnorderedElementsAre(Pair(k1, expected_1), Pair(k2, expected_2), + Pair(k3, expected_3), Pair(k4, expected_4)), + expected_has_new_usable_key)); } std::unique_ptr policy_engine_; @@ -232,16 +229,14 @@ TEST_F(PolicyEngineConstraintsTest, IsPermissiveWithoutAResolution) { { Sequence key_change; - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusOutputNotAllowed, - kKeyId3, kKeyStatusUsable, - kKeyId4, kKeyStatusOutputNotAllowed, true); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3, + kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true); } EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); policy_engine_->OnTimerEvent(); @@ -257,24 +252,23 @@ TEST_F(PolicyEngineConstraintsTest, IsPermissiveWithoutAResolution) { TEST_F(PolicyEngineConstraintsTest, HandlesResolutionsBasedOnConstraints) { { Sequence time; - for (int i=0; i<4; ++i) { - EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time) + for (int i = 0; i < 4; ++i) { + EXPECT_CALL(*mock_clock_, GetCurrentTime()) + .InSequence(time) .WillOnce(Return(i * 10)); } } { Sequence key_change; ExpectSessionKeysChange(kKeyStatusUsable, true); - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusUsable, - kKeyId3, kKeyStatusOutputNotAllowed, - kKeyId4, kKeyStatusOutputNotAllowed, false); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusUsable, kKeyId3, + kKeyStatusOutputNotAllowed, kKeyId4, kKeyStatusOutputNotAllowed, false); } EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(NO_ERROR))); + DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), Return(NO_ERROR))); policy_engine_->SetLicense(license_); policy_engine_->NotifyResolution(1, kTargetRes1); @@ -315,35 +309,28 @@ TEST_F(PolicyEngineConstraintsTest, { Sequence key_change; - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusOutputNotAllowed, - kKeyId3, kKeyStatusUsable, - kKeyId4, kKeyStatusOutputNotAllowed, true); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3, + kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillOnce( - DoAll(SetArgPointee<0>(HDCP_V2_2), - Return(GET_HDCP_CAPABILITY_FAILED))) - .WillOnce( - DoAll(SetArgPointee<0>(HDCP_V2_2), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2), + Return(GET_HDCP_CAPABILITY_FAILED))) + .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2), + Return(GET_HDCP_CAPABILITY_FAILED))); } int64_t start_time = current_time_ + 5; { InSequence calls; EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillOnce( - DoAll(SetArgPointee<0>(HDCP_V2_2), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2), + Return(GET_HDCP_CAPABILITY_FAILED))); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(start_time + kHdcpInterval / 2)) .WillOnce(Return(start_time + kHdcpInterval)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillOnce( - DoAll(SetArgPointee<0>(HDCP_V2_2), - Return(GET_HDCP_CAPABILITY_FAILED))) - .WillOnce( - DoAll(SetArgPointee<0>(HDCP_V2_2), - Return(NO_ERROR))); + .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2), + Return(GET_HDCP_CAPABILITY_FAILED))) + .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2), Return(NO_ERROR))); } policy_engine_->NotifyResolution(1, kTargetRes1); @@ -354,8 +341,7 @@ TEST_F(PolicyEngineConstraintsTest, } TEST_F(PolicyEngineConstraintsTest, DoesNotRequestHdcpWithoutALicense) { - EXPECT_CALL(*mock_clock_, GetCurrentTime()) - .WillOnce(Return(0)); + EXPECT_CALL(*mock_clock_, GetCurrentTime()).WillOnce(Return(0)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)).Times(0); policy_engine_->OnTimerEvent(); @@ -364,24 +350,22 @@ TEST_F(PolicyEngineConstraintsTest, DoesNotRequestHdcpWithoutALicense) { TEST_F(PolicyEngineConstraintsTest, HandlesConstraintOverridingHdcp) { { Sequence time; - for (int i=0; i<3; ++i) { - EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time) + for (int i = 0; i < 3; ++i) { + EXPECT_CALL(*mock_clock_, GetCurrentTime()) + .InSequence(time) .WillOnce(Return(i * 10)); } } { Sequence key_change; ExpectSessionKeysChange(kKeyStatusUsable, true); - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusUsable, - kKeyId3, kKeyStatusOutputNotAllowed, - kKeyId4, kKeyStatusOutputNotAllowed, false); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusUsable, kKeyId3, + kKeyStatusOutputNotAllowed, kKeyId4, kKeyStatusOutputNotAllowed, false); } EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_V2), - Return(NO_ERROR))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_V2), Return(NO_ERROR))); policy_engine_->SetLicense(license_); policy_engine_->NotifyResolution(1, kTargetRes1); @@ -406,27 +390,24 @@ TEST_F(PolicyEngineConstraintsTest, HandlesConstraintOverridingHdcp) { TEST_F(PolicyEngineConstraintsTest, HandlesNoHdcp) { { Sequence time; - for (int i=0; i<3; ++i) { - EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time) + for (int i = 0; i < 3; ++i) { + EXPECT_CALL(*mock_clock_, GetCurrentTime()) + .InSequence(time) .WillOnce(Return(i * 10)); } } { Sequence key_change; - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusOutputNotAllowed, - kKeyId3, kKeyStatusUsable, - kKeyId4, kKeyStatusOutputNotAllowed, true); - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusOutputNotAllowed, - kKeyId3, kKeyStatusOutputNotAllowed, - kKeyId4, kKeyStatusOutputNotAllowed, false); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3, + kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3, + kKeyStatusOutputNotAllowed, kKeyId4, kKeyStatusOutputNotAllowed, false); } EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NONE), - Return(NO_ERROR))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NONE), Return(NO_ERROR))); policy_engine_->SetLicense(license_); @@ -452,26 +433,25 @@ TEST_F(PolicyEngineConstraintsTest, HandlesNoHdcp) { TEST_F(PolicyEngineConstraintsTest, UsesDefaultHdcpWhenResolutionNotSet) { { Sequence time; - for (int i=0; i<2; ++i) { - EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time) + for (int i = 0; i < 2; ++i) { + EXPECT_CALL(*mock_clock_, GetCurrentTime()) + .InSequence(time) .WillOnce(Return(i * 10)); } } { Sequence key_change; - ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable, - kKeyId2, kKeyStatusOutputNotAllowed, - kKeyId3, kKeyStatusUsable, - kKeyId4, kKeyStatusOutputNotAllowed, true); + ExpectSessionKeysChanges( + kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3, + kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true); } EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); policy_engine_->OnTimerEvent(); diff --git a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp index 8c14a457..649900ed 100644 --- a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp @@ -16,8 +16,8 @@ #include "policy_engine.h" #include "test_base.h" #include "test_printers.h" -#include "wv_cdm_event_listener.h" #include "wv_cdm_constants.h" +#include "wv_cdm_event_listener.h" namespace wvcdm { @@ -25,10 +25,10 @@ using namespace testing; namespace { const int64_t kDurationUnlimited = 0; -const int64_t kLicenseStartTime = 1413517500; // ~ 01/01/2013 +const int64_t kLicenseStartTime = 1413517500; // ~ 01/01/2013 const int64_t kPlaybackStartTime = kLicenseStartTime + 5; -const int64_t kRentalDuration = 604800; // 7 days -const int64_t kPlaybackDuration = 172800; // 48 hours +const int64_t kRentalDuration = 604800; // 7 days +const int64_t kPlaybackDuration = 172800; // 48 hours const int64_t kLicenseDuration = kRentalDuration + kPlaybackDuration; const int64_t kLicenseRenewalPeriod = 120; // 2 minutes const int64_t kLicenseRenewalRetryInterval = 30; // 30 seconds @@ -53,13 +53,13 @@ int64_t GetLicenseRenewalDelay(int64_t license_duration) { class HdcpOnlyMockCryptoSession : public TestCryptoSession { public: - HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics) : - TestCryptoSession(metrics) {} + HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics) + : TestCryptoSession(metrics) {} MOCK_METHOD2(GetHdcpCapabilities, CdmResponseType(HdcpCapability*, HdcpCapability*)); CdmResponseType DoRealGetHdcpCapabilities(HdcpCapability* current, - HdcpCapability* max) { + HdcpCapability* max) { return CryptoSession::GetHdcpCapabilities(current, max); } }; @@ -80,8 +80,8 @@ class MockCdmEventListener : public WvCdmEventListener { using video_widevine::License; using video_widevine::License_Policy; using video_widevine::LicenseIdentification; -using video_widevine::STREAMING; using video_widevine::OFFLINE; +using video_widevine::STREAMING; // gmock methods using ::testing::_; @@ -96,14 +96,13 @@ using ::testing::UnorderedElementsAre; class PolicyEngineTest : public WvCdmTestBase { public: - PolicyEngineTest() : crypto_session_(&dummy_metrics_) { - } + PolicyEngineTest() : crypto_session_(&dummy_metrics_) {} + protected: void SetUp() override { WvCdmTestBase::SetUp(); policy_engine_.reset( - new PolicyEngine(kSessionId, &mock_event_listener_, - &crypto_session_)); + new PolicyEngine(kSessionId, &mock_event_listener_, &crypto_session_)); InjectMockClock(); license_.set_license_start_time(kLicenseStartTime); @@ -134,10 +133,9 @@ class PolicyEngineTest : public WvCdmTestBase { policy->set_renew_with_usage(false); ON_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillByDefault( - Invoke( - &crypto_session_, - &HdcpOnlyMockCryptoSession::DoRealGetHdcpCapabilities)); + .WillByDefault( + Invoke(&crypto_session_, + &HdcpOnlyMockCryptoSession::DoRealGetHdcpCapabilities)); } void InjectMockClock() { @@ -147,32 +145,33 @@ class PolicyEngineTest : public WvCdmTestBase { void ExpectSessionKeysChange(CdmKeyStatus expected_key_status, bool expected_has_new_usable_key) { - EXPECT_CALL(mock_event_listener_, - OnSessionKeysChange( - kSessionId, UnorderedElementsAre( - Pair(kKeyId, expected_key_status)), - expected_has_new_usable_key)); + EXPECT_CALL( + mock_event_listener_, + OnSessionKeysChange( + kSessionId, UnorderedElementsAre(Pair(kKeyId, expected_key_status)), + expected_has_new_usable_key)); } void ExpectSessionKeysChange(CdmKeyStatus expected_key_status, bool expected_has_new_usable_key, KeyId expected_keyid) { EXPECT_CALL(mock_event_listener_, - OnSessionKeysChange( - kSessionId, UnorderedElementsAre( - Pair(expected_keyid, expected_key_status)), - expected_has_new_usable_key)); + OnSessionKeysChange(kSessionId, + UnorderedElementsAre(Pair( + expected_keyid, expected_key_status)), + expected_has_new_usable_key)); } void ExpectSessionKeysChange(CdmKeyStatus expected_key1_status, CdmKeyStatus expected_key2_status, bool expected_has_new_usable_key) { - EXPECT_CALL(mock_event_listener_, - OnSessionKeysChange( - kSessionId, UnorderedElementsAre( - Pair(kKeyId, expected_key1_status), - Pair(kAnotherKeyId, expected_key2_status)), - expected_has_new_usable_key)); + EXPECT_CALL( + mock_event_listener_, + OnSessionKeysChange( + kSessionId, + UnorderedElementsAre(Pair(kKeyId, expected_key1_status), + Pair(kAnotherKeyId, expected_key2_status)), + expected_has_new_usable_key)); } void SetCdmSecurityLevel(CdmSecurityLevel security_level) { @@ -206,8 +205,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense) { EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(NO_ERROR))); + DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), Return(NO_ERROR))); policy_engine_->SetLicense(license_); policy_engine_->BeginDecryption(); @@ -231,8 +229,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_EntitlementLicense) { EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(NO_ERROR))); + DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), Return(NO_ERROR))); License::KeyContainer* key = license_.mutable_key(0); key->set_type(License::KeyContainer::ENTITLEMENT); @@ -298,9 +295,8 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_StreamingLicense) { OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); policy_engine_->BeginDecryption(); @@ -321,9 +317,8 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanPlayFalse) { ExpectSessionKeysChange(kKeyStatusExpired, false); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId)); @@ -346,9 +341,8 @@ TEST_F(PolicyEngineTest, LicenseExpired_RentalDurationExpiredWithoutPlayback) { .WillOnce(Return(kLicenseStartTime + kLowDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -381,9 +375,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDurationPassedWithPlayback) { .WillOnce(Return(kLicenseStartTime + kLowDuration + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -416,9 +409,8 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) { .WillOnce(Return(playback_start_time + kPlaybackDuration + 2)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -453,9 +445,8 @@ TEST_F(PolicyEngineTest, LicenseExpired_LicenseDurationExpiredWithoutPlayback) { .WillOnce(Return(kLicenseStartTime + kLowDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -489,9 +480,8 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Offline) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -529,9 +519,8 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Streaming) { .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -564,9 +553,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0) { .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -601,9 +589,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackDuration0) { .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 2)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -640,9 +627,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseDuration0) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -682,9 +668,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0) { OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); policy_engine_->BeginDecryption(); @@ -741,8 +726,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndLicense0_WithPlayback) { .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10)); ExpectSessionKeysChange(kKeyStatusUsable, true); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, 0)); + EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, 0)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); @@ -866,14 +850,12 @@ TEST_F(PolicyEngineTest, PlaybackOk_Durations0) { EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, NEVER_EXPIRES)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -894,9 +876,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime) { .WillOnce(Return(kPlaybackStartTime)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsableInFuture, false); @@ -933,9 +914,8 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -979,9 +959,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) { kLicenseRenewalRetryInterval + 10)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1036,9 +1015,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) { .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 60)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1093,9 +1071,8 @@ TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated) { .WillOnce(Return(kLicenseStartTime + kLowDuration + 10)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1156,9 +1133,8 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) { .WillOnce(Return(kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1217,9 +1193,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 20)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1292,9 +1267,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) { .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 200)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1351,9 +1325,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) { .WillOnce(Return(kLicenseStartTime + 40)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1414,9 +1387,8 @@ TEST_F(PolicyEngineTest, MultipleKeysInLicense) { .WillOnce(Return(kLicenseStartTime + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _)); @@ -1441,9 +1413,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_SoftEnforcePlaybackDuration) { .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1479,9 +1450,8 @@ TEST_F(PolicyEngineTest, LicenseExpired_SoftEnforceLoadBeforeExpire) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1508,9 +1478,8 @@ TEST_F(PolicyEngineTest, LicenseExpired_SoftEnforceLoadAfterExpire) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1542,9 +1511,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriod) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1586,9 +1554,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriodWithLoad) { .WillOnce(Return(kNewPlaybackStartTime + kPlaybackDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1629,9 +1596,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriodWithExpiredLoad) { .WillOnce(Return(kNewPlaybackStartTime)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1661,9 +1627,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_CanStoreGracePeriod) { .WillOnce(Return(kPlaybackStartTime + kGracePeriod + 2)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); InSequence seq; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -1692,20 +1657,19 @@ struct KeySecurityLevelParams { }; KeySecurityLevelParams key_security_test_vectors[] = { - { false, License::KeyContainer::HW_SECURE_ALL, true, true, true, true }, - { true, License::KeyContainer::SW_SECURE_CRYPTO, true, true, true, false }, - { true, License::KeyContainer::SW_SECURE_DECODE, true, true, true, false }, - { true, License::KeyContainer::HW_SECURE_CRYPTO, true, true, false, false }, - { true, License::KeyContainer::HW_SECURE_DECODE, true, false, false, false }, - { true, License::KeyContainer::HW_SECURE_ALL, true, false, false, false }, + {false, License::KeyContainer::HW_SECURE_ALL, true, true, true, true}, + {true, License::KeyContainer::SW_SECURE_CRYPTO, true, true, true, false}, + {true, License::KeyContainer::SW_SECURE_DECODE, true, true, true, false}, + {true, License::KeyContainer::HW_SECURE_CRYPTO, true, true, false, false}, + {true, License::KeyContainer::HW_SECURE_DECODE, true, false, false, false}, + {true, License::KeyContainer::HW_SECURE_ALL, true, false, false, false}, }; class PolicyEngineKeySecurityLevelTest - : public PolicyEngineTest, - public ::testing::WithParamInterface {}; + : public PolicyEngineTest, + public ::testing::WithParamInterface {}; TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLevel) { - KeySecurityLevelParams* param = GetParam(); license_.clear_key(); @@ -1747,18 +1711,13 @@ TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLevel) { policy_engine_->CanUseKeyForSecurityLevel(kKeyId)); } -INSTANTIATE_TEST_CASE_P( - PolicyEngine, PolicyEngineKeySecurityLevelTest, - ::testing::Range(&key_security_test_vectors[0], - &key_security_test_vectors[5])); +INSTANTIATE_TEST_CASE_P(PolicyEngine, PolicyEngineKeySecurityLevelTest, + ::testing::Range(&key_security_test_vectors[0], + &key_security_test_vectors[5])); class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest { protected: - enum KeyFlag { - kKeyFlagNull, - kKeyFlagFalse, - kKeyFlagTrue - }; + enum KeyFlag { kKeyFlagNull, kKeyFlagFalse, kKeyFlagTrue }; static const KeyFlag kEncryptNull = kKeyFlagNull; static const KeyFlag kEncryptFalse = kKeyFlagFalse; @@ -1778,7 +1737,6 @@ class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest { static const KeyFlag kContentClearFalse = kKeyFlagFalse; static const KeyFlag kContentClearTrue = kKeyFlagTrue; - void ExpectAllowedContentKeySettings(const CdmKeyAllowedUsage& key_usage, KeyFlag secure, KeyFlag clear, CdmKeySecurityLevel key_security_level) { @@ -1854,7 +1812,6 @@ class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest { }; TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) { - const KeyId kGenericKeyId = "oper_session_key"; license_.clear_key(); @@ -1883,9 +1840,8 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) { .WillOnce(Return(kLicenseStartTime + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _)); @@ -1894,8 +1850,8 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) { ExpectSecureContentKey(kKeyId, kHardwareSecureAll); ExpectLessSecureContentKey(kAnotherKeyId, kKeySecurityLevelUnset); - ExpectOperatorSessionKey(kGenericKeyId, kEncryptNull, kDecryptNull, - kSignTrue, kVerifyNull); + ExpectOperatorSessionKey(kGenericKeyId, kEncryptNull, kDecryptNull, kSignTrue, + kVerifyNull); CdmKeyAllowedUsage key_usage; EXPECT_EQ(KEY_NOT_FOUND_1, @@ -1903,7 +1859,6 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) { } TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) { - const KeyId kGenericEncryptKeyId = "oper_session_key_1"; const KeyId kGenericDecryptKeyId = "oper_session_key_2"; const KeyId kGenericSignKeyId = "oper_session_key_3"; @@ -1945,9 +1900,8 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) { .WillOnce(Return(kLicenseStartTime + 1)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _)); @@ -2014,9 +1968,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess) { .WillOnce(Return(kLicenseStartTime + 100)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2041,9 +1994,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) { .WillOnce(Return(kLicenseStartTime + 200)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2082,9 +2034,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) { .WillOnce(Return(kLicenseStartTime + 200)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2136,9 +2087,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Offline) { .WillOnce(Return(kLicenseStartTime + 300)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2223,9 +2173,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) { .WillOnce(Return(kLicenseStartTime + 100)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId)); @@ -2263,9 +2212,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) { .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2306,9 +2254,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) { .WillOnce(Return(playback_start_time + 5 + kLowDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2345,9 +2292,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) { .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2388,9 +2334,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) { .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2434,9 +2379,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) { .WillOnce(Return(kLicenseStartTime + kHighDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2454,8 +2398,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - EXPECT_EQ(0, - std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); EXPECT_EQ(LLONG_MAX, std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); @@ -2472,8 +2415,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - EXPECT_EQ(0, - std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); EXPECT_EQ(LLONG_MAX, std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); @@ -2491,9 +2433,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) { .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2566,7 +2507,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0) { EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } -TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndLicense0_WithoutPlayback) { +TEST_F(PolicyEngineQueryTest, + QuerySuccess_PlaybackAndLicense0_WithoutPlayback) { License_Policy* policy = license_.mutable_policy(); policy->set_rental_duration_seconds(kRentalDuration); policy->set_playback_duration_seconds(kDurationUnlimited); @@ -2793,8 +2735,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalAndLicense0_WithPlayback) { EXPECT_EQ(LLONG_MAX, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); - EXPECT_EQ(10, - std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); + EXPECT_EQ(10, std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); policy_engine_->OnTimerEvent(); @@ -2808,10 +2749,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalAndLicense0_WithPlayback) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - EXPECT_EQ(0, - std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); - EXPECT_EQ(0, - std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); + EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -2830,9 +2769,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Durations0) { .WillOnce(Return(kLicenseStartTime + kHighDuration + 15)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2868,9 +2806,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) { .WillOnce(Return(kLicenseStartTime + 25)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2924,9 +2861,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Renew) { kLicenseRenewalRetryInterval + 15)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -2982,9 +2918,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) { kLicenseRenewalRetryInterval + 40)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); @@ -3062,9 +2997,8 @@ TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense) { OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)) - .WillRepeatedly( - DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), - Return(GET_HDCP_CAPABILITY_FAILED))); + .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), + Return(GET_HDCP_CAPABILITY_FAILED))); policy_engine_->SetLicense(license_); policy_engine_->BeginDecryption(); diff --git a/libwvdrmengine/cdm/core/test/test_base.cpp b/libwvdrmengine/cdm/core/test/test_base.cpp index c6ed69bd..acc08317 100644 --- a/libwvdrmengine/cdm/core/test/test_base.cpp +++ b/libwvdrmengine/cdm/core/test/test_base.cpp @@ -65,7 +65,8 @@ void show_menu(char* prog_name) { << std::endl; std::cout << " --service_certificate=" << std::endl; - std::cout << " configure the signed license service certificate" << std::endl; + std::cout << " configure the signed license service certificate" + << std::endl; std::cout << " Specify the SignedDeviceCertificate (from " << "device_certificate.proto) " << std::endl; std::cout << " in hex format." << std::endl; @@ -77,11 +78,14 @@ void show_menu(char* prog_name) { std::cout << " adb push run_request_license_test.sh /system/bin" << std::endl; std::cout << " adb shell sh /system/bin/run_request_license_test.sh" - << std::endl << std::endl; + << std::endl + << std::endl; std::cout << " --provisioning_certificate=" << std::endl; - std::cout << " configure the signed provisioning service certificate" << std::endl - << " in hex" << std::endl << std::endl; + std::cout << " configure the signed provisioning service certificate" + << std::endl + << " in hex" << std::endl + << std::endl; std::cout << " --license_server_url=" << std::endl; std::cout << " configure the license server url, please include http[s]" @@ -89,9 +93,10 @@ void show_menu(char* prog_name) { << std::endl; std::cout << " --provisioning_server_url=" << std::endl; - std::cout << " configure the provisioning server url, please include http[s]" - << " in the url" << std::endl - << std::endl; + std::cout + << " configure the provisioning server url, please include http[s]" + << " in the url" << std::endl + << std::endl; } /* @@ -391,7 +396,7 @@ void WvCdmTestBase::EnsureProvisioned() { ASSERT_EQ(NO_ERROR, cdm_engine.CloseSession(session_id)); } -bool WvCdmTestBase::Initialize(int argc, char **argv) { +bool WvCdmTestBase::Initialize(int argc, char** argv) { Properties::Init(); bool is_cast_receiver = false; bool force_load_test_keybox = false; // TODO(fredgc): obsolete. remove. @@ -411,7 +416,8 @@ bool WvCdmTestBase::Initialize(int argc, char **argv) { } else { const auto index = arg.find('='); if (index == std::string::npos) { - std::cerr << "Argument values need to be specified using --arg=foo" << std::endl; + std::cerr << "Argument values need to be specified using --arg=foo" + << std::endl; show_usage = true; break; } @@ -487,9 +493,7 @@ TestLicenseHolder::TestLicenseHolder(CdmEngine* cdm_engine) enc_key_(CONTENT_KEY_SIZE, 'e'), session_key_(CONTENT_KEY_SIZE, 'f') {} -TestLicenseHolder::~TestLicenseHolder() { - CloseSession(); -} +TestLicenseHolder::~TestLicenseHolder() { CloseSession(); } void TestLicenseHolder::OpenSession(const std::string& key_system) { CdmResponseType status = @@ -640,9 +644,8 @@ void TestLicenseHolder::SignAndLoadLicense() { CdmKeySetId key_set_id; CdmLicenseType license_type; // Required for AddKey. Result value ignored. - EXPECT_EQ(KEY_ADDED, - cdm_engine_->AddKey(session_id_, response_data, - &license_type, &key_set_id)); + EXPECT_EQ(KEY_ADDED, cdm_engine_->AddKey(session_id_, response_data, + &license_type, &key_set_id)); } void TestLicenseHolder::DeriveKeysFromSessionKey() { diff --git a/libwvdrmengine/cdm/core/test/url_request.cpp b/libwvdrmengine/cdm/core/test/url_request.cpp index 8419266a..456eba49 100644 --- a/libwvdrmengine/cdm/core/test/url_request.cpp +++ b/libwvdrmengine/cdm/core/test/url_request.cpp @@ -82,7 +82,7 @@ UrlRequest::UrlRequest(const std::string& url) UrlRequest::~UrlRequest() {} void UrlRequest::Reconnect() { - for(uint32_t i = 0; i < kMaxConnectAttempts && !is_connected_; ++i) { + for (uint32_t i = 0; i < kMaxConnectAttempts && !is_connected_; ++i) { socket_.CloseSocket(); if (socket_.Connect(kConnectTimeoutMs)) { is_connected_ = true; diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp index fa95419d..5af2ac7c 100644 --- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp @@ -120,28 +120,28 @@ const size_t kUsageInfoFileArraySize = ArraySize(kUsageInfoFileArray); std::vector kUsageInfoFileList; const DeviceFiles::CdmUsageData kCdmUsageData1 = { - /* provider_session_token = */ "provider_session_token_1", - /* license_request = */ "license_request_1", - /* license = */ "license_1", - /* key_set_id = */ "key_set_id_1", - /* usage_entry = */ "usage_entry_1", - /* usage_entry_number = */ 0, + /* provider_session_token = */ "provider_session_token_1", + /* license_request = */ "license_request_1", + /* license = */ "license_1", + /* key_set_id = */ "key_set_id_1", + /* usage_entry = */ "usage_entry_1", + /* usage_entry_number = */ 0, }; const DeviceFiles::CdmUsageData kCdmUsageData2 = { - /* provider_session_token = */ "provider_session_token_2", - /* license_request = */ "license_request_2", - /* license = */ "license_2", - /* key_set_id = */ "key_set_id_2", - /* usage_entry = */ "usage_entry_2", - /* usage_entry_number = */ 0, + /* provider_session_token = */ "provider_session_token_2", + /* license_request = */ "license_request_2", + /* license = */ "license_2", + /* key_set_id = */ "key_set_id_2", + /* usage_entry = */ "usage_entry_2", + /* usage_entry_number = */ 0, }; const DeviceFiles::CdmUsageData kCdmUsageData3 = { - /* provider_session_token = */ "provider_session_token_3", - /* license_request = */ "license_request_3", - /* license = */ "license_3", - /* key_set_id = */ "key_set_id_3", - /* usage_entry = */ "usage_entry_3", - /* usage_entry_number = */ 0, + /* provider_session_token = */ "provider_session_token_3", + /* license_request = */ "license_request_3", + /* license = */ "license_3", + /* key_set_id = */ "key_set_id_3", + /* usage_entry = */ "usage_entry_3", + /* usage_entry_number = */ 0, }; const std::vector kEmptyUsageInfoUsageDataList; @@ -216,8 +216,8 @@ void InitVectorConstants() { } } -void ToVector(std::vector& vec, - const CdmUsageEntryInfo* arr, size_t total_size) { +void ToVector(std::vector& vec, const CdmUsageEntryInfo* arr, + size_t total_size) { size_t max = total_size / sizeof(CdmUsageEntryInfo); vec.clear(); for (size_t i = 0; i < max; i++) { @@ -250,8 +250,7 @@ class MockDeviceFiles : public DeviceFiles { const std::string&, const CdmUsageEntry&, uint32_t)); MOCK_METHOD2(RetrieveUsageInfo, bool(const std::string&, std::vector*)); - MOCK_METHOD1(ListLicenses, - bool(std::vector* key_set_ids)); + MOCK_METHOD1(ListLicenses, bool(std::vector* key_set_ids)); MOCK_METHOD1(ListUsageInfoFiles, bool(std::vector* usage_info_files)); @@ -279,10 +278,10 @@ class MockCryptoSession : public TestCryptoSession { // Partial mock of the UsageTableHeader. This is to test when dependency // exist on internal methods which would require complex expectations class MockUsageTableHeader : public UsageTableHeader { - public: - MockUsageTableHeader() : UsageTableHeader() {} - MOCK_METHOD3(DeleteEntry, CdmResponseType(uint32_t, DeviceFiles*, - metrics::CryptoMetrics*)); + public: + MockUsageTableHeader() : UsageTableHeader() {} + MOCK_METHOD3(DeleteEntry, CdmResponseType(uint32_t, DeviceFiles*, + metrics::CryptoMetrics*)); }; } // namespace @@ -307,9 +306,7 @@ using ::testing::UnorderedElementsAreArray; class UsageTableHeaderTest : public WvCdmTestBase { public: - static void SetUpTestCase() { - InitVectorConstants(); - } + static void SetUpTestCase() { InitVectorConstants(); } // Useful when UsageTableHeader is mocked void DeleteEntry(uint32_t usage_entry_number, DeviceFiles*, @@ -388,10 +385,7 @@ class UsageTableHeaderInitializationTest : public UsageTableHeaderTest, public ::testing::WithParamInterface { public: - static void SetUpTestCase() { - InitVectorConstants(); - } - + static void SetUpTestCase() { InitVectorConstants(); } }; TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) { @@ -400,11 +394,10 @@ TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) { SetArgPointee<1>(kEmptyUsageEntryInfoVector), Return(false))); EXPECT_CALL(*device_files_, ListLicenses(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList), - Return(false))); + .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList), Return(false))); EXPECT_CALL(*device_files_, ListUsageInfoFiles(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList), - Return(false))); + .WillOnce( + DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList), Return(false))); EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) .WillOnce( DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); @@ -422,16 +415,15 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) { SetArgPointee<1>(kEmptyUsageEntryInfoVector), Return(false))); EXPECT_CALL(*device_files_, ListLicenses(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(kLicenseList), - Return(true))); + .WillOnce(DoAll(SetArgPointee<0>(kLicenseList), Return(true))); EXPECT_CALL(*device_files_, ListUsageInfoFiles(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList), - Return(false))); + .WillOnce( + DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList), Return(false))); EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) .WillOnce( DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); // TODO: Why not being called? - //EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true)); + // EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader, kEmptyUsageEntryInfoVector)) .Times(2) @@ -448,11 +440,9 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) { SetArgPointee<1>(kEmptyUsageEntryInfoVector), Return(false))); EXPECT_CALL(*device_files_, ListLicenses(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList), - Return(false))); + .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList), Return(false))); EXPECT_CALL(*device_files_, ListUsageInfoFiles(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(kUsageInfoFileList), - Return(true))); + .WillOnce(DoAll(SetArgPointee<0>(kUsageInfoFileList), Return(true))); EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) .WillOnce( DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); @@ -463,8 +453,8 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) { for (size_t i = 0; i < kUsageInfoFileList.size(); ++i) { EXPECT_CALL(*device_files_, RetrieveUsageInfo(kUsageInfoFileList[i], NotNull())) - .WillOnce(DoAll(SetArgPointee<1>(kEmptyUsageInfoUsageDataList), - Return(false))); + .WillOnce(DoAll(SetArgPointee<1>(kEmptyUsageInfoUsageDataList), + Return(false))); } EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -485,8 +475,7 @@ TEST_P(UsageTableHeaderInitializationTest, 200UsageEntries) { usage_entries_200.resize(200); EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), - SetArgPointee<1>(usage_entries_200), - Return(true))); + SetArgPointee<1>(usage_entries_200), Return(true))); EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); @@ -498,12 +487,12 @@ TEST_P(UsageTableHeaderInitializationTest, EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(k201UsageEntryInfoVector), - Return(true))); + Return(true))); SecurityLevel security_level = (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; - EXPECT_CALL(*crypto_session_, - Open(security_level)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(security_level)) + .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) @@ -533,7 +522,7 @@ TEST_P(UsageTableHeaderInitializationTest, EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(k201UsageEntryInfoVector), - Return(true))); + Return(true))); EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) @@ -549,22 +538,20 @@ TEST_P(UsageTableHeaderInitializationTest, // Expectations for AddEntry uint32_t expect_usage_entry_number = k201UsageEntryInfoVector.size(); EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number), - Return(NO_ERROR))); - EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, - usage_entries_202)) + .WillOnce( + DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); + EXPECT_CALL(*device_files_, + StoreUsageTableInfo(kUsageTableHeader, usage_entries_202)) .WillOnce(Return(true)); // Expectations for DeleteEntry SecurityLevel security_level = (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; - EXPECT_CALL(*crypto_session_, - Open(security_level)) + EXPECT_CALL(*crypto_session_, Open(security_level)) .Times(2) .WillRepeatedly(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) .WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -578,36 +565,33 @@ TEST_P(UsageTableHeaderInitializationTest, EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(k201UsageEntryInfoVector), - Return(true))); + Return(true))); EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); // Expectations for AddEntry uint32_t expect_usage_entry_number = k201UsageEntryInfoVector.size(); EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) - .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number), - Return(NO_ERROR))); - EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, - usage_entries_202)) + .WillOnce( + DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); + EXPECT_CALL(*device_files_, + StoreUsageTableInfo(kUsageTableHeader, usage_entries_202)) .WillOnce(Return(true)); // Expectations for DeleteEntry SecurityLevel security_level = (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; - EXPECT_CALL(*crypto_session_, - Open(security_level)) + EXPECT_CALL(*crypto_session_, Open(security_level)) .Times(2) .WillRepeatedly(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) .WillOnce( DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, - StoreUsageTableInfo( - kAnotherUsageTableHeader, - SizeIs(k201UsageEntryInfoVector.size()))) + StoreUsageTableInfo(kAnotherUsageTableHeader, + SizeIs(k201UsageEntryInfoVector.size()))) .WillOnce(Return(true)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -756,7 +740,7 @@ TEST_F(UsageTableHeaderTest, std::vector usage_entry_info_vector_at_start = k10UsageEntryInfoVector; - uint32_t usage_entry_number_first_to_be_deleted; // randomly choosen + uint32_t usage_entry_number_first_to_be_deleted; // randomly chosen std::vector final_usage_entries; uint32_t expected_usage_entry_number = k10UsageEntryInfoVector.size() - 1; @@ -770,9 +754,8 @@ TEST_F(UsageTableHeaderTest, EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) .WillOnce(Return(INSUFFICIENT_CRYPTO_RESOURCES_3)) - .WillOnce( - DoAll(SetArgPointee<0>(expected_usage_entry_number), - Return(NO_ERROR))); + .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number), + Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, _)) .WillOnce(DoAll(SaveArg<1>(&final_usage_entries), Return(true))); @@ -812,8 +795,8 @@ TEST_F(UsageTableHeaderTest, std::vector usage_entry_info_vector_at_start = k10UsageEntryInfoVector; - uint32_t usage_entry_number_first_to_be_deleted; // randomly choosen - uint32_t usage_entry_number_second_to_be_deleted; // randomly choosen + uint32_t usage_entry_number_first_to_be_deleted; // randomly chosen + uint32_t usage_entry_number_second_to_be_deleted; // randomly chosen std::vector final_usage_entries; uint32_t expected_usage_entry_number = k10UsageEntryInfoVector.size() - 2; @@ -831,9 +814,8 @@ TEST_F(UsageTableHeaderTest, EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) .WillOnce(Return(INSUFFICIENT_CRYPTO_RESOURCES_3)) .WillOnce(Return(INSUFFICIENT_CRYPTO_RESOURCES_3)) - .WillOnce( - DoAll(SetArgPointee<0>(expected_usage_entry_number), - Return(NO_ERROR))); + .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number), + Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, _)) .WillOnce(DoAll(SaveArg<1>(&final_usage_entries), Return(true))); @@ -878,9 +860,9 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsThrice) { std::vector usage_entry_info_vector_at_start = k10UsageEntryInfoVector; - uint32_t usage_entry_number_first_to_be_deleted; // randomly choosen - uint32_t usage_entry_number_second_to_be_deleted; // randomly choosen - uint32_t usage_entry_number_third_to_be_deleted; // randomly choosen + uint32_t usage_entry_number_first_to_be_deleted; // randomly chosen + uint32_t usage_entry_number_second_to_be_deleted; // randomly chosen + uint32_t usage_entry_number_third_to_be_deleted; // randomly chosen std::vector final_usage_entries; // Setup expectations @@ -1000,9 +982,8 @@ TEST_F(UsageTableHeaderTest, EXPECT_CALL(*mock_usage_table_header, DeleteEntry(_, device_files_, NotNull())) .Times(1) - .WillRepeatedly( - DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry), - Return(NO_ERROR))); + .WillRepeatedly(DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry), + Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, LoadUsageEntry(usage_entry_number_to_load, usage_entry_to_load)) @@ -1010,11 +991,9 @@ TEST_F(UsageTableHeaderTest, .WillOnce(Return(NO_ERROR)); // Now invoke the method under test - EXPECT_EQ(NO_ERROR, - mock_usage_table_header->LoadEntry( - crypto_session_, - usage_entry_to_load, - usage_entry_number_to_load)); + EXPECT_EQ(NO_ERROR, mock_usage_table_header->LoadEntry( + crypto_session_, usage_entry_to_load, + usage_entry_number_to_load)); } TEST_F(UsageTableHeaderTest, @@ -1033,9 +1012,8 @@ TEST_F(UsageTableHeaderTest, EXPECT_CALL(*mock_usage_table_header, DeleteEntry(_, device_files_, NotNull())) .Times(2) - .WillRepeatedly( - DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry), - Return(NO_ERROR))); + .WillRepeatedly(DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry), + Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, LoadUsageEntry(usage_entry_number_to_load, usage_entry_to_load)) @@ -1044,11 +1022,9 @@ TEST_F(UsageTableHeaderTest, .WillOnce(Return(NO_ERROR)); // Now invoke the method under test - EXPECT_EQ(NO_ERROR, - mock_usage_table_header->LoadEntry( - crypto_session_, - usage_entry_to_load, - usage_entry_number_to_load)); + EXPECT_EQ(NO_ERROR, mock_usage_table_header->LoadEntry( + crypto_session_, usage_entry_to_load, + usage_entry_number_to_load)); } TEST_F(UsageTableHeaderTest, LoadEntry_LoadUsageEntryFailsThrice) { @@ -1066,9 +1042,8 @@ TEST_F(UsageTableHeaderTest, LoadEntry_LoadUsageEntryFailsThrice) { EXPECT_CALL(*mock_usage_table_header, DeleteEntry(_, device_files_, NotNull())) .Times(3) - .WillRepeatedly( - DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry), - Return(NO_ERROR))); + .WillRepeatedly(DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry), + Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, LoadUsageEntry(usage_entry_number_to_load, usage_entry_to_load)) @@ -1076,11 +1051,10 @@ TEST_F(UsageTableHeaderTest, LoadEntry_LoadUsageEntryFailsThrice) { .WillRepeatedly(Return(INSUFFICIENT_CRYPTO_RESOURCES_3)); // Now invoke the method under test - EXPECT_EQ(INSUFFICIENT_CRYPTO_RESOURCES_3, - mock_usage_table_header->LoadEntry( - crypto_session_, - usage_entry_to_load, - usage_entry_number_to_load)); + EXPECT_EQ( + INSUFFICIENT_CRYPTO_RESOURCES_3, + mock_usage_table_header->LoadEntry(crypto_session_, usage_entry_to_load, + usage_entry_number_to_load)); } TEST_F(UsageTableHeaderTest, DeleteEntry_InvalidUsageEntryNumber) { @@ -1198,7 +1172,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastOfflineEntry) { // # of usage entries 4 3 TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntry) { std::vector usage_entry_info_vector; - const CdmUsageEntryInfo usage_entry_info_array[] = { + const CdmUsageEntryInfo usage_entry_info_array[] = { kUsageEntryInfoOfflineLicense1, kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoSecureStop2}; ToVector(usage_entry_info_vector, usage_entry_info_array, @@ -2352,8 +2326,7 @@ TEST_F(UsageTableHeaderTest, StaleHeader) { EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), - SetArgPointee<1>(usage_entry_info_vector), - Return(true))); + SetArgPointee<1>(usage_entry_info_vector), Return(true))); EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) .WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW)); EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))