From a75ff4d57031d97bd565b55fc83b26e43d74132e Mon Sep 17 00:00:00 2001 From: tengfan Date: Thu, 26 Dec 2024 10:21:45 +0800 Subject: [PATCH 01/15] DRM_UT Signed-off-by: tengfan --- media/base/BUILD.gn | 2 + .../ohos_media_drm_bridge_client_unittest.cc | 39 +++++++++++ ...ohos_media_drm_bridge_delegate_unittest.cc | 42 ++++++++++++ media/mojo/services/BUILD.gn | 1 + .../ohos_mojo_media_client_unittests.cc | 66 +++++++++++++++++++ 5 files changed, 150 insertions(+) create mode 100644 media/base/ohos/ohos_media_drm_bridge_client_unittest.cc create mode 100644 media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc create mode 100644 media/mojo/services/ohos_mojo_media_client_unittests.cc diff --git a/media/base/BUILD.gn b/media/base/BUILD.gn index 6886ed6b5c..1453409b2b 100644 --- a/media/base/BUILD.gn +++ b/media/base/BUILD.gn @@ -693,6 +693,8 @@ source_set("unit_tests") { "ohos/ohos_media_player_bridge_unittest.cc", "ohos/ohos_media_player_callback_unittest.cc", "ohos/ohos_media_player_listener_unittest.cc", + "ohos/ohos_media_drm_bridge_client_unittest.cc", + "ohos/ohos_media_drm_bridge_delegate_unittest.cc", ] } diff --git a/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc new file mode 100644 index 0000000000..1cc1ceca26 --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc @@ -0,0 +1,39 @@ +#include "media/base/ohos/ohos_media_drm_bridge_client.h" +#include "media/base/ohos/ohos_media_drm_bridge_delegate.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { + +class SetMediaDrmBridgeClientTest : public ::testing::Test { + protected: + SetMediaDrmBridgeClientTest() = default; + ~SetMediaDrmBridgeClientTest() override = default; + + void SetUp() override { + media_drm_bridge_client = std::make_unique(); + } + + void TearDown() override { media_drm_bridge_client.reset(); } + std::unique_ptr media_drm_bridge_client; +}; + +TEST_F(SetMediaDrmBridgeClientTest, SetMediaDrmBridgeClient) { + SetMediaDrmBridgeClient(media_drm_bridge_client.get()); + EXPECT_NE(media_drm_bridge_client.get(), nullptr); +} + +TEST_F(SetMediaDrmBridgeClientTest, GetMediaDrmBridgeDelegate) { + std::vector scheme_uuid; + UUID test_scheme_uuid(scheme_uuid); + OHOSMediaDrmBridgeDelegate* result = + media_drm_bridge_client->GetMediaDrmBridgeDelegate(test_scheme_uuid); + EXPECT_EQ(result, nullptr); +} + +TEST_F(SetMediaDrmBridgeClientTest, AddKeySystemUUIDMappings) { + OHOSMediaDrmBridgeClient::KeySystemUuidMap key_system_uuid_map; + media_drm_bridge_client->AddKeySystemUUIDMappings(&key_system_uuid_map); + EXPECT_TRUE(key_system_uuid_map.empty()); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc new file mode 100644 index 0000000000..c82efd2a92 --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc @@ -0,0 +1,42 @@ +#include "media/base/ohos/ohos_media_drm_bridge_delegate.h" +#include "media/base/ohos/ohos_media_drm_bridge_client.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +using ::testing::_; + +namespace media { + +class MockOHOSMediaDrmBridgeDelegate : public OHOSMediaDrmBridgeDelegate { + public: + MOCK_METHOD(const UUID, GetUUID, (), (const override)); +}; + +class OHOSMediaDrmBridgeDelegateTest : public ::testing::Test { + protected: + OHOSMediaDrmBridgeDelegateTest() = default; + ~OHOSMediaDrmBridgeDelegateTest() override = default; + void SetUp() override { + mock_delegate = + std::make_unique(); + } + + void TearDown() override { + mock_delegate.reset(); + delegate.reset(); + } + std::unique_ptr delegate; + std::unique_ptr mock_delegate; +}; + +TEST_F(OHOSMediaDrmBridgeDelegateTest, OnCreateSession) { + delegate = std::move(mock_delegate); + EmeInitDataType init_data_type = EmeInitDataType::WEBM; + std::vector init_data = {0x01, 0x02, 0x03}; + std::vector init_data_out; + std::vector optional_parameters_out; + bool result = false; + result = delegate->OnCreateSession( + init_data_type, init_data, &init_data_out, &optional_parameters_out); + EXPECT_TRUE(result); +} +} // namespace media diff --git a/media/mojo/services/BUILD.gn b/media/mojo/services/BUILD.gn index 1c022dff17..6a5dbf40b8 100644 --- a/media/mojo/services/BUILD.gn +++ b/media/mojo/services/BUILD.gn @@ -248,6 +248,7 @@ source_set("unit_tests") { "watch_time_recorder_unittest.cc", "webrtc_video_perf_history_unittest.cc", "webrtc_video_perf_recorder_unittest.cc", + "ohos_mojo_media_client_unittests.cc", ] if (enable_playback_events_recorder) { diff --git a/media/mojo/services/ohos_mojo_media_client_unittests.cc b/media/mojo/services/ohos_mojo_media_client_unittests.cc new file mode 100644 index 0000000000..5d80240c57 --- /dev/null +++ b/media/mojo/services/ohos_mojo_media_client_unittests.cc @@ -0,0 +1,66 @@ +#include "media/base/audio_decoder.h" +#include "media/base/media_log.h" +#include "media/base/ohos/ohos_cdm_factory.h" +#include "media/mojo/mojom/frame_interface_factory.mojom.h" +#include "media/mojo/services/ohos_mojo_media_client.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { +class MockFrameInterfaceFactory : public mojom::FrameInterfaceFactory { + public: + MOCK_METHOD( + void, + CreateProvisionFetcher, + (mojo::PendingReceiver provision_fetcher), + (override)); + + MOCK_METHOD(void, + CreateCdmStorage, + (mojo::PendingReceiver cdm_storage), + (override)); + + MOCK_METHOD(bool, GetCdmOrigin, (::url::Origin * out_cdm_origin), (override)); + + MOCK_METHOD(void, GetCdmOrigin, (GetCdmOriginCallback callback), (override)); + + MOCK_METHOD(void, + BindEmbedderReceiver, + (mojo::GenericPendingReceiver receiver), + (override)); +}; + +class OhosMojoMediaClientTest : public ::testing::Test { + protected: + OhosMojoMediaClientTest() = default; + ~OhosMojoMediaClientTest() override = default; + + void SetUp() override { + client = std::make_unique(); + Mock_frame_interfaces = std::make_unique(); + } + + void TearDown() override { + client.reset(); + frame_interfaces.reset(); + Mock_frame_interfaces.reset(); + } + std::unique_ptr frame_interfaces; + std::unique_ptr client; + std::unique_ptr Mock_frame_interfaces; +}; + +TEST_F(OhosMojoMediaClientTest, CreateAudioDecoder) { + scoped_refptr task_runner = nullptr; + std::unique_ptr media_log = nullptr; + auto audio_decoder = + client->CreateAudioDecoder(task_runner, std::move(media_log)); + ASSERT_EQ(audio_decoder, nullptr); +} + +TEST_F(OhosMojoMediaClientTest, CreateCdmFactory) { + frame_interfaces = std::move(Mock_frame_interfaces); + auto cdm_factory = client->CreateCdmFactory(frame_interfaces.get()); + ASSERT_NE(cdm_factory, nullptr); +} +} // namespace media -- Gitee From 8f3aef8cbad09f7c36dae661c66a74e924cd5548 Mon Sep 17 00:00:00 2001 From: tengfan Date: Thu, 26 Dec 2024 17:53:22 +0800 Subject: [PATCH 02/15] DRM_UT Signed-off-by: tengfan --- .../ohos/ohos_media_codec_util_unittest.cc | 250 +++++++++++++----- 1 file changed, 182 insertions(+), 68 deletions(-) diff --git a/media/base/ohos/ohos_media_codec_util_unittest.cc b/media/base/ohos/ohos_media_codec_util_unittest.cc index a3a753dc8a..d0a668d038 100755 --- a/media/base/ohos/ohos_media_codec_util_unittest.cc +++ b/media/base/ohos/ohos_media_codec_util_unittest.cc @@ -14,106 +14,126 @@ */ #include "ohos_media_codec_util.h" -#include "ohos_adapter_helper.h" -#include -#include "testing/gtest/include/gtest/gtest.h" #include #include "base/logging.h" +#include "base/task/single_thread_task_executor.h" #include "base/task/task_runner.h" #include "base/trace_event/trace_event.h" -#include "base/task/single_thread_task_executor.h" +#include "media/base/audio_codecs.h" #include "media/base/ohos/decoder_format_adapter_impl.h" +#include "media/base/video_codecs.h" +#include "ohos_adapter_helper.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" #include "third_party/ohos_ndk/includes/ohos_adapter/adapter_base.h" using ::testing::_; +using ::testing::AtLeast; using ::testing::Eq; -using ::testing::Ref; -using ::testing::Return; using ::testing::Invoke; -using ::testing::AtLeast; -using ::testing::NiceMock; using ::testing::MockFunction; +using ::testing::NiceMock; +using ::testing::Ref; +using ::testing::Return; -namespace media{ +namespace media { class MockMediaCodecListAdapter : public OHOS::NWeb::MediaCodecListAdapter { -public: - MOCK_METHOD(std::shared_ptr, GetCodecCapability, - (const std::string&, bool), (override)); + public: + MOCK_METHOD(std::shared_ptr, + GetCodecCapability, + (const std::string&, bool), + (override)); }; class MockOhosAdapterHelper : public OHOS::NWeb::OhosAdapterHelper { -public: - MOCK_METHOD(std::unique_ptr, CreateAafwkAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreatePowerMgrClientAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateDisplayMgrAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateBatteryClientAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateNetConnectAdapter, (), (override)); - MOCK_METHOD(OhosWebDataBaseAdapter&, GetOhosWebDataBaseAdapterInstance, (), (override)); - MOCK_METHOD(PasteBoardClientAdapter&, GetPasteBoard, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateAudioRendererAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateAudioCapturerAdapter, (), (override)); - MOCK_METHOD(AudioSystemManagerAdapter&, GetAudioSystemManager, (), (override)); - MOCK_METHOD(OhosWebPermissionDataBaseAdapter&, GetWebPermissionDataBaseInstance, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMMIAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateSocPerfClientAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, GetResourceAdapter, (const std::string&), (override)); - MOCK_METHOD(SystemPropertiesAdapter&, GetSystemPropertiesInstance, (), (override)); - MOCK_METHOD(VSyncAdapter&, GetVSyncAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, GetInitWebAdapter, (), (override)); - MOCK_METHOD(KeystoreAdapter&, GetKeystoreAdapterInstance, (), (override)); - MOCK_METHOD(EnterpriseDeviceManagementAdapter&, GetEnterpriseDeviceManagementInstance, (), (override)); - MOCK_METHOD(DatashareAdapter&, GetDatashareInstance, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateIMFAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, GetRootCertDataAdapter, (), (override)); - MOCK_METHOD(AccessTokenAdapter&, GetAccessTokenAdapterInstance, (), (override)); - MOCK_METHOD(std::unique_ptr, GetEventHandlerAdapter, (), (override)); - MOCK_METHOD(PrintManagerAdapter&, GetPrintManagerInstance, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateConsumerSurfaceAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreatePlayerAdapter, (), (override)); - MOCK_METHOD(WindowAdapter&, GetWindowAdapterInstance, (), (override)); - MOCK_METHOD(HiSysEventAdapter&, GetHiSysEventAdapterInstance, (), (override)); - MOCK_METHOD(HiTraceAdapter&, GetHiTraceAdapterInstance, (), (override)); - MOCK_METHOD(NetProxyAdapter&, GetNetProxyInstance, (), (override)); - MOCK_METHOD(CameraManagerAdapter&, GetCameraManagerAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateScreenCaptureAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateDateTimeFormatAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMediaCodecDecoderAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateNativeImageAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMediaCodecEncoderAdapter, (), (override)); - MOCK_METHOD(MediaCodecListAdapter&, GetMediaCodecListAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateFlowbufferAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateMediaAVSessionAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateOhosImageDecoderAdapter, (), (override)); - MOCK_METHOD(std::unique_ptr, CreateSensorAdapter, (), (override)); - MOCK_METHOD(void, SetArkWebCoreHapPathOverride, (const std::string&), (override)); - - static MockOhosAdapterHelper& GetInstance() { - static MockOhosAdapterHelper instance; - return instance; - } + public: + MOCK_METHOD0(CreateAafwkAdapter, std::unique_ptr()); + MOCK_METHOD0(CreatePowerMgrClientAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateDisplayMgrAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateBatteryClientAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateNetConnectAdapter, std::unique_ptr()); + MOCK_METHOD0(GetOhosWebDataBaseAdapterInstance, OhosWebDataBaseAdapter&()); + MOCK_METHOD0(GetPasteBoard, PasteBoardClientAdapter&()); + MOCK_METHOD0(CreateAudioRendererAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateAudioCapturerAdapter, + std::unique_ptr()); + MOCK_METHOD0(GetAudioSystemManager, AudioSystemManagerAdapter&()); + MOCK_METHOD0(GetWebPermissionDataBaseInstance, + OhosWebPermissionDataBaseAdapter&()); + MOCK_METHOD0(CreateMMIAdapter, std::unique_ptr()); + MOCK_METHOD0(CreateSocPerfClientAdapter, + std::unique_ptr()); + + MOCK_METHOD(std::unique_ptr, + GetResourceAdapter, + (const std::string&)); + + MOCK_METHOD0(GetSystemPropertiesInstance, SystemPropertiesAdapter&()); + MOCK_METHOD0(GetVSyncAdapter, VSyncAdapter&()); + MOCK_METHOD0(GetInitWebAdapter, std::unique_ptr()); + MOCK_METHOD0(GetKeystoreAdapterInstance, KeystoreAdapter&()); + MOCK_METHOD0(GetEnterpriseDeviceManagementInstance, + EnterpriseDeviceManagementAdapter&()); + MOCK_METHOD0(GetDatashareInstance, DatashareAdapter&()); + MOCK_METHOD0(CreateIMFAdapter, std::unique_ptr()); + MOCK_METHOD0(GetRootCertDataAdapter, std::unique_ptr()); + MOCK_METHOD0(GetAccessTokenAdapterInstance, AccessTokenAdapter&()); + MOCK_METHOD0(GetEventHandlerAdapter, std::unique_ptr()); + MOCK_METHOD0(GetPrintManagerInstance, PrintManagerAdapter&()); + MOCK_METHOD0(CreateConsumerSurfaceAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreatePlayerAdapter, std::unique_ptr()); + MOCK_METHOD0(GetWindowAdapterInstance, WindowAdapter&()); + MOCK_METHOD0(GetHiSysEventAdapterInstance, HiSysEventAdapter&()); + MOCK_METHOD0(GetHiTraceAdapterInstance, HiTraceAdapter&()); + MOCK_METHOD0(GetNetProxyInstance, NetProxyAdapter&()); + MOCK_METHOD0(GetCameraManagerAdapter, CameraManagerAdapter&()); + MOCK_METHOD0(CreateScreenCaptureAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateDateTimeFormatAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateMediaCodecDecoderAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateNativeImageAdapter, std::unique_ptr()); + MOCK_METHOD0(CreateMediaCodecEncoderAdapter, + std::unique_ptr()); + MOCK_METHOD0(GetMediaCodecListAdapter, MediaCodecListAdapter&()); + MOCK_METHOD0(CreateFlowbufferAdapter, std::unique_ptr()); + MOCK_METHOD0(CreateMediaAVSessionAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateOhosImageDecoderAdapter, + std::unique_ptr()); + MOCK_METHOD0(CreateSensorAdapter, std::unique_ptr()); + MOCK_METHOD1(SetArkWebCoreHapPathOverride, void(const std::string&)); + MOCK_METHOD0(GetOhosNativeBufferAdapter, OhosNativeBufferAdapter&()); + MOCK_METHOD0(CreateDrmAdapter, std::unique_ptr()); + MOCK_METHOD0(GetInstance, OhosAdapterHelper&()); }; class MockCapabilityDataAdapter : public CapabilityDataAdapter { -public: + public: MOCK_METHOD(int32_t, GetMaxWidth, (), (override)); MOCK_METHOD(int32_t, GetMaxHeight, (), (override)); MOCK_METHOD(int32_t, GetMaxframeRate, (), (override)); }; class OHOSMediaCodecUtilTest : public ::testing::Test { -protected: + protected: void SetUp() override { mock_adapter_helper_ = new testing::NiceMock; ON_CALL(*mock_adapter_helper_, GetMediaCodecListAdapter()) - .WillByDefault(testing::ReturnRef(mock_media_codec_list_adapter_)); + .WillByDefault(testing::ReturnRef(mock_media_codec_list_adapter_)); } - void TearDown() override { - delete mock_adapter_helper_; - } + void TearDown() override { delete mock_adapter_helper_; } - std::shared_ptr mock_capability_data_adapter_; + std::shared_ptr + mock_capability_data_adapter_; media::MockOhosAdapterHelper* mock_adapter_helper_; media::MockMediaCodecListAdapter mock_media_codec_list_adapter_; }; @@ -131,4 +151,98 @@ TEST_F(OHOSMediaCodecUtilTest, GetCodecCapabilityReturnsCorrectValues) { ASSERT_NE(capability.maxHeight, 0); ASSERT_NE(capability.maxframeRate, 0); } + +TEST_F(OHOSMediaCodecUtilTest, CodecToOHOSMimeType) { + auto result = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kMP3); + EXPECT_EQ(result, "audio/mpeg"); +} + +TEST_F(OHOSMediaCodecUtilTest, CodecToOHOSMimeType_Audio) { + auto result1 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kMP3, + kSampleFormatAc3); + EXPECT_EQ(result1, "audio/raw"); + + auto result2 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kVorbis, + kUnknownSampleFormat); + EXPECT_EQ(result2, "audio/vorbis"); + + auto result3 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kMP3, + kUnknownSampleFormat); + EXPECT_EQ(result3, "audio/mpeg"); + + auto result4 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kFLAC, + kUnknownSampleFormat); + EXPECT_EQ(result4, "audio/flac"); + + auto result5 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kOpus, + kUnknownSampleFormat); + EXPECT_EQ(result5, "audio/opus"); + + auto result6 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kOpus, + kUnknownSampleFormat); + EXPECT_EQ(result6, "audio/opus"); + + auto result7 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kAAC, + kUnknownSampleFormat); + EXPECT_EQ(result7, "audio/mp4a-latm"); + + auto result8 = OHOSMediaCodecUtil::CodecToOHOSMimeType( + AudioCodec::kAC3, kSampleFormatPlanarS32); + EXPECT_EQ(result8, "audio/raw"); + + auto result9 = OHOSMediaCodecUtil::CodecToOHOSMimeType( + AudioCodec::kDTS, kSampleFormatPlanarS32); + EXPECT_EQ(result9, "audio/raw"); + + auto result10 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kDTSE, + kUnknownSampleFormat); + EXPECT_EQ(result10, "audio/vnd.dts;profile=lbr"); + + auto result11 = OHOSMediaCodecUtil::CodecToOHOSMimeType(AudioCodec::kDTSXP2, + kUnknownSampleFormat); + EXPECT_EQ(result11, "audio/raw"); +} + +TEST_F(OHOSMediaCodecUtilTest, CodecToOHOSMimeType_Video) { + auto result1 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kH264); + EXPECT_EQ(result1, "video/avc"); + + auto result2 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kHEVC); + EXPECT_EQ(result1, "video/avc"); + + auto result3 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kVP8); + EXPECT_EQ(result3, "video/x-vnd.on2.vp8"); + + auto result4 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kVP9); + EXPECT_EQ(result4, "video/x-vnd.on2.vp9"); + + auto result5 = + OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kDolbyVision); + EXPECT_EQ(result5, "video/dolby-vision"); + + auto result6 = OHOSMediaCodecUtil::CodecToOHOSMimeType(VideoCodec::kAV1); + EXPECT_EQ(result6, "video/av01"); +} + +TEST_F(OHOSMediaCodecUtilTest, IsPassthroughAudioFormat) { + auto result_true = + OHOSMediaCodecUtil::IsPassthroughAudioFormat(AudioCodec::kAC3); + EXPECT_EQ(result_true, true); + + auto result_false = + OHOSMediaCodecUtil::IsPassthroughAudioFormat(AudioCodec::kMP3); + EXPECT_EQ(result_false, false); +} + +TEST_F(OHOSMediaCodecUtilTest, CanDecode_Video) { + VideoCodec codec = VideoCodec::kDolbyVision; + bool result_true = OHOSMediaCodecUtil::CanDecode(codec, false); + EXPECT_TRUE(result_true); +} + +TEST_F(OHOSMediaCodecUtilTest, CanDecode_Audio) { + AudioCodec codec = AudioCodec::kAC3; + bool result_true = OHOSMediaCodecUtil::CanDecode(codec); + EXPECT_TRUE(result_true); +} } // namespace media \ No newline at end of file -- Gitee From 2caf554e0d8ef35341cb3668f16c4ce14f88325e Mon Sep 17 00:00:00 2001 From: tengfan Date: Thu, 26 Dec 2024 18:05:54 +0800 Subject: [PATCH 03/15] DRM_UT Signed-off-by: tengfan --- .../ohos/ohos_media_codec_util_unittest.cc | 203 ++++++++++++------ 1 file changed, 140 insertions(+), 63 deletions(-) diff --git a/media/base/ohos/ohos_media_codec_util_unittest.cc b/media/base/ohos/ohos_media_codec_util_unittest.cc index d0a668d038..76ded00979 100755 --- a/media/base/ohos/ohos_media_codec_util_unittest.cc +++ b/media/base/ohos/ohos_media_codec_util_unittest.cc @@ -48,71 +48,148 @@ class MockMediaCodecListAdapter : public OHOS::NWeb::MediaCodecListAdapter { class MockOhosAdapterHelper : public OHOS::NWeb::OhosAdapterHelper { public: - MOCK_METHOD0(CreateAafwkAdapter, std::unique_ptr()); - MOCK_METHOD0(CreatePowerMgrClientAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateDisplayMgrAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateBatteryClientAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateNetConnectAdapter, std::unique_ptr()); - MOCK_METHOD0(GetOhosWebDataBaseAdapterInstance, OhosWebDataBaseAdapter&()); - MOCK_METHOD0(GetPasteBoard, PasteBoardClientAdapter&()); - MOCK_METHOD0(CreateAudioRendererAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateAudioCapturerAdapter, - std::unique_ptr()); - MOCK_METHOD0(GetAudioSystemManager, AudioSystemManagerAdapter&()); - MOCK_METHOD0(GetWebPermissionDataBaseInstance, - OhosWebPermissionDataBaseAdapter&()); - MOCK_METHOD0(CreateMMIAdapter, std::unique_ptr()); - MOCK_METHOD0(CreateSocPerfClientAdapter, - std::unique_ptr()); - + MOCK_METHOD(std::unique_ptr, + CreateAafwkAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreatePowerMgrClientAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateDisplayMgrAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateBatteryClientAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateNetConnectAdapter, + (), + (override)); + MOCK_METHOD(OhosWebDataBaseAdapter&, + GetOhosWebDataBaseAdapterInstance, + (), + (override)); + MOCK_METHOD(PasteBoardClientAdapter&, GetPasteBoard, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateAudioRendererAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateAudioCapturerAdapter, + (), + (override)); + MOCK_METHOD(AudioSystemManagerAdapter&, + GetAudioSystemManager, + (), + (override)); + MOCK_METHOD(OhosWebPermissionDataBaseAdapter&, + GetWebPermissionDataBaseInstance, + (), + (override)); + MOCK_METHOD(std::unique_ptr, CreateMMIAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateSocPerfClientAdapter, + (), + (override)); MOCK_METHOD(std::unique_ptr, GetResourceAdapter, - (const std::string&)); - - MOCK_METHOD0(GetSystemPropertiesInstance, SystemPropertiesAdapter&()); - MOCK_METHOD0(GetVSyncAdapter, VSyncAdapter&()); - MOCK_METHOD0(GetInitWebAdapter, std::unique_ptr()); - MOCK_METHOD0(GetKeystoreAdapterInstance, KeystoreAdapter&()); - MOCK_METHOD0(GetEnterpriseDeviceManagementInstance, - EnterpriseDeviceManagementAdapter&()); - MOCK_METHOD0(GetDatashareInstance, DatashareAdapter&()); - MOCK_METHOD0(CreateIMFAdapter, std::unique_ptr()); - MOCK_METHOD0(GetRootCertDataAdapter, std::unique_ptr()); - MOCK_METHOD0(GetAccessTokenAdapterInstance, AccessTokenAdapter&()); - MOCK_METHOD0(GetEventHandlerAdapter, std::unique_ptr()); - MOCK_METHOD0(GetPrintManagerInstance, PrintManagerAdapter&()); - MOCK_METHOD0(CreateConsumerSurfaceAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreatePlayerAdapter, std::unique_ptr()); - MOCK_METHOD0(GetWindowAdapterInstance, WindowAdapter&()); - MOCK_METHOD0(GetHiSysEventAdapterInstance, HiSysEventAdapter&()); - MOCK_METHOD0(GetHiTraceAdapterInstance, HiTraceAdapter&()); - MOCK_METHOD0(GetNetProxyInstance, NetProxyAdapter&()); - MOCK_METHOD0(GetCameraManagerAdapter, CameraManagerAdapter&()); - MOCK_METHOD0(CreateScreenCaptureAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateDateTimeFormatAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateMediaCodecDecoderAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateNativeImageAdapter, std::unique_ptr()); - MOCK_METHOD0(CreateMediaCodecEncoderAdapter, - std::unique_ptr()); - MOCK_METHOD0(GetMediaCodecListAdapter, MediaCodecListAdapter&()); - MOCK_METHOD0(CreateFlowbufferAdapter, std::unique_ptr()); - MOCK_METHOD0(CreateMediaAVSessionAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateOhosImageDecoderAdapter, - std::unique_ptr()); - MOCK_METHOD0(CreateSensorAdapter, std::unique_ptr()); - MOCK_METHOD1(SetArkWebCoreHapPathOverride, void(const std::string&)); - MOCK_METHOD0(GetOhosNativeBufferAdapter, OhosNativeBufferAdapter&()); - MOCK_METHOD0(CreateDrmAdapter, std::unique_ptr()); - MOCK_METHOD0(GetInstance, OhosAdapterHelper&()); + (const std::string&), + (override)); + MOCK_METHOD(SystemPropertiesAdapter&, + GetSystemPropertiesInstance, + (), + (override)); + MOCK_METHOD(VSyncAdapter&, GetVSyncAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + GetInitWebAdapter, + (), + (override)); + MOCK_METHOD(KeystoreAdapter&, GetKeystoreAdapterInstance, (), (override)); + MOCK_METHOD(EnterpriseDeviceManagementAdapter&, + GetEnterpriseDeviceManagementInstance, + (), + (override)); + MOCK_METHOD(DatashareAdapter&, GetDatashareInstance, (), (override)); + MOCK_METHOD(std::unique_ptr, CreateIMFAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + GetRootCertDataAdapter, + (), + (override)); + MOCK_METHOD(AccessTokenAdapter&, + GetAccessTokenAdapterInstance, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + GetEventHandlerAdapter, + (), + (override)); + MOCK_METHOD(PrintManagerAdapter&, GetPrintManagerInstance, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateConsumerSurfaceAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreatePlayerAdapter, + (), + (override)); + MOCK_METHOD(WindowAdapter&, GetWindowAdapterInstance, (), (override)); + MOCK_METHOD(HiSysEventAdapter&, GetHiSysEventAdapterInstance, (), (override)); + MOCK_METHOD(HiTraceAdapter&, GetHiTraceAdapterInstance, (), (override)); + MOCK_METHOD(NetProxyAdapter&, GetNetProxyInstance, (), (override)); + MOCK_METHOD(CameraManagerAdapter&, GetCameraManagerAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateScreenCaptureAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateDateTimeFormatAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateMediaCodecDecoderAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateNativeImageAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateMediaCodecEncoderAdapter, + (), + (override)); + MOCK_METHOD(MediaCodecListAdapter&, GetMediaCodecListAdapter, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateFlowbufferAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateMediaAVSessionAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateOhosImageDecoderAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateSensorAdapter, + (), + (override)); + MOCK_METHOD(void, + SetArkWebCoreHapPathOverride, + (const std::string&), + (override)); + MOCK_METHOD(OhosNativeBufferAdapter&, + GetOhosNativeBufferAdapter, + (), + (override)); + MOCK_METHOD(std::unique_ptr, CreateDrmAdapter, (), (override)); + static MockOhosAdapterHelper& GetInstance() { + static MockOhosAdapterHelper instance; + return instance; + } }; class MockCapabilityDataAdapter : public CapabilityDataAdapter { -- Gitee From 4861fc622b6b68d395c4b9a2cd12b5ead3728cea Mon Sep 17 00:00:00 2001 From: tengfan Date: Sat, 28 Dec 2024 13:55:42 +0800 Subject: [PATCH 04/15] DRM_UT Signed-off-by: tengfan --- media/base/BUILD.gn | 2 + media/base/ohos/ohos_cdm_factory_unittests.cc | 128 ++++++++++++++++++ ...ohos_media_crypto_context_impl_unittest.cc | 71 ++++++++++ media/mojo/services/BUILD.gn | 1 + .../mojo/services/ohos_mojo_util_unittests.cc | 80 +++++++++++ 5 files changed, 282 insertions(+) create mode 100644 media/base/ohos/ohos_cdm_factory_unittests.cc create mode 100644 media/base/ohos/ohos_media_crypto_context_impl_unittest.cc create mode 100644 media/mojo/services/ohos_mojo_util_unittests.cc diff --git a/media/base/BUILD.gn b/media/base/BUILD.gn index 1453409b2b..e7d16ae815 100644 --- a/media/base/BUILD.gn +++ b/media/base/BUILD.gn @@ -693,8 +693,10 @@ source_set("unit_tests") { "ohos/ohos_media_player_bridge_unittest.cc", "ohos/ohos_media_player_callback_unittest.cc", "ohos/ohos_media_player_listener_unittest.cc", + "ohos/ohos_media_crypto_context_impl_unittest.cc", "ohos/ohos_media_drm_bridge_client_unittest.cc", "ohos/ohos_media_drm_bridge_delegate_unittest.cc", + "ohos/ohos_cdm_factory_unittests.cc", ] } diff --git a/media/base/ohos/ohos_cdm_factory_unittests.cc b/media/base/ohos/ohos_cdm_factory_unittests.cc new file mode 100644 index 0000000000..565dda0bd3 --- /dev/null +++ b/media/base/ohos/ohos_cdm_factory_unittests.cc @@ -0,0 +1,128 @@ +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_config.h" +#include "media/base/content_decryption_module.h" +#include "media/base/ohos/ohos_media_drm_bridge.h" +#include "media/base/provision_fetcher.h" +#include "media/cdm/aes_decryptor.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#define private public +#include "media/base/ohos/ohos_cdm_factory.h" +#undef private +using ::testing::_; + +namespace media { +class MockContentDecryptionModule : public ContentDecryptionModule { + public: + MOCK_METHOD(void, + SetServerCertificate, + (const std::vector& certificate, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + GetStatusForPolicy, + (HdcpVersion min_hdcp_version, + std::unique_ptr promise), + ()); + + MOCK_METHOD(void, + CreateSessionAndGenerateRequest, + (CdmSessionType session_type, + EmeInitDataType init_data_type, + const std::vector& init_data, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + LoadSession, + (CdmSessionType session_type, + const std::string& session_id, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + UpdateSession, + (const std::string& session_id, + const std::vector& response, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + CloseSession, + (const std::string& session_id, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(void, + RemoveSession, + (const std::string& session_id, + std::unique_ptr promise), + (override)); + + MOCK_METHOD(CdmContext*, GetCdmContext, (), (override)); +}; + +class OHOSCdmFactoryTest : public ::testing::Test { + protected: + OHOSCdmFactoryTest() = default; + ~OHOSCdmFactoryTest() override = default; + + void SetUp() override { + CreateFetcherCB create_fetcher_cb_; + CreateStorageCB create_storage_cb_; + cdm_factory = std::make_unique(create_fetcher_cb_, + create_storage_cb_); + } + + void TearDown() override { cdm_factory.reset(); } + std::unique_ptr cdm_factory; +}; + +TEST_F(OHOSCdmFactoryTest, Create) { + CdmConfig cdm_config; + SessionMessageCB session_message_cb; + SessionClosedCB session_closed_cb; + SessionKeysChangeCB session_keys_change_cb; + SessionExpirationUpdateCB session_expiration_update_cb; + scoped_refptr created_cdm; + std::string error_message; + CdmCreatedCB cdm_created_cb = base::BindOnce( + [](scoped_refptr* out_cdm, + std::string* out_error_message, + const scoped_refptr& cdm, + const std::string& error_message) { + *out_cdm = cdm; + *out_error_message = error_message; + }, + &created_cdm, &error_message); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner); + + cdm_factory->Create(cdm_config, session_message_cb, session_closed_cb, + session_keys_change_cb, session_expiration_update_cb, + std::move(cdm_created_cb)); + EXPECT_TRUE(cdm_factory->pending_creations_.empty()); +} + +TEST_F(OHOSCdmFactoryTest, OnCdmCreated) { + const uint32_t creation_id = 1; + scoped_refptr cdm( + new MockContentDecryptionModule()); + EXPECT_CALL(*cdm, CreateSessionAndGenerateRequest(_, _, _, _)).Times(0); + EXPECT_TRUE(cdm.get() != nullptr); + std::string error_message = "Success"; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner); + auto cdm_created_cb_ = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + CdmCreatedCB cdm_created_cb = base::BindOnce(cdm_created_cb_); + cdm_factory->pending_creations_.emplace( + creation_id, std::make_pair(nullptr, std::move(cdm_created_cb))); + cdm_factory->OnCdmCreated(creation_id, cdm, error_message); + ASSERT_NE(cdm_factory, nullptr); + EXPECT_TRUE(cdm_factory->pending_creations_.empty()); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc b/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc new file mode 100644 index 0000000000..deb403c231 --- /dev/null +++ b/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc @@ -0,0 +1,71 @@ +#include "media/base/ohos/ohos_media_crypto_context_impl.h" +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_context.h" +#include "media/base/ohos/ohos_media_crypto_context.h" +#define private public +#include "base/task/single_thread_task_runner.h" +#include "media/base/ohos/ohos_media_drm_bridge.h" +#undef private +#include "media/base/content_decryption_module.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +using ::testing::_; + +namespace media { +class MockOHOSMediaCryptoContext : public OHOSMediaCryptoContext { + public: + MOCK_METHOD(void, + SetOHOSMediaCryptoReadyCB, + (OHOSMediaCryptoReadyCB media_crypto_ready_cb), + (override)); +}; + +class OHOSMediaCryptoContextImplTest : public ::testing::Test { + protected: + OHOSMediaCryptoContextImplTest() = default; + ~OHOSMediaCryptoContextImplTest() override = default; + + void SetUp() override { + media_crypto_ready_cb_ = std::make_unique(); + } + + void TearDown() override { + media_crypto_ready_cb_.reset(); + media_crypto_ready.reset(); + storage.reset(); + } + std::unique_ptr media_crypto_ready_cb_; + std::unique_ptr media_crypto_ready; + std::unique_ptr storage; +}; + +TEST_F(OHOSMediaCryptoContextImplTest, SetOHOSMediaCryptoReadyCB) { + EXPECT_CALL(*media_crypto_ready_cb_, SetOHOSMediaCryptoReadyCB(_)).Times(0); + MockOHOSMediaCryptoContext::OHOSMediaCryptoReadyCB callback = + base::BindOnce([](void* session, bool requires_secure_video_codec) {}); + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "example_origin_id"; + OHOSMediaDrmBridge::SecurityLevel security_level_ = + OHOSMediaDrmBridge::SECURITY_LEVEL_DEFAULT; + bool requires_media_crypto_ = true; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto storage = std::make_unique(); + CreateFetcherCB create_fetcher_cb_; + SessionMessageCB session_message_cb_; + SessionClosedCB session_closed_cb_; + SessionKeysChangeCB session_keys_change_cb_; + SessionExpirationUpdateCB session_expiration_update_cb_; + OHOSMediaDrmBridge* media_drm_bridge = new OHOSMediaDrmBridge( + scheme_uuid_, origin_id_, security_level_, requires_media_crypto_, + std::move(storage), create_fetcher_cb_, session_message_cb_, + session_closed_cb_, session_keys_change_cb_, + session_expiration_update_cb_); + ASSERT_NE(media_drm_bridge, nullptr); + media_crypto_ready = + std::make_unique(media_drm_bridge); + media_crypto_ready->SetOHOSMediaCryptoReadyCB(std::move(callback)); + ASSERT_NE(media_crypto_ready, nullptr); +} +} // namespace media diff --git a/media/mojo/services/BUILD.gn b/media/mojo/services/BUILD.gn index 6a5dbf40b8..4406f7ede1 100644 --- a/media/mojo/services/BUILD.gn +++ b/media/mojo/services/BUILD.gn @@ -249,6 +249,7 @@ source_set("unit_tests") { "webrtc_video_perf_history_unittest.cc", "webrtc_video_perf_recorder_unittest.cc", "ohos_mojo_media_client_unittests.cc", + "ohos_mojo_util_unittests.cc", ] if (enable_playback_events_recorder) { diff --git a/media/mojo/services/ohos_mojo_util_unittests.cc b/media/mojo/services/ohos_mojo_util_unittests.cc new file mode 100644 index 0000000000..d2cb562d6d --- /dev/null +++ b/media/mojo/services/ohos_mojo_util_unittests.cc @@ -0,0 +1,80 @@ +#include "base/test/test_simple_task_runner.h" +#include "media/base/media_drm_storage.h" +#include "media/mojo/mojom/frame_interface_factory.mojom.h" +#include "media/mojo/services/mojo_media_drm_storage.h" +#include "media/mojo/services/ohos_mojo_util.h" +#include "mojo/public/cpp/bindings/pending_remote.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +using ::testing::_; +using ::testing::Invoke; + +namespace media { +namespace ohos_mojo_util { +class MockFrameInterfaceFactory : public mojom::FrameInterfaceFactory { + public: + MOCK_METHOD( + void, + CreateProvisionFetcher, + (mojo::PendingReceiver provision_fetcher), + (override)); + + MOCK_METHOD(void, + CreateCdmStorage, + (mojo::PendingReceiver cdm_storage), + (override)); + + MOCK_METHOD(bool, GetCdmOrigin, (::url::Origin * out_cdm_origin), (override)); + + MOCK_METHOD(void, GetCdmOrigin, (GetCdmOriginCallback callback), (override)); + + MOCK_METHOD(void, + BindEmbedderReceiver, + (mojo::GenericPendingReceiver receiver), + (override)); +}; + +class OHOSMojoUtilTest : public ::testing::Test { + protected: + OHOSMojoUtilTest() = default; + ~OHOSMojoUtilTest() override = default; + + void SetUp() override { + Mock_frame_interfaces = std::make_unique(); + } + + void TearDown() override {} + std::unique_ptr Mock_frame_interfaces; + std::unique_ptr frame_interfaces; +}; + +TEST_F(OHOSMojoUtilTest, CreateProvisionFetcher) { + mojo::PendingRemote provision_fetcher; + EXPECT_CALL(*Mock_frame_interfaces, CreateProvisionFetcher(_)) + .WillOnce(Invoke([&]() { + auto receiver = provision_fetcher.InitWithNewPipeAndPassReceiver(); + })); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + frame_interfaces = std::move(Mock_frame_interfaces); + auto result = ohos_mojo_util::CreateProvisionFetcher(frame_interfaces.get()); + ASSERT_TRUE(provision_fetcher.is_valid()); +} + +TEST_F(OHOSMojoUtilTest, CreateMediaDrmStorage) { + mojo::PendingRemote media_drm_storage; + EXPECT_CALL(*Mock_frame_interfaces, BindEmbedderReceiver(_)) + .WillOnce(Invoke([&](mojo::GenericPendingReceiver receiver) { + auto receiver_ = media_drm_storage.InitWithNewPipeAndPassReceiver(); + })); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + frame_interfaces = std::move(Mock_frame_interfaces); + auto result = ohos_mojo_util::CreateMediaDrmStorage(frame_interfaces.get()); + EXPECT_NE(result, nullptr); + ASSERT_TRUE(media_drm_storage.is_valid()); +} +} // namespace ohos_mojo_util +} // namespace media -- Gitee From 6e8b20471d0e331780a901061a07a566e587afba Mon Sep 17 00:00:00 2001 From: tengfan Date: Sat, 28 Dec 2024 14:11:38 +0800 Subject: [PATCH 05/15] DRM_UT Signed-off-by: tengfan --- media/base/ohos/ohos_media_crypto_context_impl_unittest.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc b/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc index deb403c231..d42217118e 100644 --- a/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc +++ b/media/base/ohos/ohos_media_crypto_context_impl_unittest.cc @@ -62,7 +62,7 @@ TEST_F(OHOSMediaCryptoContextImplTest, SetOHOSMediaCryptoReadyCB) { std::move(storage), create_fetcher_cb_, session_message_cb_, session_closed_cb_, session_keys_change_cb_, session_expiration_update_cb_); - ASSERT_NE(media_drm_bridge, nullptr); + ASSERT_NE(media_drm_bridge, nullptr); media_crypto_ready = std::make_unique(media_drm_bridge); media_crypto_ready->SetOHOSMediaCryptoReadyCB(std::move(callback)); -- Gitee From f65f3197b260af1de0e0cf69a3cc02f04f4296bb Mon Sep 17 00:00:00 2001 From: tengfan Date: Sat, 28 Dec 2024 18:30:20 +0800 Subject: [PATCH 06/15] DRM_UT Signed-off-by: tengfan --- .../base/ohos/ohos_media_drm_bridge_delegate_unittest.cc | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc index c82efd2a92..6d23a1fe37 100644 --- a/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc +++ b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc @@ -2,10 +2,8 @@ #include "media/base/ohos/ohos_media_drm_bridge_client.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" -using ::testing::_; namespace media { - class MockOHOSMediaDrmBridgeDelegate : public OHOSMediaDrmBridgeDelegate { public: MOCK_METHOD(const UUID, GetUUID, (), (const override)); @@ -16,8 +14,7 @@ class OHOSMediaDrmBridgeDelegateTest : public ::testing::Test { OHOSMediaDrmBridgeDelegateTest() = default; ~OHOSMediaDrmBridgeDelegateTest() override = default; void SetUp() override { - mock_delegate = - std::make_unique(); + mock_delegate = std::make_unique(); } void TearDown() override { @@ -35,8 +32,8 @@ TEST_F(OHOSMediaDrmBridgeDelegateTest, OnCreateSession) { std::vector init_data_out; std::vector optional_parameters_out; bool result = false; - result = delegate->OnCreateSession( - init_data_type, init_data, &init_data_out, &optional_parameters_out); + result = delegate->OnCreateSession(init_data_type, init_data, &init_data_out, + &optional_parameters_out); EXPECT_TRUE(result); } } // namespace media -- Gitee From e6e89247bfcefd54cac07144272a8c60025c6207 Mon Sep 17 00:00:00 2001 From: tengfan Date: Tue, 31 Dec 2024 18:58:41 +0800 Subject: [PATCH 07/15] DRM_UT Signed-off-by: tengfan --- media/base/BUILD.gn | 1 + .../ohos_media_drm_bridge_factory_unittest.cc | 142 ++++++++++++++++++ 2 files changed, 143 insertions(+) create mode 100644 media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc diff --git a/media/base/BUILD.gn b/media/base/BUILD.gn index e7d16ae815..445adb9127 100644 --- a/media/base/BUILD.gn +++ b/media/base/BUILD.gn @@ -697,6 +697,7 @@ source_set("unit_tests") { "ohos/ohos_media_drm_bridge_client_unittest.cc", "ohos/ohos_media_drm_bridge_delegate_unittest.cc", "ohos/ohos_cdm_factory_unittests.cc", + "ohos/ohos_media_drm_bridge_factory_unittest.cc", ] } diff --git a/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc new file mode 100644 index 0000000000..c9ff0bbad5 --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc @@ -0,0 +1,142 @@ +#define private public +#include "media/base/ohos/ohos_media_drm_bridge_factory.h" +#undef private +#include "base/functional/callback_helpers.h" +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_config.h" +#include "media/base/content_decryption_module.h" +#include "media/base/media_drm_storage.h" +#include "media/base/ohos/ohos_media_drm_bridge.h" +#include "media/base/provision_fetcher.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/widevine/cdm/widevine_cdm_common.h" +using ::testing::_; + +namespace media { +class MockMediaDrmStorage : public MediaDrmStorage { + public: + MOCK_METHOD(void, Initialize, (InitCB init_cb), (override)); + MOCK_METHOD(void, OnProvisioned, (ResultCB result_cb), (override)); + MOCK_METHOD(void, + SavePersistentSession, + (const std::string& session_id, + const SessionData& session_data, + ResultCB result_cb), + (override)); + MOCK_METHOD(void, + LoadPersistentSession, + (const std::string& session_id, + LoadPersistentSessionCB load_persistent_session_cb), + (override)); + MOCK_METHOD(void, + RemovePersistentSession, + (const std::string& session_id, ResultCB result_cb), + (override)); +}; + +class MockProvisionFetcher : public ProvisionFetcher { + public: + MOCK_METHOD(void, + Retrieve, + (const GURL&, const std::string&, ResponseCB), + (override)); +}; + +class OHOSMediaDrmBridgeFactoryTest : public ::testing::Test { + protected: + void SetUp() override { + create_fetcher_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + + factory = std::make_unique(create_fetcher_cb_, + create_storage_cb_); + } + + void TearDown() override { + factory.reset(); + create_storage_cb_.Reset(); + create_fetcher_cb_.Reset(); + } + + CdmConfig cdm_config_; + CreateFetcherCB create_fetcher_cb_; + CreateStorageCB create_storage_cb_; + std::unique_ptr factory; + CdmCreatedCB cdm_created_cb_; +}; + +TEST_F(OHOSMediaDrmBridgeFactoryTest, Create) { + cdm_config_.key_system = "nullptr"; + cdm_config_.use_hw_secure_codecs = true; + SessionMessageCB session_message_cb; + SessionClosedCB session_closed_cb; + SessionKeysChangeCB session_keys_change_cb; + SessionExpirationUpdateCB session_expiration_update_cb; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + CreateStorageCB create_storage_cb = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + factory->create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + auto storage = std::make_unique(); + EXPECT_CALL(*storage, Initialize(_)).Times(testing::AtLeast(0)); + return storage; + }); + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->Create(cdm_config_, session_message_cb, session_closed_cb, + session_keys_change_cb, session_expiration_update_cb, + std::move(cdm_created_cb_)); + ASSERT_NE(factory->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeFactoryTest, CreateMediaDrmBridge) { + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "origin_id"; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->CreateMediaDrmBridge(origin_id_); + ASSERT_NE(factory->ohos_media_drm_bridge_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeFactoryTest, OnStorageInitialized) { + bool requires_secure_video_codec = true; + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "origin_id"; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->OnStorageInitialized(requires_secure_video_codec); + ASSERT_EQ(factory->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeFactoryTest, OnOHOSMediaCryptoReady) { + cdm_config_.key_system = "nullptr"; + cdm_config_.use_hw_secure_codecs = true; + void* session = nullptr; + bool requires_secure_video_codec = true; + auto cdm_created_cb = [](const scoped_refptr& cdm, + const std::string& error_message) {}; + factory->cdm_created_cb_ = base::BindOnce(cdm_created_cb); + factory->OnOHOSMediaCryptoReady(session, requires_secure_video_codec); + ASSERT_EQ(factory->ohos_media_drm_bridge_, nullptr); +} +} // namespace media -- Gitee From 548e34e93a925a3bb58d05521df7b1ab7b161375 Mon Sep 17 00:00:00 2001 From: tengfan Date: Thu, 2 Jan 2025 20:12:21 +0800 Subject: [PATCH 08/15] DRM_UT Signed-off-by: tengfan --- media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc | 4 ---- 1 file changed, 4 deletions(-) diff --git a/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc index c9ff0bbad5..47f0ba9c7c 100644 --- a/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc +++ b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc @@ -84,10 +84,6 @@ TEST_F(OHOSMediaDrmBridgeFactoryTest, Create) { base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); auto cdm_created_cb = [](const scoped_refptr& cdm, const std::string& error_message) {}; - CreateStorageCB create_storage_cb = - base::BindRepeating([]() -> std::unique_ptr { - return std::make_unique(); - }); factory->create_storage_cb_ = base::BindRepeating([]() -> std::unique_ptr { auto storage = std::make_unique(); -- Gitee From 12b256672932f428c4457949c4f5a0147aac2034 Mon Sep 17 00:00:00 2001 From: tengfan Date: Fri, 3 Jan 2025 15:57:29 +0800 Subject: [PATCH 09/15] DRM_UT Signed-off-by: tengfan --- media/base/BUILD.gn | 1 + .../ohos_media_drm_bridge_factory_unittest.cc | 3 + .../ohos_media_drm_storage_bridge_unittest.cc | 157 ++++++++++++++++++ 3 files changed, 161 insertions(+) create mode 100644 media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc diff --git a/media/base/BUILD.gn b/media/base/BUILD.gn index 445adb9127..20cd6837e1 100644 --- a/media/base/BUILD.gn +++ b/media/base/BUILD.gn @@ -698,6 +698,7 @@ source_set("unit_tests") { "ohos/ohos_media_drm_bridge_delegate_unittest.cc", "ohos/ohos_cdm_factory_unittests.cc", "ohos/ohos_media_drm_bridge_factory_unittest.cc", + "ohos/ohos_media_drm_storage_bridge_unittest.cc", ] } diff --git a/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc index 47f0ba9c7c..fcb278e64c 100644 --- a/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc +++ b/media/base/ohos/ohos_media_drm_bridge_factory_unittest.cc @@ -45,6 +45,9 @@ class MockProvisionFetcher : public ProvisionFetcher { class OHOSMediaDrmBridgeFactoryTest : public ::testing::Test { protected: + OHOSMediaDrmBridgeFactoryTest() = default; + ~OHOSMediaDrmBridgeFactoryTest() override = default; + void SetUp() override { create_fetcher_cb_ = base::BindRepeating([]() -> std::unique_ptr { diff --git a/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc new file mode 100644 index 0000000000..0c003746b6 --- /dev/null +++ b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc @@ -0,0 +1,157 @@ +#include "base/test/bind.h" +#include "base/test/test_simple_task_runner.h" +#include "gtest/gtest.h" +#define private public +#include "media/base/ohos/ohos_media_drm_storage_bridge.h" +#include "ohos_media_drm_bridge_factory.h" +#undef private +#include "media/base/ohos/ohos_media_drm_bridge.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace media { +class MockMediaDrmStorage : public MediaDrmStorage { + public: + MOCK_METHOD(void, Initialize, (InitCB init_cb), (override)); + MOCK_METHOD(void, OnProvisioned, (ResultCB result_cb), (override)); + MOCK_METHOD(void, + SavePersistentSession, + (const std::string& session_id, + const SessionData& session_data, + ResultCB result_cb), + (override)); + MOCK_METHOD(void, + LoadPersistentSession, + (const std::string& session_id, + LoadPersistentSessionCB load_persistent_session_cb), + (override)); + MOCK_METHOD(void, + RemovePersistentSession, + (const std::string& session_id, ResultCB result_cb), + (override)); +}; + +class MockProvisionFetcher : public ProvisionFetcher { + public: + MOCK_METHOD(void, + Retrieve, + (const GURL&, const std::string&, ResponseCB), + (override)); +}; + +class OHOSMediaDrmStorageBridgeTest : public ::testing::Test { + protected: + OHOSMediaDrmStorageBridgeTest() = default; + ~OHOSMediaDrmStorageBridgeTest() override = default; + void SetUp() override { + create_fetcher_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + return std::make_unique(); + }); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + factory = std::make_unique(); + factory_ = std::make_unique(create_fetcher_cb_, + create_storage_cb_); + } + + void TearDown() override { + factory.release(); + factory_.release(); + create_storage_cb_.Reset(); + create_fetcher_cb_.Reset(); + } + CreateStorageCB create_storage_cb_; + CreateFetcherCB create_fetcher_cb_; + std::unique_ptr factory; + std::unique_ptr factory_; +}; + +TEST_F(OHOSMediaDrmStorageBridgeTest, Initialize) { + bool init_cb_ = false; + auto init_cb = base::BindLambdaForTesting( + [&init_cb_](bool result) { init_cb_ = result; }); + factory_->create_storage_cb_ = + base::BindRepeating([]() -> std::unique_ptr { + std::unique_ptr storage = std::make_unique(); + EXPECT_CALL(*storage, Initialize(testing::_)) + .Times(testing::AtLeast(0)); + testing::Mock::AllowLeak(storage.get()); + return storage; + }); + factory->Initialize(factory_->create_storage_cb_, std::move(init_cb)); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnProvisioned) { + bool result_cb = false; + auto result_cb_ = base::BindLambdaForTesting( + [&result_cb](bool result) { result_cb = result; }); + factory->impl_ = std::make_unique(); + factory->OnProvisioned(std::move(result_cb_)); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnLoadInfo) { + std::string session_id = "session_id"; + auto result_cb_ = + base::BindOnce([](std::string id, std::vector key, + std::string init_data_type, uint32_t session_id) {}); + factory->impl_ = std::make_unique(); + factory->OnLoadInfo(session_id, std::move(result_cb_)); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnSaveInfo) { + std::string session_id = "session_id"; + int32_t key_type = 1; + std::vector key_set_id = {1}; + std::string mime = "mime"; + bool result_cb = false; + auto result_cb_ = base::BindLambdaForTesting( + [&result_cb](bool result) { result_cb = result; }); + factory->impl_ = std::make_unique(); + factory->OnSaveInfo(key_set_id, mime, session_id, key_type, result_cb_); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnClearInfo) { + std::string session_id = "session_id"; + bool result_cb = false; + auto result_cb_ = base::BindLambdaForTesting( + [&result_cb](bool result) { result_cb = result; }); + factory->impl_ = std::make_unique(); + factory->OnClearInfo(session_id, result_cb_); + ASSERT_NE(factory->impl_, nullptr); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnInitialized) { + bool success = true; + auto init_cb = + base::BindLambdaForTesting([&success](bool result) { success = result; }); + MediaDrmStorage::MediaDrmOriginId origin_id(base::UnguessableToken::Create()); + factory->OnInitialized(init_cb, success, origin_id); + ASSERT_TRUE(init_cb); +} + +TEST_F(OHOSMediaDrmStorageBridgeTest, OnSessionDataLoaded) { + std::vector key_set_id = {1}; + std::string mime_type = "mime-type"; + MediaDrmKeyType key_type = MediaDrmKeyType::OFFLINE; + std::unique_ptr session_data_ = + std::make_unique(key_set_id, mime_type, + key_type); + std::string session_id = "session-id"; + auto load_result_cb = + base::BindOnce([](std::string sid, std::vector key_set_id, + std::string mime_type, uint32_t key_type) {}); + factory->OnSessionDataLoaded(std::move(load_result_cb), session_id, + std::move(session_data_)); + ASSERT_EQ(session_data_.get(), nullptr); +} +} // namespace media -- Gitee From ec64f7db9a9c197ee9143ed5bb1be7cdd079ba72 Mon Sep 17 00:00:00 2001 From: tengfan Date: Mon, 13 Jan 2025 19:20:09 +0800 Subject: [PATCH 10/15] DRM_UT Signed-off-by: tengfan --- media/base/BUILD.gn | 1 + .../ohos/ohos_media_drm_bridge_unittest.cc | 876 ++++++++++++++++++ .../ohos_media_drm_storage_bridge_unittest.cc | 5 +- 3 files changed, 879 insertions(+), 3 deletions(-) create mode 100644 media/base/ohos/ohos_media_drm_bridge_unittest.cc diff --git a/media/base/BUILD.gn b/media/base/BUILD.gn index 20cd6837e1..11128a20ac 100644 --- a/media/base/BUILD.gn +++ b/media/base/BUILD.gn @@ -699,6 +699,7 @@ source_set("unit_tests") { "ohos/ohos_cdm_factory_unittests.cc", "ohos/ohos_media_drm_bridge_factory_unittest.cc", "ohos/ohos_media_drm_storage_bridge_unittest.cc", + "ohos/ohos_media_drm_bridge_unittest.cc", ] } diff --git a/media/base/ohos/ohos_media_drm_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_unittest.cc new file mode 100644 index 0000000000..b578f23ce6 --- /dev/null +++ b/media/base/ohos/ohos_media_drm_bridge_unittest.cc @@ -0,0 +1,876 @@ +#include "base/test/bind.h" +#define private public +#include "media/base/ohos/ohos_media_drm_bridge.h" +#undef private +#include "base/functional/bind.h" +#include "base/test/test_simple_task_runner.h" +#include "media/base/cdm_promise.h" +#include "media/base/content_decryption_module.h" +#include "media/base/ohos/ohos_media_crypto_context_impl.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/ohos_ndk/includes/ohos_adapter/drm_adapter.h" + +namespace media { +class MockSimpleCdmPromise : public SimpleCdmPromise { + public: + MOCK_METHOD(void, resolve, (), (override)); + MOCK_METHOD(void, + reject, + (Exception exception_code, + uint32_t system_code, + const std::string& error_message), + (override)); +}; + +class MockNewSessionCdmPromise : public media::CdmPromiseTemplate { + public: + MOCK_METHOD(void, resolve, (const std::string& result), (override)); + MOCK_METHOD(void, + reject, + (Exception exception_code, + uint32_t system_code, + const std::string& error_message), + (override)); +}; + +class MockOHOSMediaCryptoContext : public OHOSMediaCryptoContext { + public: + MOCK_METHOD(void, + SetOHOSMediaCryptoReadyCB, + (OHOSMediaCryptoReadyCB media_crypto_ready_cb), + (override)); +}; + +class MockDrmAdapter : public OHOS::NWeb::DrmAdapter { + public: + MOCK_METHOD(bool, IsSupported, (const std::string name), (override)); + MOCK_METHOD(bool, + IsSupported2, + (const std::string name, const std::string mimeType), + (override)); + MOCK_METHOD(bool, + IsSupported3, + (const std::string name, + const std::string mimeType, + int32_t level), + (override)); + MOCK_METHOD(std::vector, GetUUID, (std::string name), (override)); + MOCK_METHOD(void, StorageProvisionedResult, (bool result), (override)); + MOCK_METHOD(void, + StorageSaveInfoResult, + (bool result, int32_t type), + (override)); + MOCK_METHOD(void, + StorageLoadInfoResult, + (std::string sessionId, + std::vector keySetId, + std::string mimeType, + uint32_t keyType), + (override)); + MOCK_METHOD(void, + StorageClearInfoResult, + (bool result, int32_t type), + (override)); + MOCK_METHOD(int32_t, ReleaseMediaKeySystem, (), (override)); + MOCK_METHOD(int32_t, ReleaseMediaKeySession, (), (override)); + MOCK_METHOD(int32_t, + CreateKeySystem, + (const std::string name, int32_t securityLevel), + (override)); + MOCK_METHOD(int32_t, CreateMediaKeySession, (int32_t & level), (override)); + MOCK_METHOD(int32_t, + GenerateKeySystemRequest, + (uint8_t * request, + int32_t* requestLen, + char* defaultUrl, + int32_t defaultUrlLen), + (override)); + MOCK_METHOD(int32_t, + SetConfigurationString, + (const std::string configName, const std::string value), + (override)); + MOCK_METHOD(int32_t, + GetConfigurationString, + (const std::string configName, char* value, int32_t valueLen), + (override)); + MOCK_METHOD(int32_t, + SetConfigurationByteArray, + (const std::string configName, uint8_t* value, int32_t valueLen), + (override)); + MOCK_METHOD(int32_t, + GetConfigurationByteArray, + (const std::string configName, uint8_t* value, int32_t* valueLen), + (override)); + MOCK_METHOD(int32_t, + GetStatistics, + (std::shared_ptr statistics), + (override)); + MOCK_METHOD(int32_t, + GetMaxContentProtectionLevel, + (int32_t & level), + (override)); + MOCK_METHOD(int32_t, + ProcessKeySystemResponse, + (std::string response, bool isResponseReceived), + (override)); + MOCK_METHOD(int32_t, + GetCertificateStatus, + (int32_t & certStatus), + (override)); + MOCK_METHOD(int32_t, + RegistDrmCallback, + (std::shared_ptr callbackAdapter), + (override)); + MOCK_METHOD(int32_t, + SetMediaKeySystemCallback, + (int32_t eventType, uint8_t* info, int32_t infoLen, char* extra), + (override)); + MOCK_METHOD(int32_t, + SetSystemCallback, + (int32_t eventType, uint8_t* info, int32_t infoLen, char* extra), + (override)); + MOCK_METHOD(int32_t, + UpdateSession, + (uint32_t promiseId, + std::string sessionId, + std::vector response), + (override)); + MOCK_METHOD(int32_t, + CloseSession, + (uint32_t promiseId, std::string sessionId), + (override)); + MOCK_METHOD(int32_t, + RemoveSession, + (uint32_t promiseId, std::string sessionId), + (override)); + MOCK_METHOD(int32_t, + LoadSession, + (uint32_t promiseId, std::string sessionId), + (override)); + MOCK_METHOD(int32_t, ClearMediaKeys, (), (override)); + MOCK_METHOD(int32_t, + GenerateOfflineReleaseRequest, + (uint8_t * offlineMediaKeyId, + int32_t offlineMediaKeyIdLen, + uint8_t* releaseRequest, + int32_t* releaseRequestLen), + (override)); + MOCK_METHOD(int32_t, + ProcessOfflineReleaseResponse, + (uint8_t * offlineMediaKeyId, + int32_t offlineMediaKeyIdLen, + uint8_t* releaseRequest, + int32_t releaseRequestLen), + (override)); + MOCK_METHOD(int32_t, + RestoreOfflineMediaKeys, + (uint8_t * offlineMediaKeyId, int32_t offlineMediaKeyIdLen), + (override)); + MOCK_METHOD(int32_t, GetSecurityLevel, (), (override)); + MOCK_METHOD(int32_t, + RequireSecureDecoderModule, + (std::string mimeType, bool& status), + (override)); + MOCK_METHOD(int32_t, + GenerateMediaKeyRequest, + (std::string sessionId, + int32_t type, + int32_t initDataLen, + std::vector initData, + std::string mimeType, + uint32_t promiseId), + (override)); + MOCK_METHOD(int32_t, CheckMediaKeyStatus, (), (override)); +}; + +class OHOSMediaDrmBridgeTest : public testing::Test { + protected: + OHOSMediaDrmBridgeTest() = default; + ~OHOSMediaDrmBridgeTest() override = default; + + void SetUp() override { + std::vector scheme_uuid = {0x10, 0x31}; + std::string origin_id = "example_origin_id"; + OHOSMediaDrmBridge::SecurityLevel security_level = + OHOSMediaDrmBridge::SECURITY_LEVEL_DEFAULT; + bool requires_media_crypto = true; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + std::unique_ptr storage = + std::make_unique(); + media_drm_bridge_ = std::make_unique( + scheme_uuid, origin_id, security_level, requires_media_crypto, + std::move(storage), create_fetcher_cb, session_message_cb, + session_closed_cb, session_keys_change_cb, + session_expiration_update_cb); + cdm_promise_adapter_ = std::make_unique(); + media_crypto_ready_cb_ = std::make_unique(); + ohos_media_drm_storage_bridge_ = + std::make_unique(); + ohos_drm_callback_ = + std::make_unique(media_drm_bridge_.get()); + } + + void TearDown() override { + media_drm_bridge_.release(); + cdm_promise_adapter_.reset(); + media_crypto_ready_cb_.reset(); + ohos_media_drm_storage_bridge_.reset(); + ohos_drm_callback_.reset(); + } + std::unique_ptr media_drm_bridge_; + std::unique_ptr cdm_promise_adapter_; + std::unique_ptr media_crypto_ready_cb_; + std::unique_ptr ohos_media_drm_storage_bridge_; + CreateFetcherCB create_fetcher_cb; + std::unique_ptr ohos_drm_callback_; + SessionMessageCB session_message_cb; + SessionClosedCB session_closed_cb; + SessionKeysChangeCB session_keys_change_cb; + SessionExpirationUpdateCB session_expiration_update_cb; +}; + +TEST_F(OHOSMediaDrmBridgeTest, IsKeySystemSupported) { + const std::string key_system = "key_system_"; + media_drm_bridge_->IsKeySystemSupported(key_system); + EXPECT_FALSE(media_drm_bridge_->IsKeySystemSupported(key_system)); +} + +TEST_F(OHOSMediaDrmBridgeTest, IsPersistentLicenseTypeSupported) { + const std::string key_system = "key_system"; + auto result = media_drm_bridge_->IsPersistentLicenseTypeSupported(key_system); + EXPECT_TRUE(result); +} + +TEST_F(OHOSMediaDrmBridgeTest, IsKeySystemSupportedWithType) { + const std::string key_system = "key_system"; + const std::string container_mime_type = "container_mime_type_"; + auto result = media_drm_bridge_->IsKeySystemSupportedWithType( + key_system, container_mime_type); + EXPECT_FALSE(result); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetPlatformKeySystemNames) { + auto result = media_drm_bridge_->GetPlatformKeySystemNames(); + EXPECT_TRUE(result.empty()); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetUUID) { + const std::string key_system = "key_system"; + auto result = media_drm_bridge_->GetUUID(key_system); + EXPECT_TRUE(result.empty()); +} + +TEST_F(OHOSMediaDrmBridgeTest, CreateInternal) { + std::vector scheme_uuid_ = {0x10, 0x31}; + std::string origin_id_ = "example_origin_id"; + OHOSMediaDrmBridge::SecurityLevel security_level_ = + OHOSMediaDrmBridge::SECURITY_LEVEL_DEFAULT; + bool requires_media_crypto_ = true; + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + std::unique_ptr storage = + std::make_unique(); + CreateFetcherCB create_fetcher_cb_; + SessionMessageCB session_message_cb_; + SessionClosedCB session_closed_cb_; + SessionKeysChangeCB session_keys_change_cb_; + SessionExpirationUpdateCB session_expiration_update_cb_; + media_drm_bridge_->CreateInternal(scheme_uuid_, origin_id_, security_level_, + requires_media_crypto_, std::move(storage), + create_fetcher_cb_, session_message_cb_, + session_closed_cb_, session_keys_change_cb_, + session_expiration_update_cb_); + ASSERT_NE(media_drm_bridge_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, SetServerCertificate) { + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::vector certificate = {0x00, 0x01, 0x02, 0x03}; + media_drm_bridge_->SetServerCertificate(certificate, std::move(mock_promise)); + ASSERT_EQ(mock_promise, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, CreateSessionAndGenerateRequest001) { + media::EmeInitDataType init_data_type = media::EmeInitDataType::WEBM; + std::vector init_data = {0x00, 0x01, 0x02, 0x03}; + CdmSessionType session_type = CdmSessionType::kTemporary; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->CreateSessionAndGenerateRequest( + session_type, init_data_type, init_data, std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, CreateSessionAndGenerateRequest002) { + media::EmeInitDataType init_data_type = media::EmeInitDataType::WEBM; + std::vector init_data = {0x00, 0x01, 0x02, 0x03}; + CdmSessionType session_type = CdmSessionType::kTemporary; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, + GenerateMediaKeyRequest(testing::_, testing::_, testing::_, + testing::_, testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->CreateSessionAndGenerateRequest( + session_type, init_data_type, init_data, std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, LoadSession001) { + const std::string session_id = "session_id"; + CdmSessionType session_type = CdmSessionType::kTemporary; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->LoadSession(session_type, session_id, + std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, LoadSession002) { + const std::string session_id = "session_id"; + CdmSessionType session_type = CdmSessionType::kPersistentLicense; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->LoadSession(session_type, session_id, + std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, LoadSession003) { + const std::string session_id = "session_id"; + CdmSessionType session_type = CdmSessionType::kPersistentLicense; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, LoadSession(testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->LoadSession(session_type, session_id, + std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, UpdateSession001) { + const std::string session_id = "session_id"; + const std::vector response = {1}; + std::unique_ptr mock_promise = + std::make_unique(); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + UpdateSession(testing::_, testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->UpdateSession(session_id, response, + std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, UpdateSession002) { + const std::string session_id = "session_id"; + const std::vector response = {1}; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->UpdateSession(session_id, response, + std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, CloseSession001) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->CloseSession(session_id, std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, CloseSession002) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, CloseSession(testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->CloseSession(session_id, std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, RemoveSession001) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->RemoveSession(session_id, std::move(mock_promise)); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, RemoveSession002) { + const std::string session_id = "session_id"; + std::unique_ptr mock_promise = + std::make_unique(); + EXPECT_CALL(*mock_promise, reject(testing::_, testing::_, testing::_)) + .Times(1); + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, RemoveSession(testing::_, testing::_)) + .Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->RemoveSession(session_id, std::move(mock_promise)); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetCdmContext) { + auto result = media_drm_bridge_->GetCdmContext(); + ASSERT_NE(result, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, DeleteOnCorrectThread) { + media_drm_bridge_->DeleteOnCorrectThread(); + ASSERT_NE(media_drm_bridge_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, RegisterEventCB) { + base::RepeatingCallback event_cb = + base::BindRepeating([](const media::CdmContext::Event event) -> void {}); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner); + auto result = media_drm_bridge_->RegisterEventCB(event_cb); + ASSERT_NE(result, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetOHOSMediaCryptoContext) { + auto result = media_drm_bridge_->GetOHOSMediaCryptoContext(); + ASSERT_NE(result, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, IsSecureCodecRequired) { + auto result = media_drm_bridge_->IsSecureCodecRequired(); + ASSERT_EQ(result, false); +} + +TEST_F(OHOSMediaDrmBridgeTest, ResolvePromise) { + uint32_t promise_id = 1; + media_drm_bridge_->ResolvePromise(promise_id); + ASSERT_NE(cdm_promise_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, ResolvePromiseWithSession) { + uint32_t promise_id = 1; + const std::string session_id = "session_id"; + media_drm_bridge_->ResolvePromiseWithSession(promise_id, session_id); + ASSERT_NE(cdm_promise_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, RejectPromise) { + uint32_t promise_id = 1; + CdmPromise::Exception exception_code = { + CdmPromise::Exception::NOT_SUPPORTED_ERROR}; + std::string error_message = "error_message"; + media_drm_bridge_->RejectPromise(promise_id, exception_code, error_message); + ASSERT_NE(cdm_promise_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, SetOHOSMediaCryptoReadyCB) { + MockOHOSMediaCryptoContext::OHOSMediaCryptoReadyCB media_crypto_ready_cb = + base::BindOnce([](void* session, bool requires_secure_video_codec) {}); + media_drm_bridge_->SetOHOSMediaCryptoReadyCB( + std::move(media_crypto_ready_cb)); + ASSERT_NE(media_crypto_ready_cb_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnOHOSMediaCryptoReady) { + media_drm_bridge_->OnOHOSMediaCryptoReady(nullptr); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisionRequest) { + std::string defaultUrl = "defaultUrl"; + std::string requestData = "requestData"; + media_drm_bridge_->OnProvisionRequest(defaultUrl, requestData); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisioningComplete) { + bool success = true; + media_drm_bridge_->provisioning_complete_cb_ = + base::BindOnce([](bool success) {}); + scoped_refptr task_runner( + base::MakeRefCounted()); + base::SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner); + media_drm_bridge_->OnProvisioningComplete(success); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolved) { + uint32_t promise_id = 1; + media_drm_bridge_->OnPromiseResolved(promise_id); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolvedWithSession) { + uint32_t promise_id = 1; + std::string session_id = "session_id"; + media_drm_bridge_->OnPromiseResolvedWithSession(promise_id, session_id); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseRejected) { + uint32_t promise_id = 1; + std::string error_message = "error_message"; + media_drm_bridge_->OnPromiseRejected(promise_id, error_message); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisionedResult001) { + bool result = true; + media_drm_bridge_->OnStorageProvisionedResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisionedResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, StorageProvisionedResult(testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageProvisionedResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoUpdateResult001) { + bool result = true; + media_drm_bridge_->OnStorageSaveInfoUpdateResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoUpdateResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + StorageSaveInfoResult(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageSaveInfoUpdateResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoRemoveResult001) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->OnStorageSaveInfoRemoveResult(result); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoRemoveResult) { + bool result = true; + media_drm_bridge_->OnStorageSaveInfoRemoveResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfoResult001) { + std::vector ket_set_id = {1}; + std::string mime = "mime_type"; + std::string session_id = "session_id"; + uint32_t key_type = 1; + media_drm_bridge_->OnStorageLoadInfoResult(session_id, ket_set_id, mime, + key_type); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfoResult002) { + std::vector ket_set_id = {1}; + std::string mime = "mime_type"; + std::string session_id = "session_id"; + uint32_t key_type = 1; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL( + *mock_ohos_drm_adapter, + StorageLoadInfoResult(testing::_, testing::_, testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageLoadInfoResult(session_id, ket_set_id, mime, + key_type); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyReleaseResult001) { + bool result = true; + media_drm_bridge_->OnStorageClearInfoForKeyReleaseResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyReleaseResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + StorageClearInfoResult(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageClearInfoForKeyReleaseResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailResult001) { + bool result = true; + media_drm_bridge_->OnStorageClearInfoForLoadFailResult(result); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailResult002) { + bool result = true; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + StorageClearInfoResult(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->OnStorageClearInfoForLoadFailResult(result); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionClosed) { + std::string session_id = "session_id"; + media_drm_bridge_->session_closed_cb_ = base::BindRepeating( + [](const std::string& session_id, CdmSessionClosedReason reason) {}); + media_drm_bridge_->OnSessionClosed(session_id); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionKeysChange) { + std::string session_id = "session_id"; + std::vector keyIdArray = {}; + std::vector statusArray = {}; + bool has_additional_usable_key = false; + SessionKeysChangeCB session_keys_change_cb; + CdmKeysInfo cdm_keys_info; + bool is_key_release = true; + media_drm_bridge_->session_keys_change_cb_ = base::BindRepeating( + [](const std::string& session_id, bool has_additional_usable_key, + CdmKeysInfo keys_info) {}); + media_drm_bridge_->OnSessionKeysChange(session_id, keyIdArray, statusArray, + has_additional_usable_key, + is_key_release); + ASSERT_EQ(keyIdArray.size(), statusArray.size()); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionExpirationUpdate) { + std::string session_id = "session_id"; + uint64_t expiry_time_ms = 1; + media_drm_bridge_->session_expiration_update_cb_ = base::BindRepeating( + [](const std::string& session_id, base::Time new_expiry_time) {}); + media_drm_bridge_->OnSessionExpirationUpdate(session_id, expiry_time_ms); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetSecurityLevel001) { + media_drm_bridge_->GetSecurityLevel(); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, GetSecurityLevel002) { + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, GetSecurityLevel()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->GetSecurityLevel(); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, NotifyMediaCryptoReady) { + void* session = nullptr; + media_drm_bridge_->NotifyMediaCryptoReady(session); + ASSERT_NE(media_crypto_ready_cb_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, ProcessProvisionResponse001) { + bool success = false; + const std::string response = "response"; + media_drm_bridge_->ProcessProvisionResponse(success, response); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, ProcessProvisionResponse002) { + bool success = false; + const std::string response = "response"; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + EXPECT_CALL(*mock_ohos_drm_adapter, + ProcessKeySystemResponse(testing::_, testing::_)) + .Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->ProcessProvisionResponse(success, response); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnHasAdditionalUsableKey) { + media_drm_bridge_->OnHasAdditionalUsableKey(); + ASSERT_NE(media_drm_bridge_->task_runner_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionMessage) { + std::string sessionId = "sessionId"; + int32_t type = 1; + std::vector message = {0x01, 0x02, 0x03, 0x04, 0x05}; + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + media_drm_bridge_->session_message_cb_ = base::BindRepeating( + [](const std::string& session_id, CdmMessageType message_type, + const std::vector& message) {}); + ohos_drm_callback_->OnSessionMessage(sessionId, type, message); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisionRequest001) { + std::string defaultUrl = "defaultUrl"; + std::string requestData = "requestData"; + ohos_drm_callback_->OnProvisionRequest(defaultUrl, requestData); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisionRequest002) { + std::unique_ptr mock_ohos_drm_adapter = + std::make_unique(); + EXPECT_CALL(*mock_ohos_drm_adapter, ReleaseMediaKeySystem()).Times(1); + media_drm_bridge_->ohos_drm_adapter_ = std::move(mock_ohos_drm_adapter); + std::string defaultUrl = "defaultUrl"; + std::string requestData = "requestData"; + ohos_drm_callback_->OnProvisionRequest(defaultUrl, requestData); + ASSERT_NE(media_drm_bridge_->ohos_drm_adapter_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnProvisioningCompleteCallback) { + bool success = true; + media_drm_bridge_->provisioning_complete_cb_ = + base::BindOnce([](bool success) {}); + ohos_drm_callback_->OnProvisioningComplete(success); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnMediaKeySessionReady) { + void* session = nullptr; + ohos_drm_callback_->OnMediaKeySessionReady(session); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseRejectedCallback) { + uint32_t promiseId = 0; + std::string errorMessage = "errorMessage"; + ohos_drm_callback_->OnPromiseRejected(promiseId, errorMessage); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolvedCallback) { + uint32_t promiseId = 0; + ohos_drm_callback_->OnPromiseResolved(promiseId); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnPromiseResolvedWithSessionCallback) { + uint32_t promiseId = 0; + std::string sessionId = "sessionId"; + ohos_drm_callback_->OnPromiseResolvedWithSession(promiseId, sessionId); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionClosedCallback) { + std::string sessionId = "sessionId"; + media_drm_bridge_->session_closed_cb_ = base::BindRepeating( + [](const std::string& session_id, CdmSessionClosedReason reason) {}); + ohos_drm_callback_->OnSessionClosed(sessionId); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionExpirationUpdateCallback) { + std::string sessionId = "sessionId"; + uint64_t expiration_time = 1; + media_drm_bridge_->session_expiration_update_cb_ = base::BindRepeating( + [](const std::string& session_id, base::Time new_expiry_time) {}); + ohos_drm_callback_->OnSessionExpirationUpdate(sessionId, expiration_time); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnSessionKeysChangeCallback) { + std::string sessionId = "sessionId"; + std::vector keyIdArray = {}; + std::vector statusArray = {}; + bool has_additional_usable_key = true; + bool is_key_release = true; + media_drm_bridge_->session_keys_change_cb_ = base::BindRepeating( + [](const std::string& session_id, bool has_additional_usable_key, + CdmKeysInfo keys_info) {}); + ohos_drm_callback_->OnSessionKeysChange(sessionId, keyIdArray, statusArray, + has_additional_usable_key, + is_key_release); + ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); +} +} // namespace media diff --git a/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc index 0c003746b6..6b8236c22c 100644 --- a/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc +++ b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc @@ -61,8 +61,8 @@ class OHOSMediaDrmStorageBridgeTest : public ::testing::Test { } void TearDown() override { - factory.release(); - factory_.release(); + factory.reset(); + factory_.reset(); create_storage_cb_.Reset(); create_fetcher_cb_.Reset(); } @@ -81,7 +81,6 @@ TEST_F(OHOSMediaDrmStorageBridgeTest, Initialize) { std::unique_ptr storage = std::make_unique(); EXPECT_CALL(*storage, Initialize(testing::_)) .Times(testing::AtLeast(0)); - testing::Mock::AllowLeak(storage.get()); return storage; }); factory->Initialize(factory_->create_storage_cb_, std::move(init_cb)); -- Gitee From 6fe12175e835d11a7e9bab35d70d1c471373e1ef Mon Sep 17 00:00:00 2001 From: tengfan Date: Tue, 14 Jan 2025 16:53:53 +0800 Subject: [PATCH 11/15] DRM_UT --- .../ohos/ohos_media_drm_bridge_unittest.cc | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/media/base/ohos/ohos_media_drm_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_unittest.cc index b578f23ce6..053273ec4c 100644 --- a/media/base/ohos/ohos_media_drm_bridge_unittest.cc +++ b/media/base/ohos/ohos_media_drm_bridge_unittest.cc @@ -184,6 +184,14 @@ class MockDrmAdapter : public OHOS::NWeb::DrmAdapter { MOCK_METHOD(int32_t, CheckMediaKeyStatus, (), (override)); }; +class MockProvisionFetcher : public ProvisionFetcher { + public: + MOCK_METHOD(void, + Retrieve, + (const GURL&, const std::string&, ResponseCB), + (override)); +}; + class OHOSMediaDrmBridgeTest : public testing::Test { protected: OHOSMediaDrmBridgeTest() = default; @@ -690,6 +698,44 @@ TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailResult002) { media_drm_bridge_.reset(); } +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisioned) { + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageProvisioned(); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfo) { + std::vector ket_set_id = {1}; + std::string mime_type = "mime_type"; + std::string session_id = "session_id"; + int32_t key_type = 1; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageSaveInfo(ket_set_id, mime_type, session_id, + key_type); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyRelease) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageClearInfoForKeyRelease(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfo) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageLoadInfo(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFail) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + media_drm_bridge_->OnStorageClearInfoForLoadFail(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + TEST_F(OHOSMediaDrmBridgeTest, OnSessionClosed) { std::string session_id = "session_id"; media_drm_bridge_->session_closed_cb_ = base::BindRepeating( @@ -873,4 +919,59 @@ TEST_F(OHOSMediaDrmBridgeTest, OnSessionKeysChangeCallback) { is_key_release); ASSERT_EQ(media_drm_bridge_->ohos_drm_adapter_, nullptr); } + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForKeyReleaseCallback) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageClearInfoForKeyRelease(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageProvisionedCallback) { + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageProvisioned(); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageSaveInfoCallback) { + std::vector ket_set_id = {1}; + std::string mime_type = "mime_type"; + std::string session_id = "session_id"; + int32_t key_type = 1; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageSaveInfo(ket_set_id, mime_type, session_id, + key_type); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageLoadInfoCallback) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageLoadInfo(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} + +TEST_F(OHOSMediaDrmBridgeTest, SendProvisioningRequest) { + const GURL default_url("default_url"); + const std::string request_data = "request_data"; + std::unique_ptr mock_provision_fetcher = + std::make_unique(); + EXPECT_CALL(*mock_provision_fetcher, + Retrieve(testing::_, testing::_, testing::_)) + .Times(testing::AnyNumber()); + media_drm_bridge_->create_fetcher_cb_ = + base::BindLambdaForTesting([&]() -> std::unique_ptr { + return std::move(mock_provision_fetcher); + }); + media_drm_bridge_->SendProvisioningRequest(default_url, request_data); + ASSERT_NE(media_drm_bridge_->provision_fetcher_, nullptr); + media_drm_bridge_.reset(); +} + +TEST_F(OHOSMediaDrmBridgeTest, OnStorageClearInfoForLoadFailCallback) { + std::string session_id = "session_id"; + media_drm_bridge_->storage_ = nullptr; + ohos_drm_callback_->OnStorageClearInfoForLoadFail(session_id); + ASSERT_EQ(media_drm_bridge_->storage_, nullptr); +} } // namespace media -- Gitee From fbca5d38a64fb640ee17ccf1bf0daa8e40aa6867 Mon Sep 17 00:00:00 2001 From: tengfan Date: Wed, 15 Jan 2025 09:50:47 +0800 Subject: [PATCH 12/15] DRM_UT --- media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc index 6b8236c22c..acaf34d622 100644 --- a/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc +++ b/media/base/ohos/ohos_media_drm_storage_bridge_unittest.cc @@ -1,6 +1,5 @@ #include "base/test/bind.h" #include "base/test/test_simple_task_runner.h" -#include "gtest/gtest.h" #define private public #include "media/base/ohos/ohos_media_drm_storage_bridge.h" #include "ohos_media_drm_bridge_factory.h" -- Gitee From f30820e171419b343449e347ea76128c10a2589c Mon Sep 17 00:00:00 2001 From: tengfan Date: Mon, 20 Jan 2025 15:01:00 +0800 Subject: [PATCH 13/15] DRM_UT --- .../ohos_media_drm_bridge_client_unittest.cc | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc index 1cc1ceca26..21347fc3e0 100644 --- a/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc +++ b/media/base/ohos/ohos_media_drm_bridge_client_unittest.cc @@ -1,39 +1,37 @@ #include "media/base/ohos/ohos_media_drm_bridge_client.h" #include "media/base/ohos/ohos_media_drm_bridge_delegate.h" -#include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" namespace media { - class SetMediaDrmBridgeClientTest : public ::testing::Test { protected: SetMediaDrmBridgeClientTest() = default; ~SetMediaDrmBridgeClientTest() override = default; void SetUp() override { - media_drm_bridge_client = std::make_unique(); + media_drm_bridge_client_ = std::make_unique(); } - void TearDown() override { media_drm_bridge_client.reset(); } - std::unique_ptr media_drm_bridge_client; + void TearDown() override { media_drm_bridge_client_.reset(); } + std::unique_ptr media_drm_bridge_client_; }; TEST_F(SetMediaDrmBridgeClientTest, SetMediaDrmBridgeClient) { - SetMediaDrmBridgeClient(media_drm_bridge_client.get()); - EXPECT_NE(media_drm_bridge_client.get(), nullptr); + SetMediaDrmBridgeClient(media_drm_bridge_client_.get()); + EXPECT_NE(media_drm_bridge_client_.get(), nullptr); } TEST_F(SetMediaDrmBridgeClientTest, GetMediaDrmBridgeDelegate) { std::vector scheme_uuid; UUID test_scheme_uuid(scheme_uuid); OHOSMediaDrmBridgeDelegate* result = - media_drm_bridge_client->GetMediaDrmBridgeDelegate(test_scheme_uuid); + media_drm_bridge_client_->GetMediaDrmBridgeDelegate(test_scheme_uuid); EXPECT_EQ(result, nullptr); } TEST_F(SetMediaDrmBridgeClientTest, AddKeySystemUUIDMappings) { OHOSMediaDrmBridgeClient::KeySystemUuidMap key_system_uuid_map; - media_drm_bridge_client->AddKeySystemUUIDMappings(&key_system_uuid_map); + media_drm_bridge_client_->AddKeySystemUUIDMappings(&key_system_uuid_map); EXPECT_TRUE(key_system_uuid_map.empty()); } } // namespace media -- Gitee From 21f75b9a9ae49a39f028391e67e0b8d415df781f Mon Sep 17 00:00:00 2001 From: tengfan Date: Mon, 20 Jan 2025 15:42:36 +0800 Subject: [PATCH 14/15] DRM_UT --- .../ohos_media_drm_bridge_delegate_unittest.cc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc index 6d23a1fe37..1f20c15f96 100644 --- a/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc +++ b/media/base/ohos/ohos_media_drm_bridge_delegate_unittest.cc @@ -14,26 +14,26 @@ class OHOSMediaDrmBridgeDelegateTest : public ::testing::Test { OHOSMediaDrmBridgeDelegateTest() = default; ~OHOSMediaDrmBridgeDelegateTest() override = default; void SetUp() override { - mock_delegate = std::make_unique(); + mock_delegate_ = std::make_unique(); } void TearDown() override { - mock_delegate.reset(); - delegate.reset(); + mock_delegate_.reset(); + delegate_.reset(); } - std::unique_ptr delegate; - std::unique_ptr mock_delegate; + std::unique_ptr delegate_; + std::unique_ptr mock_delegate_; }; TEST_F(OHOSMediaDrmBridgeDelegateTest, OnCreateSession) { - delegate = std::move(mock_delegate); + delegate_ = std::move(mock_delegate_); EmeInitDataType init_data_type = EmeInitDataType::WEBM; std::vector init_data = {0x01, 0x02, 0x03}; std::vector init_data_out; std::vector optional_parameters_out; bool result = false; - result = delegate->OnCreateSession(init_data_type, init_data, &init_data_out, - &optional_parameters_out); + result = delegate_->OnCreateSession(init_data_type, init_data, &init_data_out, + &optional_parameters_out); EXPECT_TRUE(result); } } // namespace media -- Gitee From 39332ac6193fb6fb6774f469ecc9e5e522939905 Mon Sep 17 00:00:00 2001 From: tengfan Date: Mon, 20 Jan 2025 16:00:43 +0800 Subject: [PATCH 15/15] DRM_UT --- .../mojo/services/ohos_mojo_media_client_unittests.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/media/mojo/services/ohos_mojo_media_client_unittests.cc b/media/mojo/services/ohos_mojo_media_client_unittests.cc index 5d80240c57..74ed7ef844 100644 --- a/media/mojo/services/ohos_mojo_media_client_unittests.cc +++ b/media/mojo/services/ohos_mojo_media_client_unittests.cc @@ -30,10 +30,10 @@ class MockFrameInterfaceFactory : public mojom::FrameInterfaceFactory { (override)); }; -class OhosMojoMediaClientTest : public ::testing::Test { +class OHOSMojoMediaClientTest : public ::testing::Test { protected: - OhosMojoMediaClientTest() = default; - ~OhosMojoMediaClientTest() override = default; + OHOSMojoMediaClientTest() = default; + ~OHOSMojoMediaClientTest() override = default; void SetUp() override { client = std::make_unique(); @@ -50,7 +50,7 @@ class OhosMojoMediaClientTest : public ::testing::Test { std::unique_ptr Mock_frame_interfaces; }; -TEST_F(OhosMojoMediaClientTest, CreateAudioDecoder) { +TEST_F(OHOSMojoMediaClientTest, CreateAudioDecoder) { scoped_refptr task_runner = nullptr; std::unique_ptr media_log = nullptr; auto audio_decoder = @@ -58,7 +58,7 @@ TEST_F(OhosMojoMediaClientTest, CreateAudioDecoder) { ASSERT_EQ(audio_decoder, nullptr); } -TEST_F(OhosMojoMediaClientTest, CreateCdmFactory) { +TEST_F(OHOSMojoMediaClientTest, CreateCdmFactory) { frame_interfaces = std::move(Mock_frame_interfaces); auto cdm_factory = client->CreateCdmFactory(frame_interfaces.get()); ASSERT_NE(cdm_factory, nullptr); -- Gitee