1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this 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 #define private public
17 #define protected public
18 #include "call_manager_gtest.h"
19
20 #include <gtest/gtest.h>
21 #include <cstring>
22 #include <string>
23
24 #include "bluetooth_hfp_ag.h"
25 #include "call_manager_connect.h"
26 #include "call_manager_service.h"
27 #include "interoperable_settings_handler.h"
28 #include "surface_utils.h"
29 #include "telephony_types.h"
30 #include "voip_call.h"
31
32 using namespace OHOS::Bluetooth;
33 namespace OHOS {
34 namespace Telephony {
35 using namespace testing::ext;
36 constexpr int16_t SIM2_SLOTID = 1;
37 constexpr int16_t SIM1_SLOTID_NO_CARD = 0;
38 constexpr int16_t RETURN_VALUE_IS_ZERO = 0;
39 constexpr int16_t INVALID_NEGATIVE_ID = -100;
40 constexpr int16_t INVALID_POSITIVE_ID = 100;
41 constexpr int INVALID_DIAL_TYPE = 3;
42 constexpr int WAIT_TIME = 3;
43 constexpr int16_t CAMERA_ROTATION_90 = 90;
44 constexpr int16_t CAMERA_ROTATION_ERROR = 50;
45 constexpr int16_t SLEEP_1000_MS = 1000;
46 constexpr int BASE_TIME_MS = 1000;
47 constexpr int SLEEP_TIME_MS = 50;
48 constexpr int MAX_LIMIT_TIME = 18000;
49 constexpr int16_t SIM1_SLOTID = 0;
50 const std::string PHONE_NUMBER = "0000000000";
51 constexpr const char *SYNERGY_INCOMING_MUTE_URI =
52 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=synergy_incoming_mute";
53 constexpr const char *SYNERGY_MUTE_KEY = "synergy_incoming_mute";
54
55 std::unordered_map<int32_t, std::unordered_set<int32_t>> g_callStateMap;
56 int32_t g_newCallId = -1;
57 std::mutex CallInfoManager::mutex_;
58 int16_t CallInfoManager::newCallState_;
59 CallAttributeInfo CallInfoManager::updateCallInfo_;
60 std::unordered_set<int32_t> CallInfoManager::callIdSet_;
61
CallDetailsChange(const CallAttributeInfo & info)62 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
63 {
64 TELEPHONY_LOGI("CallDetailsChange Start");
65 std::lock_guard<std::mutex> lock(mutex_);
66 updateCallInfo_ = info;
67 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
68 TELEPHONY_LOGI("CallDetailsChange new call");
69 callIdSet_.insert(updateCallInfo_.callId);
70 g_newCallId = updateCallInfo_.callId;
71 newCallState_ = (int32_t)updateCallInfo_.callState;
72 std::unordered_set<int32_t> newSet;
73 newSet.clear();
74 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
75 }
76 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
77 return TELEPHONY_SUCCESS;
78 }
79
MeeTimeDetailsChange(const CallAttributeInfo & info)80 int32_t CallInfoManager::MeeTimeDetailsChange(const CallAttributeInfo &info)
81 {
82 TELEPHONY_LOGI("MeeTimeDetailsChange Start");
83 std::lock_guard<std::mutex> lock(mutex_);
84 updateCallInfo_ = info;
85 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
86 TELEPHONY_LOGI("MeeTimeDetailsChange new call");
87 callIdSet_.insert(updateCallInfo_.callId);
88 g_newCallId = updateCallInfo_.callId;
89 newCallState_ = (int32_t)updateCallInfo_.callState;
90 std::unordered_set<int32_t> newSet;
91 newSet.clear();
92 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
93 }
94 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
95 return TELEPHONY_SUCCESS;
96 }
97
HasActiveStatus()98 bool CallInfoManager::HasActiveStatus()
99 {
100 TELEPHONY_LOGI("Waiting for activation !");
101 int sumUseTime = 0;
102 int slipMs = SLEEP_TIME_MS;
103 do {
104 if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
105 usleep(slipMs * BASE_TIME_MS);
106 sumUseTime += slipMs;
107 } else {
108 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
109 return true;
110 }
111 } while (sumUseTime < MAX_LIMIT_TIME);
112 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
113 return false;
114 }
115
HasState(int callId,int32_t callState)116 bool CallInfoManager::HasState(int callId, int32_t callState)
117 {
118 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
119 return false;
120 }
121 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
122 return false;
123 }
124 return true;
125 }
126
CallEventChange(const CallEventInfo & info)127 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
128 {
129 return TELEPHONY_SUCCESS;
130 }
131
Init()132 void CallInfoManager::Init()
133 {
134 g_newCallId = -1;
135 updateCallInfo_.speakerphoneOn = -1;
136 updateCallInfo_.startTime = -1;
137 updateCallInfo_.isEcc = -1;
138 updateCallInfo_.accountId = -1;
139 updateCallInfo_.callType = CallType::TYPE_CS;
140 updateCallInfo_.callId = -1;
141 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
142 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
143 }
144
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)145 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
146 {
147 int32_t useTimeMs = 0;
148 std::cout << "wait for a few seconds......" << std::endl;
149 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
150 usleep(slipMs * SLEEP_1000_MS);
151 useTimeMs += slipMs;
152 }
153 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
154 if (eq) {
155 EXPECT_EQ(updateCallInfo_.callId, targetId);
156 } else {
157 EXPECT_NE(updateCallInfo_.callId, targetId);
158 }
159 }
160
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)161 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
162 {
163 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
164 return;
165 }
166 int32_t usedTimeMs = 0;
167 std::cout << "wait for a few seconds......" << std::endl;
168 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
169 usleep(slipMs * SLEEP_1000_MS);
170 usedTimeMs += slipMs;
171 }
172 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
173 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
174 std::cout << "target call state:" << targetState << std::endl;
175 EXPECT_EQ(callState, targetState);
176 }
177
HangUpCall()178 void CallManagerGtest::HangUpCall()
179 {
180 clientPtr_->HangUpCall(INVALID_CALLID);
181 }
182
183 class ClientErrorBranchTest : public testing::Test {
184 public:
SetUpTestCase()185 static void SetUpTestCase() {};
TearDownTestCase()186 static void TearDownTestCase() {};
SetUp()187 void SetUp() {};
TearDown()188 void TearDown() {};
189 };
190
191 /**
192 * @tc.number Telephony_CallManager_GetCallTransferInfo_0900
193 * @tc.name input slotId out of count, CallTransferType TRANSFER_TYPE_NOT_REACHABLE,
194 * test GetCallTransferInfo() return failed
195 * @tc.desc Function test
196 */
197 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0900, TestSize.Level0)
198 {
199 AccessToken token;
200 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
201 return;
202 }
203
204 int32_t slotId = SIM_SLOT_COUNT; // out of the count
205 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
206 CALL_ERR_INVALID_SLOT_ID);
207 }
208
209 /**
210 * @tc.number Telephony_CallManager_GetCallTransferInfo_1000
211 * @tc.name input slotId 0, CallTransferType invalid, test GetCallTransferInfo() return failed
212 * @tc.desc Function test
213 */
214 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_1000, TestSize.Level0)
215 {
216 AccessToken token;
217 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
218 return;
219 }
220
221 if (HasSimCard(SIM1_SLOTID)) {
222 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, (CallTransferType)FALSE_DEFAULT),
223 CALL_ERR_INVALID_TRANSFER_TYPE);
224 }
225 if (HasSimCard(SIM2_SLOTID)) {
226 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM2_SLOTID, (CallTransferType)FALSE_DEFAULT),
227 CALL_ERR_INVALID_TRANSFER_TYPE);
228 }
229 }
230
231 /**
232 * @tc.number Telephony_CallManager_GetCallTransferInfo_1100
233 * @tc.name test GetCallTransferInfo() without permission
234 * @tc.desc Function test
235 */
236 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_1100, TestSize.Level0)
237 {
238 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
239 return;
240 }
241
242 if (HasSimCard(SIM1_SLOTID)) {
243 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
244 TELEPHONY_ERR_PERMISSION_ERR);
245 }
246 if (HasSimCard(SIM2_SLOTID)) {
247 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
248 TELEPHONY_ERR_PERMISSION_ERR);
249 }
250 }
251
252 /******************************************* Test SetCallTransferInfo() ********************************************/
253 /**
254 * @tc.number Telephony_CallManager_SetCallTransferInfo_0100
255 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
256 * test SetCallTransferInfo()
257 * @tc.desc Function test
258 */
259 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0100, TestSize.Level0)
260 {
261 AccessToken token;
262 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
263 return;
264 }
265 CallTransferInfo info;
266 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
267 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
268 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "111") != EOK) {
269 TELEPHONY_LOGE("strcpy_s fail.");
270 return;
271 }
272
273 if (HasSimCard(SIM1_SLOTID)) {
274 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), RETURN_VALUE_IS_ZERO);
275 }
276 if (HasSimCard(SIM2_SLOTID)) {
277 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), RETURN_VALUE_IS_ZERO);
278 }
279 }
280
281 /**
282 * @tc.number Telephony_CallManager_SetCallTransferInfo_0200
283 * @tc.name input invalid slotId, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
284 * test SetCallTransferInfo() return failed
285 * @tc.desc Function test
286 */
287 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0200, TestSize.Level1)
288 {
289 AccessToken token;
290 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
291 return;
292 }
293 CallTransferInfo info;
294 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
295 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
296 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "222") != EOK) {
297 TELEPHONY_LOGE("strcpy_s fail.");
298 return;
299 }
300
301 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(INVALID_SLOT_ID, info), CALL_ERR_INVALID_SLOT_ID);
302 }
303
304 /**
305 * @tc.number Telephony_CallManager_SetCallTransferInfo_0300
306 * @tc.name input slotId was out of count, CallTransferSettingType CALL_TRANSFER_ENABLE,
307 * CallTransferType TRANSFER_TYPE_BUSY, test SetCallTransferInfo() return failed
308 * @tc.desc Function test
309 */
310 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0300, TestSize.Level0)
311 {
312 AccessToken token;
313 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
314 return;
315 }
316 CallTransferInfo info;
317 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
318 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
319 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "333") != EOK) {
320 TELEPHONY_LOGE("strcpy_s fail.");
321 return;
322 }
323
324 int32_t slotId = SIM_SLOT_COUNT; // out of the count
325 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(slotId, info), CALL_ERR_INVALID_SLOT_ID);
326 }
327
328 /**
329 * @tc.number Telephony_CallManager_SetCallTransferInfo_0400
330 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType invalid,
331 * test SetCallTransferInfo() return failed
332 * @tc.desc Function test
333 */
334 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0400, TestSize.Level0)
335 {
336 AccessToken token;
337 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
338 return;
339 }
340 CallTransferInfo info;
341 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
342 info.type = (CallTransferType)FALSE_DEFAULT;
343 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
344 TELEPHONY_LOGE("strcpy_s fail.");
345 return;
346 }
347
348 if (HasSimCard(SIM1_SLOTID)) {
349 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info),
350 CALL_ERR_INVALID_TRANSFER_TYPE);
351 }
352 if (HasSimCard(SIM2_SLOTID)) {
353 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info),
354 CALL_ERR_INVALID_TRANSFER_TYPE);
355 }
356 }
357
358 /**
359 * @tc.number Telephony_CallManager_SetCallTransferInfo_0500
360 * @tc.name input slotId 0, CallTransferSettingType invalid, CallTransferType TRANSFER_TYPE_BUSY,
361 * test SetCallTransferInfo() return failed
362 * @tc.desc Function test
363 */
364 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0500, TestSize.Level0)
365 {
366 AccessToken token;
367 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
368 return;
369 }
370 CallTransferInfo info;
371 info.settingType = (CallTransferSettingType)FALSE_DEFAULT;
372 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
373 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
374 TELEPHONY_LOGE("strcpy_s fail.");
375 return;
376 }
377
378 if (HasSimCard(SIM1_SLOTID)) {
379 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info),
380 CALL_ERR_INVALID_TRANSFER_SETTING_TYPE);
381 }
382 if (HasSimCard(SIM2_SLOTID)) {
383 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info),
384 CALL_ERR_INVALID_TRANSFER_SETTING_TYPE);
385 }
386 }
387
388 /**
389 * @tc.number Telephony_CallManager_SetCallTransferInfo_0600
390 * @tc.name input slotId 0, CallTransferSettingType invalid, CallTransferType TRANSFER_TYPE_BUSY, transferNum was
391 * too long, test SetCallTransferInfo() return failed
392 * @tc.desc Function test
393 */
394 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0600, TestSize.Level1)
395 {
396 AccessToken token;
397 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
398 return;
399 }
400 CallTransferInfo info;
401 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
402 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
403 if (strcpy_s(info.transferNum, kMaxNumberLen + 2,
404 "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
405 "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
406 "123456789012345678901234567890123456789012345678901234567890") != EOK) {
407 TELEPHONY_LOGE("strcpy_s fail.");
408 return;
409 }
410
411 if (HasSimCard(SIM1_SLOTID)) {
412 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), CALL_ERR_NUMBER_OUT_OF_RANGE);
413 }
414 if (HasSimCard(SIM2_SLOTID)) {
415 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), CALL_ERR_NUMBER_OUT_OF_RANGE);
416 }
417 }
418
419 /**
420 * @tc.number Telephony_CallManager_SetCallTransferInfo_0700
421 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
422 * test SetCallTransferInfo()
423 * @tc.desc Function test
424 */
425 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0700, TestSize.Level0)
426 {
427 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
428 return;
429 }
430 CallTransferInfo info;
431 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
432 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
433 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "444") != EOK) {
434 TELEPHONY_LOGE("strcpy_s fail.");
435 return;
436 }
437
438 if (HasSimCard(SIM1_SLOTID)) {
439 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
440 }
441 if (HasSimCard(SIM2_SLOTID)) {
442 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
443 }
444 }
445
446 /******************************************* Test EnableImsSwitch() ********************************************/
447 /**
448 * @tc.number Telephony_CallManager_EnableImsSwitch_0100
449 * @tc.name input slotId 0, test EnableImsSwitch
450 * @tc.desc Function test
451 */
452 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0100, TestSize.Level0)
453 {
454 AccessToken token;
455 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
456 return;
457 }
458
459 if (HasSimCard(SIM1_SLOTID)) {
460 EXPECT_NE(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
461 }
462 if (HasSimCard(SIM2_SLOTID)) {
463 EXPECT_NE(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
464 }
465 }
466
467 /**
468 * @tc.number Telephony_CallManager_EnableImsSwitch_0200
469 * @tc.name input invalid slotId, test EnableImsSwitch return failed
470 * @tc.desc Function test
471 */
472 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0200, TestSize.Level0)
473 {
474 AccessToken token;
475 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
476 return;
477 }
478
479 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(INVALID_SLOT_ID), CALL_ERR_INVALID_SLOT_ID);
480 }
481
482 /**
483 * @tc.number Telephony_CallManager_EnableImsSwitch_0300
484 * @tc.name input slotId was out of count, test EnableImsSwitch return failed
485 * @tc.desc Function test
486 */
487 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0300, TestSize.Level0)
488 {
489 AccessToken token;
490 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
491 return;
492 }
493
494 int32_t slotId = SIM_SLOT_COUNT; // out of the count
495 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(slotId), CALL_ERR_INVALID_SLOT_ID);
496 }
497
498 /**
499 * @tc.number Telephony_CallManager_EnableImsSwitch_0400
500 * @tc.name test EnableImsSwitch without permission
501 * @tc.desc Function test
502 */
503 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0400, TestSize.Level0)
504 {
505 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
506 return;
507 }
508
509 if (HasSimCard(SIM1_SLOTID)) {
510 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
511 }
512 if (HasSimCard(SIM2_SLOTID)) {
513 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
514 }
515 }
516
517 /******************************************* Test DisableImsSwitch() ********************************************/
518 /**
519 * @tc.number Telephony_CallManager_DisableImsSwitch_0100
520 * @tc.name input slotId 0, test DisableImsSwitch
521 * @tc.desc Function test
522 */
523 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0100, TestSize.Level0)
524 {
525 AccessToken token;
526 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
527 return;
528 }
529
530 if (HasSimCard(SIM1_SLOTID)) {
531 EXPECT_NE(CallManagerGtest::clientPtr_->DisableImsSwitch(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
532 }
533 if (HasSimCard(SIM2_SLOTID)) {
534 EXPECT_NE(CallManagerGtest::clientPtr_->DisableImsSwitch(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
535 }
536 }
537
538 /**
539 * @tc.number Telephony_CallManager_DisableImsSwitch_0200
540 * @tc.name input invalid slotId, test DisableImsSwitch return failed
541 * @tc.desc Function test
542 */
543 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0200, TestSize.Level0)
544 {
545 AccessToken token;
546 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
547 return;
548 }
549
550 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(INVALID_SLOT_ID), CALL_ERR_INVALID_SLOT_ID);
551 }
552
553 /**
554 * @tc.number Telephony_CallManager_DisableImsSwitch_0300
555 * @tc.name input slotId was out of count, test DisableImsSwitch return failed
556 * @tc.desc Function test
557 */
558 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0300, TestSize.Level0)
559 {
560 AccessToken token;
561 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
562 return;
563 }
564
565 int32_t slotId = SIM_SLOT_COUNT; // out of the count
566 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(slotId), CALL_ERR_INVALID_SLOT_ID);
567 }
568
569 /******************************************* Test IsImsSwitchEnabled() ********************************************/
570 /**
571 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0100
572 * @tc.name input slotId 0, test IsImsSwitchEnabled
573 * @tc.desc Function test
574 */
575 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0100, TestSize.Level0)
576 {
577 AccessToken token;
578 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
579 return;
580 }
581
582 bool enabled;
583 if (HasSimCard(SIM1_SLOTID)) {
584 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(SIM1_SLOTID, enabled), RETURN_VALUE_IS_ZERO);
585 }
586 if (HasSimCard(SIM2_SLOTID)) {
587 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(SIM2_SLOTID, enabled), RETURN_VALUE_IS_ZERO);
588 }
589 }
590
591 /**
592 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0200
593 * @tc.name input invalid slotId, test IsImsSwitchEnabled return failed
594 * @tc.desc Function test
595 */
596 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0200, TestSize.Level0)
597 {
598 AccessToken token;
599 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
600 return;
601 }
602
603 bool enabled;
604 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(INVALID_SLOT_ID, enabled), CALL_ERR_INVALID_SLOT_ID);
605 }
606
607 /**
608 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0300
609 * @tc.name input slotId was out of count, test IsImsSwitchEnabled return failed
610 * @tc.desc Function test
611 */
612 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0300, TestSize.Level0)
613 {
614 AccessToken token;
615 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
616 return;
617 }
618
619 int32_t slotId = SIM_SLOT_COUNT; // out of the count
620 bool enabled;
621 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(slotId, enabled), CALL_ERR_INVALID_SLOT_ID);
622 }
623
624 /******************************************* Test SetVoNRState() ********************************************/
625 /**
626 * @tc.number Telephony_CallManager_SetVoNRState_0100
627 * @tc.name input slotId 0, VoNRstate ON(0) test SetVoNRState
628 * @tc.desc Function test
629 */
630 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0100, TestSize.Level1)
631 {
632 AccessToken token;
633 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
634 return;
635 }
636 int32_t state = 0;
637 if (HasSimCard(SIM1_SLOTID)) {
638 EXPECT_GE(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), RETURN_VALUE_IS_ZERO);
639 }
640 if (HasSimCard(SIM2_SLOTID)) {
641 EXPECT_NE(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), RETURN_VALUE_IS_ZERO);
642 }
643 }
644
645 /**
646 * @tc.number Telephony_CallManager_SetVoNRState_0200
647 * @tc.name input slotId 0, VoNRstate OFF(1) test SetVoNRState
648 * @tc.desc Function test
649 */
650 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0200, TestSize.Level1)
651 {
652 AccessToken token;
653 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
654 return;
655 }
656 int32_t state = 1;
657 if (HasSimCard(SIM1_SLOTID)) {
658 EXPECT_GE(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), RETURN_VALUE_IS_ZERO);
659 }
660 if (HasSimCard(SIM2_SLOTID)) {
661 EXPECT_NE(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), RETURN_VALUE_IS_ZERO);
662 }
663 }
664
665 /**
666 * @tc.number Telephony_CallManager_SetVoNRState_0300
667 * @tc.name input invalid slotId, test SetVoNRState return failed
668 * @tc.desc Function test
669 */
670 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0300, TestSize.Level0)
671 {
672 AccessToken token;
673 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
674 return;
675 }
676 int32_t state = 0;
677 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(INVALID_SLOT_ID, state), CALL_ERR_INVALID_SLOT_ID);
678 }
679
680 /**
681 * @tc.number Telephony_CallManager_SetVoNRState_0400
682 * @tc.name input slotId was out of count, test SetVoNRState return failed
683 * @tc.desc Function test
684 */
685 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0400, TestSize.Level0)
686 {
687 AccessToken token;
688 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
689 return;
690 }
691 int32_t state = 0;
692 int32_t slotId = SIM_SLOT_COUNT; // out of the count
693 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(slotId, state), CALL_ERR_INVALID_SLOT_ID);
694 }
695
696 /**
697 * @tc.number Telephony_CallManager_SetVoNRState_0500
698 * @tc.name input invalid state, test SetVoNRState return failed
699 * @tc.desc Function test
700 */
701 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0500, TestSize.Level0)
702 {
703 AccessToken token;
704 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
705 return;
706 }
707 int32_t state = -1;
708 if (HasSimCard(SIM1_SLOTID)) {
709 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_ARGUMENT_INVALID);
710 }
711 if (HasSimCard(SIM2_SLOTID)) {
712 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), TELEPHONY_ERR_ARGUMENT_INVALID);
713 }
714 }
715
716 /**
717 * @tc.number Telephony_CallManager_SetVoNRState_0600
718 * @tc.name test SetVoNRState without permission
719 * @tc.desc Function test
720 */
721 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0600, TestSize.Level0)
722 {
723 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
724 return;
725 }
726 int32_t state = 0;
727 if (HasSimCard(SIM1_SLOTID)) {
728 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
729 }
730 if (HasSimCard(SIM2_SLOTID)) {
731 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
732 }
733 }
734
735 /******************************************* Test GetVoNRState() ********************************************/
736 /**
737 * @tc.number Telephony_CallManager_GetVoNRState_0100
738 * @tc.name input slotId 0, test GetVoNRState
739 * @tc.desc Function test
740 */
741 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0100, TestSize.Level0)
742 {
743 AccessToken token;
744 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
745 return;
746 }
747
748 int32_t state;
749 if (HasSimCard(SIM1_SLOTID)) {
750 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM1_SLOTID, state), RETURN_VALUE_IS_ZERO);
751 }
752 if (HasSimCard(SIM2_SLOTID)) {
753 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM2_SLOTID, state), RETURN_VALUE_IS_ZERO);
754 }
755 }
756
757 /**
758 * @tc.number Telephony_CallManager_GetVoNRState_0200
759 * @tc.name input invalid slotId, test GetVoNRState return failed
760 * @tc.desc Function test
761 */
762 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0200, TestSize.Level0)
763 {
764 AccessToken token;
765 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
766 return;
767 }
768
769 int32_t state;
770 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(INVALID_SLOT_ID, state), CALL_ERR_INVALID_SLOT_ID);
771 }
772
773 /**
774 * @tc.number Telephony_CallManager_GetVoNRState_0300
775 * @tc.name input slotId was out of count, test GetVoNRState return failed
776 * @tc.desc Function test
777 */
778 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0300, TestSize.Level0)
779 {
780 AccessToken token;
781 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
782 return;
783 }
784
785 int32_t slotId = SIM_SLOT_COUNT; // out of the count
786 int32_t state;
787 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(slotId, state), CALL_ERR_INVALID_SLOT_ID);
788 }
789
790 /**
791 * @tc.number Telephony_CallManager_GetVoNRState_0400
792 * @tc.name test GetVoNRState without permission
793 * @tc.desc Function test
794 */
795 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0400, TestSize.Level0)
796 {
797 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
798 return;
799 }
800 int32_t state;
801 if (HasSimCard(SIM1_SLOTID)) {
802 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
803 }
804 if (HasSimCard(SIM2_SLOTID)) {
805 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM2_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
806 }
807 }
808
809 /******************************************* Test ControlCamera() *********************************************/
810 /**
811 * @tc.number Telephony_CallManager_ControlCamera_0100
812 * @tc.name input camera id lcam001, Test ControlCamera, returns 0 if success
813 * @tc.desc Function test
814 */
815 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0100, Function | MediumTest | Level0)
816 {
817 AccessToken token;
818 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
819 return;
820 }
821 int32_t callId = 1;
822 // 3516DV300 camera id string is "lcam001"
823 std::string id = "lcam001";
824
825 std::u16string cameraID = Str8ToStr16(id);
826 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
827 }
828
829 /**
830 * @tc.number Telephony_CallManager_ControlCamera_0200
831 * @tc.name input error camera id xtsautotest123456, Test ControlCamera, return err code if failed
832 * @tc.desc Function test
833 */
834 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0200, Function | MediumTest | Level2)
835 {
836 AccessToken token;
837 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
838 return;
839 }
840 int32_t callId = 1;
841 std::string id = "xtsautotest123456";
842
843 std::u16string cameraID = Str8ToStr16(id);
844 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
845 }
846
847 /**
848 * @tc.number Telephony_CallManager_ControlCamera_0300
849 * @tc.name input error camera id xtsautotest123456, Test ControlCamera,
850 * then input empty camera id, Test ControlCamera
851 * @tc.desc Function test
852 */
853 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0300, Function | MediumTest | Level2)
854 {
855 AccessToken token;
856 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
857 return;
858 }
859 int32_t callId = 1;
860 std::string id = "lcam001";
861
862 std::u16string cameraID = Str8ToStr16(id);
863 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
864
865 id = "";
866 cameraID = Str8ToStr16(id);
867 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
868 }
869
870 /**
871 * @tc.number Telephony_CallManager_ControlCamera_0600
872 * @tc.name input empty camera id, Test ControlCamera, returns error code if failed
873 * @tc.desc Function test
874 */
875 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0600, Function | MediumTest | Level2)
876 {
877 AccessToken token;
878 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
879 return;
880 }
881 int32_t callId = 1;
882 std::string id = "";
883
884 std::u16string cameraID = Str8ToStr16(id);
885 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
886 }
887
888 /******************************************* Test SetPreviewWindow() *********************************************/
889 /**
890 * @tc.number Telephony_CallManager_SetPreviewWindow_0100
891 * @tc.name input previewSurfaceId:"", Test set preview window
892 * @tc.desc Function test
893 */
894 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPreviewWindow_0100, Function | MediumTest | Level2)
895 {
896 AccessToken token;
897 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
898 return;
899 }
900 int32_t callId = 1;
901 std::string previewSurfaceId = "";
902 EXPECT_NE(CallManagerGtest::clientPtr_->SetPreviewWindow(callId, previewSurfaceId), RETURN_VALUE_IS_ZERO);
903 }
904
905 /**
906 * @tc.number Telephony_CallManager_SetPreviewWindow_0200
907 * @tc.name input previewSurfaceId:123, Test set preview window
908 * @tc.desc Function test
909 */
910 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPreviewWindow_0200, Function | MediumTest | Level2)
911 {
912 AccessToken token;
913 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
914 return;
915 }
916 int32_t callId = 1;
917 std::string previewSurfaceId = "123";
918 EXPECT_NE(CallManagerGtest::clientPtr_->SetPreviewWindow(callId, previewSurfaceId), RETURN_VALUE_IS_ZERO);
919 }
920
921 /******************************************* Test SetDisplayWindow() *********************************************/
922 /**
923 * @tc.number Telephony_CallManager_SetDisplayWindow_0100
924 * @tc.name input displaySurfaceId:"", Test set display window
925 * @tc.desc Function test
926 */
927 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDisplayWindow_0100, Function | MediumTest | Level2)
928 {
929 AccessToken token;
930 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
931 return;
932 }
933 int32_t callId = 1;
934 std::string displaySurfaceId = "";
935 EXPECT_NE(CallManagerGtest::clientPtr_->SetDisplayWindow(callId, displaySurfaceId), RETURN_VALUE_IS_ZERO);
936 }
937
938 /**
939 * @tc.number Telephony_CallManager_SetDisplayWindow_0200
940 * @tc.name input displaySurfaceId:123, Test set display window
941 * @tc.desc Function test
942 */
943 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDisplayWindow_0200, Function | MediumTest | Level2)
944 {
945 AccessToken token;
946 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
947 return;
948 }
949 int32_t callId = 1;
950 std::string displaySurfaceId = "123";
951 EXPECT_NE(CallManagerGtest::clientPtr_->SetDisplayWindow(callId, displaySurfaceId), RETURN_VALUE_IS_ZERO);
952 }
953
954 /******************************************* Test SetDeviceDirection() *********************************************/
955 /**
956 * @tc.number Telephony_CallManager_SetDeviceDirection_0100
957 * @tc.name input invalid rotation, Test SetDeviceDirection, return error code if failed
958 * @tc.desc Function test
959 */
960 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0100, Function | MediumTest | Level2)
961 {
962 AccessToken token;
963 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
964 return;
965 }
966 int32_t callId = 1;
967 int32_t rotation = CAMERA_ROTATION_ERROR;
968 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(callId, rotation), RETURN_VALUE_IS_ZERO);
969 }
970
971 /**
972 * @tc.number Telephony_CallManager_SetDeviceDirection_0200
973 * @tc.name input rotation 0, Test SetDeviceDirection, return 0 if success
974 * @tc.desc Function test
975 */
976 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0200, Function | MediumTest | Level2)
977 {
978 AccessToken token;
979 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
980 return;
981 }
982 int32_t callId = 1;
983 int32_t rotation = 0;
984 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(callId, rotation), RETURN_VALUE_IS_ZERO);
985 }
986
987 /**
988 * @tc.number Telephony_CallManager_SetDeviceDirection_0300
989 * @tc.name input rotation 90, Test SetDeviceDirection
990 * @tc.desc Function test
991 */
992 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0300, Function | MediumTest | Level2)
993 {
994 AccessToken token;
995 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
996 return;
997 }
998 int32_t callId = 1;
999 int32_t rotation = CAMERA_ROTATION_90;
1000 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(callId, rotation), RETURN_VALUE_IS_ZERO);
1001 }
1002
1003 /**
1004 * @tc.number Telephony_InteroperableSettingsHandlerTest_001
1005 * @tc.name test interoperable settings handler
1006 * @tc.desc Function test
1007 */
1008 HWTEST_F(CallManagerGtest, Telephony_CallManager_InteroperableSettingsHandlerTest_001, Function | MediumTest | Level2)
1009 {
1010 Uri uri(SYNERGY_INCOMING_MUTE_URI);
1011 auto helper = DelayedSingleton<SettingsDataShareHelper>().GetInstance();
1012
1013 EXPECT_EQ(helper->RegisterToDataShare(uri, nullptr), true);
1014 EXPECT_EQ(helper->Update(uri, SYNERGY_MUTE_KEY, "3"), -1);
1015 EXPECT_EQ(helper->Update(uri, "nokey", "0"), -1);
1016 EXPECT_EQ(helper->Insert(uri, SYNERGY_MUTE_KEY, "0"), -1);
1017 }
1018 } // namespace Telephony
1019 } // namespace OHOS
1020