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
35 static std::string g_mockString = "";
36 static bool g_mockBool = false;
37
38 namespace {
39 const string GROUP_ID = "TEST_GROUP_ID";
40 constexpr int32_t SLEEP_TIME = 1000;
41 }
42
GetBundleNameId(const std::string & bundleName,uint16_t & bundleNameId)43 bool DmsBmStorage::GetBundleNameId(const std::string& bundleName, uint16_t &bundleNameId)
44 {
45 return g_mockBool;
46 }
47
GetContinueType(const std::string & networkId,std::string & bundleName,uint8_t continueTypeId)48 std::string DmsBmStorage::GetContinueType(const std::string &networkId, std::string &bundleName,
49 uint8_t continueTypeId)
50 {
51 return g_mockString;
52 }
53
GetContinueTypeId(const std::string & bundleName,const std::string & abilityName,uint8_t & continueTypeId)54 bool DmsBmStorage::GetContinueTypeId(const std::string &bundleName, const std::string &abilityName,
55 uint8_t &continueTypeId)
56 {
57 return g_mockBool;
58 }
59
GetDistributedBundleName(const std::string & networkId,const uint16_t & bundleNameId,std::string & bundleName)60 bool DmsBmStorage::GetDistributedBundleName(const std::string &networkId, const uint16_t& bundleNameId,
61 std::string &bundleName)
62 {
63 return g_mockBool;
64 }
65
SetUpTestCase()66 void BundleManagerInternalTest::SetUpTestCase()
67 {
68 DTEST_LOG << "BundleManagerInternalTest::SetUpTestCase" << std::endl;
69 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
70 }
71
TearDownTestCase()72 void BundleManagerInternalTest::TearDownTestCase()
73 {
74 DTEST_LOG << "BundleManagerInternalTest::TearDownTestCase" << std::endl;
75 }
76
TearDown()77 void BundleManagerInternalTest::TearDown()
78 {
79 DTEST_LOG << "BundleManagerInternalTest::TearDown" << std::endl;
80 }
81
SetUp()82 void BundleManagerInternalTest::SetUp()
83 {
84 DTEST_LOG << "BundleManagerInternalTest::SetUp" << std::endl;
85 }
86
87 /**
88 * @tc.name: BundleManagerInternalTest_001
89 * @tc.desc: input invalid params
90 * @tc.type: FUNC
91 */
92 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_001, TestSize.Level0)
93 {
94 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_001 begin" << std::endl;
95 AAFwk::Want want;
96 AppExecFwk::ExtensionAbilityInfo extensionInfo;
97
98 bool ret = BundleManagerInternal::QueryExtensionAbilityInfo(want, extensionInfo);
99 EXPECT_TRUE(!ret);
100 EXPECT_TRUE(extensionInfo.name.empty());
101 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_001 end ret:" << ret << std::endl;
102 }
103
104 /**
105 * @tc.name: BundleManagerInternalTest_002
106 * @tc.desc: test ability info convert
107 * @tc.type: FUNC
108 */
109 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_002, TestSize.Level0)
110 {
111 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_002 begin" << std::endl;
112 AppExecFwk::AbilityInfo abilityInfo;
113 AppExecFwk::ExtensionAbilityInfo extensionInfo;
114 extensionInfo.bundleName.append("bundleName");
115 extensionInfo.name.append("name");
116 vector<string> permissions;
117 extensionInfo.permissions = permissions;
118 extensionInfo.visible = true;
119
120 BundleManagerInternal::InitAbilityInfoFromExtension(extensionInfo, abilityInfo);
121 EXPECT_TRUE(abilityInfo.bundleName.compare("bundleName") == 0);
122 EXPECT_TRUE(abilityInfo.name.compare("name") == 0);
123 EXPECT_TRUE(abilityInfo.permissions == permissions);
124 EXPECT_TRUE(abilityInfo.visible);
125 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_002 end "<< std::endl;
126 }
127
128 /**
129 * @tc.name: BundleManagerInternalTest_003
130 * @tc.desc: test CheckRemoteBundleInfo with empty bundleName
131 * @tc.type: FUNC
132 */
133 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_003, TestSize.Level1)
134 {
135 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_003 begin" << std::endl;
136 string deviceId = "123456";
137 string bundleName = "";
138 AppExecFwk::DistributedBundleInfo remoteBundleInfo;
139 int ret = BundleManagerInternal::CheckRemoteBundleInfoForContinuation(deviceId, bundleName, remoteBundleInfo);
140 EXPECT_TRUE(INVALID_PARAMETERS_ERR == ret);
141
142 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_003 end "<< std::endl;
143 }
144
145 /**
146 * @tc.name: BundleManagerInternalTest_004
147 * @tc.desc: test CheckRemoteBundleInfo with unexist bundle
148 * @tc.type: FUNC
149 */
150 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_004, TestSize.Level1)
151 {
152 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_004 begin" << std::endl;
153 string deviceId = "123456";
154 string bundleName = "ohos.samples.testApp";
155 AppExecFwk::DistributedBundleInfo remoteBundleInfo;
156 int ret = BundleManagerInternal::CheckRemoteBundleInfoForContinuation(deviceId, bundleName, remoteBundleInfo);
157 EXPECT_TRUE(INVALID_PARAMETERS_ERR == ret);
158
159 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_004 end "<< std::endl;
160 }
161
162 /**
163 * @tc.name: BundleManagerInternalTest_005
164 * @tc.desc: test CheckRemoteBundleInfo with valid param
165 * @tc.type: FUNC
166 */
167 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_005, TestSize.Level1)
168 {
169 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_005 begin" << std::endl;
170 string deviceId = "123456";
171 string bundleName = "com.ohos.mms";
172 AppExecFwk::DistributedBundleInfo remoteBundleInfo;
173 int ret = BundleManagerInternal::CheckRemoteBundleInfoForContinuation(deviceId, bundleName, remoteBundleInfo);
174 EXPECT_TRUE(CONTINUE_REMOTE_UNINSTALLED_UNSUPPORT_FREEINSTALL == ret);
175
176 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_005 end "<< std::endl;
177 }
178
179 /**
180 * @tc.name: BundleManagerInternalTest_006
181 * @tc.desc: test CheckIfRemoteCanInstall with valid param
182 * @tc.type: FUNC
183 */
184 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_006, TestSize.Level1)
185 {
186 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_006 begin" << std::endl;
187 string deviceId = "123456";
188 string bundleName = "com.ohos.mms";
189 string moduleName = "entry";
190 string abilityName = "bmsThirdBundle";
191 AAFwk::Want want;
192 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
193 int32_t missionId = 0;
194 bool ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
195 EXPECT_EQ(ret, false);
196 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_006 end "<< std::endl;
197 }
198
199 /**
200 * @tc.name: BundleManagerInternalTest_007
201 * @tc.desc: test CheckIfRemoteCanInstall with invalid param
202 * @tc.type: FUNC
203 */
204 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_007, TestSize.Level1)
205 {
206 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_007 begin" << std::endl;
207 string deviceId = "";
208 string bundleName = "ohos.samples.testApp";
209 string moduleName = "entry";
210 string abilityName = "MainAbility";
211 AAFwk::Want want;
212 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
213 int32_t missionId = 0;
214 bool ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
215 EXPECT_EQ(ret, false);
216
217 deviceId = "123456";
218 bundleName = "";
219 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
220 ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
221 EXPECT_EQ(ret, false);
222
223 bundleName = "ohos.samples.testApp";
224 moduleName = "";
225 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
226 ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
227 EXPECT_EQ(ret, false);
228
229 moduleName = "entry";
230 abilityName = "";
231 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
232 ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
233 EXPECT_EQ(ret, false);
234
235 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_007 end "<< std::endl;
236 }
237
238 /**
239 * @tc.name: BundleManagerInternalTest_008
240 * @tc.desc: test CheckIfRemoteCanInstall with unexist bundle
241 * @tc.type: FUNC
242 */
243 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_008, TestSize.Level1)
244 {
245 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_008 begin" << std::endl;
246 string deviceId = "123456";
247 string bundleName = "ohos.samples.testApp";
248 string moduleName = "entry";
249 string abilityName = "MainAbility";
250 AAFwk::Want want;
251 want.SetElementName(deviceId, bundleName, abilityName, moduleName);
252 int32_t missionId = 0;
253 bool ret = BundleManagerInternal::CheckIfRemoteCanInstall(want, missionId);
254 EXPECT_EQ(ret, false);
255 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_008 end "<< std::endl;
256 }
257
258 /**
259 * @tc.name: BundleManagerInternalTest_009
260 * @tc.desc: test get callerappId from bms with invalid param
261 * @tc.type: FUNC
262 */
263 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_009, TestSize.Level4)
264 {
265 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_009 begin" << std::endl;
266 int32_t callingUid = -1;
267 string appId;
268 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(callingUid, appId);
269 EXPECT_EQ(ret, false);
270 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_009 end "<< std::endl;
271 }
272
273 /**
274 * @tc.name: BundleManagerInternalTest_010
275 * @tc.desc: test get callerappId from bms with invalid param
276 * @tc.type: FUNC
277 */
278 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_010, TestSize.Level3)
279 {
280 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_010 begin" << std::endl;
281 int32_t callingUid = 5522;
282 string appId;
283 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(callingUid, appId);
284 EXPECT_EQ(ret, false);
285 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_010 end "<< std::endl;
286 }
287
288 /**
289 * @tc.name: BundleManagerInternalTest_011
290 * @tc.desc: test IsSameAppId with invalid param
291 * @tc.type: FUNC
292 */
293 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_011, TestSize.Level3)
294 {
295 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_011 begin" << std::endl;
296 string appId;
297 string targetBundleName;
298 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
299 EXPECT_EQ(ret, false);
300 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_011 end "<< std::endl;
301 }
302
303 /**
304 * @tc.name: BundleManagerInternalTest_012
305 * @tc.desc: test IsSameAppId with invalid param
306 * @tc.type: FUNC
307 */
308 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_012, TestSize.Level3)
309 {
310 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_012 begin" << std::endl;
311 string appId = "1001";
312 string targetBundleName = "ohos.samples.testApp";
313 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
314 EXPECT_EQ(ret, false);
315 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_012 end "<< std::endl;
316 }
317
318 /**
319 * @tc.name: BundleManagerInternalTest_013
320 * @tc.desc: test IsSameAppId with invalid param
321 * @tc.type: FUNC
322 */
323 HWTEST_F(BundleManagerInternalTest, BundleManagerInternalTest_013, TestSize.Level3)
324 {
325 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_013 begin" << std::endl;
326 string bundleName = "ohos.samples.testApp";
327 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
328 EXPECT_EQ(uid, -1);
329 DTEST_LOG << "BundleManagerInternalTest BundleManagerInternalTest_013 end "<< std::endl;
330 }
331
332 /**
333 * @tc.name: BundleManagerCallBackTest_001
334 * @tc.desc: test OnQueryInstallationFinished with failed result
335 * @tc.type: FUNC
336 */
337 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_001, TestSize.Level1)
338 {
339 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_001 begin" << std::endl;
340 int32_t resultCode = -1;
341 int32_t missionId = 0;
342 int32_t versionCode = 10000;
343 auto callback = new DmsBundleManagerCallbackStub();
344 ASSERT_NE(callback, nullptr);
345 int32_t ret = callback->OnQueryInstallationFinished(resultCode, missionId, versionCode);
346 EXPECT_TRUE(CONTINUE_REMOTE_UNINSTALLED_CANNOT_FREEINSTALL == ret);
347 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_001 end "<< std::endl;
348 }
349
350 /**
351 * @tc.name: BundleManagerCallBackTest_002
352 * @tc.desc: test OnQueryInstallationFinished
353 * @tc.type: FUNC
354 */
355 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_002, TestSize.Level1)
356 {
357 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_002 begin" << std::endl;
358 int32_t resultCode = 0;
359 int32_t missionId = 0;
360 int32_t versionCode = 10000;
361 auto callback = new DmsBundleManagerCallbackStub();
362 ASSERT_NE(callback, nullptr);
363 int32_t ret = callback->OnQueryInstallationFinished(resultCode, missionId, versionCode);
364 EXPECT_TRUE(ERR_OK != ret);
365 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_002 end "<< std::endl;
366 }
367
368 /**
369 * @tc.name: BundleManagerCallBackTest_003
370 * @tc.desc: test OnRemoteRequest
371 * @tc.type: FUNC
372 */
373 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_003, TestSize.Level1)
374 {
375 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_003 begin" << std::endl;
376 MessageParcel data;
377 MessageParcel reply;
378 MessageOption option;
379 auto callback = new DmsBundleManagerCallbackStub();
380 ASSERT_NE(callback, nullptr);
381 int32_t ret = callback->OnRemoteRequest(-1, data, reply, option);
382 EXPECT_TRUE(ERR_OK != ret);
383 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_003 end "<< std::endl;
384 }
385
386 /**
387 * @tc.name: BundleManagerCallBackTest_004
388 * @tc.desc: test OnRemoteRequest
389 * @tc.type: FUNC
390 */
391 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_004, TestSize.Level1)
392 {
393 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_004 begin" << std::endl;
394 MessageParcel data;
395 MessageParcel reply;
396 MessageOption option;
397 auto callback = new DmsBundleManagerCallbackStub();
398 ASSERT_NE(callback, nullptr);
399 data.WriteInterfaceToken(callback->GetDescriptor());
400 int32_t ret = callback->OnRemoteRequest(-1, data, reply, option);
401 EXPECT_TRUE(ERR_OK != ret);
402 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_004 end "<< std::endl;
403 }
404
405 /**
406 * @tc.name: BundleManagerCallBackTest_005
407 * @tc.desc: test OnRemoteRequest
408 * @tc.type: FUNC
409 */
410 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_005, TestSize.Level1)
411 {
412 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_005 begin" << std::endl;
413 MessageParcel data;
414 MessageParcel reply;
415 MessageOption option;
416 auto callback = new DmsBundleManagerCallbackStub();
417 ASSERT_NE(callback, nullptr);
418 data.WriteInterfaceToken(callback->GetDescriptor());
419 int32_t ret = callback->OnRemoteRequest(1, data, reply, option);
420 EXPECT_TRUE(ERR_OK != ret);
421 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_005 end "<< std::endl;
422 }
423
424 /**
425 * @tc.name: GetBundleNameListFromBms_001
426 * @tc.desc: test GetBundleNameListFromBms
427 * @tc.type: FUNC
428 */
429 HWTEST_F(BundleManagerInternalTest, GetBundleNameListFromBms_001, TestSize.Level3)
430 {
431 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_001 begin" << std::endl;
432 const std::string bundleName = "com.ohos.permissionmanager";
433 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
434 ASSERT_TRUE(uid > 0);
435 std::vector<std::u16string> u16BundleNameList;
436 BundleManagerInternal::GetBundleNameListFromBms(uid, u16BundleNameList);
437 EXPECT_TRUE(!u16BundleNameList.empty());
438 u16BundleNameList.clear();
439 BundleManagerInternal::GetBundleNameListFromBms(-1, u16BundleNameList);
440 EXPECT_TRUE(u16BundleNameList.empty());
441 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_001 end "<< std::endl;
442 }
443
444 /**
445 * @tc.name: GetBundleNameListFromBms_002
446 * @tc.desc: test GetBundleNameListFromBms
447 * @tc.type: FUNC
448 */
449 HWTEST_F(BundleManagerInternalTest, GetBundleNameListFromBms_002, TestSize.Level3)
450 {
451 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_002 begin" << std::endl;
452 const std::string bundleName = "com.ohos.permissionmanager";
453 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
454 ASSERT_TRUE(uid > 0);
455 std::vector<std::u16string> u16BundleNameList;
456 bool ret1 = BundleManagerInternal::GetBundleNameListFromBms(uid, u16BundleNameList);
457 EXPECT_EQ(ret1, true);
458 u16BundleNameList.clear();
459 bool ret2 = BundleManagerInternal::GetBundleNameListFromBms(-1, u16BundleNameList);
460 EXPECT_EQ(ret2, false);
461 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_002 end "<< std::endl;
462 }
463
464 /**
465 * @tc.name: GetCallerAppIdFromBms_001
466 * @tc.desc: test get callerappId from bms
467 * @tc.type: FUNC
468 */
469 HWTEST_F(BundleManagerInternalTest, GetCallerAppIdFromBms_001, TestSize.Level3)
470 {
471 DTEST_LOG << "BundleManagerInternalTest GetCallerAppIdFromBms_001 begin" << std::endl;
472 const std::string bundleName = "com.ohos.permissionmanager";
473 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
474 ASSERT_TRUE(uid > 0);
475 string appId;
476 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(uid, appId);
477 EXPECT_EQ(ret, true);
478 DTEST_LOG << "BundleManagerInternalTest GetCallerAppIdFromBms_001 end "<< std::endl;
479 }
480
481 /**
482 * @tc.name: IsSameAppId_001
483 * @tc.desc: test IsSameAppId with invalid param
484 * @tc.type: FUNC
485 */
486 HWTEST_F(BundleManagerInternalTest, IsSameAppId_001, TestSize.Level3)
487 {
488 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_001 begin" << std::endl;
489 string appId = "1001";
490 string targetBundleName = "ohos.samples.dms.testApp";
491 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
492 EXPECT_EQ(ret, false);
493 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_001 end "<< std::endl;
494 }
495
496 /**
497 * @tc.name: IsSameAppId_002
498 * @tc.desc: test IsSameAppId with invalid param
499 * @tc.type: FUNC
500 */
501 HWTEST_F(BundleManagerInternalTest, IsSameAppId_002, TestSize.Level3)
502 {
503 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_002 begin" << std::endl;
504 string appId = "1001";
505 string targetBundleName = "";
506 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
507 EXPECT_EQ(ret, false);
508 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_002 end "<< std::endl;
509 }
510
511 /**
512 * @tc.name: IsSameAppId_003
513 * @tc.desc: test IsSameAppId with invalid param
514 * @tc.type: FUNC
515 */
516 HWTEST_F(BundleManagerInternalTest, IsSameAppId_003, TestSize.Level3)
517 {
518 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_003 begin" << std::endl;
519 string appId = "";
520 string targetBundleName = "ohos.samples.dms.testApp";
521 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
522 EXPECT_EQ(ret, false);
523 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_003 end "<< std::endl;
524 }
525
526 /**
527 * @tc.name: IsSameAppId_004
528 * @tc.desc: test IsSameAppId with invalid param
529 * @tc.type: FUNC
530 */
531 HWTEST_F(BundleManagerInternalTest, IsSameAppId_004, TestSize.Level3)
532 {
533 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_004 begin" << std::endl;
534 string appId = "";
535 string targetBundleName = "";
536 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
537 EXPECT_EQ(ret, false);
538 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_004 end "<< std::endl;
539 }
540
541 /**
542 * @tc.name: GetBundleNameId_001
543 * @tc.desc: test get bundleNameId from bms
544 * @tc.type: FUNC
545 */
546 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_001, TestSize.Level3)
547 {
548 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_001 begin" << std::endl;
549 const std::string bundleName = "ohos.samples.dms.testApp";
550 uint16_t bundleNameId = 0;
551 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
552 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
553 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_001 end "<< std::endl;
554 }
555
556 /**
557 * @tc.name: GetBundleNameId_002
558 * @tc.desc: test get bundleNameId from bms
559 * @tc.type: FUNC
560 */
561 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_002, TestSize.Level3)
562 {
563 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_002 begin" << std::endl;
564 const std::string bundleName = "com.ohos.mms";
565 uint16_t bundleNameId = 0;
566 BundleManagerInternal::GetDistributedBundleManager();
567 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
568 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
569 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_002 end "<< std::endl;
570 }
571
572 /**
573 * @tc.name: IsSameDeveloperId_001
574 * @tc.desc: IsSameDeveloperId
575 * @tc.type: FUNC
576 */
577 HWTEST_F(BundleManagerInternalTest, IsSameDeveloperId_001, TestSize.Level3)
578 {
579 DTEST_LOG << "BundleManagerInternalTest IsSameDeveloperId_001 begin" << std::endl;
580 std::string bundleNameInCurrentSide;
581 std::string developerId4OtherSide;
582 bool ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
583 EXPECT_EQ(ret, false);
584
585 developerId4OtherSide = "developerId4OtherSide";
586 ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
587 EXPECT_EQ(ret, false);
588
589 bundleNameInCurrentSide = "bundleNameInCurrentSide";
590 ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
591 EXPECT_EQ(ret, false);
592
593 developerId4OtherSide.clear();
594 ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
595 EXPECT_EQ(ret, false);
596 DTEST_LOG << "BundleManagerInternalTest IsSameDeveloperId_001 end "<< std::endl;
597 }
598
599 /**
600 * @tc.name: GetContinueBundle4Src_001
601 * @tc.desc: GetContinueBundle4Src
602 * @tc.type: FUNC
603 */
604 HWTEST_F(BundleManagerInternalTest, GetContinueBundle4Src_001, TestSize.Level3)
605 {
606 DTEST_LOG << "BundleManagerInternalTest GetContinueBundle4Src_001 begin" << std::endl;
607 std::string srcBundleName;
608 std::vector<std::string> bundleNameList;
609 bool ret = BundleManagerInternal::GetContinueBundle4Src(srcBundleName, bundleNameList);
610 EXPECT_EQ(ret, false);
611 DTEST_LOG << "BundleManagerInternalTest GetContinueBundle4Src_001 end "<< std::endl;
612 }
613
614 /**
615 * @tc.name: GetAppProvisionInfo4CurrentUser_001
616 * @tc.desc: GetAppProvisionInfo4CurrentUser
617 * @tc.type: FUNC
618 */
619 HWTEST_F(BundleManagerInternalTest, GetAppProvisionInfo4CurrentUser_001, TestSize.Level3)
620 {
621 DTEST_LOG << "BundleManagerInternalTest GetAppProvisionInfo4CurrentUser_001 begin" << std::endl;
622 std::string bundleName;
623 AppExecFwk::AppProvisionInfo appProvisionInfo;
624 bool ret = BundleManagerInternal::GetAppProvisionInfo4CurrentUser(bundleName, appProvisionInfo);
625 EXPECT_EQ(ret, false);
626 DTEST_LOG << "BundleManagerInternalTest GetAppProvisionInfo4CurrentUser_001 end "<< std::endl;
627 }
628
629 /**
630 * @tc.name: GetContinueType_001
631 * @tc.desc: GetContinueType
632 * @tc.type: FUNC
633 */
634 HWTEST_F(BundleManagerInternalTest, GetContinueType_001, TestSize.Level3)
635 {
636 DTEST_LOG << "BundleManagerInternalTest GetContinueType_001 begin" << std::endl;
637 std::string networkId = "networkId";
638 std::string bundleName;
639 uint8_t continueTypeId = 0;
640 std::string str = BundleManagerInternal::GetContinueType(networkId, bundleName, continueTypeId);
641 EXPECT_EQ(str, "");
642 DTEST_LOG << "BundleManagerInternalTest GetContinueType_001 end "<< std::endl;
643 }
644
645 /**
646 * @tc.name: GetContinueTypeId_001
647 * @tc.desc: GetContinueTypeId
648 * @tc.type: FUNC
649 */
650 HWTEST_F(BundleManagerInternalTest, GetContinueTypeId_001, TestSize.Level3)
651 {
652 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_001 begin" << std::endl;
653 std::string networkId = "networkId";
654 std::string abilityName;
655 uint8_t continueTypeId = 0;
656 int32_t ret = BundleManagerInternal::GetContinueTypeId(networkId, abilityName, continueTypeId);
657 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
658 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_001 end "<< std::endl;
659 }
660
661 /**
662 * @tc.name: GetBundleNameById_001
663 * @tc.desc: GetBundleNameById
664 * @tc.type: FUNC
665 */
666 HWTEST_F(BundleManagerInternalTest, GetBundleNameById_001, TestSize.Level3)
667 {
668 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_001 begin" << std::endl;
669 std::string networkId = "networkId";
670 std::string bundleName;
671 uint16_t bundleNameId = 0;
672 int32_t ret = BundleManagerInternal::GetBundleNameById(networkId, bundleNameId, bundleName);
673 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
674 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_001 end "<< std::endl;
675 }
676
677
678 /**
679 * @tc.name: GetBundleNameId_003
680 * @tc.desc: test get bundleNameId from bms
681 * @tc.type: FUNC
682 */
683 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_003, TestSize.Level3)
684 {
685 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_003 begin" << std::endl;
686 const std::string bundleName = "com.ohos.mms";
687 uint16_t bundleNameId = 0;
688 g_mockBool = true;
689 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
690 EXPECT_EQ(ret, ERR_OK);
691 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_003 end "<< std::endl;
692 }
693
694 /**
695 * @tc.name: GetContinueType_002
696 * @tc.desc: GetContinueType
697 * @tc.type: FUNC
698 */
699 HWTEST_F(BundleManagerInternalTest, GetContinueType_002, TestSize.Level3)
700 {
701 DTEST_LOG << "BundleManagerInternalTest GetContinueType_002 begin" << std::endl;
702 std::string networkId = "networkId";
703 std::string bundleName;
704 uint8_t continueTypeId = 0;
705 g_mockString = "continueType";
706 std::string str = BundleManagerInternal::GetContinueType(networkId, bundleName, continueTypeId);
707 EXPECT_NE(str, "");
708 DTEST_LOG << "BundleManagerInternalTest GetContinueType_002 end "<< std::endl;
709 }
710
711 /**
712 * @tc.name: GetContinueTypeId_002
713 * @tc.desc: GetContinueTypeId
714 * @tc.type: FUNC
715 */
716 HWTEST_F(BundleManagerInternalTest, GetContinueTypeId_002, TestSize.Level3)
717 {
718 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_002 begin" << std::endl;
719 std::string networkId = "networkId";
720 std::string abilityName;
721 uint8_t continueTypeId = 0;
722 g_mockBool = true;
723 int32_t ret = BundleManagerInternal::GetContinueTypeId(networkId, abilityName, continueTypeId);
724 EXPECT_EQ(ret, ERR_OK);
725 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_002 end "<< std::endl;
726 }
727
728 /**
729 * @tc.name: GetBundleNameById_002
730 * @tc.desc: GetBundleNameById
731 * @tc.type: FUNC
732 */
733 HWTEST_F(BundleManagerInternalTest, GetBundleNameById_002, TestSize.Level3)
734 {
735 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_002 begin" << std::endl;
736 std::string networkId = "networkId";
737 std::string bundleName;
738 uint16_t bundleNameId = 0;
739 g_mockBool = true;
740 int32_t ret = BundleManagerInternal::GetBundleNameById(networkId, bundleNameId, bundleName);
741 EXPECT_EQ(ret, ERR_OK);
742 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_002 end "<< std::endl;
743 }
744
745 /**
746 * @tc.name: GetLocalAbilityInfo_001
747 * @tc.desc: GetLocalAbilityInfo
748 * @tc.type: FUNC
749 */
750 HWTEST_F(BundleManagerInternalTest, GetLocalAbilityInfo_001, TestSize.Level3)
751 {
752 DTEST_LOG << "BundleManagerInternalTest GetLocalAbilityInfo_001 begin" << std::endl;
753 std::string bundleName = "bundleName";
754 std::string moduleName = "moduleName";
755 std::string abilityName = "abilityName";
756 AppExecFwk::AbilityInfo abilityInfo;
757 int32_t ret = BundleManagerInternal::GetLocalAbilityInfo(bundleName, moduleName, abilityName, abilityInfo);
758 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
759 DTEST_LOG << "BundleManagerInternalTest GetLocalAbilityInfo_001 end "<< std::endl;
760 }
761 }
762 }
763