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
499 ret = DecodeAppSpawnMsg(outMsg);
500 EXPECT_EQ(0, ret);
501 AppSpawnResult result = {};
502 // app exist
503 ret = ProcessTerminationStatusMsg(outMsg, &result);
504 EXPECT_EQ(0, ret);
505
506 ret = ProcessTerminationStatusMsg(nullptr, &result);
507 EXPECT_NE(0, ret);
508
509 ret = ProcessTerminationStatusMsg(outMsg, nullptr);
510 EXPECT_NE(0, ret);
511
512 ret = ProcessTerminationStatusMsg(nullptr, nullptr);
513 EXPECT_NE(0, ret);
514 DeleteAppSpawnMsg(outMsg);
515
516 DeleteAppSpawnMgr(mgr);
517 }
518
519 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_006, TestSize.Level0)
520 {
521 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
522 EXPECT_EQ(mgr != nullptr, 1);
523
524 // get from buffer
525 AppSpawnTestHelper testHelper;
526 std::vector<uint8_t> buffer(1024); // 1024 max buffer
527 uint32_t msgLen = 0;
528 int ret = testHelper.CreateSendMsg(buffer, MSG_GET_RENDER_TERMINATION_STATUS, msgLen, {AddRenderTerminationTlv});
529 EXPECT_EQ(0, ret);
530
531 AppSpawnMsgNode *outMsg = nullptr;
532 uint32_t msgRecvLen = 0;
533 uint32_t reminder = 0;
534 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
535 EXPECT_EQ(0, ret);
536 EXPECT_EQ(msgLen, msgRecvLen);
537 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
538 EXPECT_EQ(0, reminder);
539
540 AppSpawnedProcess *app = AddSpawnedProcess(9999999, "aaaa", false); // 9999999 test
541 EXPECT_EQ(app != nullptr, 1);
542
543 ret = DecodeAppSpawnMsg(outMsg);
544 EXPECT_EQ(0, ret);
545 AppSpawnResult result = {};
546 // die app not exist
547 ret = ProcessTerminationStatusMsg(outMsg, &result);
548 EXPECT_EQ(0, ret);
549
550 DeleteAppSpawnMsg(outMsg);
551 DeleteAppSpawnMgr(mgr);
552 }
553
554 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_007, TestSize.Level0)
555 {
556 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
557 EXPECT_EQ(mgr != nullptr, 1);
558
559 // get from buffer
560 AppSpawnTestHelper testHelper;
561 std::vector<uint8_t> buffer(1024); // 1024 max buffer
562 uint32_t msgLen = 0;
563 int ret = testHelper.CreateSendMsg(buffer, MSG_GET_RENDER_TERMINATION_STATUS, msgLen, {AddRenderTerminationTlv});
564 EXPECT_EQ(0, ret);
565
566 AppSpawnMsgNode *outMsg = nullptr;
567 uint32_t msgRecvLen = 0;
568 uint32_t reminder = 0;
569 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
570 EXPECT_EQ(0, ret);
571 EXPECT_EQ(msgLen, msgRecvLen);
572 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
573 EXPECT_EQ(0, reminder);
574
575 ret = DecodeAppSpawnMsg(outMsg);
576 EXPECT_EQ(0, ret);
577 AppSpawnResult result = {};
578 // app not exist
579 ret = ProcessTerminationStatusMsg(outMsg, &result);
580 EXPECT_EQ(0, ret);
581
582 DeleteAppSpawnMsg(outMsg);
583 DeleteAppSpawnMgr(mgr);
584 }
585
586 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsgNode_008, TestSize.Level0)
587 {
588 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
589 EXPECT_EQ(mgr != nullptr, 1);
590
591 // get from buffer
592 AppSpawnTestHelper testHelper;
593 std::vector<uint8_t> buffer(1024); // 1024 max buffer
594 uint32_t msgLen = 0;
595 int ret = testHelper.CreateSendMsg(buffer, MSG_DUMP, msgLen, {});
596 EXPECT_EQ(0, ret);
597
598 AppSpawnMsgNode *outMsg = nullptr;
599 uint32_t msgRecvLen = 0;
600 uint32_t reminder = 0;
601 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
602 EXPECT_EQ(0, ret);
603 EXPECT_EQ(msgLen, msgRecvLen);
604 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
605 EXPECT_EQ(0, reminder);
606
607 ret = DecodeAppSpawnMsg(outMsg);
608 EXPECT_EQ(0, ret);
609
610 ProcessAppSpawnDumpMsg(outMsg);
611 ProcessAppSpawnDumpMsg(nullptr);
612
613 DeleteAppSpawnMsg(outMsg);
614 DeleteAppSpawnMgr(mgr);
615 }
616
617 /**
618 * @brief 消息内容操作接口
619 *
620 */
621 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_001, TestSize.Level0)
622 {
623 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
624 EXPECT_EQ(mgr != nullptr, 1);
625
626 // get from buffer
627 AppSpawnTestHelper testHelper;
628 std::vector<uint8_t> buffer(1024); // 1024 max buffer
629 uint32_t msgLen = 0;
630 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
631 EXPECT_EQ(0, ret);
632
633 AppSpawnMsgNode *outMsg = nullptr;
634 uint32_t msgRecvLen = 0;
635 uint32_t reminder = 0;
636 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
637 EXPECT_EQ(0, ret);
638 EXPECT_EQ(msgLen, msgRecvLen);
639 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
640 EXPECT_EQ(0, reminder);
641 ret = DecodeAppSpawnMsg(outMsg);
642 EXPECT_EQ(0, ret);
643
644 // get msg info
645 int inputTlv[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, TLV_MAX, TLV_MAX + 1, TLV_MAX + 2, -1}; // 13 test
646 int result[13] = {1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0}; // 13 test
647 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
648 void *info = GetAppSpawnMsgInfo(outMsg, i);
649 EXPECT_EQ(info != nullptr, result[i]);
650 }
651
652 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
653 void *info = GetAppSpawnMsgInfo(nullptr, i);
654 EXPECT_EQ(info == nullptr, 1);
655 }
656 DeleteAppSpawnMsg(outMsg);
657 DeleteAppSpawnMgr(mgr);
658 }
659
AddTest001ExtTlv(uint8_t * buffer,uint32_t bufferLen,uint32_t & realLen,uint32_t & tlvCount)660 static int AddTest001ExtTlv(uint8_t *buffer, uint32_t bufferLen, uint32_t &realLen, uint32_t &tlvCount)
661 {
662 const char *testData = "555555555555555555555555555";
663 uint32_t currLen = 0;
664 AppSpawnTlvExt tlv = {};
665 tlv.tlvType = TLV_MAX;
666 int ret = strcpy_s(tlv.tlvName, sizeof(tlv.tlvName), "test-001");
667 APPSPAWN_CHECK(ret == 0, return -1, "Failed to strcpy");
668 tlv.dataLen = strlen(testData) + 1;
669 tlv.tlvLen = sizeof(AppSpawnTlvExt) + APPSPAWN_ALIGN(tlv.dataLen);
670
671 ret = memcpy_s(buffer, bufferLen, &tlv, sizeof(tlv));
672 APPSPAWN_CHECK(ret == 0, return -1, "Failed to memcpy_s bufferSize");
673 ret = memcpy_s(buffer + sizeof(tlv), bufferLen - sizeof(tlv), testData, tlv.dataLen + 1);
674 APPSPAWN_CHECK(ret == 0, return -1, "Failed to memcpy_s bufferSize");
675 currLen += tlv.tlvLen;
676 tlvCount++;
677 realLen = currLen;
678 return 0;
679 }
680
681 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_002, TestSize.Level0)
682 {
683 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
684 EXPECT_EQ(mgr != nullptr, 1);
685
686 // get from buffer
687 AppSpawnTestHelper testHelper;
688 std::vector<uint8_t> buffer(1024 * 2); // 1024 * 2 max buffer
689 uint32_t msgLen = 0;
690 int ret = testHelper.CreateSendMsg(buffer,
691 MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv, AddTest001ExtTlv});
692 EXPECT_EQ(0, ret);
693
694 AppSpawnMsgNode *outMsg = nullptr;
695 uint32_t msgRecvLen = 0;
696 uint32_t reminder = 0;
697 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
698 EXPECT_EQ(0, ret);
699 EXPECT_EQ(msgLen, msgRecvLen);
700 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
701 EXPECT_EQ(0, reminder);
702 ret = DecodeAppSpawnMsg(outMsg);
703 EXPECT_EQ(0, ret);
704
705 // get msg ext info
706 const int inputCount = 5;
707 const char *inputName[inputCount] = {nullptr, "1", "22", "test-001", ""};
708 int result[inputCount] = {0, 0, 0, 1, 0 };
709 for (int i = 0; i < inputCount; i++) {
710 uint32_t len = 0;
711 void *info = GetAppSpawnMsgExtInfo(outMsg, inputName[i], &len);
712 EXPECT_EQ(info != nullptr, result[i]);
713 }
714 for (int i = 0; i < inputCount; i++) {
715 void *info = GetAppSpawnMsgExtInfo(outMsg, inputName[i], nullptr);
716 EXPECT_EQ(info != nullptr, result[i]);
717 }
718 for (int i = 0; i < inputCount; i++) {
719 uint32_t len = 0;
720 void *info = GetAppSpawnMsgExtInfo(nullptr, inputName[i], &len);
721 EXPECT_EQ(info == nullptr, 1);
722 }
723 DeleteAppSpawnMsg(outMsg);
724 DeleteAppSpawnMgr(mgr);
725 }
726
727 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_003, TestSize.Level0)
728 {
729 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
730 EXPECT_EQ(mgr != nullptr, 1);
731
732 // get from buffer
733 AppSpawnTestHelper testHelper;
734 std::vector<uint8_t> buffer(1024); // 1024 max buffer
735 uint32_t msgLen = 0;
736 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
737 EXPECT_EQ(0, ret);
738
739 AppSpawnMsgNode *outMsg = nullptr;
740 uint32_t msgRecvLen = 0;
741 uint32_t reminder = 0;
742 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
743 EXPECT_EQ(0, ret);
744 EXPECT_EQ(msgLen, msgRecvLen);
745 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
746 EXPECT_EQ(0, reminder);
747 ret = DecodeAppSpawnMsg(outMsg);
748 EXPECT_EQ(0, ret);
749
750 const int inputCount = 4;
751 uint32_t inputType[inputCount] = {0, TLV_MSG_FLAGS, TLV_PERMISSION, TLV_MAX};
752 int result[inputCount] = {0, 1, 1, 0};
753
754 for (int i = 0; i < inputCount; i++) {
755 for (int j = 0; j < 32; j++) { // max index 32
756 ret = SetAppSpawnMsgFlag(outMsg, inputType[i], j);
757 EXPECT_EQ(result[i], ret == 0);
758 ret = CheckAppSpawnMsgFlag(outMsg, inputType[i], j);
759 EXPECT_EQ(result[i], ret);
760 }
761 }
762 for (int i = 0; i < inputCount; i++) {
763 for (int j = 32; j < MAX_FLAGS_INDEX + 5; j++) { // 5 test
764 ret = SetAppSpawnMsgFlag(outMsg, inputType[i], j);
765 EXPECT_EQ(0, ret == 0);
766 ret = CheckAppSpawnMsgFlag(outMsg, inputType[i], j);
767 EXPECT_EQ(0, ret);
768 }
769 }
770 for (int i = 0; i < inputCount; i++) {
771 for (int j = 0; j < MAX_FLAGS_INDEX; j++) {
772 ret = SetAppSpawnMsgFlag(nullptr, inputType[i], j);
773 EXPECT_EQ(0, ret == 0);
774 ret = CheckAppSpawnMsgFlag(nullptr, inputType[i], j);
775 EXPECT_EQ(0, ret);
776 }
777 }
778 DeleteAppSpawnMsg(outMsg);
779 DeleteAppSpawnMgr(mgr);
780 }
781
782 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawnMsg_004, TestSize.Level0)
783 {
784 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
785 EXPECT_EQ(mgr != nullptr, 1);
786
787 // get from buffer
788 AppSpawnTestHelper testHelper;
789 std::vector<uint8_t> buffer(1024); // 1024 max buffer
790 uint32_t msgLen = 0;
791 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
792 EXPECT_EQ(0, ret);
793
794 AppSpawnMsgNode *outMsg = nullptr;
795 uint32_t msgRecvLen = 0;
796 uint32_t reminder = 0;
797 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
798 EXPECT_EQ(0, ret);
799 EXPECT_EQ(msgLen, msgRecvLen);
800 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
801 EXPECT_EQ(0, reminder);
802 ret = DecodeAppSpawnMsg(outMsg);
803 EXPECT_EQ(0, ret);
804
805 // dump msg
806 DumpAppSpawnMsg(outMsg);
807 DumpAppSpawnMsg(nullptr);
808 DeleteAppSpawnMsg(outMsg);
809 DeleteAppSpawnMgr(mgr);
810 }
811
812 /**
813 * @brief AppSpawningCtx AppSpawnMsg
814 *
815 */
816 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_001, TestSize.Level0)
817 {
818 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
819 EXPECT_EQ(mgr != nullptr, 1);
820
821 // get from buffer
822 AppSpawnTestHelper testHelper;
823 std::vector<uint8_t> buffer(1024); // 1024 max buffer
824 uint32_t msgLen = 0;
825 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
826 EXPECT_EQ(0, ret);
827
828 AppSpawnMsgNode *outMsg = nullptr;
829 uint32_t msgRecvLen = 0;
830 uint32_t reminder = 0;
831 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
832 EXPECT_EQ(0, ret);
833 EXPECT_EQ(msgLen, msgRecvLen);
834 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
835 EXPECT_EQ(0, reminder);
836 ret = DecodeAppSpawnMsg(outMsg);
837 EXPECT_EQ(0, ret);
838
839 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
840 EXPECT_EQ(appCtx != nullptr, 1);
841 appCtx->message = outMsg;
842 int msgType = GetAppSpawnMsgType(appCtx);
843 EXPECT_EQ(msgType, MSG_APP_SPAWN);
844 outMsg->msgHeader.msgType = MSG_GET_RENDER_TERMINATION_STATUS;
845 msgType = GetAppSpawnMsgType(appCtx);
846 EXPECT_EQ(msgType, MSG_GET_RENDER_TERMINATION_STATUS);
847 outMsg->msgHeader.msgType = MSG_SPAWN_NATIVE_PROCESS;
848 msgType = GetAppSpawnMsgType(appCtx);
849 EXPECT_EQ(msgType, MSG_SPAWN_NATIVE_PROCESS);
850 msgType = GetAppSpawnMsgType(nullptr);
851 EXPECT_EQ(msgType, MAX_TYPE_INVALID);
852
853 // GetBundleName
854 const char *bundleName = GetBundleName(appCtx);
855 EXPECT_NE(nullptr, bundleName);
856 bundleName = GetBundleName(nullptr);
857 EXPECT_EQ(nullptr, bundleName);
858
859 DeleteAppSpawningCtx(appCtx);
860 DeleteAppSpawnMgr(mgr);
861 }
862
863 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_002, TestSize.Level0)
864 {
865 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
866 EXPECT_EQ(mgr != nullptr, 1);
867
868 // get from buffer
869 AppSpawnTestHelper testHelper;
870 std::vector<uint8_t> buffer(1024); // 1024 max buffer
871 uint32_t msgLen = 0;
872 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
873 EXPECT_EQ(0, ret);
874
875 AppSpawnMsgNode *outMsg = nullptr;
876 uint32_t msgRecvLen = 0;
877 uint32_t reminder = 0;
878 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
879 EXPECT_EQ(0, ret);
880 EXPECT_EQ(msgLen, msgRecvLen);
881 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
882 EXPECT_EQ(0, reminder);
883 ret = DecodeAppSpawnMsg(outMsg);
884 EXPECT_EQ(0, ret);
885
886 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
887 EXPECT_EQ(appCtx != nullptr, 1);
888 appCtx->message = outMsg;
889
890 // GetBundleName
891 const char *name = GetProcessName(appCtx);
892 EXPECT_NE(nullptr, name);
893 name = GetProcessName(nullptr);
894 EXPECT_EQ(nullptr, name);
895
896 DeleteAppSpawningCtx(appCtx);
897 DeleteAppSpawnMgr(mgr);
898 }
899
900 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_003, TestSize.Level0)
901 {
902 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
903 EXPECT_EQ(mgr != nullptr, 1);
904
905 // get from buffer
906 AppSpawnTestHelper testHelper;
907 std::vector<uint8_t> buffer(1024); // 1024 max buffer
908 uint32_t msgLen = 0;
909 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
910 EXPECT_EQ(0, ret);
911
912 AppSpawnMsgNode *outMsg = nullptr;
913 uint32_t msgRecvLen = 0;
914 uint32_t reminder = 0;
915 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
916 EXPECT_EQ(0, ret);
917 EXPECT_EQ(msgLen, msgRecvLen);
918 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
919 EXPECT_EQ(0, reminder);
920 ret = DecodeAppSpawnMsg(outMsg);
921 EXPECT_EQ(0, ret);
922 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
923 EXPECT_EQ(appCtx != nullptr, 1);
924 appCtx->message = outMsg;
925
926 for (int j = 0; j < 32; j++) { // max index 32
927 ret = SetAppPermissionFlags(appCtx, j);
928 EXPECT_EQ(1, ret == 0);
929 ret = CheckAppPermissionFlagSet(appCtx, j);
930 EXPECT_EQ(1, ret);
931 }
932 for (int j = 32; j < MAX_FLAGS_INDEX + 5; j++) { // 32 5 test
933 ret = SetAppPermissionFlags(appCtx, j);
934 EXPECT_NE(0, ret);
935 ret = CheckAppPermissionFlagSet(appCtx, j);
936 EXPECT_EQ(0, ret);
937 }
938 for (int j = 0; j < MAX_FLAGS_INDEX; j++) {
939 ret = SetAppPermissionFlags(nullptr, j);
940 EXPECT_NE(0, ret);
941 ret = CheckAppPermissionFlagSet(nullptr, j);
942 EXPECT_EQ(0, ret);
943 }
944 uint32_t result[MAX_FLAGS_INDEX] = {0};
945 result[0] = 0;
946 result[1] = 1;
947 result[3] = 1;
948 for (int j = 0; j < MAX_FLAGS_INDEX; j++) {
949 ret = CheckAppMsgFlagsSet(appCtx, j);
950 EXPECT_EQ(result[j], ret);
951 }
952 DeleteAppSpawningCtx(appCtx);
953 DeleteAppSpawnMgr(mgr);
954 }
955
956 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_004, TestSize.Level0)
957 {
958 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
959 EXPECT_EQ(mgr != nullptr, 1);
960
961 // get from buffer
962 AppSpawnTestHelper testHelper;
963 std::vector<uint8_t> buffer(1024); // 1024 max buffer
964 uint32_t msgLen = 0;
965 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
966 EXPECT_EQ(0, ret);
967
968 AppSpawnMsgNode *outMsg = nullptr;
969 uint32_t msgRecvLen = 0;
970 uint32_t reminder = 0;
971 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
972 EXPECT_EQ(0, ret);
973 EXPECT_EQ(msgLen, msgRecvLen);
974 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
975 EXPECT_EQ(0, reminder);
976 ret = DecodeAppSpawnMsg(outMsg);
977 EXPECT_EQ(0, ret);
978 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
979 EXPECT_EQ(appCtx != nullptr, 1);
980 appCtx->message = outMsg;
981
982 // get msg info
983 int inputTlv[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, TLV_MAX, TLV_MAX + 1, TLV_MAX + 2, -1}; // 13 test
984 int result[13] = {1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0}; // 13 test
985 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
986 void *info = GetAppProperty(appCtx, i);
987 EXPECT_EQ(info != nullptr, result[i]);
988 }
989
990 for (size_t i = 0; i < ARRAY_LENGTH(inputTlv); i++) {
991 void *info = GetAppProperty(nullptr, i);
992 EXPECT_EQ(info == nullptr, 1);
993 }
994 DeleteAppSpawningCtx(appCtx);
995 DeleteAppSpawnMgr(mgr);
996 }
997
998 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_005, TestSize.Level0)
999 {
1000 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
1001 EXPECT_EQ(mgr != nullptr, 1);
1002
1003 // get from buffer
1004 AppSpawnTestHelper testHelper;
1005 std::vector<uint8_t> buffer(1024 * 2); // 1024 * 2 max buffer
1006 uint32_t msgLen = 0;
1007 int ret = testHelper.CreateSendMsg(buffer,
1008 MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv, AddTest001ExtTlv});
1009 EXPECT_EQ(0, ret);
1010
1011 AppSpawnMsgNode *outMsg = nullptr;
1012 uint32_t msgRecvLen = 0;
1013 uint32_t reminder = 0;
1014 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
1015 EXPECT_EQ(0, ret);
1016 EXPECT_EQ(msgLen, msgRecvLen);
1017 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
1018 EXPECT_EQ(0, reminder);
1019 ret = DecodeAppSpawnMsg(outMsg);
1020 EXPECT_EQ(0, ret);
1021 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1022 EXPECT_EQ(appCtx != nullptr, 1);
1023 appCtx->message = outMsg;
1024
1025 // get msg ext info
1026 const int inputCount = 5;
1027 const char *inputName[inputCount] = {nullptr, "1", "22", "test-001", ""};
1028 int result[inputCount] = {0, 0, 0, 1, 0 };
1029 for (int i = 0; i < inputCount; i++) {
1030 uint32_t len = 0;
1031 void *info = GetAppPropertyExt(appCtx, inputName[i], &len);
1032 EXPECT_EQ(info != nullptr, result[i]);
1033 }
1034 for (int i = 0; i < inputCount; i++) {
1035 void *info = GetAppPropertyExt(appCtx, inputName[i], nullptr);
1036 EXPECT_EQ(info != nullptr, result[i]);
1037 }
1038 for (int i = 0; i < inputCount; i++) {
1039 uint32_t len = 0;
1040 void *info = GetAppPropertyExt(nullptr, inputName[i], &len);
1041 EXPECT_EQ(info == nullptr, 1);
1042 }
1043 DeleteAppSpawningCtx(appCtx);
1044 DeleteAppSpawnMgr(mgr);
1045 }
1046
1047 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_006, TestSize.Level0)
1048 {
1049 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
1050 EXPECT_EQ(mgr != nullptr, 1);
1051
1052 // get from buffer
1053 AppSpawnTestHelper testHelper;
1054 std::vector<uint8_t> buffer(1024); // 1024 max buffer
1055 uint32_t msgLen = 0;
1056 int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
1057 EXPECT_EQ(0, ret);
1058
1059 AppSpawnMsgNode *outMsg = nullptr;
1060 uint32_t msgRecvLen = 0;
1061 uint32_t reminder = 0;
1062 ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
1063 EXPECT_EQ(0, ret);
1064 EXPECT_EQ(msgLen, msgRecvLen);
1065 EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
1066 EXPECT_EQ(0, reminder);
1067 ret = DecodeAppSpawnMsg(outMsg);
1068 EXPECT_EQ(0, ret);
1069
1070 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1071 EXPECT_EQ(appCtx != nullptr, 1);
1072 appCtx->message = outMsg;
1073
1074 EXPECT_EQ(CheckAppSpawnMsgFlag(outMsg, TLV_MSG_FLAGS, APP_FLAGS_DEVELOPER_MODE), 0);
1075 EXPECT_EQ(SetAppSpawnMsgFlag(outMsg, TLV_MSG_FLAGS, APP_FLAGS_DEVELOPER_MODE), 0);
1076 EXPECT_EQ(CheckAppSpawnMsgFlag(outMsg, TLV_MSG_FLAGS, APP_FLAGS_DEVELOPER_MODE), 1);
1077
1078 DeleteAppSpawningCtx(appCtx);
1079 DeleteAppSpawnMgr(mgr);
1080 }
1081
1082 HWTEST_F(AppSpawnAppMgrTest, App_Spawn_AppSpawningCtx_Msg_007, TestSize.Level0)
1083 {
1084 AppSpawningCtx *appCtx = CreateAppSpawningCtx();
1085 EXPECT_EQ(appCtx != nullptr, 1);
1086
1087 // IsDeveloperModeOn
1088 int ret = IsDeveloperModeOn(appCtx);
1089 EXPECT_EQ(ret, 0);
1090 appCtx->client.flags |= APP_DEVELOPER_MODE;
1091 ret = IsDeveloperModeOn(appCtx);
1092 EXPECT_EQ(ret, 1);
1093 ret = IsDeveloperModeOn(nullptr);
1094 EXPECT_EQ(ret, 0);
1095
1096 //IsJitFortModeOn
1097 ret = IsJitFortModeOn(appCtx);
1098 EXPECT_EQ(ret, 0);
1099 appCtx->client.flags |= APP_JITFORT_MODE;
1100 ret = IsJitFortModeOn(appCtx);
1101 EXPECT_EQ(ret, 1);
1102 ret = IsJitFortModeOn(nullptr);
1103 EXPECT_EQ(ret, 0);
1104
1105 DeleteAppSpawningCtx(appCtx);
1106 }
1107 } // namespace OHOS