1 /*
2 * Copyright (c) 2024-2024 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 #include <cstring>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <unistd.h>
22
23 #include "appspawn.h"
24 #include "appspawn_hook.h"
25 #include "appspawn_manager.h"
26 #include "appspawn_modulemgr.h"
27 #include "appspawn_permission.h"
28 #include "appspawn_sandbox.h"
29 #include "appspawn_utils.h"
30 #include "securec.h"
31
32 #include "app_spawn_stub.h"
33 #include "app_spawn_test_helper.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 class AppSpawnAppMgrTest : public testing::Test {
40 public:
SetUpTestCase()41 static void SetUpTestCase() {}
TearDownTestCase()42 static void TearDownTestCase() {}
SetUp()43 void SetUp() {}
TearDown()44 void TearDown() {}
45 };
46
47 /**
48 * @brief test for appspawn_manager.h
49 *
50 */
51 /**
52 * @brief AppSpawnMgr
53 *
54 */
55 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMgr_001, TestSize.Level0)
56 {
57 int ret = 0;
58 for (int i = 0; i < MODE_INVALID; i++) {
59 AppSpawnMgr *mgr = CreateAppSpawnMgr(i);
60 EXPECT_EQ(mgr != nullptr, 1);
61
62 AppSpawnContent *content = GetAppSpawnContent();
63 EXPECT_EQ(content != nullptr, 1);
64 EXPECT_EQ(content->mode == static_cast<RunMode>(i), 1);
65
66 if (i == MODE_FOR_NWEB_SPAWN || i == MODE_FOR_NWEB_COLD_RUN) {
67 ret = IsNWebSpawnMode(mgr);
68 EXPECT_EQ(1, ret); // true
69 } else {
70 ret = IsNWebSpawnMode(mgr);
71 EXPECT_EQ(0, ret); // false
72 }
73
74 if (i == MODE_FOR_APP_COLD_RUN || i == MODE_FOR_NWEB_COLD_RUN) {
75 ret = IsColdRunMode(mgr);
76 EXPECT_EQ(1, ret); // true
77 } else {
78 ret = IsColdRunMode(mgr);
79 EXPECT_EQ(0, ret); // false
80 }
81
82 // get
83 mgr = GetAppSpawnMgr();
84 EXPECT_EQ(mgr != nullptr, 1);
85
86 // delete
87 DeleteAppSpawnMgr(mgr);
88
89 // get not exist
90 mgr = GetAppSpawnMgr();
91 EXPECT_EQ(mgr == nullptr, 1);
92
93 // get not exist
94 content = GetAppSpawnContent();
95 EXPECT_EQ(content == nullptr, 1);
96
97 ret = IsColdRunMode(mgr);
98 EXPECT_EQ(0, ret); // false
99 ret = IsNWebSpawnMode(mgr);
100 EXPECT_EQ(0, ret); // false
101
102 // delete not exist
103 DeleteAppSpawnMgr(mgr);
104 }
105 }
106
107 /**
108 * @brief AppSpawnedProcess
109 *
110 */
TestAppTraversal(const AppSpawnMgr * mgr,AppSpawnedProcess * appInfo,void * data)111 static void TestAppTraversal(const AppSpawnMgr *mgr, AppSpawnedProcess *appInfo, void *data)
112 {
113 }
114
115 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnedProcess_001, TestSize.Level0)
116 {
117 AppSpawnMgr *mgr = CreateAppSpawnMgr(0);
118 EXPECT_EQ(mgr != nullptr, 1);
119 const size_t processNameCount = 3;
120 const size_t pidCount = 4;
121 const size_t resultCount = processNameCount * pidCount;
122 const char *processNameInput[processNameCount] = {nullptr, "aaaaaa", ""}; // 3 size
123 pid_t pidInput[pidCount] = {0, 100, 1000, -100}; // 4 size
124 int result[resultCount] = {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0};
125 for (size_t i = 0; i < processNameCount; i++) {
126 for (size_t j = 0; j < pidCount; j++) {
127 AppSpawnedProcess *app = AddSpawnedProcess(pidInput[j], processNameInput[i], false);
128 EXPECT_EQ(app != nullptr, result[i * pidCount + j]);
129 }
130 }
131
132 // Traversal
133 TraversalSpawnedProcess(TestAppTraversal, nullptr);
134 TraversalSpawnedProcess(TestAppTraversal, reinterpret_cast<void *>(mgr));
135 TraversalSpawnedProcess(nullptr, nullptr);
136 TraversalSpawnedProcess(nullptr, reinterpret_cast<void *>(mgr));
137
138 // GetSpawnedProcess
139 int resultGet[pidCount] = {0, 1, 1, 0};
140 for (size_t j = 0; j < pidCount; j++) {
141 AppSpawnedProcess *app = GetSpawnedProcess(pidInput[j]);
142 EXPECT_EQ(app != nullptr, resultGet[j]);
143 }
144
145 // GetSpawnedProcessByName
146 int resultGetByName[processNameCount] = {0, 1, 0};
147 for (size_t i = 0; i < processNameCount; i++) {
148 AppSpawnedProcess *app = GetSpawnedProcessByName(processNameInput[i]);
149 EXPECT_EQ(app != nullptr, resultGetByName[i]);
150
151 // delete app
152 TerminateSpawnedProcess(app);
153 }
154 // delete not exist
155 DeleteAppSpawnMgr(mgr);
156 }
157
158 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnedProcess_002, TestSize.Level0)
159 {
160 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
161 EXPECT_EQ(mgr != nullptr, 1);
162 const size_t processNameCount = 3;
163 const size_t pidCount = 4;
164 const size_t resultCount = processNameCount * pidCount;
165 const char *processNameInput[processNameCount] = {nullptr, "aaaaaa", ""}; // 3 size
166 pid_t pidInput[pidCount] = {0, 100, 1000, -100}; // 4 size
167 int result[resultCount] = {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0};
168 for (size_t i = 0; i < processNameCount; i++) {
169 for (size_t j = 0; j < pidCount; j++) {
170 AppSpawnedProcess *app = AddSpawnedProcess(pidInput[j], processNameInput[i], false);
171 EXPECT_EQ(app != nullptr, result[i * pidCount + j]);
172 }
173 }
174
175 // Traversal
176 TraversalSpawnedProcess(TestAppTraversal, nullptr);
177 TraversalSpawnedProcess(TestAppTraversal, reinterpret_cast<void *>(mgr));
178 TraversalSpawnedProcess(nullptr, nullptr);
179 TraversalSpawnedProcess(nullptr, reinterpret_cast<void *>(mgr));
180
181 // GetSpawnedProcess
182 int resultGet[pidCount] = {0, 1, 1, 0};
183 for (size_t j = 0; j < pidCount; j++) {
184 AppSpawnedProcess *app = GetSpawnedProcess(pidInput[j]);
185 EXPECT_EQ(app != nullptr, resultGet[j]);
186 }
187
188 // GetSpawnedProcessByName
189 int resultGetByName[processNameCount] = {0, 1, 0};
190 for (size_t i = 0; i < processNameCount; i++) {
191 AppSpawnedProcess *app = GetSpawnedProcessByName(processNameInput[i]);
192 EXPECT_EQ(app != nullptr, resultGetByName[i]);
193 // delete app
194 TerminateSpawnedProcess(app);
195 }
196 // delete not exist
197 DeleteAppSpawnMgr(mgr);
198 }
199
200 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnedProcess_003, TestSize.Level0)
201 {
202 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
203 EXPECT_EQ(mgr != nullptr, 1);
204 const char *processNameInput[] = {"1", "22", "333", "4444", "55555", "6666"};
205 // GetSpawnedProcessByName
206 size_t processNameCount = ARRAY_LENGTH(processNameInput);
207 for (size_t i = 0; i < processNameCount; i++) {
208 AppSpawnedProcess *app = AddSpawnedProcess(1000, processNameInput[i], false); // 10000
209 EXPECT_EQ(app != nullptr, 1);
210 }
211 for (size_t i = 0; i < processNameCount; i++) {
212 AppSpawnedProcess *app = GetSpawnedProcessByName(processNameInput[i]);
213 EXPECT_EQ(app != nullptr, 1);
214 // delete app
215 TerminateSpawnedProcess(app);
216 }
217 // delete not exist
218 DeleteAppSpawnMgr(mgr);
219 }
220
221 /**
222 * @brief AppSpawningCtx
223 *
224 */
TestProcessTraversal(const AppSpawnMgr * mgr,AppSpawningCtx * ctx,void * data)225 static void TestProcessTraversal(const AppSpawnMgr *mgr, AppSpawningCtx *ctx, void *data)
226 {
227 }
228
229 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_001, TestSize.Level0)
230 {
231 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
232 EXPECT_EQ(appCtx != nullptr, 1);
233 DeleteAppSpawningCtx(appCtx);
234 DeleteAppSpawningCtx(nullptr);
235
236 AppSpawnMgr *mgr = CreateAppSpawnMgr(0);
237 EXPECT_EQ(mgr != nullptr, 1);
238 appCtx = CreateAppSpawningCtx();
239 EXPECT_EQ(appCtx != nullptr, 1);
240
241 // GetAppSpawningCtxByPid
242 appCtx->pid = 100; // 100 test
243 appCtx = GetAppSpawningCtxByPid(0);
244 EXPECT_EQ(appCtx == nullptr, 1);
245 appCtx = GetAppSpawningCtxByPid(100000); // 100000 test
246 EXPECT_EQ(appCtx == nullptr, 1);
247 appCtx = GetAppSpawningCtxByPid(-2); // -2 test
248 EXPECT_EQ(appCtx == nullptr, 1);
249 appCtx = GetAppSpawningCtxByPid(100); // 100 test
250 EXPECT_EQ(appCtx != nullptr, 1);
251
252 AppSpawningCtxTraversal(TestProcessTraversal, reinterpret_cast<void *>(appCtx));
253 AppSpawningCtxTraversal(nullptr, reinterpret_cast<void *>(appCtx));
254 AppSpawningCtxTraversal(TestProcessTraversal, nullptr);
255 AppSpawningCtxTraversal(nullptr, nullptr);
256
257 appCtx = CreateAppSpawningCtx();
258 EXPECT_EQ(appCtx != nullptr, 1);
259 // delete not exist
260 DeleteAppSpawnMgr(mgr);
261 DeleteAppSpawningCtx(nullptr);
262 }
263
264 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_002, TestSize.Level0)
265 {
266 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
267 EXPECT_EQ(appCtx != nullptr, 1);
268 DeleteAppSpawningCtx(appCtx);
269 DeleteAppSpawningCtx(nullptr);
270
271 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
272 EXPECT_EQ(mgr != nullptr, 1);
273 appCtx = CreateAppSpawningCtx();
274 EXPECT_EQ(appCtx != nullptr, 1);
275
276 // GetAppSpawningCtxByPid
277 appCtx->pid = 100; // 100 test
278 appCtx = GetAppSpawningCtxByPid(0);
279 EXPECT_EQ(appCtx == nullptr, 1);
280 appCtx = GetAppSpawningCtxByPid(100000); // 100000 test
281 EXPECT_EQ(appCtx == nullptr, 1);
282 appCtx = GetAppSpawningCtxByPid(-2); // -2 test
283 EXPECT_EQ(appCtx == nullptr, 1);
284 appCtx = GetAppSpawningCtxByPid(100); // 100 test
285 EXPECT_EQ(appCtx != nullptr, 1);
286
287 AppSpawningCtxTraversal(TestProcessTraversal, reinterpret_cast<void *>(appCtx));
288 AppSpawningCtxTraversal(nullptr, reinterpret_cast<void *>(appCtx));
289 AppSpawningCtxTraversal(TestProcessTraversal, nullptr);
290 AppSpawningCtxTraversal(nullptr, nullptr);
291
292 DeleteAppSpawningCtx(appCtx);
293 // delete not exist
294 DeleteAppSpawnMgr(mgr);
295 DeleteAppSpawningCtx(nullptr);
296 }
297
298 /**
299 * @brief AppSpawnMsgNode
300 *
301 */
302 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_001, TestSize.Level0)
303 {
304 AppSpawnMsgNode *msgNode = CreateAppSpawnMsg();
305 EXPECT_EQ(msgNode != nullptr, 1);
306 int ret = CheckAppSpawnMsg(msgNode);
307 EXPECT_NE(0, ret); // check fail
308
309 // delete
310 DeleteAppSpawnMsg(&msgNode);
311 DeleteAppSpawnMsg(nullptr);
312
313 // get from buffer
314 std::vector<uint8_t> buffer(16); // 16
315 AppSpawnMsgNode *outMsg = nullptr;
316 uint32_t msgRecvLen = 0;
317 uint32_t reminder = 0;
318 const int inputCount = 2; // 2 test
319 const uint8_t *inputBuffer[inputCount] = {nullptr, buffer.data()}; // 2 test
320 uint32_t *inputMsgLen[inputCount] = {nullptr, &msgRecvLen};
321 uint32_t *inputReminder[inputCount] = {nullptr, &reminder};
322 int result[inputCount * inputCount * inputCount] = {0};
323 result[7] = 1;
324 for (int i = 0; i < inputCount; i++) {
325 for (int j = 0; j < inputCount; j++) {
326 for (int k = 0; k < inputCount; k++) {
327 ret = GetAppSpawnMsgFromBuffer(inputBuffer[i], buffer.size(),
328 &outMsg, inputMsgLen[j], inputReminder[k]);
329 EXPECT_EQ(ret == 0, result[i * inputCount * inputCount + j * inputCount + k]); // check fail
330 DeleteAppSpawnMsg(&outMsg);
331 }
332 }
333 }
334 for (int i = 0; i < inputCount; i++) {
335 for (int j = 0; j < inputCount; j++) {
336 for (int k = 0; k < inputCount; k++) {
337 ret = GetAppSpawnMsgFromBuffer(inputBuffer[i], buffer.size(),
338 nullptr, inputMsgLen[j], inputReminder[k]);
339 EXPECT_NE(0, ret); // check fail
340 }
341 }
342 }
343
344 ret = DecodeAppSpawnMsg(nullptr);
345 EXPECT_NE(0, ret);
346 ret = CheckAppSpawnMsg(nullptr);
347 EXPECT_NE(0, ret);
348 DeleteAppSpawnMsg(nullptr);
349 }
350
351 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_002, TestSize.Level0)
352 {
353 // get from buffer
354 AppSpawnTestHelper testHelper;
355 std::vector<uint8_t> buffer(1024 + sizeof(AppSpawnMsg)); // 1024 max buffer
356 uint32_t msgLen = 0;
357 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
358 EXPECT_EQ(0, ret);
359
360 // copy msg header
361 ret = memcpy_s(buffer.data() + msgLen, sizeof(AppSpawnMsg), buffer.data(), sizeof(AppSpawnMsg));
362 EXPECT_EQ(0, ret);
363
364 AppSpawnMsgNode *outMsg = nullptr;
365 uint32_t msgRecvLen = 0;
366 uint32_t reminder = 0;
367 // 测试部分头信息
368 // only msg type
369 uint32_t currLen = sizeof(uint32_t) + sizeof(uint32_t);
370 ret = GetAppSpawnMsgFromBuffer(buffer.data(), currLen, &outMsg, &msgRecvLen, &reminder);
371 EXPECT_EQ(0, ret);
372 EXPECT_EQ(currLen, msgRecvLen);
373 EXPECT_EQ(memcmp(buffer.data(), &outMsg->msgHeader, currLen), 0);
374 // continue msg
375 ret = GetAppSpawnMsgFromBuffer(buffer.data() + currLen, sizeof(uint32_t), &outMsg, &msgRecvLen, &reminder);
376 currLen += sizeof(uint32_t);
377 EXPECT_EQ(0, ret);
378 EXPECT_EQ(currLen, msgRecvLen);
379 EXPECT_EQ(memcmp(buffer.data(), &outMsg->msgHeader, currLen), 0);
380 EXPECT_EQ(0, reminder);
381
382 // end msg header
383 ret = GetAppSpawnMsgFromBuffer(buffer.data() + currLen,
384 sizeof(AppSpawnMsg) - currLen, &outMsg, &msgRecvLen, &reminder);
385 currLen = sizeof(AppSpawnMsg);
386 EXPECT_EQ(0, ret);
387 EXPECT_EQ(currLen, msgRecvLen);
388 EXPECT_EQ(memcmp(buffer.data(), &outMsg->msgHeader, currLen), 0);
389 EXPECT_EQ(0, reminder);
390
391 // reminder msg + next header
392 ret = GetAppSpawnMsgFromBuffer(buffer.data() + currLen, msgLen, &outMsg, &msgRecvLen, &reminder);
393 EXPECT_EQ(0, ret);
394 EXPECT_EQ(msgLen, msgRecvLen);
395 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
396 EXPECT_EQ(sizeof(AppSpawnMsg), reminder);
397 DeleteAppSpawnMsg(&outMsg);
398 }
399
400 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_003, TestSize.Level0)
401 {
402 // get from buffer
403 AppSpawnTestHelper testHelper;
404 std::vector<uint8_t> buffer(1024 + sizeof(AppSpawnMsg)); // 1024 max buffer
405 uint32_t msgLen = 0;
406 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
407 EXPECT_EQ(0, ret);
408 // copy msg header
409 ret = memcpy_s(buffer.data() + msgLen, sizeof(AppSpawnMsg), buffer.data(), sizeof(AppSpawnMsg));
410 EXPECT_EQ(0, ret);
411
412 AppSpawnMsgNode *outMsg = nullptr;
413 uint32_t msgRecvLen = 0;
414 uint32_t reminder = 0;
415 // 测试部分头信息
416 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen + sizeof(AppSpawnMsg), &outMsg, &msgRecvLen, &reminder);
417 EXPECT_EQ(0, ret);
418 EXPECT_EQ(msgLen, msgRecvLen);
419 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
420 EXPECT_EQ(sizeof(AppSpawnMsg), reminder);
421
422 ret = DecodeAppSpawnMsg(outMsg);
423 EXPECT_EQ(0, ret);
424 ret = CheckAppSpawnMsg(outMsg);
425 EXPECT_EQ(0, ret);
426 DeleteAppSpawnMsg(&outMsg);
427 }
428
429 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_004, TestSize.Level0)
430 {
431 // get from buffer
432 AppSpawnTestHelper testHelper;
433 std::vector<uint8_t> buffer(1024); // 1024 max buffer
434 uint32_t msgLen = 0;
435 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
436 EXPECT_EQ(0, ret);
437
438 AppSpawnMsgNode *outMsg = nullptr;
439 uint32_t msgRecvLen = 0;
440 uint32_t reminder = 0;
441
442 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
443 EXPECT_EQ(0, ret);
444 EXPECT_EQ(msgLen, msgRecvLen);
445 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
446 EXPECT_EQ(0, reminder);
447
448 ret = DecodeAppSpawnMsg(outMsg);
449 EXPECT_EQ(0, ret);
450 ret = CheckAppSpawnMsg(outMsg);
451 EXPECT_NE(0, ret);
452 DeleteAppSpawnMsg(&outMsg);
453 }
454
AddRenderTerminationTlv(uint8_t * buffer,uint32_t bufferLen,uint32_t & realLen,uint32_t & tlvCount)455 static int AddRenderTerminationTlv(uint8_t *buffer, uint32_t bufferLen, uint32_t &realLen, uint32_t &tlvCount)
456 {
457 // add app flage
458 uint32_t currLen = 0;
459 AppSpawnTlv tlv = {};
460 tlv.tlvType = TLV_RENDER_TERMINATION_INFO;
461 pid_t pid = 9999999; // 9999999 test
462 tlv.tlvLen = sizeof(AppSpawnTlv) + sizeof(pid);
463
464 int ret = memcpy_s(buffer, bufferLen, &tlv, sizeof(tlv));
465 APPSPAWN_CHECK(ret == 0, return -1, "Failed to memcpy_s bufferSize");
466 ret = memcpy_s(buffer + sizeof(tlv), bufferLen - sizeof(tlv), &pid, tlv.tlvLen - sizeof(tlv));
467 APPSPAWN_CHECK(ret == 0, return -1, "Failed to memcpy_s bufferSize");
468 currLen += tlv.tlvLen;
469 tlvCount++;
470 realLen = currLen;
471 return 0;
472 }
473
474 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_005, TestSize.Level0)
475 {
476 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
477 EXPECT_EQ(mgr != nullptr, 1);
478
479 // get from buffer
480 AppSpawnTestHelper testHelper;
481 std::vector<uint8_t> buffer(1024); // 1024 max buffer
482 uint32_t msgLen = 0;
483 int ret = testHelper.CreateSendMsg(buffer, MSG_GET_RENDER_TERMINATION_STATUS, msgLen, {AddRenderTerminationTlv});
484 EXPECT_EQ(0, ret);
485
486 AppSpawnMsgNode *outMsg = nullptr;
487 uint32_t msgRecvLen = 0;
488 uint32_t reminder = 0;
489 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
490 EXPECT_EQ(0, ret);
491 EXPECT_EQ(msgLen, msgRecvLen);
492 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
493 EXPECT_EQ(0, reminder);
494
495 AppSpawnedProcess *app = AddSpawnedProcess(9999999, "aaaa", false); // 9999999 test
496 EXPECT_EQ(app != nullptr, 1);
497 TerminateSpawnedProcess(app);
498 AppSpawnExtData extData;
499 OH_ListAddTail(&(mgr->extData), &(extData.node));
500 ProcessAppSpawnDumpMsg(outMsg);
501
502 ret = DecodeAppSpawnMsg(outMsg);
503 EXPECT_EQ(0, ret);
504 AppSpawnResult result = {};
505 // app exist
506 ret = ProcessTerminationStatusMsg(outMsg, &result);
507 EXPECT_EQ(0, ret);
508
509 ret = ProcessTerminationStatusMsg(nullptr, &result);
510 EXPECT_NE(0, ret);
511
512 ret = ProcessTerminationStatusMsg(outMsg, nullptr);
513 EXPECT_NE(0, ret);
514
515 ret = ProcessTerminationStatusMsg(nullptr, nullptr);
516 EXPECT_NE(0, ret);
517 DeleteAppSpawnMsg(&outMsg);
518
519 DeleteAppSpawnMgr(mgr);
520 }
521
522 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_006, TestSize.Level0)
523 {
524 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
525 EXPECT_EQ(mgr != nullptr, 1);
526
527 // get from buffer
528 AppSpawnTestHelper testHelper;
529 std::vector<uint8_t> buffer(1024); // 1024 max buffer
530 uint32_t msgLen = 0;
531 int ret = testHelper.CreateSendMsg(buffer, MSG_GET_RENDER_TERMINATION_STATUS, msgLen, {AddRenderTerminationTlv});
532 EXPECT_EQ(0, ret);
533
534 AppSpawnMsgNode *outMsg = nullptr;
535 uint32_t msgRecvLen = 0;
536 uint32_t reminder = 0;
537 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
538 EXPECT_EQ(0, ret);
539 EXPECT_EQ(msgLen, msgRecvLen);
540 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
541 EXPECT_EQ(0, reminder);
542
543 AppSpawnedProcess *app = AddSpawnedProcess(9999999, "aaaa", false); // 9999999 test
544 EXPECT_EQ(app != nullptr, 1);
545
546 ret = DecodeAppSpawnMsg(outMsg);
547 EXPECT_EQ(0, ret);
548 AppSpawnResult result = {};
549 // die app not exist
550 ret = ProcessTerminationStatusMsg(outMsg, &result);
551 EXPECT_EQ(0, ret);
552
553 DeleteAppSpawnMsg(&outMsg);
554 DeleteAppSpawnMgr(mgr);
555 }
556
557 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_007, TestSize.Level0)
558 {
559 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
560 EXPECT_EQ(mgr != nullptr, 1);
561
562 // get from buffer
563 AppSpawnTestHelper testHelper;
564 std::vector<uint8_t> buffer(1024); // 1024 max buffer
565 uint32_t msgLen = 0;
566 int ret = testHelper.CreateSendMsg(buffer, MSG_GET_RENDER_TERMINATION_STATUS, msgLen, {AddRenderTerminationTlv});
567 EXPECT_EQ(0, ret);
568
569 AppSpawnMsgNode *outMsg = nullptr;
570 uint32_t msgRecvLen = 0;
571 uint32_t reminder = 0;
572 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
573 EXPECT_EQ(0, ret);
574 EXPECT_EQ(msgLen, msgRecvLen);
575 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
576 EXPECT_EQ(0, reminder);
577
578 ret = DecodeAppSpawnMsg(outMsg);
579 EXPECT_EQ(0, ret);
580 AppSpawnResult result = {};
581 // app not exist
582 ret = ProcessTerminationStatusMsg(outMsg, &result);
583 EXPECT_EQ(0, ret);
584
585 DeleteAppSpawnMsg(&outMsg);
586 DeleteAppSpawnMgr(mgr);
587 }
588
589 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_008, TestSize.Level0)
590 {
591 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
592 EXPECT_EQ(mgr != nullptr, 1);
593
594 // get from buffer
595 AppSpawnTestHelper testHelper;
596 std::vector<uint8_t> buffer(1024); // 1024 max buffer
597 uint32_t msgLen = 0;
598 int ret = testHelper.CreateSendMsg(buffer, MSG_DUMP, msgLen, {});
599 EXPECT_EQ(0, ret);
600
601 AppSpawnMsgNode *outMsg = nullptr;
602 uint32_t msgRecvLen = 0;
603 uint32_t reminder = 0;
604 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
605 EXPECT_EQ(0, ret);
606 EXPECT_EQ(msgLen, msgRecvLen);
607 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
608 EXPECT_EQ(0, reminder);
609
610 ret = DecodeAppSpawnMsg(outMsg);
611 EXPECT_EQ(0, ret);
612
613 ProcessAppSpawnDumpMsg(outMsg);
614 ProcessAppSpawnDumpMsg(nullptr);
615 outMsg->tlvOffset = nullptr;
616 ProcessAppSpawnDumpMsg(outMsg);
617
618 DeleteAppSpawnMsg(&outMsg);
619 DeleteAppSpawnMgr(mgr);
620 }
621
622 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_009, TestSize.Level0)
623 {
624 AppSpawnMsgNode *msgNode = CreateAppSpawnMsg();
625 msgNode->buffer = static_cast<uint8_t *>(malloc(255));;
626 msgNode->tlvOffset = static_cast<uint32_t *>(malloc(128));
627 EXPECT_EQ(msgNode != nullptr, 1);
628 DeleteAppSpawnMsg(&msgNode);
629 EXPECT_EQ(msgNode, NULL);
630 DeleteAppSpawnMsg(&msgNode);
631 EXPECT_EQ(msgNode, NULL);
632 msgNode = CreateAppSpawnMsg();
633 EXPECT_NE(msgNode, NULL);
634 DeleteAppSpawnMsg(&msgNode);
635 EXPECT_EQ(msgNode, NULL);
636 DeleteAppSpawnMsg(nullptr);
637 }
638 /**
639 * @brief 消息内容操作接口
640 *
641 */
642 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_001, TestSize.Level0)
643 {
644 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
645 EXPECT_EQ(mgr != nullptr, 1);
646
647 // get from buffer
648 AppSpawnTestHelper testHelper;
649 std::vector<uint8_t> buffer(1024); // 1024 max buffer
650 uint32_t msgLen = 0;
651 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
652 EXPECT_EQ(0, ret);
653
654 AppSpawnMsgNode *outMsg = nullptr;
655 uint32_t msgRecvLen = 0;
656 uint32_t reminder = 0;
657 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
658 EXPECT_EQ(0, ret);
659 EXPECT_EQ(msgLen, msgRecvLen);
660 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
661 EXPECT_EQ(0, reminder);
662 ret = DecodeAppSpawnMsg(outMsg);
663 EXPECT_EQ(0, ret);
664
665 // get msg info
666 int inputTlv[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, TLV_MAX, TLV_MAX + 1, TLV_MAX + 2, -1}; // 13 test
667 int result[13] = {1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0}; // 13 test
668 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
669 void *info = GetAppSpawnMsgInfo(outMsg, i);
670 EXPECT_EQ(info != nullptr, result[i]);
671 }
672
673 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
674 void *info = GetAppSpawnMsgInfo(nullptr, i);
675 EXPECT_EQ(info == nullptr, 1);
676 }
677 DeleteAppSpawnMsg(&outMsg);
678 DeleteAppSpawnMgr(mgr);
679 }
680
AddTest001ExtTlv(uint8_t * buffer,uint32_t bufferLen,uint32_t & realLen,uint32_t & tlvCount)681 static int AddTest001ExtTlv(uint8_t *buffer, uint32_t bufferLen, uint32_t &realLen, uint32_t &tlvCount)
682 {
683 const char *testData = "555555555555555555555555555";
684 uint32_t currLen = 0;
685 AppSpawnTlvExt tlv = {};
686 tlv.tlvType = TLV_MAX;
687 int ret = strcpy_s(tlv.tlvName, sizeof(tlv.tlvName), "test-001");
688 APPSPAWN_CHECK(ret == 0, return -1, "Failed to strcpy");
689 tlv.dataLen = strlen(testData) + 1;
690 tlv.tlvLen = sizeof(AppSpawnTlvExt) + APPSPAWN_ALIGN(tlv.dataLen);
691
692 ret = memcpy_s(buffer, bufferLen, &tlv, sizeof(tlv));
693 APPSPAWN_CHECK(ret == 0, return -1, "Failed to memcpy_s bufferSize");
694 ret = memcpy_s(buffer + sizeof(tlv), bufferLen - sizeof(tlv), testData, tlv.dataLen + 1);
695 APPSPAWN_CHECK(ret == 0, return -1, "Failed to memcpy_s bufferSize");
696 currLen += tlv.tlvLen;
697 tlvCount++;
698 realLen = currLen;
699 return 0;
700 }
701
702 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_002, TestSize.Level0)
703 {
704 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
705 EXPECT_EQ(mgr != nullptr, 1);
706
707 // get from buffer
708 AppSpawnTestHelper testHelper;
709 std::vector<uint8_t> buffer(1024 * 2); // 1024 * 2 max buffer
710 uint32_t msgLen = 0;
711 int ret = testHelper.CreateSendMsg(buffer,
712 MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv, AddTest001ExtTlv});
713 EXPECT_EQ(0, ret);
714
715 AppSpawnMsgNode *outMsg = nullptr;
716 uint32_t msgRecvLen = 0;
717 uint32_t reminder = 0;
718 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
719 EXPECT_EQ(0, ret);
720 EXPECT_EQ(msgLen, msgRecvLen);
721 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
722 EXPECT_EQ(0, reminder);
723 ret = DecodeAppSpawnMsg(outMsg);
724 EXPECT_EQ(0, ret);
725
726 // get msg ext info
727 const int inputCount = 5;
728 const char *inputName[inputCount] = {nullptr, "1", "22", "test-001", ""};
729 int result[inputCount] = {0, 0, 0, 1, 0 };
730 for (int i = 0; i < inputCount; i++) {
731 uint32_t len = 0;
732 void *info = GetAppSpawnMsgExtInfo(outMsg, inputName[i], &len);
733 EXPECT_EQ(info != nullptr, result[i]);
734 }
735 for (int i = 0; i < inputCount; i++) {
736 void *info = GetAppSpawnMsgExtInfo(outMsg, inputName[i], nullptr);
737 EXPECT_EQ(info != nullptr, result[i]);
738 }
739 for (int i = 0; i < inputCount; i++) {
740 uint32_t len = 0;
741 void *info = GetAppSpawnMsgExtInfo(nullptr, inputName[i], &len);
742 EXPECT_EQ(info == nullptr, 1);
743 }
744 DeleteAppSpawnMsg(&outMsg);
745 DeleteAppSpawnMgr(mgr);
746 }
747
748 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_003, TestSize.Level0)
749 {
750 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
751 EXPECT_EQ(mgr != nullptr, 1);
752
753 // get from buffer
754 AppSpawnTestHelper testHelper;
755 std::vector<uint8_t> buffer(1024); // 1024 max buffer
756 uint32_t msgLen = 0;
757 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
758 EXPECT_EQ(0, ret);
759
760 AppSpawnMsgNode *outMsg = nullptr;
761 uint32_t msgRecvLen = 0;
762 uint32_t reminder = 0;
763 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
764 EXPECT_EQ(0, ret);
765 EXPECT_EQ(msgLen, msgRecvLen);
766 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
767 EXPECT_EQ(0, reminder);
768 ret = DecodeAppSpawnMsg(outMsg);
769 EXPECT_EQ(0, ret);
770
771 const int inputCount = 4;
772 uint32_t inputType[inputCount] = {0, TLV_MSG_FLAGS, TLV_PERMISSION, TLV_MAX};
773 int result[inputCount] = {0, 1, 1, 0};
774
775 for (int i = 0; i < inputCount; i++) {
776 for (int j = 0; j < 32; j++) { // max index 32
777 ret = SetAppSpawnMsgFlag(outMsg, inputType[i], j);
778 EXPECT_EQ(result[i], ret == 0);
779 ret = CheckAppSpawnMsgFlag(outMsg, inputType[i], j);
780 EXPECT_EQ(result[i], ret);
781 }
782 }
783 for (int i = 0; i < inputCount; i++) {
784 for (int j = 32; j < MAX_FLAGS_INDEX + 5; j++) { // 5 test
785 ret = SetAppSpawnMsgFlag(outMsg, inputType[i], j);
786 EXPECT_EQ(0, ret == 0);
787 ret = CheckAppSpawnMsgFlag(outMsg, inputType[i], j);
788 EXPECT_EQ(0, ret);
789 }
790 }
791 for (int i = 0; i < inputCount; i++) {
792 for (int j = 0; j < MAX_FLAGS_INDEX; j++) {
793 ret = SetAppSpawnMsgFlag(nullptr, inputType[i], j);
794 EXPECT_EQ(0, ret == 0);
795 ret = CheckAppSpawnMsgFlag(nullptr, inputType[i], j);
796 EXPECT_EQ(0, ret);
797 }
798 }
799 DeleteAppSpawnMsg(&outMsg);
800 DeleteAppSpawnMgr(mgr);
801 }
802
803 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_004, TestSize.Level0)
804 {
805 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
806 EXPECT_EQ(mgr != nullptr, 1);
807
808 // get from buffer
809 AppSpawnTestHelper testHelper;
810 std::vector<uint8_t> buffer(1024); // 1024 max buffer
811 uint32_t msgLen = 0;
812 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
813 EXPECT_EQ(0, ret);
814
815 AppSpawnMsgNode *outMsg = nullptr;
816 uint32_t msgRecvLen = 0;
817 uint32_t reminder = 0;
818 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
819 EXPECT_EQ(0, ret);
820 EXPECT_EQ(msgLen, msgRecvLen);
821 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
822 EXPECT_EQ(0, reminder);
823 ret = DecodeAppSpawnMsg(outMsg);
824 EXPECT_EQ(0, ret);
825
826 // dump msg
827 DumpAppSpawnMsg(outMsg);
828 DumpAppSpawnMsg(nullptr);
829 DeleteAppSpawnMsg(&outMsg);
830 DeleteAppSpawnMgr(mgr);
831 }
832
833 /**
834 * @brief AppSpawningCtx AppSpawnMsg
835 *
836 */
837 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_001, TestSize.Level0)
838 {
839 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
840 EXPECT_EQ(mgr != nullptr, 1);
841
842 // get from buffer
843 AppSpawnTestHelper testHelper;
844 std::vector<uint8_t> buffer(1024); // 1024 max buffer
845 uint32_t msgLen = 0;
846 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
847 EXPECT_EQ(0, ret);
848
849 AppSpawnMsgNode *outMsg = nullptr;
850 uint32_t msgRecvLen = 0;
851 uint32_t reminder = 0;
852 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
853 EXPECT_EQ(0, ret);
854 EXPECT_EQ(msgLen, msgRecvLen);
855 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
856 EXPECT_EQ(0, reminder);
857 ret = DecodeAppSpawnMsg(outMsg);
858 EXPECT_EQ(0, ret);
859
860 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
861 EXPECT_EQ(appCtx != nullptr, 1);
862 appCtx->message = outMsg;
863 int msgType = GetAppSpawnMsgType(appCtx);
864 EXPECT_EQ(msgType, MSG_APP_SPAWN);
865 outMsg->msgHeader.msgType = MSG_GET_RENDER_TERMINATION_STATUS;
866 msgType = GetAppSpawnMsgType(appCtx);
867 EXPECT_EQ(msgType, MSG_GET_RENDER_TERMINATION_STATUS);
868 outMsg->msgHeader.msgType = MSG_SPAWN_NATIVE_PROCESS;
869 msgType = GetAppSpawnMsgType(appCtx);
870 EXPECT_EQ(msgType, MSG_SPAWN_NATIVE_PROCESS);
871 msgType = GetAppSpawnMsgType(nullptr);
872 EXPECT_EQ(msgType, MAX_TYPE_INVALID);
873
874 // GetBundleName
875 const char *bundleName = GetBundleName(appCtx);
876 EXPECT_NE(nullptr, bundleName);
877 bundleName = GetBundleName(nullptr);
878 EXPECT_EQ(nullptr, bundleName);
879
880 // IsDeveloperModeOn
881 ret = IsDeveloperModeOn(appCtx);
882 EXPECT_EQ(ret, 0);
883 appCtx->client.flags |= APP_DEVELOPER_MODE;
884 ret = IsDeveloperModeOn(appCtx);
885 EXPECT_EQ(ret, 1);
886 ret = IsDeveloperModeOn(nullptr);
887 EXPECT_EQ(ret, 0);
888
889 DeleteAppSpawningCtx(appCtx);
890 DeleteAppSpawnMgr(mgr);
891 }
892
893 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_002, TestSize.Level0)
894 {
895 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
896 EXPECT_EQ(mgr != nullptr, 1);
897
898 // get from buffer
899 AppSpawnTestHelper testHelper;
900 std::vector<uint8_t> buffer(1024); // 1024 max buffer
901 uint32_t msgLen = 0;
902 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
903 EXPECT_EQ(0, ret);
904
905 AppSpawnMsgNode *outMsg = nullptr;
906 uint32_t msgRecvLen = 0;
907 uint32_t reminder = 0;
908 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
909 EXPECT_EQ(0, ret);
910 EXPECT_EQ(msgLen, msgRecvLen);
911 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
912 EXPECT_EQ(0, reminder);
913 ret = DecodeAppSpawnMsg(outMsg);
914 EXPECT_EQ(0, ret);
915
916 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
917 EXPECT_EQ(appCtx != nullptr, 1);
918 appCtx->message = outMsg;
919
920 // GetBundleName
921 const char *name = GetProcessName(appCtx);
922 EXPECT_NE(nullptr, name);
923 name = GetProcessName(nullptr);
924 EXPECT_EQ(nullptr, name);
925
926 DeleteAppSpawningCtx(appCtx);
927 DeleteAppSpawnMgr(mgr);
928 }
929
930 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_003, TestSize.Level0)
931 {
932 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
933 EXPECT_EQ(mgr != nullptr, 1);
934
935 // get from buffer
936 AppSpawnTestHelper testHelper;
937 std::vector<uint8_t> buffer(1024); // 1024 max buffer
938 uint32_t msgLen = 0;
939 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
940 EXPECT_EQ(0, ret);
941
942 AppSpawnMsgNode *outMsg = nullptr;
943 uint32_t msgRecvLen = 0;
944 uint32_t reminder = 0;
945 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
946 EXPECT_EQ(0, ret);
947 EXPECT_EQ(msgLen, msgRecvLen);
948 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
949 EXPECT_EQ(0, reminder);
950 ret = DecodeAppSpawnMsg(outMsg);
951 EXPECT_EQ(0, ret);
952 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
953 EXPECT_EQ(appCtx != nullptr, 1);
954 appCtx->message = outMsg;
955
956 for (int j = 0; j < 32; j++) { // max index 32
957 ret = SetAppPermissionFlags(appCtx, j);
958 EXPECT_EQ(1, ret == 0);
959 ret = CheckAppPermissionFlagSet(appCtx, j);
960 EXPECT_EQ(1, ret);
961 }
962 for (int j = 32; j < MAX_FLAGS_INDEX + 5; j++) { // 32 5 test
963 ret = SetAppPermissionFlags(appCtx, j);
964 EXPECT_NE(0, ret);
965 ret = CheckAppPermissionFlagSet(appCtx, j);
966 EXPECT_EQ(0, ret);
967 }
968 for (int j = 0; j < MAX_FLAGS_INDEX; j++) {
969 ret = SetAppPermissionFlags(nullptr, j);
970 EXPECT_NE(0, ret);
971 ret = CheckAppPermissionFlagSet(nullptr, j);
972 EXPECT_EQ(0, ret);
973 }
974 uint32_t result[MAX_FLAGS_INDEX] = {0};
975 result[0] = 0;
976 result[1] = 1;
977 result[3] = 1;
978 for (int j = 0; j < MAX_FLAGS_INDEX; j++) {
979 ret = CheckAppMsgFlagsSet(appCtx, j);
980 EXPECT_EQ(result[j], ret);
981 }
982 DeleteAppSpawningCtx(appCtx);
983 DeleteAppSpawnMgr(mgr);
984 }
985
986 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_004, TestSize.Level0)
987 {
988 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
989 EXPECT_EQ(mgr != nullptr, 1);
990
991 // get from buffer
992 AppSpawnTestHelper testHelper;
993 std::vector<uint8_t> buffer(1024); // 1024 max buffer
994 uint32_t msgLen = 0;
995 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
996 EXPECT_EQ(0, ret);
997
998 AppSpawnMsgNode *outMsg = nullptr;
999 uint32_t msgRecvLen = 0;
1000 uint32_t reminder = 0;
1001 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
1002 EXPECT_EQ(0, ret);
1003 EXPECT_EQ(msgLen, msgRecvLen);
1004 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
1005 EXPECT_EQ(0, reminder);
1006 ret = DecodeAppSpawnMsg(outMsg);
1007 EXPECT_EQ(0, ret);
1008 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1009 EXPECT_EQ(appCtx != nullptr, 1);
1010 appCtx->message = outMsg;
1011
1012 // get msg info
1013 int inputTlv[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, TLV_MAX, TLV_MAX + 1, TLV_MAX + 2, -1}; // 13 test
1014 int result[13] = {1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0}; // 13 test
1015 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
1016 void *info = GetAppProperty(appCtx, i);
1017 EXPECT_EQ(info != nullptr, result[i]);
1018 }
1019
1020 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
1021 void *info = GetAppProperty(nullptr, i);
1022 EXPECT_EQ(info == nullptr, 1);
1023 }
1024 DeleteAppSpawningCtx(appCtx);
1025 DeleteAppSpawnMgr(mgr);
1026 }
1027
1028 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_005, TestSize.Level0)
1029 {
1030 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
1031 EXPECT_EQ(mgr != nullptr, 1);
1032
1033 // get from buffer
1034 AppSpawnTestHelper testHelper;
1035 std::vector<uint8_t> buffer(1024 * 2); // 1024 * 2 max buffer
1036 uint32_t msgLen = 0;
1037 int ret = testHelper.CreateSendMsg(buffer,
1038 MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv, AddTest001ExtTlv});
1039 EXPECT_EQ(0, ret);
1040
1041 AppSpawnMsgNode *outMsg = nullptr;
1042 uint32_t msgRecvLen = 0;
1043 uint32_t reminder = 0;
1044 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
1045 EXPECT_EQ(0, ret);
1046 EXPECT_EQ(msgLen, msgRecvLen);
1047 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
1048 EXPECT_EQ(0, reminder);
1049 ret = DecodeAppSpawnMsg(outMsg);
1050 EXPECT_EQ(0, ret);
1051 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1052 EXPECT_EQ(appCtx != nullptr, 1);
1053 appCtx->message = outMsg;
1054
1055 // get msg ext info
1056 const int inputCount = 5;
1057 const char *inputName[inputCount] = {nullptr, "1", "22", "test-001", ""};
1058 int result[inputCount] = {0, 0, 0, 1, 0 };
1059 for (int i = 0; i < inputCount; i++) {
1060 uint32_t len = 0;
1061 void *info = GetAppPropertyExt(appCtx, inputName[i], &len);
1062 EXPECT_EQ(info != nullptr, result[i]);
1063 }
1064 for (int i = 0; i < inputCount; i++) {
1065 void *info = GetAppPropertyExt(appCtx, inputName[i], nullptr);
1066 EXPECT_EQ(info != nullptr, result[i]);
1067 }
1068 for (int i = 0; i < inputCount; i++) {
1069 uint32_t len = 0;
1070 void *info = GetAppPropertyExt(nullptr, inputName[i], &len);
1071 EXPECT_EQ(info == nullptr, 1);
1072 }
1073 DeleteAppSpawningCtx(appCtx);
1074 DeleteAppSpawnMgr(mgr);
1075 }
1076
1077 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_006, TestSize.Level0)
1078 {
1079 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
1080 EXPECT_EQ(mgr != nullptr, 1);
1081
1082 // get from buffer
1083 AppSpawnTestHelper testHelper;
1084 std::vector<uint8_t> buffer(1024); // 1024 max buffer
1085 uint32_t msgLen = 0;
1086 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
1087 EXPECT_EQ(0, ret);
1088
1089 AppSpawnMsgNode *outMsg = nullptr;
1090 uint32_t msgRecvLen = 0;
1091 uint32_t reminder = 0;
1092 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
1093 EXPECT_EQ(0, ret);
1094 EXPECT_EQ(msgLen, msgRecvLen);
1095 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
1096 EXPECT_EQ(0, reminder);
1097 ret = DecodeAppSpawnMsg(outMsg);
1098 EXPECT_EQ(0, ret);
1099
1100 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1101 EXPECT_EQ(appCtx != nullptr, 1);
1102 appCtx->message = outMsg;
1103
1104 EXPECT_EQ(CheckAppSpawnMsgFlag(outMsg, TLV_MSG_FLAGS, APP_FLAGS_DEVELOPER_MODE), 0);
1105 EXPECT_EQ(SetAppSpawnMsgFlag(outMsg, TLV_MSG_FLAGS, APP_FLAGS_DEVELOPER_MODE), 0);
1106 EXPECT_EQ(CheckAppSpawnMsgFlag(outMsg, TLV_MSG_FLAGS, APP_FLAGS_DEVELOPER_MODE), 1);
1107
1108 DeleteAppSpawningCtx(appCtx);
1109 DeleteAppSpawnMgr(mgr);
1110 }
1111
1112 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_007, TestSize.Level0)
1113 {
1114 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1115 EXPECT_EQ(appCtx != nullptr, 1);
1116
1117 // IsDeveloperModeOn
1118 int ret = IsDeveloperModeOn(appCtx);
1119 EXPECT_EQ(ret, 0);
1120 appCtx->client.flags |= APP_DEVELOPER_MODE;
1121 ret = IsDeveloperModeOn(appCtx);
1122 EXPECT_EQ(ret, 1);
1123 ret = IsDeveloperModeOn(nullptr);
1124 EXPECT_EQ(ret, 0);
1125
1126 //IsJitFortModeOn
1127 ret = IsJitFortModeOn(appCtx);
1128 EXPECT_EQ(ret, 0);
1129 appCtx->client.flags |= APP_JITFORT_MODE;
1130 ret = IsJitFortModeOn(appCtx);
1131 EXPECT_EQ(ret, 1);
1132 ret = IsJitFortModeOn(nullptr);
1133 EXPECT_EQ(ret, 0);
1134
1135 DeleteAppSpawningCtx(appCtx);
1136 }
1137
1138 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_RebuildAppSpawnMsgNode, TestSize.Level0)
1139 {
1140 AppSpawnMsgNode *msgNode = CreateAppSpawnMsg();
1141 EXPECT_EQ(msgNode != nullptr, 1);
1142 int ret = CheckAppSpawnMsg(msgNode);
1143 EXPECT_NE(0, ret); // check fail
1144 AppSpawnedProcess *app = (AppSpawnedProcess *)malloc(sizeof(AppSpawnedProcess) + sizeof(char) * 10);
1145 EXPECT_EQ(app != nullptr, 1);
1146 app->message = (AppSpawnMsgNode *)malloc(sizeof(AppSpawnMsgNode));
1147 EXPECT_EQ(app->message != nullptr, 1);
1148 app->message->msgHeader.tlvCount = 10; // 10 is tlvCount
1149 app->message->msgHeader.msgLen = 200; // 200 is msgLen
1150 ret = strcpy_s(app->message->msgHeader.processName, APP_LEN_PROC_NAME, "test.xxx");
1151 EXPECT_EQ(ret, 0);
1152 ret = strcpy_s(app->name, 10, "test.xxx"); // 10 is appNmae length
1153 EXPECT_EQ(ret, 0);
1154 RebuildAppSpawnMsgNode(msgNode, app);
1155 free(app->message);
1156 free(app);
1157 }
1158
SignalHandle(int sig)1159 static void SignalHandle(int sig)
1160 {
1161 std::cout<<"signal is: "<<sig<<std::endl;
1162 }
1163
1164 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_KillAndWaitStatus, TestSize.Level0)
1165 {
1166 pid_t pid = -1;
1167 int sig = SIGTERM;
1168 int exitStatus;
1169 int ret = KillAndWaitStatus(pid, sig, &exitStatus);
1170 EXPECT_EQ(0, ret);
1171 ret = KillAndWaitStatus(pid, sig, nullptr);
1172 EXPECT_EQ(0, ret);
1173 pid = getpid(); //test pid
1174 signal(SIGTERM, SignalHandle);
1175 ret = KillAndWaitStatus(pid, sig, &exitStatus);
1176 EXPECT_EQ(-1, ret);
1177 }
1178 } // namespace OHOS
1179