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

clang-format core/test files

Browse Source 
[ 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
This commit is contained in:
Rahul Frias
2019-10-16 16:48:50 -07:00
parent 0acde10d1a
commit 2e22e2321e
18 changed files with 776 additions and 946 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libwvdrmengine/cdm/core/test/buffer_reader_test.cpp
View File

@@ -2,9 +2,9 @@
// source code may only be used and distributed under the Widevine Master
// License Agreement.
#include <string>
#include <errno.h>
#include <gtest/gtest.h>
#include <string>
#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

355
libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp
View File

@@ -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<EngineMetrics> 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::string>*, std::vector<std::string>*));
MOCK_METHOD4(ListUsageIds,
CdmResponseType(const std::string&, CdmSecurityLevel,
std::vector<std::string>*,
std::vector<std::string>*));
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<StrictMock<MockCdmEngineImpl>>(
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<const CdmSessionId&>(Eq("bar")), Eq(&event_listener)))
EXPECT_CALL(
*test_cdm_metrics_engine_,
OpenSession(StrEq("foo"), Eq(&property_set),
Matcher<const CdmSessionId&>(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<CdmSessionId*>(Eq(&session_id))))
OpenSession(StrEq("foo"), Eq(&property_set), Eq(&event_listener),
Matcher<CdmSessionId*>(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<std::string> 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

49
libwvdrmengine/cdm/core/test/cdm_engine_test.cpp
View File

@@ -11,15 +11,15 @@
#include <string>
#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<uint8_t> binary_hash{ 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0xFF };
std::vector<uint8_t> 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

59
libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
View File

@@ -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);
}

20
libwvdrmengine/cdm/core/test/config_test_env.cpp
View File

@@ -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;
}
}

8
libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp
View File

@@ -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<const char *>(kOemCert),
std::string oem_cert(reinterpret_cast<const char*>(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<uint32_t *>(key_data);
uint32_t* data = reinterpret_cast<uint32_t*>(key_data);
uint32_t system_id = htonl(data[1]);
return system_id;
}

32
libwvdrmengine/cdm/core/test/device_files_unittest.cpp
View File

@@ -2064,9 +2064,9 @@ class DeviceFilesSecurityLevelTest
: public DeviceFilesTest,
public ::testing::WithParamInterface<CdmSecurityLevel> {};
class DeviceFilesUsageInfoListTest
: public DeviceFilesTest,
public ::testing::WithParamInterface<int> {};
class DeviceFilesUsageInfoListTest : public DeviceFilesTest,
public ::testing::WithParamInterface<int> {
};
class DeviceFilesUsageInfoTest : public DeviceFilesTest,
public ::testing::WithParamInterface<int> {};
@@ -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<std::string> key_set_ids;
std::vector<std::string> 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);
}
}

16
libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp
View File

@@ -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);
}

34
libwvdrmengine/cdm/core/test/http_socket.cpp
View File

@@ -4,22 +4,22 @@
#include "http_socket.h"
#include <cstring>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#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 <netdb.h>
# include <netinet/in.h>
# include <sys/socket.h>
# include <unistd.h>
# define ERROR_ASYNC_COMPLETE EINPROGRESS
# include <netdb.h>
# include <netinet/in.h>
# include <sys/socket.h>
# include <unistd.h>
# define ERROR_ASYNC_COMPLETE EINPROGRESS
#endif
#include <openssl/bio.h>
@@ -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 {

2
libwvdrmengine/cdm/core/test/http_socket_test.cpp
View File

@@ -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:

1
libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp
View File

@@ -501,7 +501,6 @@ class HlsParseTest : public ::testing::TestWithParam<HlsAttributeVariant> {};
class HlsTest : public ::testing::Test {};
TEST_F(InitializationDataTest, BadType) {
InitializationData init_data("bad", kWidevinePssh);
EXPECT_TRUE(init_data.IsEmpty());

255
libwvdrmengine/cdm/core/test/license_keys_unittest.cpp
View File

@@ -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<VideoResolutionConstraint>::iterator
it = constraints->begin(); it != constraints->end(); ++it) {
for (std::vector<VideoResolutionConstraint>::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<LicenseKeys> 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));

115
libwvdrmengine/cdm/core/test/license_unittest.cpp
View File

@@ -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<video_widevine::WidevinePsshData_EntitledKey>&));
};
@@ -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

164
libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp
View File

@@ -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<KeyContainer>;
using ConstraintList =
::google::protobuf::RepeatedPtrField<VideoResolutionConstraint>;
::google::protobuf::RepeatedPtrField<VideoResolutionConstraint>;
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<PolicyEngine> 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();

370
libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
View File

@@ -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<KeySecurityLevelParams*> {};
: public PolicyEngineTest,
public ::testing::WithParamInterface<KeySecurityLevelParams*> {};
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();

33
libwvdrmengine/cdm/core/test/test_base.cpp
View File

@@ -65,7 +65,8 @@ void show_menu(char* prog_name) {
<< std::endl;
std::cout << " --service_certificate=<cert>" << 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=<cert>" << 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=<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=<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() {

2
libwvdrmengine/cdm/core/test/url_request.cpp
View File

@@ -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;

203
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -120,28 +120,28 @@ const size_t kUsageInfoFileArraySize = ArraySize(kUsageInfoFileArray);
std::vector<std::string> 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<DeviceFiles::CdmUsageData> kEmptyUsageInfoUsageDataList;
@@ -216,8 +216,8 @@ void InitVectorConstants() {
}
}
void ToVector(std::vector<CdmUsageEntryInfo>& vec,
const CdmUsageEntryInfo* arr, size_t total_size) {
void ToVector(std::vector<CdmUsageEntryInfo>& 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<CdmUsageData>*));
MOCK_METHOD1(ListLicenses,
bool(std::vector<std::string>* key_set_ids));
MOCK_METHOD1(ListLicenses, bool(std::vector<std::string>* key_set_ids));
MOCK_METHOD1(ListUsageInfoFiles,
bool(std::vector<std::string>* 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<CdmSecurityLevel> {
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<CdmUsageEntryInfo> 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<CdmUsageEntryInfo> 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<CdmUsageEntryInfo> 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<CdmUsageEntryInfo> 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<CdmUsageEntryInfo> 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<CdmUsageEntryInfo> 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<CdmUsageEntryInfo> 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()))