1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use sinkDev_ file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "daudio_sink_manager_test.h"
17 
18 #include "audio_event.h"
19 #include "daudio_errorcode.h"
20 #include "if_system_ability_manager.h"
21 #include "iservice_registry.h"
22 #include "daudio_sink_ipc_callback_proxy.h"
23 #include "daudio_sink_load_callback.h"
24 
25 using namespace testing::ext;
26 
27 namespace OHOS {
28 namespace DistributedHardware {
SetUpTestCase(void)29 void DAudioSinkManagerTest::SetUpTestCase(void) {}
30 
TearDownTestCase(void)31 void DAudioSinkManagerTest::TearDownTestCase(void) {}
32 
SetUp()33 void DAudioSinkManagerTest::SetUp()
34 {
35     sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
36     if (samgr == nullptr) {
37         return;
38     }
39     remoteObject_ = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
40     if (remoteObject_ == nullptr) {
41         return;
42     }
43 }
44 
TearDown()45 void DAudioSinkManagerTest::TearDown() {}
46 
47 /**
48  * @tc.name: Init_001
49  * @tc.desc: Verify the Init function.
50  * @tc.type: FUNC
51  * @tc.require: AR000H0E5F
52  */
53 HWTEST_F(DAudioSinkManagerTest, Init_001, TestSize.Level1)
54 {
55     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
56     EXPECT_NE(DH_SUCCESS, daudioSinkManager.Init(dAudioSinkIpcCallbackProxy));
57     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnInit());
58 }
59 
60 /**
61  * @tc.name: HandleDAudioNotify_001
62  * @tc.desc: Verify the HandleDAudioNotify function.
63  * @tc.type: FUNC
64  * @tc.require: AR000H0E5F
65  */
66 HWTEST_F(DAudioSinkManagerTest, HandleDAudioNotify_001, TestSize.Level1)
67 {
68     std::string devId = "1";
69     std::string dhId = "1";
70     std::string content = "1";
71     int32_t type = 1;
72     daudioSinkManager.audioDevMap_.emplace(devId, nullptr);
73     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.HandleDAudioNotify(devId, dhId, type, content));
74 }
75 
76 /**
77  * @tc.name: DAudioNotify_001
78  * @tc.desc: Verify the DAudioNotify function.
79  * @tc.type: FUNC
80  * @tc.require: AR000H0E5F
81  */
82 HWTEST_F(DAudioSinkManagerTest, DAudioNotify_001, TestSize.Level1)
83 {
84     std::string devId = "devId";
85     std::string dhId = "dhId";
86     const int32_t eventType = 1;
87     const std::string eventContent = "eventContent";
88     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR,
89         daudioSinkManager.DAudioNotify(devId, dhId, eventType, eventContent));
90     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
91     auto remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, devId);
92     sptr<IDAudioSource> remoteSvrProxy = iface_cast<IDAudioSource>(remoteObject);
93     daudioSinkManager.sourceServiceMap_[devId] = remoteSvrProxy;
94     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, daudioSinkManager.DAudioNotify(devId, dhId, eventType, eventContent));
95 }
96 
97 /**
98  * @tc.name: CreateAudioDevice_001
99  * @tc.desc: Verify the CreateAudioDevice function.
100  * @tc.type: FUNC
101  * @tc.require: AR000H0E5F
102  */
103 HWTEST_F(DAudioSinkManagerTest, CreateAudioDevice_001, TestSize.Level1)
104 {
105     std::string devId = "devId";
106     std::string params = "params";
107     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
108     if (samgr == nullptr) {
109         return;
110     }
111     sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
112     samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
113     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
114     if (remoteObject == nullptr) {
115         return;
116     }
117     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
118     daudioSinkManager.ipcSinkCallback_ = dAudioSinkIpcCallbackProxy;
119     EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, daudioSinkManager.CreateAudioDevice(devId));
120     daudioSinkManager.audioDevMap_.emplace(devId, nullptr);
121     EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, daudioSinkManager.CreateAudioDevice(devId));
122     daudioSinkManager.channelState_ = ChannelState::SPK_CONTROL_OPENED;
123     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.CreateAudioDevice(devId));
124     daudioSinkManager.ClearAudioDev(devId);
125     daudioSinkManager.channelState_ = ChannelState::MIC_CONTROL_OPENED;
126     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.CreateAudioDevice(devId));
127 }
128 
129 /**
130  * @tc.name: InitAudioDevice_001
131  * @tc.desc: Verify the InitAudioDevice function.
132  * @tc.type: FUNC
133  * @tc.require: AR000H0E5F
134  */
135 HWTEST_F(DAudioSinkManagerTest, InitAudioDevice_001, TestSize.Level1)
136 {
137     std::string devId = "1";
138     std::string params = "params";
139     std::shared_ptr<DAudioSinkDev> dev = nullptr;
140     EXPECT_NE(DH_SUCCESS, daudioSinkManager.InitAudioDevice(dev, devId, true));
141     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
142     if (samgr == nullptr) {
143         return;
144     }
145     sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
146     samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
147     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
148     if (remoteObject == nullptr) {
149         return;
150     }
151     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
152     daudioSinkManager.ipcSinkCallback_ = dAudioSinkIpcCallbackProxy;
153     dev = std::make_shared<DAudioSinkDev>(devId, dAudioSinkIpcCallbackProxy);
154     EXPECT_NE(DH_SUCCESS, daudioSinkManager.InitAudioDevice(dev, devId, true));
155     EXPECT_NE(DH_SUCCESS, daudioSinkManager.InitAudioDevice(dev, devId, false));
156 }
157 
158 /**
159  * @tc.name: LoadAVSenderEngineProvider_001
160  * @tc.desc: Verify the LoadAVSenderEngineProvider function.
161  * @tc.type: FUNC
162  * @tc.require: AR000H0E5F
163  */
164 HWTEST_F(DAudioSinkManagerTest, LoadAVSenderEngineProvider_001, TestSize.Level1)
165 {
166     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.LoadAVSenderEngineProvider());
167     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnloadAVSenderEngineProvider());
168     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.LoadAVReceiverEngineProvider());
169     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnloadAVReceiverEngineProvider());
170 }
171 
172 /**
173  * @tc.name: PauseDistributedHardware_001
174  * @tc.desc: Verify the PauseDistributedHardware function.
175  * @tc.type: FUNC
176  * @tc.require: AR000H0E5F
177  */
178 HWTEST_F(DAudioSinkManagerTest, PauseDistributedHardware_001, TestSize.Level1)
179 {
180     std::string networkId = "networkId";
181     std::string devId = "devId";
182     std::string params = "params";
183     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
184     if (samgr == nullptr) {
185         return;
186     }
187     sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
188     samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
189     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
190     if (remoteObject == nullptr) {
191         return;
192     }
193     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
194     auto dev = std::make_shared<DAudioSinkDev>(networkId, dAudioSinkIpcCallbackProxy);
195     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.PauseDistributedHardware(networkId));
196     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.ResumeDistributedHardware(networkId));
197     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.StopDistributedHardware(networkId));
198     daudioSinkManager.audioDevMap_.emplace(networkId, dev);
199     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.PauseDistributedHardware(networkId));
200     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.ResumeDistributedHardware(networkId));
201     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.StopDistributedHardware(networkId));
202 }
203 
204 /**
205  * @tc.name: VerifySecurityLevel_001
206  * @tc.desc: Verify the VerifySecurityLevel function.
207  * @tc.type: FUNC
208  * @tc.require: AR000H0E5F
209  */
210 HWTEST_F(DAudioSinkManagerTest, VerifySecurityLevel_001, TestSize.Level1)
211 {
212     std::string devId = "devId";
213     std::string networkId = "networkId";
214     std::string params = "params";
215     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
216     if (samgr == nullptr) {
217         return;
218     }
219     sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
220     samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
221     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
222     if (remoteObject == nullptr) {
223         return;
224     }
225     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
226     daudioSinkManager.ipcSinkCallback_ = dAudioSinkIpcCallbackProxy;
227     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.VerifySecurityLevel(devId));
228     daudioSinkManager.isSensitive_ = true;
229     daudioSinkManager.isSameAccount_ = false;
230     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.VerifySecurityLevel(devId));
231     daudioSinkManager.isSameAccount_ = true;
232     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.VerifySecurityLevel(devId));
233 }
234 
235 /**
236  * @tc.name: GetDeviceSecurityLevel_001
237  * @tc.desc: Verify the GetDeviceSecurityLevel function.
238  * @tc.type: FUNC
239  * @tc.require: AR000H0E5F
240  */
241 HWTEST_F(DAudioSinkManagerTest, GetDeviceSecurityLevel_001, TestSize.Level1)
242 {
243     std::string udid = "udid";
244     std::string content = "";
245     int32_t ret = -1;
246     daudioSinkManager.SetChannelState(content);
247     content = "ohos.dhardware.daudio.dmic";
248     daudioSinkManager.SetChannelState(content);
249     content = "ohos.dhardware.daudio.dspeaker";
250     daudioSinkManager.SetChannelState(content);
251     EXPECT_EQ(ret, daudioSinkManager.GetDeviceSecurityLevel(udid));
252 }
253 
254 /**
255  * @tc.name: CheckDeviceSecurityLevel_001
256  * @tc.desc: Verify the CheckDeviceSecurityLevel function.
257  * @tc.type: FUNC
258  * @tc.require: AR000H0E5F
259  */
260 HWTEST_F(DAudioSinkManagerTest, CheckDeviceSecurityLevel_001, TestSize.Level1)
261 {
262     std::string devId = "1";
263     daudioSinkManager.devClearThread_ = std::thread(&DAudioSinkManager::ClearAudioDev, &daudioSinkManager, devId);
264     daudioSinkManager.OnSinkDevReleased(devId);
265     std::string srcDeviceId = "srcDeviceId";
266     std::string dstDeviceId = "dstDeviceId";
267     EXPECT_EQ(false, daudioSinkManager.CheckDeviceSecurityLevel(srcDeviceId, dstDeviceId));
268 }
269 
270 /**
271  * @tc.name: GetUdidByNetworkId_001
272  * @tc.desc: Verify the GetUdidByNetworkId function.
273  * @tc.type: FUNC
274  * @tc.require: AR000H0E5F
275  */
276 HWTEST_F(DAudioSinkManagerTest, GetUdidByNetworkId_001, TestSize.Level1)
277 {
278     std::string networkId;
279     EXPECT_EQ("", daudioSinkManager.GetUdidByNetworkId(networkId));
280     networkId = "123";
281     EXPECT_EQ("", daudioSinkManager.GetUdidByNetworkId(networkId));
282 }
283 
284 /**
285  * @tc.name: OnProviderEvent_001
286  * @tc.desc: Verify the OnProviderEvent function.
287  * @tc.type: FUNC
288  * @tc.require: AR000H0E5F
289  */
290 HWTEST_F(DAudioSinkManagerTest, OnProviderEvent_001, TestSize.Level1)
291 {
292     AVTransEvent event1 = { EventType::EVENT_CHANNEL_OPENED, "", ""};
293     daudioSinkManager.providerListener_ = std::make_shared<EngineProviderListener>();
294     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event1));
295     AVTransEvent event2 = { EventType::EVENT_CHANNEL_CLOSED, "", ""};
296     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event2));
297     AVTransEvent event3 = { EventType::EVENT_REMOVE_STREAM, "", ""};
298     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event3));
299 }
300 } // DistributedHardware
301 } // OHOS
302