1 /*
2 * Copyright (c) 2021-2023 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 <thread>
17
18 #include "bundle_manager_internal_test.h"
19 #include "bundle/bundle_manager_internal.h"
20
21 #define private public
22 #include "bundle/bundle_manager_callback_stub.h"
23 #undef private
24
25 #include "distributed_sched_test_util.h"
26 #include "dtbschedmgr_log.h"
27 #include "test_log.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace DistributedSchedule {
34 namespace {
35 const string GROUP_ID = "TEST_GROUP_ID";
36 constexpr int32_t SLEEP_TIME = 1000;
37 }
38
SetUpTestCase()39 void BundleManagerInternalTest::SetUpTestCase()
40 {
41 DTEST_LOG << "BundleManagerInternalTest::SetUpTestCase" << std::endl;
42 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
43 }
44
TearDownTestCase()45 void BundleManagerInternalTest::TearDownTestCase()
46 {
47 DTEST_LOG << "BundleManagerInternalTest::TearDownTestCase" << std::endl;
48 }
49
TearDown()50 void BundleManagerInternalTest::TearDown()
51 {
52 DTEST_LOG << "BundleManagerInternalTest::TearDown" << std::endl;
53 }
54
SetUp()55 void BundleManagerInternalTest::SetUp()
56 {
57 DTEST_LOG << "BundleManagerInternalTest::SetUp" << std::endl;
58 }
59
60 /**
61 * @tc.name: BundleManagerInternalTest_001
62 * @tc.desc: input invalid params
63 * @tc.type: FUNC
64 */
65 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_001, TestSize.Level0)
66 {
67 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_001 begin" << std::endl;
68 AAFwk::Want want;
69 AppExecFwk::ExtensionAbilityInfo extensionInfo;
70
71 bool ret = BundleManagerInternal::QueryExtensionAbilityInfo(want, extensionInfo);
72 EXPECT_TRUE(!ret);
73 EXPECT_TRUE(extensionInfo.name.empty());
74 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_001 end ret:" << ret << std::endl;
75 }
76
77 /**
78 * @tc.name: BundleManagerInternalTest_002
79 * @tc.desc: test ability info convert
80 * @tc.type: FUNC
81 */
82 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_002, TestSize.Level0)
83 {
84 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_002 begin" << std::endl;
85 AppExecFwk::AbilityInfo abilityInfo;
86 AppExecFwk::ExtensionAbilityInfo extensionInfo;
87 extensionInfo.bundleName.append("bundleName");
88 extensionInfo.name.append("name");
89 vector<string> permissions;
90 extensionInfo.permissions = permissions;
91 extensionInfo.visible = true;
92
93 BundleManagerInternal::InitAbilityInfoFromExtension(extensionInfo, abilityInfo);
94 EXPECT_TRUE(abilityInfo.bundleName.compare("bundleName") == 0);
95 EXPECT_TRUE(abilityInfo.name.compare("name") == 0);
96 EXPECT_TRUE(abilityInfo.permissions == permissions);
97 EXPECT_TRUE(abilityInfo.visible);
98 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_002 end "<< std::endl;
99 }
100
101 /**
102 * @tc.name: BundleManagerInternalTest_003
103 * @tc.desc: test CheckRemoteBundleInfo with empty bundleName
104 * @tc.type: FUNC
105 */
106 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_003, TestSize.Level1)
107 {
108 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_003 begin" << std::endl;
109 string deviceId = "123456";
110 string bundleName = "";
111 AppExecFwk::DistributedBundleInfo remoteBundleInfo;
112 int ret = BundleManagerInternal::CheckRemoteBundleInfoForContinuation(deviceId, bundleName, remoteBundleInfo);
113 EXPECT_TRUE(INVALID_PARAMETERS_ERR == ret);
114
115 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_003 end "<< std::endl;
116 }
117
118 /**
119 * @tc.name: BundleManagerInternalTest_004
120 * @tc.desc: test CheckRemoteBundleInfo with unexist bundle
121 * @tc.type: FUNC
122 */
123 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_004, TestSize.Level1)
124 {
125 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_004 begin" << std::endl;
126 string deviceId = "123456";
127 string bundleName = "ohos.samples.testApp";
128 AppExecFwk::DistributedBundleInfo remoteBundleInfo;
129 int ret = BundleManagerInternal::CheckRemoteBundleInfoForContinuation(deviceId, bundleName, remoteBundleInfo);
130 EXPECT_TRUE(INVALID_PARAMETERS_ERR == ret);
131
132 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_004 end "<< std::endl;
133 }
134
135 /**
136 * @tc.name: BundleManagerInternalTest_005
137 * @tc.desc: test CheckRemoteBundleInfo with valid param
138 * @tc.type: FUNC
139 */
140 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_005, TestSize.Level1)
141 {
142 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_005 begin" << std::endl;
143 string deviceId = "123456";
144 string bundleName = "com.ohos.mms";
145 AppExecFwk::DistributedBundleInfo remoteBundleInfo;
146 int ret = BundleManagerInternal::CheckRemoteBundleInfoForContinuation(deviceId, bundleName, remoteBundleInfo);
147 EXPECT_TRUE(CONTINUE_REMOTE_UNINSTALLED_UNSUPPORT_FREEINSTALL == ret);
148
149 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_005 end "<< std::endl;
150 }
151
152 /**
153 * @tc.name: BundleManagerInternalTest_006
154 * @tc.desc: test CheckIfRemoteCanInstall with valid param
155 * @tc.type: FUNC
156 */
157 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_006, TestSize.Level1)
158 {
159 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_006 begin" << std::endl;
160 string deviceId = "123456";
161 string bundleName = "com.ohos.mms";
162 string moduleName = "entry";
163 string abilityName = "bmsThirdBundle";
164 AAFwk::Want want;
165 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
166 int32_t missionId = 0;
167 bool ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
168 EXPECT_EQ(ret, false);
169 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_006 end "<< std::endl;
170 }
171
172 /**
173 * @tc.name: BundleManagerInternalTest_007
174 * @tc.desc: test CheckIfRemoteCanInstall with invalid param
175 * @tc.type: FUNC
176 */
177 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_007, TestSize.Level1)
178 {
179 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_007 begin" << std::endl;
180 string deviceId = "";
181 string bundleName = "ohos.samples.testApp";
182 string moduleName = "entry";
183 string abilityName = "MainAbility";
184 AAFwk::Want want;
185 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
186 int32_t missionId = 0;
187 bool ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
188 EXPECT_EQ(ret, false);
189
190 deviceId = "123456";
191 bundleName = "";
192 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
193 ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
194 EXPECT_EQ(ret, false);
195
196 bundleName = "ohos.samples.testApp";
197 moduleName = "";
198 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
199 ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
200 EXPECT_EQ(ret, false);
201
202 moduleName = "entry";
203 abilityName = "";
204 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
205 ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
206 EXPECT_EQ(ret, false);
207
208 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_007 end "<< std::endl;
209 }
210
211 /**
212 * @tc.name: BundleManagerInternalTest_008
213 * @tc.desc: test CheckIfRemoteCanInstall with unexist bundle
214 * @tc.type: FUNC
215 */
216 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_008, TestSize.Level1)
217 {
218 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_008 begin" << std::endl;
219 string deviceId = "123456";
220 string bundleName = "ohos.samples.testApp";
221 string moduleName = "entry";
222 string abilityName = "MainAbility";
223 AAFwk::Want want;
224 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
225 int32_t missionId = 0;
226 bool ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
227 EXPECT_EQ(ret, false);
228 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_008 end "<< std::endl;
229 }
230
231 /**
232 * @tc.name: BundleManagerInternalTest_009
233 * @tc.desc: test get callerappId from bms with invalid param
234 * @tc.type: FUNC
235 */
236 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_009, TestSize.Level4)
237 {
238 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_009 begin" << std::endl;
239 int32_t callingUid = -1;
240 string appId;
241 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(callingUid, appId);
242 EXPECT_EQ(ret, false);
243 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_009 end "<< std::endl;
244 }
245
246 /**
247 * @tc.name: BundleManagerInternalTest_010
248 * @tc.desc: test get callerappId from bms with invalid param
249 * @tc.type: FUNC
250 */
251 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_010, TestSize.Level3)
252 {
253 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_010 begin" << std::endl;
254 int32_t callingUid = 5522;
255 string appId;
256 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(callingUid, appId);
257 EXPECT_EQ(ret, false);
258 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_010 end "<< std::endl;
259 }
260
261 /**
262 * @tc.name: BundleManagerInternalTest_011
263 * @tc.desc: test IsSameAppId with invalid param
264 * @tc.type: FUNC
265 */
266 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_011, TestSize.Level3)
267 {
268 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_011 begin" << std::endl;
269 string appId;
270 string targetBundleName;
271 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
272 EXPECT_EQ(ret, false);
273 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_011 end "<< std::endl;
274 }
275
276 /**
277 * @tc.name: BundleManagerInternalTest_012
278 * @tc.desc: test IsSameAppId with invalid param
279 * @tc.type: FUNC
280 */
281 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_012, TestSize.Level3)
282 {
283 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_012 begin" << std::endl;
284 string appId = "1001";
285 string targetBundleName = "ohos.samples.testApp";
286 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
287 EXPECT_EQ(ret, false);
288 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_012 end "<< std::endl;
289 }
290
291 /**
292 * @tc.name: BundleManagerInternalTest_013
293 * @tc.desc: test IsSameAppId with invalid param
294 * @tc.type: FUNC
295 */
296 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_013, TestSize.Level3)
297 {
298 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_013 begin" << std::endl;
299 string bundleName = "ohos.samples.testApp";
300 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
301 EXPECT_EQ(uid, -1);
302 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_013 end "<< std::endl;
303 }
304
305 /**
306 * @tc.name: BundleManagerCallBackTest_001
307 * @tc.desc: test OnQueryInstallationFinished with failed result
308 * @tc.type: FUNC
309 */
310 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_001, TestSize.Level1)
311 {
312 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_001 begin" << std::endl;
313 int32_t resultCode = -1;
314 int32_t missionId = 0;
315 int32_t versionCode = 10000;
316 auto callback = new DmsBundleManagerCallbackStub();
317 ASSERT_NE(callback, nullptr);
318 int32_t ret = callback->OnQueryInstallationFinished(resultCode, missionId, versionCode);
319 EXPECT_TRUE(CONTINUE_REMOTE_UNINSTALLED_CANNOT_FREEINSTALL == ret);
320 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_001 end "<< std::endl;
321 }
322
323 /**
324 * @tc.name: BundleManagerCallBackTest_002
325 * @tc.desc: test OnQueryInstallationFinished
326 * @tc.type: FUNC
327 */
328 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_002, TestSize.Level1)
329 {
330 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_002 begin" << std::endl;
331 int32_t resultCode = 0;
332 int32_t missionId = 0;
333 int32_t versionCode = 10000;
334 auto callback = new DmsBundleManagerCallbackStub();
335 ASSERT_NE(callback, nullptr);
336 int32_t ret = callback->OnQueryInstallationFinished(resultCode, missionId, versionCode);
337 EXPECT_TRUE(ERR_OK != ret);
338 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_002 end "<< std::endl;
339 }
340
341 /**
342 * @tc.name: BundleManagerCallBackTest_003
343 * @tc.desc: test OnRemoteRequest
344 * @tc.type: FUNC
345 */
346 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_003, TestSize.Level1)
347 {
348 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_003 begin" << std::endl;
349 MessageParcel data;
350 MessageParcel reply;
351 MessageOption option;
352 auto callback = new DmsBundleManagerCallbackStub();
353 ASSERT_NE(callback, nullptr);
354 int32_t ret = callback->OnRemoteRequest(-1, data, reply, option);
355 EXPECT_TRUE(ERR_OK != ret);
356 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_003 end "<< std::endl;
357 }
358
359 /**
360 * @tc.name: BundleManagerCallBackTest_004
361 * @tc.desc: test OnRemoteRequest
362 * @tc.type: FUNC
363 */
364 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_004, TestSize.Level1)
365 {
366 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_004 begin" << std::endl;
367 MessageParcel data;
368 MessageParcel reply;
369 MessageOption option;
370 auto callback = new DmsBundleManagerCallbackStub();
371 ASSERT_NE(callback, nullptr);
372 data.WriteInterfaceToken(callback->GetDescriptor());
373 int32_t ret = callback->OnRemoteRequest(-1, data, reply, option);
374 EXPECT_TRUE(ERR_OK != ret);
375 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_004 end "<< std::endl;
376 }
377
378 /**
379 * @tc.name: BundleManagerCallBackTest_005
380 * @tc.desc: test OnRemoteRequest
381 * @tc.type: FUNC
382 */
383 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_005, TestSize.Level1)
384 {
385 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_005 begin" << std::endl;
386 MessageParcel data;
387 MessageParcel reply;
388 MessageOption option;
389 auto callback = new DmsBundleManagerCallbackStub();
390 ASSERT_NE(callback, nullptr);
391 data.WriteInterfaceToken(callback->GetDescriptor());
392 int32_t ret = callback->OnRemoteRequest(1, data, reply, option);
393 EXPECT_TRUE(ERR_OK != ret);
394 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_005 end "<< std::endl;
395 }
396
397 /**
398 * @tc.name: GetBundleNameListFromBms_001
399 * @tc.desc: test GetBundleNameListFromBms
400 * @tc.type: FUNC
401 */
402 HWTEST_F(BundleManagerInternalTest, GetBundleNameListFromBms_001, TestSize.Level3)
403 {
404 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_001 begin" << std::endl;
405 const std::string bundleName = "com.ohos.launcher";
406 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
407 if (uid <= 0) {
408 return;
409 }
410 std::vector<std::u16string> u16BundleNameList;
411 BundleManagerInternal::GetBundleNameListFromBms(uid, u16BundleNameList);
412 EXPECT_TRUE(!u16BundleNameList.empty());
413 u16BundleNameList.clear();
414 BundleManagerInternal::GetBundleNameListFromBms(-1, u16BundleNameList);
415 EXPECT_TRUE(u16BundleNameList.empty());
416 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_001 end "<< std::endl;
417 }
418
419 /**
420 * @tc.name: GetBundleNameListFromBms_002
421 * @tc.desc: test GetBundleNameListFromBms
422 * @tc.type: FUNC
423 */
424 HWTEST_F(BundleManagerInternalTest, GetBundleNameListFromBms_002, TestSize.Level3)
425 {
426 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_002 begin" << std::endl;
427 const std::string bundleName = "com.ohos.permissionmanager";
428 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
429 if (uid <= 0) {
430 return;
431 }
432 std::vector<std::u16string> u16BundleNameList;
433 bool ret1 = BundleManagerInternal::GetBundleNameListFromBms(uid, u16BundleNameList);
434 EXPECT_EQ(ret1, true);
435 u16BundleNameList.clear();
436 bool ret2 = BundleManagerInternal::GetBundleNameListFromBms(-1, u16BundleNameList);
437 EXPECT_EQ(ret2, false);
438 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_002 end "<< std::endl;
439 }
440
441 /**
442 * @tc.name: GetCallerAppIdFromBms_001
443 * @tc.desc: test get callerappId from bms
444 * @tc.type: FUNC
445 */
446 HWTEST_F(BundleManagerInternalTest, GetCallerAppIdFromBms_001, TestSize.Level3)
447 {
448 DTEST_LOG << "BundleManagerInternalTest GetCallerAppIdFromBms_001 begin" << std::endl;
449 const std::string bundleName = "com.ohos.launcher";
450 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
451 if (uid <= 0) {
452 return;
453 }
454 string appId;
455 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(uid, appId);
456 EXPECT_EQ(ret, true);
457 DTEST_LOG << "BundleManagerInternalTest GetCallerAppIdFromBms_001 end "<< std::endl;
458 }
459
460 /**
461 * @tc.name: IsSameAppId_001
462 * @tc.desc: test IsSameAppId with invalid param
463 * @tc.type: FUNC
464 */
465 HWTEST_F(BundleManagerInternalTest, IsSameAppId_001, TestSize.Level3)
466 {
467 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_001 begin" << std::endl;
468 string appId = "1001";
469 string targetBundleName = "ohos.samples.dms.testApp";
470 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
471 EXPECT_EQ(ret, false);
472 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_001 end "<< std::endl;
473 }
474
475 /**
476 * @tc.name: IsSameAppId_002
477 * @tc.desc: test IsSameAppId with invalid param
478 * @tc.type: FUNC
479 */
480 HWTEST_F(BundleManagerInternalTest, IsSameAppId_002, TestSize.Level3)
481 {
482 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_002 begin" << std::endl;
483 string appId = "1001";
484 string targetBundleName = "";
485 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
486 EXPECT_EQ(ret, false);
487 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_002 end "<< std::endl;
488 }
489
490 /**
491 * @tc.name: IsSameAppId_003
492 * @tc.desc: test IsSameAppId with invalid param
493 * @tc.type: FUNC
494 */
495 HWTEST_F(BundleManagerInternalTest, IsSameAppId_003, TestSize.Level3)
496 {
497 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_003 begin" << std::endl;
498 string appId = "";
499 string targetBundleName = "ohos.samples.dms.testApp";
500 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
501 EXPECT_EQ(ret, false);
502 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_003 end "<< std::endl;
503 }
504
505 /**
506 * @tc.name: IsSameAppId_004
507 * @tc.desc: test IsSameAppId with invalid param
508 * @tc.type: FUNC
509 */
510 HWTEST_F(BundleManagerInternalTest, IsSameAppId_004, TestSize.Level3)
511 {
512 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_004 begin" << std::endl;
513 string appId = "";
514 string targetBundleName = "";
515 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
516 EXPECT_EQ(ret, false);
517 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_004 end "<< std::endl;
518 }
519
520 /**
521 * @tc.name: GetBundleNameId_001
522 * @tc.desc: test get bundleNameId from bms
523 * @tc.type: FUNC
524 */
525 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_001, TestSize.Level3)
526 {
527 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_001 begin" << std::endl;
528 const std::string bundleName = "ohos.samples.dms.testApp";
529 uint16_t bundleNameId = 0;
530 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
531 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
532 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_001 end "<< std::endl;
533 }
534
535 /**
536 * @tc.name: GetBundleNameId_002
537 * @tc.desc: test get bundleNameId from bms
538 * @tc.type: FUNC
539 */
540 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_002, TestSize.Level3)
541 {
542 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_002 begin" << std::endl;
543 const std::string bundleName = "com.ohos.mms";
544 uint16_t bundleNameId = 0;
545 BundleManagerInternal::GetDistributedBundleManager();
546 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
547 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
548 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_002 end "<< std::endl;
549 }
550 }
551 }