diff --git a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/include/distributed_hardware_proxy_test.h b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/include/distributed_hardware_proxy_test.h index 7108d198fa29ac5f0be3080d0779987b07b30fd7..ab51ec58305fe66ec04a81b908ff39ef350b7809 100644 --- a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/include/distributed_hardware_proxy_test.h +++ b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/include/distributed_hardware_proxy_test.h @@ -79,6 +79,34 @@ public: (void)message; } }; + +class MockHDSinkStatusListenerStub : public IRemoteStub { +public: + void OnEnable(const DHDescriptor &dhDescriptor) override + { + (void)dhDescriptor; + } + + void OnDisable(const DHDescriptor &dhDescriptor) override + { + (void)dhDescriptor; + } +}; + +class MockHDSourceStatusListenerStub : public IRemoteStub { +public: + void OnEnable(const std::string &networkId, const DHDescriptor &dhDescriptor) override + { + (void)networkId; + (void)dhDescriptor; + } + + void OnDisable(const std::string &networkId, const DHDescriptor &dhDescriptor) override + { + (void)networkId; + (void)dhDescriptor; + } +}; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DISTRIBUTED_HARDWARE_PROXY_TEST_H \ No newline at end of file diff --git a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp index 5ebac24dd07a19ce85a6d374f67418d3c2b4e6f1..283120adf30eeb602700fc1f384ddaab5d7c8693 100644 --- a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp +++ b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp @@ -518,5 +518,105 @@ HWTEST_F(DistributedHardwareProxyTest, StopDistributedHardware_001, TestSize.Lev ret = dhProxy.StopDistributedHardware(dhType, networkId); EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); } + +HWTEST_F(DistributedHardwareProxyTest, GetDistributedHardware_001, TestSize.Level1) +{ + std::string networkId = "123456"; + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + std::vector descriptors; + auto ret = dhProxy.GetDistributedHardware(networkId, descriptors); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Source_001, TestSize.Level1) +{ + std::string networkId = "123456"; + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSourceStatusListenerStub()); + auto ret = dhProxy.RegisterDHStatusListener(networkId, listener); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_001, TestSize.Level1) +{ + std::string networkId = "123456"; + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSourceStatusListenerStub()); + auto ret = dhProxy.UnregisterDHStatusListener(networkId, listener); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_001, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSinkStatusListenerStub()); + auto ret = dhProxy.RegisterDHStatusListener(listener); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_001, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSinkStatusListenerStub()); + auto ret = dhProxy.UnregisterDHStatusListener(listener); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, EnableSink_001, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + std::vector descriptors = {{ .id = "camera_1", .dhType = DHType::CAMERA }}; + auto ret = dhProxy.EnableSink(descriptors); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, DisableSink_001, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + std::vector descriptors = {{ .id = "camera_1", .dhType = DHType::CAMERA }}; + auto ret = dhProxy.DisableSink(descriptors); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, EnableSource_001, TestSize.Level1) +{ + std::string networkId = "123456"; + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + std::vector descriptors; + auto ret = dhProxy.EnableSource(networkId, descriptors); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, DisableSource_001, TestSize.Level1) +{ + std::string networkId = "123456"; + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + std::vector descriptors; + auto ret = dhProxy.DisableSource(networkId, descriptors); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/BUILD.gn index 2d76738612138a74c51ae8b1b580678d3bed36af..fbcbadbf8e643e97f94a60e6c0667f6a510d4ffa 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/BUILD.gn +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/BUILD.gn @@ -37,7 +37,10 @@ config("module_private_config") { ohos_unittest("DistributedHardwareStubTest") { module_out_path = module_out_path - sources = [ "src/distributed_hardware_stub_test.cpp" ] + sources = [ + "src/accesstoken_kit_mock.cpp", + "src/distributed_hardware_stub_test.cpp", + ] configs = [ ":module_private_config" ] @@ -59,9 +62,14 @@ ohos_unittest("DistributedHardwareStubTest") { ] external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", "cJSON:cjson", "c_utils:utils", "eventhandler:libeventhandler", + "googletest:gmock", + "googletest:gmock_main", "ipc:ipc_core", "safwk:system_ability_fwk", ] diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/accesstoken_kit_mock.h b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/accesstoken_kit_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..3175a951fe63321f9b5751157c5b6240645f4dbd --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/accesstoken_kit_mock.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License") = 0; + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DISTRIBUTED_HARDWARE_ACCESSTOKEN_KIT_MOCK_H +#define OHOS_DISTRIBUTED_HARDWARE_ACCESSTOKEN_KIT_MOCK_H + +#include + +#include "accesstoken_kit.h" +#include "tokenid_kit.h" + +using OHOS::Security::AccessToken::ATokenTypeEnum; +using OHOS::Security::AccessToken::AccessTokenID; +using OHOS::Security::AccessToken::HapTokenInfo; +using OHOS::Security::AccessToken::NativeTokenInfo; + +namespace OHOS { +namespace DistributedHardware { +class AccessTokenKitInterface { +public: + AccessTokenKitInterface() = default; + virtual ~AccessTokenKitInterface() = default; + + virtual ATokenTypeEnum GetTokenTypeFlag(AccessTokenID) = 0; + virtual int GetHapTokenInfo(AccessTokenID, HapTokenInfo &) = 0; + virtual int GetNativeTokenInfo(AccessTokenID, NativeTokenInfo &) = 0; + virtual AccessTokenID GetNativeTokenId(const std::string &) = 0; + virtual AccessTokenID GetHapTokenID(int32_t, const std::string &, int32_t) = 0; + virtual int VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName) = 0; + + static std::shared_ptr GetOrCreateAccessTokenKit(); + static void ReleaseAccessTokenKit(); +private: + static std::shared_ptr token_; +}; + +class AccessTokenKitMock : public AccessTokenKitInterface { +public: + AccessTokenKitMock() = default; + ~AccessTokenKitMock() override = default; + + MOCK_METHOD(ATokenTypeEnum, GetTokenTypeFlag, (AccessTokenID)); + MOCK_METHOD(int, GetHapTokenInfo, (AccessTokenID, HapTokenInfo &)); + MOCK_METHOD(int, GetNativeTokenInfo, (AccessTokenID, NativeTokenInfo &)); + MOCK_METHOD(AccessTokenID, GetNativeTokenId, (const std::string &)); + MOCK_METHOD(AccessTokenID, GetHapTokenID, (int32_t, const std::string &, int32_t)); + MOCK_METHOD(int, VerifyAccessToken, (AccessTokenID, const std::string&)); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DISTRIBUTED_HARDWARE_ACCESSTOKEN_KIT_MOCK_H diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h index bc5d86fb119a904c80fea465df6f593b4c9d190e..f7a38b77a106a304dfcfb0a3648465bd631e7c86 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h @@ -18,6 +18,7 @@ #include +#include "accesstoken_kit_mock.h" #include "distributed_hardware_errno.h" #include "distributed_hardware_fwk_kit_paras.h" #include "distributed_hardware_stub.h" @@ -31,6 +32,7 @@ public: void SetUp(); void TearDown(); std::shared_ptr stubTest_ = nullptr; + std::shared_ptr token_ = nullptr; }; class MockDistributedHardwareStub : public DistributedHardwareStub { @@ -182,6 +184,43 @@ int32_t DisableSource(const std::string &networkId, const std::vector { +public: + void OnMessage(const DHTopic topic, const std::string& message) + { + (void)topic; + (void)message; + } +}; + +class MockHDSinkStatusListenerStub : public IRemoteStub { +public: + void OnEnable(const DHDescriptor &dhDescriptor) override + { + (void)dhDescriptor; + } + + void OnDisable(const DHDescriptor &dhDescriptor) override + { + (void)dhDescriptor; + } +}; + +class MockHDSourceStatusListenerStub : public IRemoteStub { +public: + void OnEnable(const std::string &networkId, const DHDescriptor &dhDescriptor) override + { + (void)networkId; + (void)dhDescriptor; + } + + void OnDisable(const std::string &networkId, const DHDescriptor &dhDescriptor) override + { + (void)networkId; + (void)dhDescriptor; + } +}; } // namespace DistributedHardware } // namespace OHOS #endif diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/accesstoken_kit_mock.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/accesstoken_kit_mock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8475fc5f33ad5d23783e1e46b88cdbe38905b06d --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/accesstoken_kit_mock.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "accesstoken_kit_mock.h" + +using namespace OHOS::DistributedHardware; + +namespace OHOS { +namespace Security { +namespace AccessToken { +ATokenTypeEnum AccessTokenKit::GetTokenTypeFlag(AccessTokenID tokenID) +{ + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetTokenTypeFlag(tokenID); +} + +int AccessTokenKit::GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfo &hapTokenInfoRes) +{ + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetHapTokenInfo(tokenID, hapTokenInfoRes); +} + +int AccessTokenKit::GetNativeTokenInfo(AccessTokenID tokenID, NativeTokenInfo &nativeTokenInfoRes) +{ + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetNativeTokenInfo(tokenID, nativeTokenInfoRes); +} + +AccessTokenID AccessTokenKit::GetNativeTokenId(const std::string &GetNativeTokenId) +{ + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetNativeTokenId(GetNativeTokenId); +} + +AccessTokenID AccessTokenKit::GetHapTokenID(int32_t userID, const std::string &bundleName, int32_t instIndex) +{ + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetHapTokenID(userID, bundleName, instIndex); +} + +int AccessTokenKit::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName) +{ + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->VerifyAccessToken(tokenID, permissionName); +} +} // namespace AccessToken +} // namespace Security + +namespace DistributedHardware { +std::shared_ptr AccessTokenKitInterface::token_ = nullptr; + +std::shared_ptr AccessTokenKitInterface::GetOrCreateAccessTokenKit() +{ + if (!token_) { + token_ = std::make_shared(); + } + return token_; +} + +void AccessTokenKitInterface::ReleaseAccessTokenKit() +{ + token_.reset(); + token_ = nullptr; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp index 8b9ff7388fa0a5182abe9ad49aaef2feafa50bfd..5338ad995db3cc84a54ebdae9da920eb5de76c3a 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp @@ -19,6 +19,9 @@ #include "iremote_stub.h" #include "dhardware_ipc_interface_code.h" + +using namespace OHOS::Security::AccessToken; +using namespace testing; using namespace testing::ext; namespace OHOS { @@ -30,11 +33,17 @@ void DistributedHardwareStubTest::TearDownTestCase(void) {} void DistributedHardwareStubTest::SetUp() { stubTest_ = std::make_shared(); + auto token = AccessTokenKitInterface::GetOrCreateAccessTokenKit(); + token_ = std::static_pointer_cast(token); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_DENIED)); } void DistributedHardwareStubTest::TearDown() { stubTest_ = nullptr; + AccessTokenKitInterface::ReleaseAccessTokenKit(); + token_ = nullptr; } /** @@ -387,6 +396,208 @@ HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_025, TestSize.Level1) EXPECT_NE(DH_FWK_SUCCESS, ret); } +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_026, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::REG_PUBLISHER_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + uint32_t topicInt = (uint32_t)DHTopic::TOPIC_START_DSCREEN; + data.WriteUint32(topicInt); + + sptr listener(new MockIPublisherListener()); + data.WriteRemoteObject(listener); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_027, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::UNREG_PUBLISHER_LISTENER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + uint32_t topicInt = (uint32_t)DHTopic::TOPIC_START_DSCREEN; + data.WriteUint32(topicInt); + + sptr listener(new MockIPublisherListener()); + data.WriteRemoteObject(listener); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_028, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::GET_DISTRIBUTED_HARDWARE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteString("netWorkId_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_029, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::REG_DH_SINK_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + sptr listener(new MockHDSinkStatusListenerStub()); + data.WriteRemoteObject(listener); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_030, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::UNREG_DH_SINK_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + sptr listener(new MockHDSinkStatusListenerStub()); + data.WriteRemoteObject(listener); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_031, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::REG_DH_SOURCE_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteString("networkId_test"); + sptr listener(new MockHDSourceStatusListenerStub()); + data.WriteRemoteObject(listener); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_032, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::UNREG_DH_SOURCE_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteString("networkId_test"); + sptr listener(new MockHDSourceStatusListenerStub()); + data.WriteRemoteObject(listener); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_033, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::ENABLE_SINK); + MessageParcel data; + MessageParcel reply; + MessageOption option; + size_t descriptorCount = 1; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(descriptorCount); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_034, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::DISABLE_SINK); + MessageParcel data; + MessageParcel reply; + MessageOption option; + size_t descriptorCount = 1; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(descriptorCount); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_035, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::ENABLE_SOURCE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + size_t descriptorCount = 1; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(descriptorCount); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_036, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + + uint32_t code = static_cast(DHMsgInterfaceCode::DISABLE_SOURCE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + size_t descriptorCount = 1; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(descriptorCount); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + /** * @tc.name: RegisterPublisherListenerInner_001 * @tc.desc: Verify the RegisterPublisherListenerInner function