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