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