1 /*
2 * Copyright (c) 2024-2025 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 #include "gtest/gtest.h"
17
18 #include "ability_config.h"
19 #include "ability_record.h"
20 #define private public
21 #include "dialog_session_manager.h"
22 #undef private
23 #include "hilog_tag_wrapper.h"
24 #include "mock_ability_token.h"
25 #include "start_ability_utils.h"
26
27 using OHOS::AppExecFwk::AbilityType;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace AAFwk {
32 namespace {
33 constexpr int32_t TEST_USER_ID = 10001;
34 constexpr int32_t TEST_ERMS_ISALLOW_RESULTCODE = 9;
35 const std::string TEST_BUNDLE_NAME = "com.test.demo";
36 const std::string TEST_DIALOG_SESSION_ID = "dialogSessionId";
37 const std::string APP_LAUNCH_TRUSTLIST = "ohos.params.appLaunchTrustList";
38 const std::string SHOW_DEFAULT_PICKER_FLAG = "ohos.ability.params.showDefaultPicker";
39 constexpr const char* KEY_REQUEST_ID = "com.ohos.param.requestId";
40 }
41
42 class DialogSessionManagerTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp() override;
47 void TearDown() override;
48 std::shared_ptr<AbilityRecord> MockAbilityRecord(AbilityType);
49 sptr<Token> MockToken(AbilityType);
50 };
51
SetUpTestCase(void)52 void DialogSessionManagerTest::SetUpTestCase(void)
53 {}
54
TearDownTestCase(void)55 void DialogSessionManagerTest::TearDownTestCase(void)
56 {}
57
SetUp()58 void DialogSessionManagerTest::SetUp()
59 {}
60
TearDown()61 void DialogSessionManagerTest::TearDown()
62 {}
63
MockAbilityRecord(AbilityType abilityType)64 std::shared_ptr<AbilityRecord> DialogSessionManagerTest::MockAbilityRecord(AbilityType abilityType)
65 {
66 AbilityRequest abilityRequest;
67 abilityRequest.appInfo.bundleName = TEST_BUNDLE_NAME;
68 abilityRequest.abilityInfo.name = "MainAbility";
69 abilityRequest.abilityInfo.type = abilityType;
70 return AbilityRecord::CreateAbilityRecord(abilityRequest);
71 }
72
MockToken(AbilityType abilityType)73 sptr<Token> DialogSessionManagerTest::MockToken(AbilityType abilityType)
74 {
75 std::shared_ptr<AbilityRecord> abilityRecord = MockAbilityRecord(abilityType);
76 if (!abilityRecord) {
77 return nullptr;
78 }
79 return abilityRecord->GetToken();
80 }
81
82 /**
83 * @tc.name: GetStartupSessionInfoTest_0100
84 * @tc.desc: Test GetStartupSessionInfo
85 * @tc.type: FUNC
86 */
87 HWTEST_F(DialogSessionManagerTest, GetStartupSessionInfoTest_0100, TestSize.Level1)
88 {
89 GTEST_LOG_(INFO) << "GetStartupSessionInfoTest_0100 start";
90 DialogSessionManager dialogSessionManager;
91 std::shared_ptr<StartupSessionInfo> ret = dialogSessionManager.GetStartupSessionInfo(TEST_DIALOG_SESSION_ID);
92 EXPECT_EQ(ret, nullptr);
93
94 AbilityRequest abilityRequest;
95 dialogSessionManager.SetStartupSessionInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
96 ret = dialogSessionManager.GetStartupSessionInfo(TEST_DIALOG_SESSION_ID);
97 EXPECT_NE(ret, nullptr);
98 GTEST_LOG_(INFO) << "GetStartupSessionInfoTest_0100 end";
99 }
100
101 /**
102 * @tc.name: SendDialogResultTest_0100
103 * @tc.desc: Test SendDialogResult
104 * @tc.type: FUNC
105 */
106 HWTEST_F(DialogSessionManagerTest, SendDialogResultTest_0100, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO) << "SendDialogResultTest_0100 start";
109 AbilityRequest abilityRequest;
110 DialogSessionManager dialogSessionManager;
111 Want want;
112 bool isAllowed = false;
113 int32_t ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
114 EXPECT_EQ(ret, ERR_OK);
115
116 isAllowed = true;
117 ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
118 EXPECT_EQ(ret, ERR_INVALID_VALUE);
119
120 dialogSessionManager.SetStartupSessionInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
121 ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
122 EXPECT_EQ(ret, ERR_INVALID_VALUE);
123 GTEST_LOG_(INFO) << "SendDialogResultTest_0100 end";
124 }
125
126 /**
127 * @tc.name: SendDialogResultTest_0200
128 * @tc.desc: Test SendDialogResult
129 * @tc.type: FUNC
130 */
131 HWTEST_F(DialogSessionManagerTest, SendDialogResultTest_0200, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "SendDialogResultTest_0200 start";
134 AbilityRequest abilityRequest;
135 DialogSessionManager dialogSessionManager;
136 Want want;
137 bool isAllowed = true;
138 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
139 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
140
141 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
142 int32_t ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
143 EXPECT_EQ(ret, ERR_NULL_INTERCEPTOR_EXECUTER);
144
145 want.SetParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0);
146 ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
147 EXPECT_EQ(ret, ERR_NULL_INTERCEPTOR_EXECUTER);
148 GTEST_LOG_(INFO) << "SendDialogResultTest_0200 end";
149 }
150
151 /**
152 * @tc.name: SendDialogResultTest_0300
153 * @tc.desc: Test SendDialogResult
154 * @tc.type: FUNC
155 */
156 HWTEST_F(DialogSessionManagerTest, SendDialogResultTest_0300, TestSize.Level1)
157 {
158 GTEST_LOG_(INFO) << "SendDialogResultTest_0300 start";
159 AbilityRequest abilityRequest;
160 DialogSessionManager dialogSessionManager;
161 Want want;
162 bool isAllowed = true;
163 abilityRequest.isQueryERMS = true;
164 dialogSessionManager.SetQueryERMSInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
165 int32_t ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
166 EXPECT_EQ(ret, ERR_OK);
167 GTEST_LOG_(INFO) << "SendDialogResultTest_0300 end";
168 }
169
170 /**
171 * @tc.name: NotifySCBToRecoveryAfterInterceptionTest_0100
172 * @tc.desc: Test NotifySCBToRecoveryAfterInterception
173 * @tc.type: FUNC
174 */
175 HWTEST_F(DialogSessionManagerTest, NotifySCBToRecoveryAfterInterceptionTest_0100, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "NotifySCBToRecoveryAfterInterceptionTest_0100 start";
178 AbilityRequest abilityRequest;
179 DialogSessionManager dialogSessionManager;
180
181 int32_t ret = dialogSessionManager.NotifySCBToRecoveryAfterInterception(TEST_DIALOG_SESSION_ID, abilityRequest);
182 EXPECT_EQ(ret, ERR_INVALID_VALUE);
183 GTEST_LOG_(INFO) << "NotifySCBToRecoveryAfterInterceptionTest_0100 end";
184 }
185
186 /**
187 * @tc.name: CreateModalDialogCommonTest_0100
188 * @tc.desc: Test CreateModalDialogCommon
189 * @tc.type: FUNC
190 */
191 HWTEST_F(DialogSessionManagerTest, CreateModalDialogCommonTest_0100, TestSize.Level1)
192 {
193 GTEST_LOG_(INFO) << "CreateModalDialogCommonTest_0100 start";
194 Want replaceWant;
195 sptr<IRemoteObject> callerToken = MockToken(AbilityType::PAGE);
196 DialogSessionManager dialogSessionManager;
197
198 int32_t ret = dialogSessionManager.CreateModalDialogCommon(replaceWant, callerToken, TEST_DIALOG_SESSION_ID);
199 EXPECT_EQ(ret, ERR_INVALID_VALUE);
200 GTEST_LOG_(INFO) << "CreateModalDialogCommonTest_0100 end";
201 }
202
203 /**
204 * @tc.name: IsCreateCloneSelectorDialogTest_0100
205 * @tc.desc: Test IsCreateCloneSelectorDialog
206 * @tc.type: FUNC
207 */
208 HWTEST_F(DialogSessionManagerTest, IsCreateCloneSelectorDialogTest_0100, TestSize.Level1)
209 {
210 GTEST_LOG_(INFO) << "IsCreateCloneSelectorDialogTest_0100 start";
211 DialogSessionManager dialogSessionManager;
212
213 StartAbilityUtils::isWantWithAppCloneIndex = true;
214 bool ret = dialogSessionManager.IsCreateCloneSelectorDialog(TEST_BUNDLE_NAME, TEST_USER_ID);
215 EXPECT_FALSE(ret);
216 GTEST_LOG_(INFO) << "IsCreateCloneSelectorDialogTest_0100 end";
217 }
218
219 /**
220 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0100
221 * @tc.desc: callerToken is nullptr
222 * @tc.type: FUNC
223 */
224 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0100, TestSize.Level1)
225 {
226 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0100 start";
227 std::string dialogSessionId = "";
228 AbilityRequest abilityRequest;
229 bool isSCBCall = false;
230 sptr<IRemoteObject> callerToken = nullptr;
231 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
232 DialogSessionManager dialogSessionManager;
233 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
234 EXPECT_FALSE(ret);
235 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0100 end";
236 }
237
238 /**
239 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0200
240 * @tc.desc: dialogSessionId is empty
241 * @tc.type: FUNC
242 */
243 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0200, TestSize.Level1)
244 {
245 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0200 start";
246 std::string dialogSessionId = "";
247 AbilityRequest abilityRequest;
248 bool isSCBCall = false;
249 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
250 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
251 DialogSessionManager dialogSessionManager;
252 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
253 EXPECT_FALSE(ret);
254 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0200 end";
255 }
256
257 /**
258 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0300
259 * @tc.desc: can not find dialogCallerInfo by dialogSessionId
260 * @tc.type: FUNC
261 */
262 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0300, TestSize.Level1)
263 {
264 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0300 start";
265 std::string dialogSessionId = "1000001";
266 AbilityRequest abilityRequest;
267 bool isSCBCall = false;
268 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
269 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
270 DialogSessionManager dialogSessionManager;
271 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
272 EXPECT_FALSE(ret);
273 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0300 end";
274 }
275
276 /**
277 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0400
278 * @tc.desc: dialog callerInfo do not need grant uri permission
279 * @tc.type: FUNC
280 */
281 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0400, TestSize.Level1)
282 {
283 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0400 start";
284 std::string dialogSessionId = "1000001";
285 AbilityRequest abilityRequest;
286 bool isSCBCall = false;
287 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
288 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
289
290 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
291 dialogCallerInfo->needGrantUriPermission = false;
292 DialogSessionManager dialogSessionManager;
293 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
294 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
295 EXPECT_FALSE(ret);
296 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0400 end";
297 }
298
299 /**
300 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0500
301 * @tc.desc: do not have uri permission flag
302 * @tc.type: FUNC
303 */
304 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0500, TestSize.Level1)
305 {
306 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0500 start";
307 std::string dialogSessionId = "1000001";
308 AbilityRequest abilityRequest;
309 bool isSCBCall = false;
310 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
311 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
312
313 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
314 dialogCallerInfo->needGrantUriPermission = true;
315 DialogSessionManager dialogSessionManager;
316 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
317 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
318 EXPECT_FALSE(ret);
319 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0500 end";
320 }
321
322 /**
323 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0600
324 * @tc.desc: not scb call and have uri permission flag
325 * @tc.type: FUNC
326 */
327 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0600, TestSize.Level1)
328 {
329 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0600 start";
330 std::string dialogSessionId = "1000001";
331 AbilityRequest abilityRequest;
332 bool isSCBCall = false;
333 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
334 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
335
336 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
337 uint32_t flag = 1;
338 dialogCallerInfo->targetWant.SetFlags(flag);
339 dialogCallerInfo->needGrantUriPermission = true;
340
341 DialogSessionManager dialogSessionManager;
342 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
343 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
344 EXPECT_FALSE(ret);
345 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0600 end";
346 }
347
348 /**
349 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0700
350 * @tc.desc: scb call and have uri permission flag
351 * @tc.type: FUNC
352 */
353 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0700, TestSize.Level1)
354 {
355 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0600 start";
356 std::string dialogSessionId = "1000001";
357 AbilityRequest abilityRequest;
358 bool isSCBCall = true;
359 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
360 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
361
362 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
363 uint32_t flag = 1;
364 std::string uri = "file://com.example.test/temp.txt";
365 std::vector<std::string> uriVec = { uri };
366 dialogCallerInfo->targetWant.SetFlags(flag);
367 dialogCallerInfo->targetWant.SetUri(uri);
368 dialogCallerInfo->targetWant.SetParam(AbilityConfig::PARAMS_STREAM, uriVec);
369 dialogCallerInfo->needGrantUriPermission = true;
370
371 DialogSessionManager dialogSessionManager;
372 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
373 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
374 EXPECT_FALSE(ret);
375
376 EXPECT_EQ(abilityRequest.want.GetFlags(), flag);
377 EXPECT_EQ(abilityRequest.want.GetUriString(), uri);
378 EXPECT_EQ(abilityRequest.want.GetStringArrayParam(AbilityConfig::PARAMS_STREAM).size(), 1);
379 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0700 end";
380 }
381
382 /**
383 * @tc.name: OnlySetDialogCallerInfo_0100
384 * @tc.desc: OnlySetDialogCallerInfo
385 * @tc.type: FUNC
386 */
387 HWTEST_F(DialogSessionManagerTest, OnlySetDialogCallerInfo_0100, TestSize.Level1)
388 {
389 GTEST_LOG_(INFO) << "OnlySetDialogCallerInfo_0100 start";
390 SelectorType type = SelectorType::INTERCEPTOR_SELECTOR;
391 AbilityRequest abilityRequest;
392 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, TEST_DIALOG_SESSION_ID);
393
394 DialogSessionManager dialogSessionManager;
395 dialogSessionManager.OnlySetDialogCallerInfo(abilityRequest, TEST_USER_ID, type, TEST_DIALOG_SESSION_ID, false);
396 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
397 GTEST_LOG_(INFO) << "OnlySetDialogCallerInfo_0100 end";
398 }
399
400 /**
401 * @tc.name: CreateImplicitSelectorModalDialog_0001
402 * @tc.desc: No APP_LAUNCH_TRUSTLIST
403 * @tc.type: FUNC
404 */
405 HWTEST_F(DialogSessionManagerTest, CreateImplicitSelectorModalDialog_0001, TestSize.Level1)
406 {
407 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0001 start";
408 std::string dialogSessionId = "1000001";
409 AbilityRequest abilityRequest;
410 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
411 AAFwk::Want want;
412 int32_t userId = 0;
413 std::vector<DialogAppInfo> dialogAppInfos;
414 abilityRequest.want.SetParam("deviceType", 1);
415 abilityRequest.want.SetParam("userId", userId);
416 std::string mockAction = "mockAction";
417 abilityRequest.want.SetParam("action", mockAction);
418 std::string mockType = "mockType";
419 abilityRequest.want.SetParam("wantType", mockType);
420 std::string mockUri = "mockUri";
421 abilityRequest.want.SetParam("uri", mockUri);
422 std::vector<std::string> mockEntities = {"mockEntities"};
423 abilityRequest.want.SetParam("entities", mockEntities);
424 abilityRequest.want.SetParam("appselector.selectorType", static_cast<int>(SelectorType::IMPLICIT_START_SELECTOR));
425 abilityRequest.want.SetParam("showCaller", false);
426 abilityRequest.want.SetParam(SHOW_DEFAULT_PICKER_FLAG, false);
427
428 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
429 DialogSessionManager dialogSessionManager;
430 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
431 auto ret = dialogSessionManager.CreateImplicitSelectorModalDialog(abilityRequest,
432 want, userId, dialogAppInfos, false);
433
434 EXPECT_NE(ret, ERR_INVALID_VALUE);
435 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0001 end";
436 }
437
438 /**
439 * @tc.name: CreateImplicitSelectorModalDialog_0002
440 * @tc.desc: Has APP_LAUNCH_TRUSTLIST
441 * @tc.type: FUNC
442 */
443 HWTEST_F(DialogSessionManagerTest, CreateImplicitSelectorModalDialog_0002, TestSize.Level1)
444 {
445 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0002 start";
446 std::string dialogSessionId = "1000001";
447 AbilityRequest abilityRequest;
448 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
449 AAFwk::Want want;
450 int32_t userId = 0;
451 std::vector<DialogAppInfo> dialogAppInfos;
452 abilityRequest.want.SetParam("deviceType", 1);
453 abilityRequest.want.SetParam("userId", userId);
454 std::string mockAction = "mockAction";
455 abilityRequest.want.SetParam("action", mockAction);
456 std::string mockType = "mockType";
457 abilityRequest.want.SetParam("wantType", mockType);
458 std::string mockUri = "mockUri";
459 abilityRequest.want.SetParam("uri", mockUri);
460 std::vector<std::string> mockEntities = {"mockEntities"};
461 abilityRequest.want.SetParam("entities", mockEntities);
462 abilityRequest.want.SetParam("appselector.selectorType", static_cast<int>(SelectorType::IMPLICIT_START_SELECTOR));
463 abilityRequest.want.SetParam("showCaller", false);
464 abilityRequest.want.SetParam(SHOW_DEFAULT_PICKER_FLAG, false);
465 std::vector<std::string> mockTrustlist = {"abc", "bca", "cab"};
466 abilityRequest.want.SetParam(APP_LAUNCH_TRUSTLIST, mockTrustlist);
467
468 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
469 DialogSessionManager dialogSessionManager;
470 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
471 auto ret = dialogSessionManager.CreateImplicitSelectorModalDialog(abilityRequest,
472 want, userId, dialogAppInfos, false);
473
474 EXPECT_NE(ret, ERR_INVALID_VALUE);
475 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0002 end";
476 }
477
478 /**
479 * @tc.name: NotifyAbilityRequestFailure_0100
480 * @tc.desc: Test NotifyAbilityRequestFailure
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0100, TestSize.Level1)
484 {
485 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0100 start";
486 DialogSessionManager dialogSessionManager;
487 Want want;
488 EXPECT_EQ(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
489
490 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
491
492 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0100 end";
493 }
494
495 /**
496 * @tc.name: NotifyAbilityRequestFailure_0200
497 * @tc.desc: Test NotifyAbilityRequestFailure
498 * @tc.type: FUNC
499 */
500 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0200, TestSize.Level1)
501 {
502 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0200 start";
503 DialogSessionManager dialogSessionManager;
504 Want want;
505 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
506 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
507 EXPECT_NE(dialogCallerInfo, nullptr);
508
509 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
510 auto callerInfo = dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID);
511 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
512
513 auto requestId = callerInfo->targetWant.GetStringParam(KEY_REQUEST_ID);
514 EXPECT_EQ(requestId.empty(), true);
515
516 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
517
518 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0200 end";
519 }
520
521 /**
522 * @tc.name: NotifyAbilityRequestFailure_0300
523 * @tc.desc: Test NotifyAbilityRequestFailure
524 * @tc.type: FUNC
525 */
526 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0300, TestSize.Level1)
527 {
528 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0300 start";
529 DialogSessionManager dialogSessionManager;
530 Want want;
531 want.SetParam(KEY_REQUEST_ID, std::string("1234567890"));
532 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
533 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
534 EXPECT_NE(dialogCallerInfo, nullptr);
535 dialogCallerInfo->targetWant = want;
536
537 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
538 auto callerInfo = dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID);
539 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
540
541 auto requestId = callerInfo->targetWant.GetStringParam(KEY_REQUEST_ID);
542 EXPECT_EQ(requestId.empty(), false);
543 EXPECT_EQ(callerInfo->callerToken, nullptr);
544
545 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
546
547 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0300 end";
548 }
549
550 /**
551 * @tc.name: NotifyAbilityRequestFailure_0400
552 * @tc.desc: Test NotifyAbilityRequestFailure
553 * @tc.type: FUNC
554 */
555 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0400, TestSize.Level1)
556 {
557 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0400 start";
558 DialogSessionManager dialogSessionManager;
559 Want want;
560 want.SetParam(KEY_REQUEST_ID, std::string("1234567890"));
561 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
562 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
563 EXPECT_NE(dialogCallerInfo, nullptr);
564 dialogCallerInfo->targetWant = want;
565
566 AbilityRequest abilityRequest;
567 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
568 EXPECT_NE(abilityRecord, nullptr);
569 dialogCallerInfo->callerToken = MockToken(AbilityType::PAGE);
570 EXPECT_NE(dialogCallerInfo->callerToken, nullptr);
571 EXPECT_EQ(Token::GetAbilityRecordByToken(dialogCallerInfo->callerToken), nullptr);
572
573 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
574 auto callerInfo = dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID);
575 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
576
577 auto requestId = callerInfo->targetWant.GetStringParam(KEY_REQUEST_ID);
578 EXPECT_EQ(requestId.empty(), false);
579 EXPECT_NE(callerInfo->callerToken, nullptr);
580 EXPECT_EQ(Token::GetAbilityRecordByToken(callerInfo->callerToken), nullptr);
581
582 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
583
584 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0400 end";
585 }
586
587 /**
588 * @tc.name: NotifyAbilityRequestFailure_0500
589 * @tc.desc: Test NotifyAbilityRequestFailure
590 * @tc.type: FUNC
591 */
592 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0500, TestSize.Level1)
593 {
594 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0500 start";
595 DialogSessionManager dialogSessionManager;
596 Want want;
597 want.SetParam(KEY_REQUEST_ID, std::string("1234567890"));
598 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
599 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
600 EXPECT_NE(dialogCallerInfo, nullptr);
601 dialogCallerInfo->targetWant = want;
602
603 AbilityRequest abilityRequest;
604 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
605 EXPECT_NE(abilityRecord, nullptr);
606 dialogCallerInfo->callerToken = new (std::nothrow) Token(abilityRecord);
607 EXPECT_NE(dialogCallerInfo->callerToken, nullptr);
608 EXPECT_NE(Token::GetAbilityRecordByToken(dialogCallerInfo->callerToken), nullptr);
609
610 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
611 auto callerInfo = dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID);
612 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
613
614 auto requestId = callerInfo->targetWant.GetStringParam(KEY_REQUEST_ID);
615 EXPECT_EQ(requestId.empty(), false);
616 EXPECT_NE(callerInfo->callerToken, nullptr);
617 EXPECT_NE(Token::GetAbilityRecordByToken(callerInfo->callerToken), nullptr);
618
619 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
620
621 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0500 end";
622 }
623
624 /**
625 * @tc.name: NotifyAbilityRequestFailure_0600
626 * @tc.desc: Test NotifyAbilityRequestFailure
627 * @tc.type: FUNC
628 */
629 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0600, TestSize.Level1)
630 {
631 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0600 start";
632 DialogSessionManager dialogSessionManager;
633 Want want;
634 want.SetParam(KEY_REQUEST_ID, std::string("1234567890"));
635 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
636 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
637 EXPECT_NE(dialogCallerInfo, nullptr);
638 dialogCallerInfo->targetWant = want;
639
640 AbilityRequest abilityRequest;
641 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
642 EXPECT_NE(abilityRecord, nullptr);
643 dialogCallerInfo->callerToken = new (std::nothrow) Token(abilityRecord);
644 EXPECT_NE(dialogCallerInfo->callerToken, nullptr);
645 EXPECT_NE(Token::GetAbilityRecordByToken(dialogCallerInfo->callerToken), nullptr);
646 dialogCallerInfo->type = SelectorType::IMPLICIT_START_SELECTOR;
647
648 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
649 auto callerInfo = dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID);
650 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
651
652 auto requestId = callerInfo->targetWant.GetStringParam(KEY_REQUEST_ID);
653 EXPECT_EQ(requestId.empty(), false);
654 EXPECT_NE(callerInfo->callerToken, nullptr);
655 EXPECT_NE(Token::GetAbilityRecordByToken(callerInfo->callerToken), nullptr);
656 EXPECT_EQ(callerInfo->type, SelectorType::IMPLICIT_START_SELECTOR);
657
658 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
659
660 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0600 end";
661 }
662
663 /**
664 * @tc.name: NotifyAbilityRequestFailure_0700
665 * @tc.desc: Test NotifyAbilityRequestFailure
666 * @tc.type: FUNC
667 */
668 HWTEST_F(DialogSessionManagerTest, NotifyAbilityRequestFailure_0700, TestSize.Level1)
669 {
670 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0700 start";
671 DialogSessionManager dialogSessionManager;
672 Want want;
673 want.SetParam(KEY_REQUEST_ID, std::string("1234567890"));
674 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
675 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
676 EXPECT_NE(dialogCallerInfo, nullptr);
677 dialogCallerInfo->targetWant = want;
678
679 AbilityRequest abilityRequest;
680 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
681 EXPECT_NE(abilityRecord, nullptr);
682 dialogCallerInfo->callerToken = new (std::nothrow) Token(abilityRecord);
683 EXPECT_NE(dialogCallerInfo->callerToken, nullptr);
684 EXPECT_NE(Token::GetAbilityRecordByToken(dialogCallerInfo->callerToken), nullptr);
685 dialogCallerInfo->type = SelectorType::APP_CLONE_SELECTOR;
686
687 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
688 auto callerInfo = dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID);
689 EXPECT_NE(dialogSessionManager.GetDialogCallerInfo(TEST_DIALOG_SESSION_ID), nullptr);
690
691 auto requestId = callerInfo->targetWant.GetStringParam(KEY_REQUEST_ID);
692 EXPECT_EQ(requestId.empty(), false);
693 EXPECT_NE(callerInfo->callerToken, nullptr);
694 EXPECT_NE(Token::GetAbilityRecordByToken(callerInfo->callerToken), nullptr);
695 EXPECT_EQ(callerInfo->type, SelectorType::APP_CLONE_SELECTOR);
696
697 dialogSessionManager.NotifyAbilityRequestFailure(TEST_DIALOG_SESSION_ID, want);
698
699 GTEST_LOG_(INFO) << "NotifyAbilityRequestFailure_0700 end";
700 }
701
702 /**
703 * @tc.name: SetQueryERMSInfo_001
704 * @tc.desc: test SetQueryERMSInfo function
705 * @tc.type: FUNC
706 */
707 HWTEST_F(DialogSessionManagerTest, SetQueryERMSInfo_001, TestSize.Level1)
708 {
709 GTEST_LOG_(INFO) << "SetQueryERMSInfo_001 start";
710 DialogSessionManager dialogSessionManager;
711 AbilityRequest abilityRequest;
712 abilityRequest.isQueryERMS = true;
713 dialogSessionManager.SetQueryERMSInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
714 bool found = dialogSessionManager.queryERMSInfoMap_.find(TEST_DIALOG_SESSION_ID) !=
715 dialogSessionManager.queryERMSInfoMap_.end();
716 EXPECT_TRUE(found);
717 GTEST_LOG_(INFO) << "SetQueryERMSInfo_001 end";
718 }
719
720 /**
721 * @tc.name: NotifyQueryERMSFinished_001
722 * @tc.desc: test NotifyQueryERMSFinished function
723 * @tc.type: FUNC
724 */
725 HWTEST_F(DialogSessionManagerTest, NotifyQueryERMSFinished_001, TestSize.Level1)
726 {
727 GTEST_LOG_(INFO) << "NotifyQueryERMSFinished_001 start";
728 DialogSessionManager dialogSessionManager;
729 AbilityRequest abilityRequest;
730 abilityRequest.isQueryERMS = true;
731 dialogSessionManager.SetQueryERMSInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
732 bool result = dialogSessionManager.NotifyQueryERMSFinished(TEST_DIALOG_SESSION_ID, true);
733 EXPECT_TRUE(result);
734 GTEST_LOG_(INFO) << "NotifyQueryERMSFinished_001 end";
735 }
736
737 /**
738 * @tc.name: NotifyQueryERMSFinished_002
739 * @tc.desc: test NotifyQueryERMSFinished function
740 * @tc.type: FUNC
741 */
742 HWTEST_F(DialogSessionManagerTest, NotifyQueryERMSFinished_002, TestSize.Level1)
743 {
744 GTEST_LOG_(INFO) << "NotifyQueryERMSFinished_002 start";
745 DialogSessionManager dialogSessionManager;
746 AbilityRequest abilityRequest;
747 abilityRequest.isQueryERMS = true;
748 dialogSessionManager.SetQueryERMSInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
749 bool result = dialogSessionManager.NotifyQueryERMSFinished("OTHERS", true);
750 EXPECT_FALSE(result);
751 GTEST_LOG_(INFO) << "NotifyQueryERMSFinished_002 end";
752 }
753
754 /**
755 * @tc.name: ClearDialogContext_001
756 * @tc.desc: test ClearDialogContext function
757 * @tc.type: FUNC
758 */
759 HWTEST_F(DialogSessionManagerTest, ClearDialogContext_001, TestSize.Level1)
760 {
761 GTEST_LOG_(INFO) << "ClearDialogContext_001 start";
762 DialogSessionManager dialogSessionManager;
763 dialogSessionManager.dialogSessionInfoMap_[TEST_DIALOG_SESSION_ID] = nullptr;
764 dialogSessionManager.dialogCallerInfoMap_[TEST_DIALOG_SESSION_ID] = nullptr;
765 dialogSessionManager.startupSessionInfoMap_[TEST_DIALOG_SESSION_ID] = nullptr;
766 dialogSessionManager.ClearDialogContext(TEST_DIALOG_SESSION_ID);
767 bool found1 = dialogSessionManager.dialogSessionInfoMap_.find(TEST_DIALOG_SESSION_ID) ==
768 dialogSessionManager.dialogSessionInfoMap_.end();
769 bool found2 = dialogSessionManager.dialogCallerInfoMap_.find(TEST_DIALOG_SESSION_ID) ==
770 dialogSessionManager.dialogCallerInfoMap_.end();
771 bool found3 = dialogSessionManager.startupSessionInfoMap_.find(TEST_DIALOG_SESSION_ID) ==
772 dialogSessionManager.startupSessionInfoMap_.end();
773 EXPECT_TRUE(found1 && found2 && found3);
774 GTEST_LOG_(INFO) << "ClearDialogContext_001 end";
775 }
776
777 /**
778 * @tc.name: GenerateSelectorTargetAbilityInfos_001
779 * @tc.desc: test GenerateSelectorTargetAbilityInfos function
780 * @tc.type: FUNC
781 */
782 HWTEST_F(DialogSessionManagerTest, GenerateSelectorTargetAbilityInfos_001, TestSize.Level1)
783 {
784 GTEST_LOG_(INFO) << "GenerateSelectorTargetAbilityInfos_001 start";
785 DialogSessionManager dialogSessionManager;
786 std::vector<DialogAppInfo> dialogAppInfos;
787 std::vector<DialogAbilityInfo> targetAbilityInfos;
788 DialogAppInfo dialogAppInfo;
789 dialogAppInfos.push_back(dialogAppInfo);
790 dialogSessionManager.GenerateSelectorTargetAbilityInfos(dialogAppInfos, targetAbilityInfos);
791 bool insertSuccess = targetAbilityInfos.size() > 0;
792 EXPECT_TRUE(insertSuccess);
793 GTEST_LOG_(INFO) << "GenerateSelectorTargetAbilityInfos_001 end";
794 }
795
796 /**
797 * @tc.name: CreateJumpModalDialog_001
798 * @tc.desc: test CreateJumpModalDialog function
799 * @tc.type: FUNC
800 */
801 HWTEST_F(DialogSessionManagerTest, CreateJumpModalDialog_001, TestSize.Level1)
802 {
803 GTEST_LOG_(INFO) << "CreateJumpModalDialog_001 start";
804 DialogSessionManager dialogSessionManager;
805 AbilityRequest abilityRequest;
806 Want replaceWant;
807 int result = dialogSessionManager.CreateJumpModalDialog(abilityRequest, 0, replaceWant);
808 EXPECT_NE(result, ERR_INVALID_VALUE);
809 GTEST_LOG_(INFO) << "CreateJumpModalDialog_001 end";
810 }
811
812 /**
813 * @tc.name: CreateModalDialogCommon_001
814 * @tc.desc: test CreateModalDialogCommon function
815 * @tc.type: FUNC
816 */
817 HWTEST_F(DialogSessionManagerTest, CreateModalDialogCommon_001, TestSize.Level1)
818 {
819 GTEST_LOG_(INFO) << "CreateModalDialogCommon_001 start";
820 DialogSessionManager dialogSessionManager;
821 Want replaceWant;
822 sptr<IRemoteObject> callerToken = nullptr;
823 int result = dialogSessionManager.CreateModalDialogCommon(replaceWant, callerToken, TEST_DIALOG_SESSION_ID);
824 EXPECT_EQ(result, INNER_ERR);
825 GTEST_LOG_(INFO) << "CreateModalDialogCommon_001 end";
826 }
827
828 /**
829 * @tc.name: CreateModalDialogCommon_002
830 * @tc.desc: test CreateModalDialogCommon function
831 * @tc.type: FUNC
832 */
833 HWTEST_F(DialogSessionManagerTest, CreateModalDialogCommon_002, TestSize.Level1)
834 {
835 GTEST_LOG_(INFO) << "CreateModalDialogCommon_002 start";
836 DialogSessionManager dialogSessionManager;
837 Want replaceWant;
838 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
839 int result = dialogSessionManager.CreateModalDialogCommon(replaceWant, callerToken, TEST_DIALOG_SESSION_ID);
840 EXPECT_EQ(result, ERR_INVALID_VALUE);
841 GTEST_LOG_(INFO) << "CreateModalDialogCommon_002 end";
842 }
843
844 /**
845 * @tc.name: HandleErmsResult_001
846 * @tc.desc: test HandleErmsResult function
847 * @tc.type: FUNC
848 */
849 HWTEST_F(DialogSessionManagerTest, HandleErmsResult_001, TestSize.Level1)
850 {
851 GTEST_LOG_(INFO) << "HandleErmsResult_001 start";
852 DialogSessionManager dialogSessionManager;
853 AbilityRequest abilityRequest;
854 Want replaceWant;
855 int result = dialogSessionManager.HandleErmsResult(abilityRequest, 0, replaceWant);
856 EXPECT_NE(result, ERR_INVALID_VALUE);
857 GTEST_LOG_(INFO) << "HandleErmsResult_001 end";
858 }
859
860 /**
861 * @tc.name: HandleErmsResultBySCB_001
862 * @tc.desc: test HandleErmsResultBySCB function
863 * @tc.type: FUNC
864 */
865 HWTEST_F(DialogSessionManagerTest, HandleErmsResultBySCB_001, TestSize.Level1)
866 {
867 GTEST_LOG_(INFO) << "HandleErmsResultBySCB_001 start";
868 DialogSessionManager dialogSessionManager;
869 AbilityRequest abilityRequest;
870 Want replaceWant;
871 int result = dialogSessionManager.HandleErmsResultBySCB(abilityRequest, replaceWant);
872 EXPECT_NE(result, ERR_INVALID_VALUE);
873 GTEST_LOG_(INFO) << "HandleErmsResultBySCB_001 end";
874 }
875 } // namespace AAFwk
876 } // namespace OHOS
877