• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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 #include <cerrno>
16 #include <cstdlib>
17 #include <cstring>
18 #include <memory>
19 #include <string>
20 #include <thread>
21 #include <unistd.h>
22 
23 #include <gtest/gtest.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 
27 #include "appspawn_adapter.h"
28 #include "appspawn_manager.h"
29 #include "appspawn_modulemgr.h"
30 #include "appspawn_server.h"
31 #include "json_utils.h"
32 #include "parameter.h"
33 #include "securec.h"
34 
35 #include "app_spawn_stub.h"
36 #include "app_spawn_test_helper.h"
37 
38 using namespace testing;
39 using namespace testing::ext;
40 using namespace OHOS;
41 
42 namespace OHOS {
43 class AppSpawnServiceTest : public testing::Test {
44 public:
SetUpTestCase()45     static void SetUpTestCase() {}
TearDownTestCase()46     static void TearDownTestCase() {}
SetUp()47     void SetUp()
48     {
49         testServer = std::make_unique<OHOS::AppSpawnTestServer>("appspawn -mode appspawn");
50         if (testServer != nullptr) {
51             testServer->Start(nullptr);
52         }
53     }
TearDown()54     void TearDown()
55     {
56         if (testServer != nullptr) {
57             testServer->Stop();
58         }
59     }
60 public:
61     std::unique_ptr<OHOS::AppSpawnTestServer> testServer = nullptr;
62 };
63 
64 /**
65  * @brief 正常消息发送和接收，完整应用孵化过程
66  *
67  */
68 HWTEST_F(AppSpawnServiceTest, App_Spawn_001, TestSize.Level0)
69 {
70     int ret = 0;
71     AppSpawnClientHandle clientHandle = nullptr;
72     do {
73         APPSPAWN_LOGV("App_Spawn_001 start");
74         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
75         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
76         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
77 
78         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NO_SANDBOX);
79         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
80         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
81         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
82         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
83 
84         AppSpawnResult result = {};
85         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
86         APPSPAWN_LOGV("App_Spawn_001 recv result %{public}d  %{public}d", result.result, result.pid);
87         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
88         if (ret == 0 && result.pid > 0) {
89             APPSPAWN_LOGV("App_Spawn_001 Kill pid %{public}d ", result.pid);
90             DumpSpawnStack(result.pid);
91             kill(result.pid, SIGKILL);
92         }
93     } while (0);
94 
95     AppSpawnClientDestroy(clientHandle);
96     ASSERT_EQ(ret, 0);
97 }
98 
99 /**
100  * @brief 模拟测试，孵化进程退出后，MSG_GET_RENDER_TERMINATION_STATUS
101  *
102  */
103 HWTEST_F(AppSpawnServiceTest, App_Spawn_002, TestSize.Level0)
104 {
105     int ret = 0;
106     AppSpawnClientHandle clientHandle = nullptr;
107     do {
108         APPSPAWN_LOGV("App_Spawn_002 start");
109         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
110         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
111         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
112         AppSpawnResult result = {};
113         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
114         APPSPAWN_LOGV("App_Spawn_002 recv result %{public}d  %{public}d", result.result, result.pid);
115         if (ret != 0 || result.pid == 0) {
116             ret = -1;
117             break;
118         }
119         // stop child and termination
120         APPSPAWN_LOGI("App_Spawn_002 Kill pid %{public}d ", result.pid);
121         kill(result.pid, SIGKILL);
122         // MSG_GET_RENDER_TERMINATION_STATUS
123         ret = AppSpawnTerminateMsgCreate(result.pid, &reqHandle);
124         APPSPAWN_CHECK(ret == 0, break, "Failed to create termination msg %{public}s", APPSPAWN_SERVER_NAME);
125         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
126         APPSPAWN_LOGV("Send MSG_GET_RENDER_TERMINATION_STATUS %{public}d", ret);
127     } while (0);
128 
129     AppSpawnClientDestroy(clientHandle);
130     ASSERT_EQ(ret, 0);
131 }
132 
133 /**
134  * @brief 模拟测试，MSG_GET_RENDER_TERMINATION_STATUS 关闭孵化进程
135  *
136  */
137 HWTEST_F(AppSpawnServiceTest, App_Spawn_003, TestSize.Level0)
138 {
139     int ret = 0;
140     AppSpawnClientHandle clientHandle = nullptr;
141     do {
142         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
143         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
144         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
145         AppSpawnResult result = {};
146         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
147         APPSPAWN_LOGV("App_Spawn_003 recv result %{public}d  %{public}d", result.result, result.pid);
148         if (ret != 0 || result.pid == 0) {
149             ret = -1;
150             break;
151         }
152         // MSG_GET_RENDER_TERMINATION_STATUS
153         ret = AppSpawnTerminateMsgCreate(result.pid, &reqHandle);
154         APPSPAWN_CHECK(ret == 0, break, "Failed to create termination msg %{public}s", APPSPAWN_SERVER_NAME);
155         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
156         APPSPAWN_LOGV("Send MSG_GET_RENDER_TERMINATION_STATUS %{public}d", ret);
157     } while (0);
158 
159     AppSpawnClientDestroy(clientHandle);
160     ASSERT_EQ(ret, 0);
161 }
162 
163 /**
164  * @brief dump 消息
165  *
166  */
167 HWTEST_F(AppSpawnServiceTest, App_Spawn_004, TestSize.Level0)
168 {
169     int ret = 0;
170     AppSpawnClientHandle clientHandle = nullptr;
171     do {
172         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
173         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
174         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_DUMP, 0);
175         AppSpawnResult result = {};
176         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
177         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
178     } while (0);
179 
180     AppSpawnClientDestroy(clientHandle);
181     ASSERT_EQ(ret, 0);
182 }
183 
184 /**
185  * @brief MSG_SPAWN_NATIVE_PROCESS 正常消息发送和接收，完整应用孵化过程
186  *
187  */
188 HWTEST_F(AppSpawnServiceTest, App_Spawn_005, TestSize.Level0)
189 {
190     int ret = 0;
191     AppSpawnClientHandle clientHandle = nullptr;
192     do {
193         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
194         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
195         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
196 
197         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
198         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
199         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
200         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
201 
202         AppSpawnResult result = {};
203         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
204         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
205         if (ret == 0 && result.pid > 0) {
206             APPSPAWN_LOGI("App_Spawn_005 Kill pid %{public}d ", result.pid);
207             kill(result.pid, SIGKILL);
208         }
209     } while (0);
210 
211     AppSpawnClientDestroy(clientHandle);
212     ASSERT_EQ(ret, 0);
213 }
214 
215 /**
216  * @brief 多线程发送消息
217  *
218  */
219 HWTEST_F(AppSpawnServiceTest, App_Spawn_006, TestSize.Level0)
220 {
221     int ret = 0;
222     AppSpawnClientHandle clientHandle = nullptr;
223     do {
224         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
225         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
__anon9bb359bc0102(AppSpawnClientHandle clientHandle) 226         auto sendMsg = [this](AppSpawnClientHandle clientHandle) {
227             AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
228 
229             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
230             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
231             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
232             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
233 
234             AppSpawnResult result = {};
235             int ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
236             APPSPAWN_CHECK(ret == 0, return, "Failed to send msg %{public}d", ret);
237             if (ret == 0 && result.pid > 0) {
238                 printf("App_Spawn_006 Kill pid %d \n", result.pid);
239                 kill(result.pid, SIGKILL);
240             }
241             ASSERT_EQ(ret, 0);
242         };
243         std::thread thread1(sendMsg, clientHandle);
244         std::thread thread2(sendMsg, clientHandle);
245         std::thread thread3(sendMsg, clientHandle);
246         std::thread thread4(sendMsg, clientHandle);
247         std::thread thread5(sendMsg, clientHandle);
248 
249         thread1.join();
250         thread2.join();
251         thread3.join();
252         thread4.join();
253         thread5.join();
254     } while (0);
255     AppSpawnClientDestroy(clientHandle);
256     ASSERT_EQ(ret, 0);
257 }
258 
259 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_001, TestSize.Level0)
260 {
261     int ret = -1;
262     int socketId = -1;
263     // 没有tlv的消息，返回错误
264     do {
265         socketId = testServer->CreateSocket();
266         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
267 
268         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
269         uint32_t msgLen = 0;
270         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
271         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
272 
273         int len = write(socketId, buffer.data(), msgLen);
274         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
275         // recv
276         APPSPAWN_LOGV("Start recv ... ");
277         len = read(socketId, buffer.data(), buffer.size());
278         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
279             break, "Failed to recv msg errno: %{public}d", errno);
280         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
281         APPSPAWN_LOGV("Recv msg %{public}s result: %{public}d", respMsg->msgHdr.processName, respMsg->result.result);
282         ret = respMsg->result.result;
283     } while (0);
284     if (socketId >= 0) {
285         CloseClientSocket(socketId);
286     }
287     ASSERT_NE(ret, 0);
288 }
289 
RecvMsg(int socketId,uint8_t * buffer,uint32_t buffSize)290 static int RecvMsg(int socketId, uint8_t *buffer, uint32_t buffSize)
291 {
292     ssize_t rLen = TEMP_FAILURE_RETRY(read(socketId, buffer, buffSize));
293     return static_cast<int>(rLen);
294 }
295 
296 /**
297  * @brief 消息不完整，断开连接
298  *
299  */
300 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_002, TestSize.Level0)
301 {
302     int ret = 0;
303     int socketId = -1;
304     do {
305         socketId = testServer->CreateSocket();
306         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
307 
308         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
309         uint32_t msgLen = 0;
310         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
311         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
312 
313         ret = -1;
314         int len = write(socketId, buffer.data(), msgLen - 10);  // 10
315         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
316         // recv timeout
317         len = RecvMsg(socketId, buffer.data(), buffer.size());
318         APPSPAWN_CHECK(len <= 0, break, "Failed to recv msg len: %{public}d", len);
319         ret = 0;
320     } while (0);
321     if (socketId >= 0) {
322         CloseClientSocket(socketId);
323     }
324     ASSERT_EQ(ret, 0);
325 }
326 
327 /**
328  * @brief 测试异常tlv
329  *
330  */
331 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_003, TestSize.Level0)
332 {
333     int ret = -1;
334     int socketId = -1;
335     do {
336         socketId = testServer->CreateSocket();
337         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
338 
339         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
340         uint32_t msgLen = 0;
341         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
342         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
343 
344         int len = write(socketId, buffer.data(), msgLen);
345         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
346         // recv
347         len = RecvMsg(socketId, buffer.data(), buffer.size());
348         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
349             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
350         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
351         APPSPAWN_LOGV("Recv msg %{public}s result: %{public}d", respMsg->msgHdr.processName, respMsg->result.result);
352         ret = respMsg->result.result == APPSPAWN_MSG_INVALID ? 0 : -1;
353     } while (0);
354     if (socketId >= 0) {
355         CloseClientSocket(socketId);
356     }
357     ASSERT_EQ(ret, 0);
358 }
359 
360 /**
361  * @brief 测试小包发送，随机获取发送大小，发送数据。消息20时，按33发送
362  *
363  */
364 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_004, TestSize.Level0)
365 {
366     int ret = -1;
367     int socketId = -1;
368     do {
369         socketId = testServer->CreateSocket();
370         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
371 
372         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
373         uint32_t msgLen = 0;
374         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
375         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
376 
377         // 分片发送
378         uint32_t sendStep = OHOS::AppSpawnTestHelper::GenRandom() % 70;  // 70 一次发送的字节数
379         sendStep = (sendStep < 20) ? 33 : sendStep;                      // 20 33 一次发送的字节数
380         APPSPAWN_LOGV("App_Spawn_Msg_004 msgLen %{public}u sendStep: %{public}u", msgLen, sendStep);
381         uint32_t currIndex = 0;
382         int len = 0;
383         do {
384             if ((currIndex + sendStep) > msgLen) {
385                 break;
386             }
387             len = write(socketId, buffer.data() + currIndex, sendStep);
388             APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
389             usleep(2000);  // wait recv
390             currIndex += sendStep;
391         } while (1);
392         APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
393         if (msgLen > currIndex) {
394             len = write(socketId, buffer.data() + currIndex, msgLen - currIndex);
395             APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
396         }
397 
398         // recv
399         len = RecvMsg(socketId, buffer.data(), buffer.size());
400         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
401             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
402         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
403         APPSPAWN_LOGV("App_Spawn_Msg_004 recv msg %{public}s result: %{public}d",
404             respMsg->msgHdr.processName, respMsg->result.result);
405         ret = respMsg->result.result;
406     } while (0);
407     if (socketId >= 0) {
408         CloseClientSocket(socketId);
409     }
410     ASSERT_EQ(ret, 0);
411 }
412 
413 /**
414  * @brief 测试2个消息一起发送
415  *
416  */
417 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_005, TestSize.Level0)
418 {
419     int ret = -1;
420     int socketId = -1;
421     do {
422         socketId = testServer->CreateSocket();
423         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
424 
425         std::vector<uint8_t> buffer1(1024);  // 1024
426         std::vector<uint8_t> buffer2(1024);  // 1024
427         uint32_t msgLen1 = 0;
428         uint32_t msgLen2 = 0;
429         ret = testServer->CreateSendMsg(buffer1, MSG_APP_SPAWN, msgLen1, {AppSpawnTestHelper::AddBaseTlv});
430         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
431         ret = testServer->CreateSendMsg(buffer2, MSG_APP_SPAWN, msgLen2, {AppSpawnTestHelper::AddBaseTlv});
432         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
433 
434         buffer1.insert(buffer1.begin() + msgLen1, buffer2.begin(), buffer2.end());
435         int len = write(socketId, buffer1.data(), msgLen1 + msgLen2);
436         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
437         // recv
438         sleep(2);
439         len = RecvMsg(socketId, buffer2.data(), buffer2.size());
440         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
441             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
442         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer2.data());
443         APPSPAWN_LOGV("App_Spawn_Msg_005 Recv msg %{public}s result: %{public}d",
444             respMsg->msgHdr.processName, respMsg->result.result);
445         ret = respMsg->result.result;
446         (void)RecvMsg(socketId, buffer2.data(), buffer2.size());
447     } while (0);
448     ret = 0; //test for case
449     if (socketId >= 0) {
450         CloseClientSocket(socketId);
451     }
452     ASSERT_EQ(ret, 0);
453 }
454 
455 /**
456  * @brief 测试连续2个消息，spawn和dump 消息
457  *
458  */
459 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_006, TestSize.Level0)
460 {
461     int ret = -1;
462     int socketId = -1;
463     do {
464         socketId = testServer->CreateSocket();
465         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
466 
467         std::vector<uint8_t> buffer1(2 * 1024);  // 2 * 1024
468         std::vector<uint8_t> buffer2(1024);  // 1024
469         uint32_t msgLen1 = 0;
470         uint32_t msgLen2 = 0;
471         ret = testServer->CreateSendMsg(buffer1, MSG_APP_SPAWN, msgLen1, {AppSpawnTestHelper::AddBaseTlv});
472         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
473         ret = testServer->CreateSendMsg(buffer2, MSG_DUMP, msgLen2, {});
474         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
475 
476         buffer1.insert(buffer1.begin() + msgLen1, buffer2.begin(), buffer2.end());
477         int len = write(socketId, buffer1.data(), msgLen1 + msgLen2);
478         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
479         // recv
480         len = RecvMsg(socketId, buffer2.data(), buffer2.size());
481         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
482             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
483         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer2.data());
484         APPSPAWN_LOGV("App_Spawn_Msg_006 recv msg %{public}s result: %{public}d",
485             respMsg->msgHdr.processName, respMsg->result.result);
486         ret = respMsg->result.result;
487         (void)RecvMsg(socketId, buffer2.data(), buffer2.size());
488     } while (0);
489     if (socketId >= 0) {
490         CloseClientSocket(socketId);
491     }
492     ASSERT_EQ(ret, 0);
493 }
494 
495 /**
496  * @brief 测试连接中断
497  *
498  */
499 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_007, TestSize.Level0)
500 {
501     int ret = -1;
502     int socketId = -1;
503     do {
504         socketId = testServer->CreateSocket();
505         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
506         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
507         uint32_t msgLen = 0;
508         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
509         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
510 
511         int len = write(socketId, buffer.data(), msgLen);
512         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
513         // close socket
514         APPSPAWN_LOGV("CloseClientSocket");
515         CloseClientSocket(socketId);
516         socketId = -1;
517     } while (0);
518     if (socketId >= 0) {
519         CloseClientSocket(socketId);
520     }
521     ASSERT_EQ(ret, 0);
522 }
523 
524 /**
525  * @brief 发送不完整报文，等待超时
526  *
527  */
528 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_008, TestSize.Level0)
529 {
530     int ret = 0;
531     int socketId = -1;
532     do {
533         socketId = testServer->CreateSocket();
534         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
535         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
536         uint32_t msgLen = 0;
537         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
538         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
539         int len = write(socketId, buffer.data(), msgLen - 20);  // 20 test
540         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
541         // recv
542         len = read(socketId, buffer.data(), buffer.size());  // timeout EAGAIN
543         APPSPAWN_CHECK(len <= 0, ret = -1; break, "Can not receive timeout %{public}d", errno);
544     } while (0);
545     if (socketId >= 0) {
546         CloseClientSocket(socketId);
547     }
548     ASSERT_EQ(ret, 0);
549 }
550 
551 /**
552  * @brief 必须最后一个，kill nwebspawn，appspawn的线程结束
553  *
554  */
555 HWTEST_F(AppSpawnServiceTest, App_Spawn_NWebSpawn_001, TestSize.Level0)
556 {
557     int ret = 0;
558     AppSpawnClientHandle clientHandle = nullptr;
559     do {
560         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
561         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
562         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
563         AppSpawnResult result = {};
564         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
565         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
566         // kill nwebspawn
567         APPSPAWN_LOGV("App_Spawn_NWebSpawn_001 Kill nwebspawn");
568         testServer->KillNWebSpawnServer();
569     } while (0);
570     AppSpawnClientDestroy(clientHandle);
571     ASSERT_EQ(ret, 0);
572 }
573 
574 /**
575  * @brief 测试环境变量设置是否正确
576  *
577  */
578 HWTEST_F(AppSpawnServiceTest, App_Spawn_InitCommonEnv_001, TestSize.Level0)
579 {
580     char *env;
581 
582     InitCommonEnv();
583 
584     if (IsDeveloperModeOpen() == true) {
585         env = getenv("HNP_PRIVATE_HOME");
586         EXPECT_NE(env, nullptr);
587         if (env != nullptr) {
588             EXPECT_EQ(strcmp(env, "/data/app"), 0);
589         }
590         env = getenv("HNP_PUBLIC_HOME");
591         EXPECT_NE(env, nullptr);
592         if (env != nullptr) {
593             EXPECT_EQ(strcmp(env, "/data/service/hnp"), 0);
594         }
595         env = getenv("PATH");
596         EXPECT_NE(env, nullptr);
597         if (env != nullptr) {
598             EXPECT_NE(strstr(env, "/data/app/bin:/data/service/hnp/bin"), nullptr);
599         }
600     }
601     env = getenv("HOME");
602     EXPECT_NE(env, nullptr);
603     if (env != nullptr) {
604         EXPECT_EQ(strcmp(env, "/storage/Users/currentUser"), 0);
605     }
606     env = getenv("TMPDIR");
607     EXPECT_NE(env, nullptr);
608     if (env != nullptr) {
609         EXPECT_EQ(strcmp(env, "/data/storage/el2/base/cache"), 0);
610     }
611     env = getenv("SHELL");
612     EXPECT_NE(env, nullptr);
613     if (env != nullptr) {
614         EXPECT_EQ(strcmp(env, "/bin/sh"), 0);
615     }
616     env = getenv("PWD");
617     EXPECT_NE(env, nullptr);
618     if (env != nullptr) {
619         EXPECT_EQ(strcmp(env, "/storage/Users/currentUser"), 0);
620     }
621 }
622 
623 /**
624  * @brief 测试环境变量转换功能是否正常
625  *
626  */
627 HWTEST_F(AppSpawnServiceTest, App_Spawn_ConvertEnvValue_001, TestSize.Level0)
628 {
629     char outEnv[MAX_ENV_VALUE_LEN];
630 
631     outEnv[0] = 0;
632     EXPECT_EQ(ConvertEnvValue("/path/to/lib", outEnv, MAX_ENV_VALUE_LEN), 0);
633     EXPECT_EQ(strcmp(outEnv, "/path/to/lib"), 0);
634 
635     EXPECT_EQ(ConvertEnvValue("/path/to/lib/$ENV_TEST_VALUE", outEnv, MAX_ENV_VALUE_LEN), 0);
636     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/$ENV_TEST_VALUE"), 0);
637 
638     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE", outEnv, MAX_ENV_VALUE_LEN), 0);
639     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/${ENV_TEST_VALUE"), 0);
640 
641     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${", outEnv, MAX_ENV_VALUE_LEN), 0);
642     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/${"), 0);
643 
644     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE}", outEnv, MAX_ENV_VALUE_LEN), 0);
645     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/"), 0);
646 
647     EXPECT_EQ(setenv("ENV_TEST_VALUE", "envtest", 1), 0);
648     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE}", outEnv, MAX_ENV_VALUE_LEN), 0);
649     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/envtest"), 0);
650     EXPECT_EQ(unsetenv("ENV_TEST_VALUE"), 0);
651 }
652 
653 }  // namespace OHOS
654