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 delete callback;
384 callback = nullptr;
385 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_003 end "<< std::endl;
386 }
387
388 /**
389 * @tc.name: BundleManagerCallBackTest_004
390 * @tc.desc: test OnRemoteRequest
391 * @tc.type: FUNC
392 */
393 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_004, TestSize.Level1)
394 {
395 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_004 begin" << std::endl;
396 MessageParcel data;
397 MessageParcel reply;
398 MessageOption option;
399 auto callback = new DmsBundleManagerCallbackStub();
400 ASSERT_NE(callback, nullptr);
401 data.WriteInterfaceToken(callback->GetDescriptor());
402 int32_t ret = callback->OnRemoteRequest(-1, data, reply, option);
403 EXPECT_TRUE(ERR_OK != ret);
404 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_004 end "<< std::endl;
405 }
406
407 /**
408 * @tc.name: BundleManagerCallBackTest_005
409 * @tc.desc: test OnRemoteRequest
410 * @tc.type: FUNC
411 */
412 HWTEST_F(BundleManagerInternalTest, BundleManagerCallBackTest_005, TestSize.Level1)
413 {
414 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_005 begin" << std::endl;
415 MessageParcel data;
416 MessageParcel reply;
417 MessageOption option;
418 auto callback = new DmsBundleManagerCallbackStub();
419 ASSERT_NE(callback, nullptr);
420 data.WriteInterfaceToken(callback->GetDescriptor());
421 int32_t ret = callback->OnRemoteRequest(1, data, reply, option);
422 EXPECT_TRUE(ERR_OK != ret);
423 DTEST_LOG << "BundleManagerCallBackTest BundleManagerCallBackTest_005 end "<< std::endl;
424 }
425
426 /**
427 * @tc.name: GetBundleNameListFromBms_001
428 * @tc.desc: test GetBundleNameListFromBms
429 * @tc.type: FUNC
430 */
431 HWTEST_F(BundleManagerInternalTest, GetBundleNameListFromBms_001, TestSize.Level3)
432 {
433 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_001 begin" << std::endl;
434 const std::string bundleName = "com.ohos.permissionmanager";
435 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
436 ASSERT_TRUE(uid > 0);
437 std::vector<std::u16string> u16BundleNameList;
438 BundleManagerInternal::GetBundleNameListFromBms(uid, u16BundleNameList);
439 EXPECT_TRUE(!u16BundleNameList.empty());
440 u16BundleNameList.clear();
441 BundleManagerInternal::GetBundleNameListFromBms(-1, u16BundleNameList);
442 EXPECT_TRUE(u16BundleNameList.empty());
443 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_001 end "<< std::endl;
444 }
445
446 /**
447 * @tc.name: GetBundleNameListFromBms_002
448 * @tc.desc: test GetBundleNameListFromBms
449 * @tc.type: FUNC
450 */
451 HWTEST_F(BundleManagerInternalTest, GetBundleNameListFromBms_002, TestSize.Level3)
452 {
453 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_002 begin" << std::endl;
454 const std::string bundleName = "com.ohos.permissionmanager";
455 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
456 ASSERT_TRUE(uid > 0);
457 std::vector<std::u16string> u16BundleNameList;
458 bool ret1 = BundleManagerInternal::GetBundleNameListFromBms(uid, u16BundleNameList);
459 EXPECT_EQ(ret1, true);
460 u16BundleNameList.clear();
461 bool ret2 = BundleManagerInternal::GetBundleNameListFromBms(-1, u16BundleNameList);
462 EXPECT_EQ(ret2, false);
463 DTEST_LOG << "BundleManagerCallBackTest GetBundleNameListFromBms_002 end "<< std::endl;
464 }
465
466 /**
467 * @tc.name: GetCallerAppIdFromBms_001
468 * @tc.desc: test get callerappId from bms
469 * @tc.type: FUNC
470 */
471 HWTEST_F(BundleManagerInternalTest, GetCallerAppIdFromBms_001, TestSize.Level3)
472 {
473 DTEST_LOG << "BundleManagerInternalTest GetCallerAppIdFromBms_001 begin" << std::endl;
474 const std::string bundleName = "com.ohos.permissionmanager";
475 int32_t uid = BundleManagerInternal::GetUidFromBms(bundleName);
476 ASSERT_TRUE(uid > 0);
477 string appId;
478 bool ret = BundleManagerInternal::GetCallerAppIdFromBms(uid, appId);
479 EXPECT_EQ(ret, true);
480 DTEST_LOG << "BundleManagerInternalTest GetCallerAppIdFromBms_001 end "<< std::endl;
481 }
482
483 /**
484 * @tc.name: IsSameAppId_001
485 * @tc.desc: test IsSameAppId with invalid param
486 * @tc.type: FUNC
487 */
488 HWTEST_F(BundleManagerInternalTest, IsSameAppId_001, TestSize.Level3)
489 {
490 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_001 begin" << std::endl;
491 string appId = "1001";
492 string targetBundleName = "ohos.samples.dms.testApp";
493 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
494 EXPECT_EQ(ret, false);
495 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_001 end "<< std::endl;
496 }
497
498 /**
499 * @tc.name: IsSameAppId_002
500 * @tc.desc: test IsSameAppId with invalid param
501 * @tc.type: FUNC
502 */
503 HWTEST_F(BundleManagerInternalTest, IsSameAppId_002, TestSize.Level3)
504 {
505 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_002 begin" << std::endl;
506 string appId = "1001";
507 string targetBundleName = "";
508 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
509 EXPECT_EQ(ret, false);
510 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_002 end "<< std::endl;
511 }
512
513 /**
514 * @tc.name: IsSameAppId_003
515 * @tc.desc: test IsSameAppId with invalid param
516 * @tc.type: FUNC
517 */
518 HWTEST_F(BundleManagerInternalTest, IsSameAppId_003, TestSize.Level3)
519 {
520 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_003 begin" << std::endl;
521 string appId = "";
522 string targetBundleName = "ohos.samples.dms.testApp";
523 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
524 EXPECT_EQ(ret, false);
525 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_003 end "<< std::endl;
526 }
527
528 /**
529 * @tc.name: IsSameAppId_004
530 * @tc.desc: test IsSameAppId with invalid param
531 * @tc.type: FUNC
532 */
533 HWTEST_F(BundleManagerInternalTest, IsSameAppId_004, TestSize.Level3)
534 {
535 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_004 begin" << std::endl;
536 string appId = "";
537 string targetBundleName = "";
538 bool ret = BundleManagerInternal::IsSameAppId(appId, targetBundleName);
539 EXPECT_EQ(ret, false);
540 DTEST_LOG << "BundleManagerInternalTest IsSameAppId_004 end "<< std::endl;
541 }
542
543 /**
544 * @tc.name: GetBundleNameId_001
545 * @tc.desc: test get bundleNameId from bms
546 * @tc.type: FUNC
547 */
548 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_001, TestSize.Level3)
549 {
550 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_001 begin" << std::endl;
551 const std::string bundleName = "ohos.samples.dms.testApp";
552 uint16_t bundleNameId = 0;
553 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
554 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
555 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_001 end "<< std::endl;
556 }
557
558 /**
559 * @tc.name: GetBundleNameId_002
560 * @tc.desc: test get bundleNameId from bms
561 * @tc.type: FUNC
562 */
563 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_002, TestSize.Level3)
564 {
565 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_002 begin" << std::endl;
566 const std::string bundleName = "com.ohos.mms";
567 uint16_t bundleNameId = 0;
568 BundleManagerInternal::GetDistributedBundleManager();
569 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
570 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
571 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_002 end "<< std::endl;
572 }
573
574 /**
575 * @tc.name: IsSameDeveloperId_001
576 * @tc.desc: IsSameDeveloperId
577 * @tc.type: FUNC
578 */
579 HWTEST_F(BundleManagerInternalTest, IsSameDeveloperId_001, TestSize.Level3)
580 {
581 DTEST_LOG << "BundleManagerInternalTest IsSameDeveloperId_001 begin" << std::endl;
582 std::string bundleNameInCurrentSide;
583 std::string developerId4OtherSide;
584 bool ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
585 EXPECT_EQ(ret, false);
586
587 developerId4OtherSide = "developerId4OtherSide";
588 ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
589 EXPECT_EQ(ret, false);
590
591 bundleNameInCurrentSide = "bundleNameInCurrentSide";
592 ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
593 EXPECT_EQ(ret, false);
594
595 developerId4OtherSide.clear();
596 ret = BundleManagerInternal::IsSameDeveloperId(bundleNameInCurrentSide, developerId4OtherSide);
597 EXPECT_EQ(ret, false);
598 DTEST_LOG << "BundleManagerInternalTest IsSameDeveloperId_001 end "<< std::endl;
599 }
600
601 /**
602 * @tc.name: GetContinueBundle4Src_001
603 * @tc.desc: GetContinueBundle4Src
604 * @tc.type: FUNC
605 */
606 HWTEST_F(BundleManagerInternalTest, GetContinueBundle4Src_001, TestSize.Level3)
607 {
608 DTEST_LOG << "BundleManagerInternalTest GetContinueBundle4Src_001 begin" << std::endl;
609 std::string srcBundleName;
610 std::vector<std::string> bundleNameList;
611 bool ret = BundleManagerInternal::GetContinueBundle4Src(srcBundleName, bundleNameList);
612 EXPECT_EQ(ret, false);
613 DTEST_LOG << "BundleManagerInternalTest GetContinueBundle4Src_001 end "<< std::endl;
614 }
615
616 /**
617 * @tc.name: GetAppProvisionInfo4CurrentUser_001
618 * @tc.desc: GetAppProvisionInfo4CurrentUser
619 * @tc.type: FUNC
620 */
621 HWTEST_F(BundleManagerInternalTest, GetAppProvisionInfo4CurrentUser_001, TestSize.Level3)
622 {
623 DTEST_LOG << "BundleManagerInternalTest GetAppProvisionInfo4CurrentUser_001 begin" << std::endl;
624 std::string bundleName;
625 AppExecFwk::AppProvisionInfo appProvisionInfo;
626 bool ret = BundleManagerInternal::GetAppProvisionInfo4CurrentUser(bundleName, appProvisionInfo);
627 EXPECT_EQ(ret, false);
628 DTEST_LOG << "BundleManagerInternalTest GetAppProvisionInfo4CurrentUser_001 end "<< std::endl;
629 }
630
631 /**
632 * @tc.name: GetContinueType_001
633 * @tc.desc: GetContinueType
634 * @tc.type: FUNC
635 */
636 HWTEST_F(BundleManagerInternalTest, GetContinueType_001, TestSize.Level3)
637 {
638 DTEST_LOG << "BundleManagerInternalTest GetContinueType_001 begin" << std::endl;
639 std::string networkId = "networkId";
640 std::string bundleName;
641 uint8_t continueTypeId = 0;
642 std::string str = BundleManagerInternal::GetContinueType(networkId, bundleName, continueTypeId);
643 EXPECT_EQ(str, "");
644 DTEST_LOG << "BundleManagerInternalTest GetContinueType_001 end "<< std::endl;
645 }
646
647 /**
648 * @tc.name: GetContinueTypeId_001
649 * @tc.desc: GetContinueTypeId
650 * @tc.type: FUNC
651 */
652 HWTEST_F(BundleManagerInternalTest, GetContinueTypeId_001, TestSize.Level3)
653 {
654 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_001 begin" << std::endl;
655 std::string networkId = "networkId";
656 std::string abilityName;
657 uint8_t continueTypeId = 0;
658 int32_t ret = BundleManagerInternal::GetContinueTypeId(networkId, abilityName, continueTypeId);
659 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
660 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_001 end "<< std::endl;
661 }
662
663 /**
664 * @tc.name: GetBundleNameById_001
665 * @tc.desc: GetBundleNameById
666 * @tc.type: FUNC
667 */
668 HWTEST_F(BundleManagerInternalTest, GetBundleNameById_001, TestSize.Level3)
669 {
670 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_001 begin" << std::endl;
671 std::string networkId = "networkId";
672 std::string bundleName;
673 uint16_t bundleNameId = 0;
674 int32_t ret = BundleManagerInternal::GetBundleNameById(networkId, bundleNameId, bundleName);
675 EXPECT_EQ(ret, CAN_NOT_FOUND_ABILITY_ERR);
676 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_001 end "<< std::endl;
677 }
678
679
680 /**
681 * @tc.name: GetBundleNameId_003
682 * @tc.desc: test get bundleNameId from bms
683 * @tc.type: FUNC
684 */
685 HWTEST_F(BundleManagerInternalTest, GetBundleNameId_003, TestSize.Level3)
686 {
687 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_003 begin" << std::endl;
688 const std::string bundleName = "com.ohos.mms";
689 uint16_t bundleNameId = 0;
690 g_mockBool = true;
691 int32_t ret = BundleManagerInternal::GetBundleNameId(bundleName, bundleNameId);
692 EXPECT_EQ(ret, ERR_OK);
693 DTEST_LOG << "BundleManagerInternalTest GetBundleNameId_003 end "<< std::endl;
694 }
695
696 /**
697 * @tc.name: GetContinueType_002
698 * @tc.desc: GetContinueType
699 * @tc.type: FUNC
700 */
701 HWTEST_F(BundleManagerInternalTest, GetContinueType_002, TestSize.Level3)
702 {
703 DTEST_LOG << "BundleManagerInternalTest GetContinueType_002 begin" << std::endl;
704 std::string networkId = "networkId";
705 std::string bundleName;
706 uint8_t continueTypeId = 0;
707 g_mockString = "continueType";
708 std::string str = BundleManagerInternal::GetContinueType(networkId, bundleName, continueTypeId);
709 EXPECT_NE(str, "");
710 DTEST_LOG << "BundleManagerInternalTest GetContinueType_002 end "<< std::endl;
711 }
712
713 /**
714 * @tc.name: GetContinueTypeId_002
715 * @tc.desc: GetContinueTypeId
716 * @tc.type: FUNC
717 */
718 HWTEST_F(BundleManagerInternalTest, GetContinueTypeId_002, TestSize.Level3)
719 {
720 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_002 begin" << std::endl;
721 std::string networkId = "networkId";
722 std::string abilityName;
723 uint8_t continueTypeId = 0;
724 g_mockBool = true;
725 int32_t ret = BundleManagerInternal::GetContinueTypeId(networkId, abilityName, continueTypeId);
726 EXPECT_EQ(ret, ERR_OK);
727 DTEST_LOG << "BundleManagerInternalTest GetContinueTypeId_002 end "<< std::endl;
728 }
729
730 /**
731 * @tc.name: GetBundleNameById_002
732 * @tc.desc: GetBundleNameById
733 * @tc.type: FUNC
734 */
735 HWTEST_F(BundleManagerInternalTest, GetBundleNameById_002, TestSize.Level3)
736 {
737 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_002 begin" << std::endl;
738 std::string networkId = "networkId";
739 std::string bundleName;
740 uint16_t bundleNameId = 0;
741 g_mockBool = true;
742 int32_t ret = BundleManagerInternal::GetBundleNameById(networkId, bundleNameId, bundleName);
743 EXPECT_EQ(ret, ERR_OK);
744 DTEST_LOG << "BundleManagerInternalTest GetBundleNameById_002 end "<< std::endl;
745 }
746
747 /**
748 * @tc.name: GetLocalAbilityInfo_001
749 * @tc.desc: GetLocalAbilityInfo
750 * @tc.type: FUNC
751 */
752 HWTEST_F(BundleManagerInternalTest, GetLocalAbilityInfo_001, TestSize.Level3)
753 {
754 DTEST_LOG << "BundleManagerInternalTest GetLocalAbilityInfo_001 begin" << std::endl;
755 std::string bundleName = "bundleName";
756 std::string moduleName = "moduleName";
757 std::string abilityName = "abilityName";
758 AppExecFwk::AbilityInfo abilityInfo;
759 int32_t ret = BundleManagerInternal::GetLocalAbilityInfo(bundleName, moduleName, abilityName, abilityInfo);
760 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
761 DTEST_LOG << "BundleManagerInternalTest GetLocalAbilityInfo_001 end "<< std::endl;
762 }
763 }
764 }
765