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 ASSERT_TRUE(samgr != nullptr);
109 sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
110 samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
111 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
112 ASSERT_TRUE(remoteObject != nullptr);
113 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
114 daudioSinkManager.ipcSinkCallback_ = dAudioSinkIpcCallbackProxy;
115 EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, daudioSinkManager.CreateAudioDevice(devId));
116 daudioSinkManager.audioDevMap_.emplace(devId, nullptr);
117 EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, daudioSinkManager.CreateAudioDevice(devId));
118 daudioSinkManager.channelState_ = ChannelState::SPK_CONTROL_OPENED;
119 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.CreateAudioDevice(devId));
120 daudioSinkManager.ClearAudioDev(devId);
121 daudioSinkManager.channelState_ = ChannelState::MIC_CONTROL_OPENED;
122 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.CreateAudioDevice(devId));
123 }
124
125 /**
126 * @tc.name: InitAudioDevice_001
127 * @tc.desc: Verify the InitAudioDevice function.
128 * @tc.type: FUNC
129 * @tc.require: AR000H0E5F
130 */
131 HWTEST_F(DAudioSinkManagerTest, InitAudioDevice_001, TestSize.Level1)
132 {
133 std::string devId = "1";
134 std::string params = "params";
135 std::shared_ptr<DAudioSinkDev> dev = nullptr;
136 EXPECT_NE(DH_SUCCESS, daudioSinkManager.InitAudioDevice(dev, devId, true));
137 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
138 ASSERT_TRUE(samgr != nullptr);
139 sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
140 samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
141 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
142 ASSERT_TRUE(remoteObject != nullptr);
143 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
144 daudioSinkManager.ipcSinkCallback_ = dAudioSinkIpcCallbackProxy;
145 dev = std::make_shared<DAudioSinkDev>(devId, dAudioSinkIpcCallbackProxy);
146 EXPECT_NE(DH_SUCCESS, daudioSinkManager.InitAudioDevice(dev, devId, true));
147 EXPECT_NE(DH_SUCCESS, daudioSinkManager.InitAudioDevice(dev, devId, false));
148 }
149
150 /**
151 * @tc.name: LoadAVSenderEngineProvider_001
152 * @tc.desc: Verify the LoadAVSenderEngineProvider function.
153 * @tc.type: FUNC
154 * @tc.require: AR000H0E5F
155 */
156 HWTEST_F(DAudioSinkManagerTest, LoadAVSenderEngineProvider_001, TestSize.Level1)
157 {
158 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.LoadAVSenderEngineProvider());
159 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnloadAVSenderEngineProvider());
160 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.LoadAVReceiverEngineProvider());
161 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnloadAVReceiverEngineProvider());
162 }
163
164 /**
165 * @tc.name: PauseDistributedHardware_001
166 * @tc.desc: Verify the PauseDistributedHardware function.
167 * @tc.type: FUNC
168 * @tc.require: AR000H0E5F
169 */
170 HWTEST_F(DAudioSinkManagerTest, PauseDistributedHardware_001, TestSize.Level1)
171 {
172 std::string networkId = "networkId";
173 std::string devId = "devId";
174 std::string params = "params";
175 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
176 ASSERT_TRUE(samgr != nullptr);
177 sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
178 samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
179 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
180 ASSERT_TRUE(remoteObject != nullptr);
181 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
182 auto dev = std::make_shared<DAudioSinkDev>(networkId, dAudioSinkIpcCallbackProxy);
183 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.PauseDistributedHardware(networkId));
184 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.ResumeDistributedHardware(networkId));
185 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.StopDistributedHardware(networkId));
186 daudioSinkManager.audioDevMap_.emplace(networkId, dev);
187 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.PauseDistributedHardware(networkId));
188 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.ResumeDistributedHardware(networkId));
189 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.StopDistributedHardware(networkId));
190 }
191
192 /**
193 * @tc.name: VerifySecurityLevel_001
194 * @tc.desc: Verify the VerifySecurityLevel function.
195 * @tc.type: FUNC
196 * @tc.require: AR000H0E5F
197 */
198 HWTEST_F(DAudioSinkManagerTest, VerifySecurityLevel_001, TestSize.Level1)
199 {
200 std::string devId = "devId";
201 std::string networkId = "networkId";
202 std::string params = "params";
203 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
204 ASSERT_TRUE(samgr != nullptr);
205 sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
206 samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
207 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
208 ASSERT_TRUE(remoteObject != nullptr);
209 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
210 daudioSinkManager.ipcSinkCallback_ = dAudioSinkIpcCallbackProxy;
211 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.VerifySecurityLevel(devId));
212 daudioSinkManager.isSensitive_ = true;
213 daudioSinkManager.isSameAccount_ = false;
214 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.VerifySecurityLevel(devId));
215 daudioSinkManager.isSameAccount_ = true;
216 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.VerifySecurityLevel(devId));
217 }
218
219 /**
220 * @tc.name: GetDeviceSecurityLevel_001
221 * @tc.desc: Verify the GetDeviceSecurityLevel function.
222 * @tc.type: FUNC
223 * @tc.require: AR000H0E5F
224 */
225 HWTEST_F(DAudioSinkManagerTest, GetDeviceSecurityLevel_001, TestSize.Level1)
226 {
227 std::string udid = "udid";
228 std::string content = "";
229 int32_t ret = -1;
230 daudioSinkManager.SetChannelState(content);
231 content = "ohos.dhardware.daudio.dmic";
232 daudioSinkManager.SetChannelState(content);
233 content = "ohos.dhardware.daudio.dspeaker";
234 daudioSinkManager.SetChannelState(content);
235 EXPECT_EQ(ret, daudioSinkManager.GetDeviceSecurityLevel(udid));
236 }
237
238 /**
239 * @tc.name: CheckDeviceSecurityLevel_001
240 * @tc.desc: Verify the CheckDeviceSecurityLevel function.
241 * @tc.type: FUNC
242 * @tc.require: AR000H0E5F
243 */
244 HWTEST_F(DAudioSinkManagerTest, CheckDeviceSecurityLevel_001, TestSize.Level1)
245 {
246 std::string devId = "1";
247 daudioSinkManager.devClearThread_ = std::thread(&DAudioSinkManager::ClearAudioDev, &daudioSinkManager, devId);
248 daudioSinkManager.OnSinkDevReleased(devId);
249 std::string srcDeviceId = "srcDeviceId";
250 std::string dstDeviceId = "dstDeviceId";
251 EXPECT_EQ(false, daudioSinkManager.CheckDeviceSecurityLevel(srcDeviceId, dstDeviceId));
252 }
253
254 /**
255 * @tc.name: GetUdidByNetworkId_001
256 * @tc.desc: Verify the GetUdidByNetworkId function.
257 * @tc.type: FUNC
258 * @tc.require: AR000H0E5F
259 */
260 HWTEST_F(DAudioSinkManagerTest, GetUdidByNetworkId_001, TestSize.Level1)
261 {
262 std::string networkId;
263 EXPECT_EQ("", daudioSinkManager.GetUdidByNetworkId(networkId));
264 networkId = "123";
265 EXPECT_EQ("", daudioSinkManager.GetUdidByNetworkId(networkId));
266 }
267
268 /**
269 * @tc.name: OnProviderEvent_001
270 * @tc.desc: Verify the OnProviderEvent function.
271 * @tc.type: FUNC
272 * @tc.require: AR000H0E5F
273 */
274 HWTEST_F(DAudioSinkManagerTest, OnProviderEvent_001, TestSize.Level1)
275 {
276 AVTransEvent event1 = { EventType::EVENT_CHANNEL_OPENED, "", ""};
277 daudioSinkManager.providerListener_ = std::make_shared<EngineProviderListener>();
278 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event1));
279 AVTransEvent event2 = { EventType::EVENT_CHANNEL_CLOSED, "", ""};
280 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event2));
281 AVTransEvent event3 = { EventType::EVENT_REMOVE_STREAM, "", ""};
282 EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event3));
283 }
284
285 /**
286 * @tc.name: ParseValueFromCjson_001
287 * @tc.desc: Verify the ParseValueFromCjson function.
288 * @tc.type: FUNC
289 * @tc.require: AR000H0E5F
290 */
291 HWTEST_F(DAudioSinkManagerTest, ParseValueFromCjson_001, TestSize.Level1)
292 {
293 int32_t volume = 50;
294 std::string jsonStr = "{\"OS_TYPE\": 50}";
295 std::string key = "OS_TYPE";
296 int32_t result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
297 EXPECT_EQ(result, volume);
298
299 jsonStr = "invalid_json";
300 key = "volume";
301 result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
302 EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
303
304 jsonStr = "{\"brightness\": 80}";
305 result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
306 EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
307
308 jsonStr = "{\"volume\": \"high\"}";
309 result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
310 EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
311
312 jsonStr = "";
313 result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
314 EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
315
316 jsonStr = "null";
317 key = "volume";
318 result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
319 EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
320 }
321 } // DistributedHardware
322 } // OHOS
323