1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #define private public
19 #include "app_spawn_client.h"
20 #undef private
21 #include "app_spawn_client.cpp"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AppExecFwk {
28 class AppSpawnClientTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
SetUpTestCase(void)36 void AppSpawnClientTest::SetUpTestCase(void)
37 {}
38
TearDownTestCase(void)39 void AppSpawnClientTest::TearDownTestCase(void)
40 {}
41
SetUp()42 void AppSpawnClientTest::SetUp()
43 {}
44
TearDown()45 void AppSpawnClientTest::TearDown()
46 {}
47
48 /**
49 * @tc.name: PreStartNWebSpawnProcess_001
50 * @tc.desc: prestart nwebspawn process.
51 * @tc.type: FUNC
52 * @tc.require: issueI5W4S7
53 */
54 HWTEST_F(AppSpawnClientTest, PreStartNWebSpawnProcess_001, TestSize.Level0)
55 {
56 auto asc = std::make_shared<AppSpawnClient>(true);
57 int ret = asc->PreStartNWebSpawnProcess();
58 EXPECT_EQ(ret, ERR_OK);
59 }
60
61 /**
62 * @tc.name: PreStartNWebSpawnProcessImpl_002
63 * @tc.desc: prestart nwebspawn process.
64 * @tc.type: FUNC
65 * @tc.require: issueI5W4S7
66 */
67 HWTEST_F(AppSpawnClientTest, PreStartNWebSpawnProcessImpl_002, TestSize.Level0)
68 {
69 auto asc = std::make_shared<AppSpawnClient>(true);
70 asc->OpenConnection();
71 int ret = asc->PreStartNWebSpawnProcess();
72 EXPECT_EQ(ret, ERR_OK);
73 }
74 /**
75 * @tc.name: SendAppSpawnUninstallDebugHapMsg_001
76 * @tc.desc: SendAppSpawnUninstallDebugHapMsg
77 * @tc.type: FUNC
78 */
79 HWTEST_F(AppSpawnClientTest, SendAppSpawnUninstallDebugHapMsg_001, TestSize.Level0)
80 {
81 auto appSpawnClient = std::make_shared<AppSpawnClient>(false);
82 int32_t userId = 0;
83 auto ret = appSpawnClient->SendAppSpawnUninstallDebugHapMsg(userId);
84 ASSERT_EQ(ret, ERR_OK);
85 }
86
87 /**
88 * @tc.name: AppSpawnClient_002
89 * @tc.desc: new AppSpawnClient object
90 * @tc.type: FUNC
91 * @tc.require: issueI5W4S7
92 */
93 HWTEST_F(AppSpawnClientTest, AppSpawnClient_002, TestSize.Level0)
94 {
95 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_002 start");
96 const char* serviceName = "cjappspawn";
97 auto asc = std::make_shared<AppSpawnClient>(serviceName);
98 auto ret = asc->OpenConnection();
99 EXPECT_EQ(ret, ERR_OK);
100 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_002 end");
101 }
102
103 /**
104 * @tc.name: AppSpawnClient_003
105 * @tc.desc: new AppSpawnClient object
106 * @tc.type: FUNC
107 * @tc.require: issueI5W4S7
108 */
109 HWTEST_F(AppSpawnClientTest, AppSpawnClient_003, TestSize.Level0)
110 {
111 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_003 start");
112 const char* serviceName = "nwebRestart";
113 auto asc = std::make_shared<AppSpawnClient>(serviceName);
114 auto ret = asc->OpenConnection();
115 EXPECT_EQ(ret, ERR_OK);
116 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_003 end");
117 }
118
119 /**
120 * @tc.name: AppSpawnClient_004
121 * @tc.desc: new AppSpawnClient object
122 * @tc.type: FUNC
123 * @tc.require: issueI5W4S7
124 */
125 HWTEST_F(AppSpawnClientTest, AppSpawnClient_004, TestSize.Level0)
126 {
127 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_004 start");
128 const char* serviceName = "nativespawn";
129 auto asc = std::make_shared<AppSpawnClient>(serviceName);
130 auto ret = asc->OpenConnection();
131 EXPECT_EQ(ret, ERR_OK);
132 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_004 end");
133 }
134
135 /**
136 * @tc.name: AppSpawnClient_005
137 * @tc.desc: new AppSpawnClient object
138 * @tc.type: FUNC
139 * @tc.require: issueI5W4S7
140 */
141 HWTEST_F(AppSpawnClientTest, AppSpawnClient_005, TestSize.Level0)
142 {
143 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_005 start");
144 const char* serviceName = "nwebspawn";
145 auto asc = std::make_shared<AppSpawnClient>(serviceName);
146 auto ret = asc->OpenConnection();
147 EXPECT_EQ(ret, ERR_OK);
148 TAG_LOGI(AAFwkTag::TEST, "AppSpawnClient_005 end");
149 }
150
151 /**
152 * @tc.name: OpenConnection_001
153 * @tc.desc: appspawn OpenConnection
154 * @tc.type: FUNC
155 * @tc.require: issueI5W4S7
156 */
157 HWTEST_F(AppSpawnClientTest, OpenConnection_001, TestSize.Level0)
158 {
159 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 start");
160 auto asc = std::make_shared<AppSpawnClient>(true);
161 auto ret = asc->OpenConnection();
162 EXPECT_EQ(ret, ERR_OK);
163 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 end");
164 }
165
166 /**
167 * @tc.name: OpenConnection_002
168 * @tc.desc: appspawn OpenConnection
169 * @tc.type: FUNC
170 * @tc.require: issueI5W4S7
171 */
172 HWTEST_F(AppSpawnClientTest, OpenConnection_002, TestSize.Level0)
173 {
174 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 start");
175 auto asc = std::make_shared<AppSpawnClient>(false);
176 auto ret = asc->OpenConnection();
177 EXPECT_EQ(ret, ERR_OK);
178 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 end");
179 }
180
181 /**
182 * @tc.name: CloseConnection_001
183 * @tc.desc: appspawn CloseConnection
184 * @tc.type: FUNC
185 * @tc.require: issueI5W4S7
186 */
187 HWTEST_F(AppSpawnClientTest, CloseConnection_001, TestSize.Level0)
188 {
189 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 start");
190 auto asc = std::make_shared<AppSpawnClient>(true);
191 auto ret = asc->OpenConnection();
192 EXPECT_EQ(ret, ERR_OK);
193 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 end");
194 }
195
196 /**
197 * @tc.name: CloseConnection_002
198 * @tc.desc: appspawn CloseConnection
199 * @tc.type: FUNC
200 * @tc.require: issueI5W4S7
201 */
202 HWTEST_F(AppSpawnClientTest, CloseConnection_002, TestSize.Level0)
203 {
204 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 start");
205 auto asc = std::make_shared<AppSpawnClient>(false);
206 auto ret = asc->OpenConnection();
207 EXPECT_EQ(ret, ERR_OK);
208 TAG_LOGI(AAFwkTag::TEST, "OpenConnection_001 end");
209 }
210
211 /**
212 * @tc.name: SetDacInfo_001
213 * @tc.desc: appspawn SetDacInfo
214 * @tc.type: FUNC
215 * @tc.require: issueI5W4S7
216 */
217 HWTEST_F(AppSpawnClientTest, SetDacInfo_001, TestSize.Level0)
218 {
219 TAG_LOGI(AAFwkTag::TEST, "SetDacInfo_001 start");
220 AppSpawnStartMsg startMsg = {0};
221 startMsg.uid = 1001;
222 startMsg.gid = 2001;
223 startMsg.gids = {1001, 1002, 1003};
224 std::string procName("test_proc_name");
225 startMsg.procName = procName;
226 std::string permission1("permission_for_test_1");
227 std::string permission2("permission_for_test_2");
228 std::string permission3("permission_for_test_3");
229 startMsg.permissions.insert(permission1);
230 startMsg.permissions.insert(permission2);
231 startMsg.permissions.insert(permission3);
232 startMsg.flags = 0x1000;
233 startMsg.atomicServiceFlag = false;
234 startMsg.strictMode = false;
235 startMsg.isolatedExtension = false;
236 startMsg.childProcessType = 1;
237 startMsg.isolationMode = false;
238 std::string provisionType("test_provisionType");
239 startMsg.provisionType = provisionType;
240 std::string processType("test_processType");
241 startMsg.processType = processType;
242 startMsg.maxChildProcess = 1;
243 std::string extensionSandboxPath("test_extensionSandboxPath");
244 startMsg.extensionSandboxPath = extensionSandboxPath;
245
246 auto asc = std::make_shared<AppSpawnClient>(false);
247 int32_t ret = 0;
248 AppSpawnReqMsgHandle reqHandle = nullptr;
249 ret = asc->OpenConnection();
250 EXPECT_EQ(ret, ERR_OK);
251 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
252 EXPECT_EQ(ret, ERR_OK);
253 ret = asc->SetDacInfo(startMsg, reqHandle);
254 EXPECT_EQ(ret, ERR_OK);
255
256 TAG_LOGI(AAFwkTag::TEST, "SetDacInfo_001 end");
257 }
258
259 /**
260 * @tc.name: SetMountPermission_001
261 * @tc.desc: appspawn SetMountPermission
262 * @tc.type: FUNC
263 * @tc.require: issueI5W4S7
264 */
265 HWTEST_F(AppSpawnClientTest, SetMountPermission_001, TestSize.Level0)
266 {
267 TAG_LOGI(AAFwkTag::TEST, "SetMountPermission_001 start");
268 AppSpawnStartMsg startMsg = {0};
269 startMsg.uid = 1001;
270 startMsg.gid = 2001;
271 startMsg.gids = {1001, 1002, 1003};
272 std::string procName("test_proc_name");
273 startMsg.procName = procName;
274 std::string permission1("permission_for_test_1");
275 std::string permission2("permission_for_test_2");
276 std::string permission3("permission_for_test_3");
277 startMsg.permissions.insert(permission1);
278 startMsg.permissions.insert(permission2);
279 startMsg.permissions.insert(permission3);
280 startMsg.flags = 0x1000;
281 startMsg.atomicServiceFlag = false;
282 startMsg.strictMode = false;
283 startMsg.isolatedExtension = false;
284 startMsg.childProcessType = 1;
285 startMsg.isolationMode = false;
286 std::string provisionType("test_provisionType");
287 startMsg.provisionType = provisionType;
288 std::string processType("test_processType");
289 startMsg.processType = processType;
290 startMsg.maxChildProcess = 1;
291 std::string extensionSandboxPath("test_extensionSandboxPath");
292 startMsg.extensionSandboxPath = extensionSandboxPath;
293
294 auto asc = std::make_shared<AppSpawnClient>(false);
295 int32_t ret = 0;
296 AppSpawnReqMsgHandle reqHandle = nullptr;
297 ret = asc->OpenConnection();
298 EXPECT_EQ(ret, ERR_OK);
299 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
300 EXPECT_EQ(ret, ERR_OK);
301 ret = asc->SetMountPermission(startMsg, reqHandle);
302 EXPECT_NE(ret, ERR_OK);
303
304 TAG_LOGI(AAFwkTag::TEST, "SetMountPermission_001 end");
305 }
306
307 /**
308 * @tc.name: SetStartFlags_001
309 * @tc.desc: appspawn SetStartFlags
310 * @tc.type: FUNC
311 * @tc.require: issueI5W4S7
312 */
313 HWTEST_F(AppSpawnClientTest, SetStartFlags_001, TestSize.Level0)
314 {
315 TAG_LOGI(AAFwkTag::TEST, "SetStartFlags_001 start");
316 AppSpawnStartMsg startMsg = {0};
317 startMsg.uid = 1001;
318 startMsg.gid = 2001;
319 startMsg.gids = {1001, 1002, 1003};
320 std::string procName("test_proc_name");
321 startMsg.procName = procName;
322 std::string permission1("permission_for_test_1");
323 std::string permission2("permission_for_test_2");
324 std::string permission3("permission_for_test_3");
325 startMsg.permissions.insert(permission1);
326 startMsg.permissions.insert(permission2);
327 startMsg.permissions.insert(permission3);
328 startMsg.flags = 0x1000;
329 startMsg.atomicServiceFlag = false;
330 startMsg.strictMode = false;
331 startMsg.isolatedExtension = false;
332 startMsg.childProcessType = 1;
333 startMsg.isolationMode = false;
334 std::string provisionType("test_provisionType");
335 startMsg.provisionType = provisionType;
336 std::string processType("test_processType");
337 startMsg.processType = processType;
338 startMsg.maxChildProcess = 1;
339 std::string extensionSandboxPath("test_extensionSandboxPath");
340 startMsg.extensionSandboxPath = extensionSandboxPath;
341
342 auto asc = std::make_shared<AppSpawnClient>(false);
343 int32_t ret = 0;
344 AppSpawnReqMsgHandle reqHandle = nullptr;
345 ret = asc->OpenConnection();
346 EXPECT_EQ(ret, ERR_OK);
347 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
348 EXPECT_EQ(ret, ERR_OK);
349 ret = asc->SetStartFlags(startMsg, reqHandle);
350 EXPECT_EQ(ret, ERR_OK);
351 TAG_LOGI(AAFwkTag::TEST, "SetStartFlags_001 end");
352 }
353
354
355 /**
356 * @tc.name: AppspawnSetExtMsgMore_001
357 * @tc.desc: appspawn AppspawnSetExtMsgMore
358 * @tc.type: FUNC
359 * @tc.require: issueI5W4S7
360 */
361 HWTEST_F(AppSpawnClientTest, AppspawnSetExtMsgMore_001, TestSize.Level0)
362 {
363 TAG_LOGI(AAFwkTag::TEST, "AppspawnSetExtMsgMore_001 start");
364 AppSpawnStartMsg startMsg = {0};
365 startMsg.uid = 1001;
366 startMsg.gid = 2001;
367 startMsg.gids = {1001, 1002, 1003};
368 std::string procName("test_proc_name");
369 startMsg.procName = procName;
370 std::string permission1("permission_for_test_1");
371 std::string permission2("permission_for_test_2");
372 std::string permission3("permission_for_test_3");
373 startMsg.permissions.insert(permission1);
374 startMsg.permissions.insert(permission2);
375 startMsg.permissions.insert(permission3);
376 startMsg.flags = 0x1000;
377 startMsg.atomicServiceFlag = false;
378 startMsg.strictMode = false;
379 startMsg.isolatedExtension = false;
380 startMsg.childProcessType = 1;
381 startMsg.isolationMode = false;
382 std::string provisionType("test_provisionType");
383 startMsg.provisionType = provisionType;
384 std::string processType("test_processType");
385 startMsg.processType = processType;
386 startMsg.maxChildProcess = 1;
387 std::string extensionSandboxPath("test_extensionSandboxPath");
388 startMsg.extensionSandboxPath = extensionSandboxPath;
389
390 auto asc = std::make_shared<AppSpawnClient>(false);
391 int32_t ret = 0;
392 AppSpawnReqMsgHandle reqHandle = nullptr;
393 ret = asc->OpenConnection();
394 EXPECT_EQ(ret, ERR_OK);
395 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
396 EXPECT_EQ(ret, ERR_OK);
397 ret = asc->AppspawnSetExtMsgMore(startMsg, reqHandle);
398 EXPECT_EQ(ret, ERR_OK);
399
400 TAG_LOGI(AAFwkTag::TEST, "AppspawnSetExtMsgMore_001 end");
401 }
402
403
404 /**
405 * @tc.name: AppspawnCreateDefaultMsg_001
406 * @tc.desc: appspawn AppspawnCreateDefaultMsg
407 * @tc.type: FUNC
408 * @tc.require: issueI5W4S7
409 */
410 HWTEST_F(AppSpawnClientTest, AppspawnCreateDefaultMsg_001, TestSize.Level0)
411 {
412 TAG_LOGI(AAFwkTag::TEST, "AppspawnCreateDefaultMsg_001 start");
413 AppSpawnStartMsg startMsg = {0};
414 startMsg.uid = 1001;
415 startMsg.gid = 2001;
416 startMsg.gids = {1001, 1002, 1003};
417 std::string procName("test_proc_name");
418 startMsg.procName = procName;
419 std::string apl("test_apl");
420 startMsg.apl = apl;
421 std::string ownerId("test_owner_id");
422 startMsg.ownerId = ownerId;
423 std::string bundleName("test_bundle_name");
424 startMsg.bundleName = bundleName;
425 std::string permission1("permission_for_test_1");
426 std::string permission2("permission_for_test_2");
427 std::string permission3("permission_for_test_3");
428 startMsg.permissions.insert(permission1);
429 startMsg.permissions.insert(permission2);
430 startMsg.permissions.insert(permission3);
431 startMsg.flags = 0x1000;
432 startMsg.atomicServiceFlag = false;
433 startMsg.strictMode = false;
434 startMsg.isolatedExtension = false;
435 startMsg.childProcessType = 1;
436 startMsg.isolationMode = false;
437 std::string provisionType("test_provisionType");
438 startMsg.provisionType = provisionType;
439 std::string processType("test_processType");
440 startMsg.processType = processType;
441 startMsg.maxChildProcess = 1;
442 std::string extensionSandboxPath("test_extensionSandboxPath");
443 startMsg.extensionSandboxPath = extensionSandboxPath;
444
445 auto asc = std::make_shared<AppSpawnClient>(false);
446 int32_t ret = 0;
447 AppSpawnReqMsgHandle reqHandle = nullptr;
448 ret = asc->OpenConnection();
449 EXPECT_EQ(ret, ERR_OK);
450 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
451 EXPECT_EQ(ret, ERR_OK);
452 ret = asc->AppspawnCreateDefaultMsg(startMsg, reqHandle);
453 EXPECT_NE(ret, ERR_OK);
454
455 TAG_LOGI(AAFwkTag::TEST, "AppspawnCreateDefaultMsg_001 end");
456 }
457
458
459 /**
460 * @tc.name: VerifyMsg_001
461 * @tc.desc: appspawn VerifyMsg
462 * @tc.type: FUNC
463 * @tc.require: issueI5W4S7
464 */
465 HWTEST_F(AppSpawnClientTest, VerifyMsg_001, TestSize.Level0)
466 {
467 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_001 start");
468 AppSpawnStartMsg startMsg = {0};
469 startMsg.uid = 1001;
470 startMsg.gid = 2001;
471 startMsg.gids = {1001, 1002, 1003};
472 std::string procName("test_proc_name");
473 startMsg.procName = procName;
474 std::string permission1("permission_for_test_1");
475 std::string permission2("permission_for_test_2");
476 std::string permission3("permission_for_test_3");
477 startMsg.permissions.insert(permission1);
478 startMsg.permissions.insert(permission2);
479 startMsg.permissions.insert(permission3);
480 startMsg.flags = 0x1000;
481 startMsg.atomicServiceFlag = false;
482 startMsg.strictMode = false;
483 startMsg.isolatedExtension = false;
484 startMsg.childProcessType = 1;
485 startMsg.isolationMode = false;
486 std::string provisionType("test_provisionType");
487 startMsg.provisionType = provisionType;
488 std::string processType("test_processType");
489 startMsg.processType = processType;
490 startMsg.maxChildProcess = 1;
491 std::string extensionSandboxPath("test_extensionSandboxPath");
492 startMsg.extensionSandboxPath = extensionSandboxPath;
493
494 auto asc = std::make_shared<AppSpawnClient>(false);
495 int32_t ret = 0;
496 bool result = false;
497 AppSpawnReqMsgHandle reqHandle = nullptr;
498 ret = asc->OpenConnection();
499 EXPECT_EQ(ret, ERR_OK);
500 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
501 EXPECT_EQ(ret, ERR_OK);
502
503 result = asc->VerifyMsg(startMsg);
504 EXPECT_EQ(result, true);
505
506 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_001 end");
507 }
508
509 /**
510 * @tc.name: VerifyMsg_002
511 * @tc.desc: appspawn VerifyMsg
512 * @tc.type: FUNC
513 * @tc.require: issueI5W4S7
514 */
515 HWTEST_F(AppSpawnClientTest, VerifyMsg_002, TestSize.Level0)
516 {
517 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_002 start");
518 AppSpawnStartMsg startMsg = {0};
519 startMsg.uid = -1;
520 startMsg.gid = 2001;
521 startMsg.gids = {1001, 1002, 1003};
522 std::string procName("test_proc_name");
523 startMsg.procName = procName;
524 std::string permission1("permission_for_test_1");
525 std::string permission2("permission_for_test_2");
526 std::string permission3("permission_for_test_3");
527 startMsg.permissions.insert(permission1);
528 startMsg.permissions.insert(permission2);
529 startMsg.permissions.insert(permission3);
530 startMsg.flags = 0x1000;
531 startMsg.atomicServiceFlag = false;
532 startMsg.strictMode = false;
533 startMsg.isolatedExtension = false;
534 startMsg.childProcessType = 1;
535 startMsg.isolationMode = false;
536 std::string provisionType("test_provisionType");
537 startMsg.provisionType = provisionType;
538 std::string processType("test_processType");
539 startMsg.processType = processType;
540 startMsg.maxChildProcess = 1;
541 std::string extensionSandboxPath("test_extensionSandboxPath");
542 startMsg.extensionSandboxPath = extensionSandboxPath;
543
544 auto asc = std::make_shared<AppSpawnClient>(false);
545 int32_t ret = 0;
546 bool result = false;
547 AppSpawnReqMsgHandle reqHandle = nullptr;
548 ret = asc->OpenConnection();
549 EXPECT_EQ(ret, ERR_OK);
550 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
551 EXPECT_EQ(ret, ERR_OK);
552
553 result = asc->VerifyMsg(startMsg);
554 EXPECT_EQ(result, false);
555
556 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_002 end");
557 }
558
559 /**
560 * @tc.name: VerifyMsg_003
561 * @tc.desc: appspawn VerifyMsg
562 * @tc.type: FUNC
563 * @tc.require: issueI5W4S7
564 */
565 HWTEST_F(AppSpawnClientTest, VerifyMsg_003, TestSize.Level0)
566 {
567 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_003 start");
568 AppSpawnStartMsg startMsg = {0};
569 startMsg.uid = 1001;
570 startMsg.gid = -1;
571 startMsg.gids = {1001, 1002, 1003};
572 std::string procName("test_proc_name");
573 startMsg.procName = procName;
574 std::string permission1("permission_for_test_1");
575 std::string permission2("permission_for_test_2");
576 std::string permission3("permission_for_test_3");
577 startMsg.permissions.insert(permission1);
578 startMsg.permissions.insert(permission2);
579 startMsg.permissions.insert(permission3);
580 startMsg.flags = 0x1000;
581 startMsg.atomicServiceFlag = false;
582 startMsg.strictMode = false;
583 startMsg.isolatedExtension = false;
584 startMsg.childProcessType = 1;
585 startMsg.isolationMode = false;
586 std::string provisionType("test_provisionType");
587 startMsg.provisionType = provisionType;
588 std::string processType("test_processType");
589 startMsg.processType = processType;
590 startMsg.maxChildProcess = 1;
591 std::string extensionSandboxPath("test_extensionSandboxPath");
592 startMsg.extensionSandboxPath = extensionSandboxPath;
593
594 auto asc = std::make_shared<AppSpawnClient>(false);
595 int32_t ret = 0;
596 bool result = false;
597 AppSpawnReqMsgHandle reqHandle = nullptr;
598 ret = asc->OpenConnection();
599 EXPECT_EQ(ret, ERR_OK);
600 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
601 EXPECT_EQ(ret, ERR_OK);
602
603 result = asc->VerifyMsg(startMsg);
604 EXPECT_EQ(result, false);
605
606 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_003 end");
607 }
608
609 /**
610 * @tc.name: VerifyMsg_004
611 * @tc.desc: appspawn VerifyMsg
612 * @tc.type: FUNC
613 * @tc.require: issueI5W4S7
614 */
615 HWTEST_F(AppSpawnClientTest, VerifyMsg_004, TestSize.Level0)
616 {
617 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_004 start");
618 AppSpawnStartMsg startMsg = {0};
619 startMsg.uid = 1001;
620 startMsg.gid = 2001;
621 startMsg.gids = {1001, 1002, 1003, -1};
622 std::string procName("test_proc_name");
623 startMsg.procName = procName;
624 std::string permission1("permission_for_test_1");
625 std::string permission2("permission_for_test_2");
626 std::string permission3("permission_for_test_3");
627 startMsg.permissions.insert(permission1);
628 startMsg.permissions.insert(permission2);
629 startMsg.permissions.insert(permission3);
630 startMsg.flags = 0x1000;
631 startMsg.atomicServiceFlag = false;
632 startMsg.strictMode = false;
633 startMsg.isolatedExtension = false;
634 startMsg.childProcessType = 1;
635 startMsg.isolationMode = false;
636 std::string provisionType("test_provisionType");
637 startMsg.provisionType = provisionType;
638 std::string processType("test_processType");
639 startMsg.processType = processType;
640 startMsg.maxChildProcess = 1;
641 std::string extensionSandboxPath("test_extensionSandboxPath");
642 startMsg.extensionSandboxPath = extensionSandboxPath;
643
644 auto asc = std::make_shared<AppSpawnClient>(false);
645 int32_t ret = 0;
646 bool result = false;
647 ret = asc->OpenConnection();
648 EXPECT_EQ(ret, ERR_OK);
649 result = asc->VerifyMsg(startMsg);
650 EXPECT_EQ(result, false);
651
652 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_004 end");
653 }
654
655 /**
656 * @tc.name: VerifyMsg_005
657 * @tc.desc: appspawn VerifyMsg
658 * @tc.type: FUNC
659 * @tc.require: issueI5W4S7
660 */
661 HWTEST_F(AppSpawnClientTest, VerifyMsg_005, TestSize.Level0)
662 {
663 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_005 start");
664 AppSpawnStartMsg startMsg = {0};
665 startMsg.uid = 1001;
666 startMsg.gid = 2001;
667 startMsg.gids = {1001, 1002};
668 std::string procName("");
669 startMsg.procName = procName;
670 std::string permission1("permission_for_test_1");
671 std::string permission2("permission_for_test_2");
672 std::string permission3("permission_for_test_3");
673 startMsg.permissions.insert(permission1);
674 startMsg.permissions.insert(permission2);
675 startMsg.permissions.insert(permission3);
676 startMsg.flags = 0x1000;
677 startMsg.atomicServiceFlag = false;
678 startMsg.strictMode = false;
679 startMsg.isolatedExtension = false;
680 startMsg.childProcessType = 1;
681 startMsg.isolationMode = false;
682 std::string provisionType("test_provisionType");
683 startMsg.provisionType = provisionType;
684 std::string processType("test_processType");
685 startMsg.processType = processType;
686 startMsg.maxChildProcess = 1;
687 std::string extensionSandboxPath("test_extensionSandboxPath");
688 startMsg.extensionSandboxPath = extensionSandboxPath;
689
690 auto asc = std::make_shared<AppSpawnClient>(false);
691 int32_t ret = 0;
692 bool result = false;
693 ret = asc->OpenConnection();
694 EXPECT_EQ(ret, ERR_OK);
695 result = asc->VerifyMsg(startMsg);
696 EXPECT_EQ(result, false);
697
698 TAG_LOGI(AAFwkTag::TEST, "VerifyMsg_005 end");
699 }
700
701 /**
702 * @tc.name: SetChildProcessTypeStartFlag_001
703 * @tc.desc: appspawn SetChildProcessTypeStartFlag
704 * @tc.type: FUNC
705 * @tc.require: issueI5W4S7
706 */
707 HWTEST_F(AppSpawnClientTest, SetChildProcessTypeStartFlag_001, TestSize.Level0)
708 {
709 TAG_LOGI(AAFwkTag::TEST, "SetChildProcessTypeStartFlag_001 start");
710 AppSpawnStartMsg startMsg = {0};
711 std::string procName("test_proc_name");
712 startMsg.procName = procName;
713 int32_t childProcessType = 1;
714 auto asc = std::make_shared<AppSpawnClient>(false);
715 int32_t ret = 0;
716 AppSpawnReqMsgHandle reqHandle = nullptr;
717 ret = asc->OpenConnection();
718 EXPECT_EQ(ret, ERR_OK);
719 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
720 EXPECT_EQ(ret, ERR_OK);
721 ret = asc->SetChildProcessTypeStartFlag(reqHandle, childProcessType);
722 EXPECT_EQ(ret, ERR_OK);
723 TAG_LOGI(AAFwkTag::TEST, "SetChildProcessTypeStartFlag_001 end");
724 }
725
726 /**
727 * @tc.name: SetChildProcessTypeStartFlag_002
728 * @tc.desc: appspawn SetChildProcessTypeStartFlag
729 * @tc.type: FUNC
730 * @tc.require: issueI5W4S7
731 */
732 HWTEST_F(AppSpawnClientTest, SetChildProcessTypeStartFlag_002, TestSize.Level0)
733 {
734 TAG_LOGI(AAFwkTag::TEST, "SetChildProcessTypeStartFlag_002 start");
735 AppSpawnStartMsg startMsg = {0};
736 std::string procName("test_proc_name");
737 startMsg.procName = procName;
738 int32_t childProcessType = -1;
739 auto asc = std::make_shared<AppSpawnClient>(false);
740 int32_t ret = 0;
741 AppSpawnReqMsgHandle reqHandle = nullptr;
742 ret = asc->OpenConnection();
743 EXPECT_EQ(ret, ERR_OK);
744 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
745 EXPECT_EQ(ret, ERR_OK);
746 ret = asc->SetChildProcessTypeStartFlag(reqHandle, childProcessType);
747 EXPECT_EQ(ret, ERR_OK);
748 TAG_LOGI(AAFwkTag::TEST, "SetChildProcessTypeStartFlag_002 end");
749 }
750
751 /**
752 * @tc.name: SetExtMsgFds_001
753 * @tc.desc: appspawn SetExtMsgFds
754 * @tc.type: FUNC
755 * @tc.require: issueI5W4S7
756 */
757 HWTEST_F(AppSpawnClientTest, SetExtMsgFds_001, TestSize.Level0)
758 {
759 TAG_LOGI(AAFwkTag::TEST, "SetExtMsgFds_001 start");
760 AppSpawnStartMsg startMsg = {0};
761 std::string procName("test_proc_name");
762 startMsg.procName = procName;
763 startMsg.fds.emplace("test_fd1", 100);
764 startMsg.fds.emplace("test_fd2", 101);
765 startMsg.fds.emplace("test_fd3", 102);
766
767 auto asc = std::make_shared<AppSpawnClient>(false);
768 int32_t ret = 0;
769 AppSpawnReqMsgHandle reqHandle = nullptr;
770 ret = asc->OpenConnection();
771 EXPECT_EQ(ret, ERR_OK);
772 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
773 EXPECT_EQ(ret, ERR_OK);
774 ret = asc->SetExtMsgFds(reqHandle, startMsg.fds);
775 EXPECT_EQ(ret, ERR_OK);
776 TAG_LOGI(AAFwkTag::TEST, "SetExtMsgFds_001 end");
777 }
778
779 /**
780 * @tc.name: SetExtMsgFds_002
781 * @tc.desc: appspawn SetExtMsgFds
782 * @tc.type: FUNC
783 * @tc.require: issueI5W4S7
784 */
785 HWTEST_F(AppSpawnClientTest, SetExtMsgFds_002, TestSize.Level0)
786 {
787 TAG_LOGI(AAFwkTag::TEST, "SetExtMsgFds_002 start");
788 AppSpawnStartMsg startMsg = {0};
789 std::string procName("test_proc_name");
790 startMsg.procName = procName;
791 startMsg.fds.emplace("test_fd1", 100);
792 startMsg.fds.emplace("test_fd2", 101);
793 startMsg.fds.emplace("test_fd3", -1);
794 auto asc = std::make_shared<AppSpawnClient>(false);
795 int32_t ret = 0;
796 AppSpawnReqMsgHandle reqHandle = nullptr;
797 ret = asc->OpenConnection();
798 EXPECT_EQ(ret, ERR_OK);
799 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
800 EXPECT_EQ(ret, ERR_OK);
801 ret = asc->SetExtMsgFds(reqHandle, startMsg.fds);
802 EXPECT_NE(ret, ERR_OK);
803 TAG_LOGI(AAFwkTag::TEST, "SetExtMsgFds_002 end");
804 }
805
806 /**
807 * @tc.name: SetIsolationModeFlag_001
808 * @tc.desc: appspawn SetIsolationModeFlag
809 * @tc.type: FUNC
810 * @tc.require: issueI5W4S7
811 */
812 HWTEST_F(AppSpawnClientTest, SetIsolationModeFlag_001, TestSize.Level0)
813 {
814 TAG_LOGI(AAFwkTag::TEST, "SetIsolationModeFlag_001 start");
815 AppSpawnStartMsg startMsg = {0};
816 std::string procName("test_proc_name");
817 startMsg.procName = procName;
818 startMsg.isolationMode = true;
819 auto asc = std::make_shared<AppSpawnClient>(false);
820 int32_t ret = 0;
821 AppSpawnReqMsgHandle reqHandle = nullptr;
822 ret = asc->OpenConnection();
823 EXPECT_EQ(ret, ERR_OK);
824 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
825 EXPECT_EQ(ret, ERR_OK);
826 ret = asc->SetIsolationModeFlag(startMsg, reqHandle);
827 EXPECT_EQ(ret, ERR_OK);
828 TAG_LOGI(AAFwkTag::TEST, "SetIsolationModeFlag_001 end");
829 }
830
831 /**
832 * @tc.name: SetIsolationModeFlag_002
833 * @tc.desc: appspawn SetIsolationModeFlag
834 * @tc.type: FUNC
835 * @tc.require: issueI5W4S7
836 */
837 HWTEST_F(AppSpawnClientTest, SetIsolationModeFlag_002, TestSize.Level0)
838 {
839 TAG_LOGI(AAFwkTag::TEST, "SetIsolationModeFlag_002 start");
840 AppSpawnStartMsg startMsg = {0};
841 std::string procName("test_proc_name");
842 startMsg.procName = procName;
843 startMsg.isolationMode = false;
844 auto asc = std::make_shared<AppSpawnClient>(false);
845 int32_t ret = 0;
846 AppSpawnReqMsgHandle reqHandle = nullptr;
847 ret = asc->OpenConnection();
848 EXPECT_EQ(ret, ERR_OK);
849 ret = AppSpawnReqMsgCreate(static_cast<AppSpawnMsgType>(startMsg.code), startMsg.procName.c_str(), &reqHandle);
850 EXPECT_EQ(ret, ERR_OK);
851 ret = asc->SetIsolationModeFlag(startMsg, reqHandle);
852 EXPECT_EQ(ret, ERR_OK);
853 TAG_LOGI(AAFwkTag::TEST, "SetIsolationModeFlag_002 end");
854 }
855
856
857 /**
858 * @tc.name: StartProcess_001
859 * @tc.desc: appspawn StartProcess
860 * @tc.type: FUNC
861 * @tc.require: issueI5W4S7
862 */
863 HWTEST_F(AppSpawnClientTest, StartProcess_001, TestSize.Level0)
864 {
865 TAG_LOGI(AAFwkTag::TEST, "StartProcess_001 start");
866 AppSpawnStartMsg startMsg = {0};
867 startMsg.uid = 1001;
868 startMsg.gid = 2001;
869 startMsg.gids = {1001, 1002, 1003};
870 std::string procName("test_proc_name");
871 startMsg.procName = procName;
872 std::string permission1("permission_for_test_1");
873 std::string permission2("permission_for_test_2");
874 std::string permission3("permission_for_test_3");
875 startMsg.permissions.insert(permission1);
876 startMsg.permissions.insert(permission2);
877 startMsg.permissions.insert(permission3);
878 startMsg.flags = 0x1000;
879 startMsg.atomicServiceFlag = false;
880 startMsg.strictMode = false;
881 startMsg.isolatedExtension = false;
882 startMsg.childProcessType = 1;
883 startMsg.isolationMode = false;
884 std::string provisionType("test_provisionType");
885 startMsg.provisionType = provisionType;
886 std::string processType("test_processType");
887 startMsg.processType = processType;
888 startMsg.maxChildProcess = 1;
889 std::string extensionSandboxPath("test_extensionSandboxPath");
890 startMsg.extensionSandboxPath = extensionSandboxPath;
891
892 int32_t ret = 0;
893 auto asc = std::make_shared<AppSpawnClient>(false);
894 pid_t pid = 0;
895 ret = asc->StartProcess(startMsg, pid);
896 EXPECT_NE(ret, ERR_OK);
897
898 TAG_LOGI(AAFwkTag::TEST, "StartProcess_001 end");
899 }
900
901 /**
902 * @tc.name: StartProcess_002
903 * @tc.desc: appspawn StartProcess
904 * @tc.type: FUNC
905 * @tc.require: issueI5W4S7
906 */
907 HWTEST_F(AppSpawnClientTest, StartProcess_002, TestSize.Level0)
908 {
909 TAG_LOGI(AAFwkTag::TEST, "StartProcess_002 start");
910 AppSpawnStartMsg startMsg = {0};
911 startMsg.uid = 1001;
912 startMsg.gid = 2001;
913 startMsg.gids = {1001, 1002, 1003, -1};
914 std::string procName("test_proc_name");
915 startMsg.procName = procName;
916 std::string permission1("permission_for_test_1");
917 std::string permission2("permission_for_test_2");
918 std::string permission3("permission_for_test_3");
919 startMsg.permissions.insert(permission1);
920 startMsg.permissions.insert(permission2);
921 startMsg.permissions.insert(permission3);
922 startMsg.flags = 0x1000;
923 startMsg.atomicServiceFlag = false;
924 startMsg.strictMode = false;
925 startMsg.isolatedExtension = false;
926 startMsg.childProcessType = 1;
927 startMsg.isolationMode = false;
928 std::string provisionType("test_provisionType");
929 startMsg.provisionType = provisionType;
930 std::string processType("test_processType");
931 startMsg.processType = processType;
932 startMsg.maxChildProcess = 1;
933 std::string extensionSandboxPath("test_extensionSandboxPath");
934 startMsg.extensionSandboxPath = extensionSandboxPath;
935
936 int32_t ret = 0;
937 auto asc = std::make_shared<AppSpawnClient>(false);
938 pid_t pid = 0;
939 ret = asc->StartProcess(startMsg, pid);
940 EXPECT_NE(ret, ERR_OK);
941
942 TAG_LOGI(AAFwkTag::TEST, "StartProcess_002 end");
943 }
944
945 /**
946 * @tc.name: DumpJITPermissionListToJson_001
947 * @tc.desc: appspawn client DumpJITPermissionListToJson_001
948 * @tc.type: FUNC
949 */
950 HWTEST_F(AppSpawnClientTest, DumpJITPermissionListToJson_001, TestSize.Level0)
951 {
952 JITPermissionsList jitPermissionsList = {
953 "ohos.permission.jit1",
954 "ohos.permission.jit2"
955 };
956 std::string expectJITPermission1 = "ohos.permission.jit1";
957 std::string expectJITPermission2 = "ohos.permission.jit2";
958 std::string jsonJITPermissions = DumpJITPermissionListToJson(jitPermissionsList);
959
960 size_t pos = jsonJITPermissions.find(expectJITPermission1);
961 ASSERT_NE(pos, std::string::npos);
962 pos = jsonJITPermissions.find(expectJITPermission2);
963 ASSERT_NE(pos, std::string::npos);
964 pos = jsonJITPermissions.find(expectJITPermission2);
965 ASSERT_NE(pos, std::string::npos);
966 }
967
968 } // namespace AppExecFwk
969 } // namespace OHOS
970