• 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 #include "cJSON.h"
35 
36 #include "app_spawn_stub.h"
37 #include "app_spawn_test_helper.h"
38 
39 using namespace testing;
40 using namespace testing::ext;
41 using namespace OHOS;
42 
43 namespace OHOS {
44 class AppSpawnServiceTest : public testing::Test {
45 public:
SetUpTestCase()46     static void SetUpTestCase() {}
TearDownTestCase()47     static void TearDownTestCase() {}
SetUp()48     void SetUp()
49     {
50         testServer = std::make_unique<OHOS::AppSpawnTestServer>("appspawn -mode appspawn");
51         if (testServer != nullptr) {
52             testServer->Start(nullptr);
53         }
54     }
TearDown()55     void TearDown()
56     {
57         if (testServer != nullptr) {
58             testServer->Stop();
59         }
60     }
61 public:
62     std::unique_ptr<OHOS::AppSpawnTestServer> testServer = nullptr;
63 };
64 
65 /**
66  * @brief 向appspawn发送MSG_APP_SPAWN类型的消息
67  * @note 预期结果：appspawn接收到请求消息，孵化应用进程
68  *
69  */
70 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_APP_SPAWN_001, TestSize.Level0)
71 {
72     int ret = 0;
73     AppSpawnClientHandle clientHandle = nullptr;
74     do {
75         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
76         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
77         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
78 
79         AppSpawnResult result = {};
80         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
81         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
82             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
83 
84         DumpSpawnStack(result.pid);
85         ret = kill(result.pid, SIGKILL);
86         APPSPAWN_CHECK(ret == 0, break, "unable to kill pid %{public}d, err %{public}d", result.pid, errno);
87     } while (0);
88 
89     AppSpawnClientDestroy(clientHandle);
90     ASSERT_EQ(ret, 0);
91 }
92 
93 /**
94  * @brief 通过多线程模拟多个客户端向appspawn发送MSG_APP_SPAWN类型的消息
95  * @note 预期结果：appspawn接收到请求消息，逐个孵化应用进程
96  *
97  */
98 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_APP_SPAWN_002, TestSize.Level0)
99 {
100     int ret = 0;
101     AppSpawnClientHandle clientHandle = nullptr;
102     do {
103         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
104         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
105 
__anondcc1ec5e0102(AppSpawnClientHandle clientHandle) 106         auto sendMsg = [this, &ret](AppSpawnClientHandle clientHandle) {
107             AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
108 
109             AppSpawnResult result = {};
110             ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
111             APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
112                 return, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
113 
114             ret = kill(result.pid, SIGKILL);
115             APPSPAWN_CHECK(ret == 0, return, "unable to kill pid %{public}d, err %{public}d", result.pid, errno);
116         };
117         std::thread thread1(sendMsg, clientHandle);
118         std::thread thread2(sendMsg, clientHandle);
119         std::thread thread3(sendMsg, clientHandle);
120         std::thread thread4(sendMsg, clientHandle);
121         std::thread thread5(sendMsg, clientHandle);
122         thread1.join();
123         thread2.join();
124         thread3.join();
125         thread4.join();
126         thread5.join();
127     } while (0);
128 
129     AppSpawnClientDestroy(clientHandle);
130     ASSERT_EQ(ret, 0);
131 }
132 
133 /**
134  * @brief appspawn孵化的应用进程退出后，向appspawn发送MSG_GET_RENDER_TERMINATION_STATUS类型的消息
135  * @note 预期结果：appspawn不支持处理该类型消息，不会根据消息中传入的pid去查询进程的退出状态
136  *
137  */
138 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_GET_RENDER_TERMINATION_STATUS_001, TestSize.Level0)
139 {
140     int ret = 0;
141     AppSpawnClientHandle clientHandle = nullptr;
142     do {
143         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
144         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
145         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
146 
147         AppSpawnResult result = {};
148         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
149         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
150             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
151 
152         ret = kill(result.pid, SIGKILL);
153         APPSPAWN_CHECK(ret == 0, break, "unable to kill pid %{public}d, err %{public}d", result.pid, errno);
154 
155         ret = AppSpawnTerminateMsgCreate(result.pid, &reqHandle);   // MSG_GET_RENDER_TERMINATION_STATUS
156         APPSPAWN_CHECK(ret == 0, break, "Failed to create termination msg %{public}s", APPSPAWN_SERVER_NAME);
157 
158         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
159         APPSPAWN_CHECK(ret == 0 && result.result == APPSPAWN_MSG_INVALID, ret = -1;
160             break, "Failed to send MSG_GET_RENDER_TERMINATION_STATUS, ret %{public}d", ret);
161     } while (0);
162 
163     AppSpawnClientDestroy(clientHandle);
164     ASSERT_EQ(ret, 0);
165 }
166 
167 /**
168  * @brief 向appspawn发送MSG_SPAWN_NATIVE_PROCESS类型的消息
169  * @note 预期结果：appspawn接收到请求消息，孵化native进程
170  *
171  */
172 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_SPAWN_NATIVE_PROCESS_001, TestSize.Level0)
173 {
174     int ret = 0;
175     AppSpawnClientHandle clientHandle = nullptr;
176     do {
177         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
178         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
179         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
180 
181         AppSpawnResult result = {};
182         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
183         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
184             break, "Failed to send MSG_SPAWN_NATIVE_PROCESS, ret %{public}d pid %{public}d", ret, result.pid);
185 
186         ret = kill(result.pid, SIGKILL);
187         APPSPAWN_CHECK(ret == 0, break, "unable to kill pid %{public}d, err %{public}d", result.pid, errno);
188     } while (0);
189 
190     AppSpawnClientDestroy(clientHandle);
191     ASSERT_EQ(ret, 0);
192 }
193 
194 /**
195  * @brief appspawn孵化应用进程后，向appspawn发送MSG_DUMP类型的消息
196  * @note 预期结果：appspawn接收到请求消息，dump打印出appQueue等信息
197  *
198  */
199 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_DUMP_001, TestSize.Level0)
200 {
201     int ret = 0;
202     AppSpawnClientHandle clientHandle = nullptr;
203     do {
204         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
205         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
206         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
207 
208         AppSpawnResult result = {};
209         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
210         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
211             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
212 
213         reqHandle = testServer->CreateMsg(clientHandle, MSG_DUMP, 0);
214         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
215         APPSPAWN_CHECK(ret == 0, break, "Failed to send MSG_DUMP, ret %{public}d", ret);
216     } while (0);
217 
218     AppSpawnClientDestroy(clientHandle);
219     ASSERT_EQ(ret, 0);
220 }
221 
222 /**
223  * @brief 非开发者模式下，向appspawn发送MSG_BEGET_CMD类型的消息
224  * @note 预期结果：非开发者模式下，appspawn不支持处理该类型消息，不会根据消息中传入的pid进入应用沙箱
225  *
226  */
227 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_BEGET_CMD_001, TestSize.Level0)
228 {
229     int ret = 0;
230     AppSpawnClientHandle clientHandle = nullptr;
231     SetDeveloperMode(false);
232     do {
233         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
234         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
235         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
236 
237         AppSpawnResult result = {};
238         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
239         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
240             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
241 
242         reqHandle = testServer->CreateMsg(clientHandle, MSG_BEGET_CMD, 0);
243         ret = AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BEGETCTL_BOOT);
244         APPSPAWN_CHECK(ret == 0, break, "Failed to set msg flag 0x%{public}x", APP_FLAGS_BEGETCTL_BOOT);
245         ret = AppSpawnReqMsgAddStringInfo(reqHandle, MSG_EXT_NAME_BEGET_PID, std::to_string(result.pid).c_str());
246         APPSPAWN_CHECK(ret == 0, break, "Failed to add MSG_EXT_NAME_BEGET_PID %{public}d", result.pid);
247         ret = AppSpawnReqMsgAddStringInfo(reqHandle, MSG_EXT_NAME_BEGET_PTY_NAME, "/dev/pts/1");
248         APPSPAWN_CHECK(ret == 0, break, "Failed to add MSG_EXT_NAME_BEGET_PTY_NAME %{public}s", "/dev/pts/1");
249 
250         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
251         APPSPAWN_CHECK(ret == 0 && result.result == APPSPAWN_DEBUG_MODE_NOT_SUPPORT, ret = -1;
252             break, "Failed to send MSG_BEGET_CMD, ret %{public}d result %{public}d", ret, result.result);
253     } while (0);
254 
255     SetDeveloperMode(true);
256     AppSpawnClientDestroy(clientHandle);
257     ASSERT_EQ(ret, 0);
258 }
259 
260 /**
261  * @brief 向appspawn发送MSG_BEGET_SPAWNTIME类型的消息
262  * @note 预期结果：appspawn接收到请求消息，获取appspawn启动时各hook执行的最小时间(result.result)和最大时间(result.pid)
263  *
264  */
265 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_BEGET_SPAWNTIME_001, TestSize.Level0)
266 {
267     int ret = 0;
268     AppSpawnClientHandle clientHandle = nullptr;
269     int minAppspawnTime = 0;
270     int maxAppspawnTime = APPSPAWN_MAX_TIME;
271     do {
272         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
273         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
274         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_BEGET_SPAWNTIME, 0);
275 
276         AppSpawnResult result = {};
277         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
278         minAppspawnTime = result.result;
279         maxAppspawnTime = result.pid;
280         APPSPAWN_CHECK(ret == 0, break, "Failed to send MSG_BEGET_SPAWNTIME, ret %{public}d", ret);
281     } while (0);
282 
283     AppSpawnClientDestroy(clientHandle);
284     EXPECT_GT(minAppspawnTime, 0);
285     EXPECT_LT(maxAppspawnTime, APPSPAWN_MAX_TIME);
286     ASSERT_EQ(ret, 0);
287 }
288 
289 /**
290  * @brief 向appspawn发送MSG_UPDATE_MOUNT_POINTS类型的消息
291  * @note 预期结果：appspawn接收到请求消息，遍历沙箱包名更新挂载点
292  *
293  */
294 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_UPDATE_MOUNT_POINTS_001, TestSize.Level0)
295 {
296     int ret = 0;
297     AppSpawnClientHandle clientHandle = nullptr;
298     do {
299         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
300         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
301         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_UPDATE_MOUNT_POINTS, 0);
302 
303         AppSpawnResult result = {};
304         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
305         APPSPAWN_CHECK(ret == 0 && result.result == 0, ret = -1;
306             break, "Failed to send MSG_UPDATE_MOUNT_POINTS, ret %{public}d result %{public}d", ret, result.result);
307     } while (0);
308 
309     AppSpawnClientDestroy(clientHandle);
310     ASSERT_EQ(ret, 0);
311 }
312 
313 /**
314  * @brief 向appspawn发送MSG_RESTART_SPAWNER类型的消息
315  * @note 预期结果：appspawn不支持处理该类型消息，返回APPSPAWN_MSG_INVALID
316  *
317  */
318 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_RESTART_SPAWNER_001, TestSize.Level0)
319 {
320     int ret = 0;
321     AppSpawnClientHandle clientHandle = nullptr;
322     do {
323         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
324         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
325         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_RESTART_SPAWNER, 0);
326 
327         AppSpawnResult result = {};
328         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
329         APPSPAWN_CHECK(ret == 0 && result.result == APPSPAWN_MSG_INVALID, ret = -1;
330             break, "Failed to send MSG_RESTART_SPAWNER, ret %{public}d result %{public}d", ret, result.result);
331     } while (0);
332 
333     AppSpawnClientDestroy(clientHandle);
334     ASSERT_EQ(ret, 0);
335 }
336 
337 /**
338  * @brief appspawn孵化debuggable应用后，向appspawn发送MSG_DEVICE_DEBUG类型的消息
339  * @note 预期结果：appspawn接收到请求消息，根据消息中传入的debuggable应用pid和signal杀死先前孵化的应用
340  *
341  */
342 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_DEVICE_DEBUG_001, TestSize.Level0)
343 {
344     int ret = 0;
345     AppSpawnClientHandle clientHandle = nullptr;
346     do {
347         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
348         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
349         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
350         ret = AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
351         APPSPAWN_CHECK(ret == 0, break, "Failed to set msg flag 0x%{public}x", APP_FLAGS_DEBUGGABLE);
352 
353         AppSpawnResult result = {};
354         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
355         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
356             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
357 
358         reqHandle = testServer->CreateMsg(clientHandle, MSG_DEVICE_DEBUG, 0);
359         char buffer[256] = {0};
360         ret = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1,
361             "{ \"app\": %d, \"op\": \"kill\", \"args\": { \"signal\": 9 } }", result.pid);
362         APPSPAWN_CHECK(ret > 0, ret = -1;
363             break, "Failed to snprintf_s devicedebug extra info, err %{public}d", errno);
364         ret = AppSpawnReqMsgAddStringInfo(reqHandle, "devicedebug", buffer);
365         APPSPAWN_CHECK(ret == 0, break, "Failed to add devicedebug extra info %{public}s", buffer);
366 
367         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
368         APPSPAWN_CHECK(ret == 0 && result.result == 0, ret = -1;
369             break, "Failed to send MSG_DEVICE_DEBUG, ret %{public}d result %{public}d", ret, result.result);
370     } while (0);
371 
372     AppSpawnClientDestroy(clientHandle);
373     ASSERT_EQ(ret, 0);
374 }
375 
376 /**
377  * @brief appspawn孵化非debuggable应用后，向appspawn发送MSG_DEVICE_DEBUG类型的消息
378  * @note 预期结果：appspawn接收到请求消息，但不支持向非debuggable应用发送signal
379  *
380  */
381 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_DEVICE_DEBUG_002, TestSize.Level0)
382 {
383     int ret = 0;
384     AppSpawnClientHandle clientHandle = nullptr;
385     do {
386         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
387         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
388         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
389 
390         AppSpawnResult result = {};
391         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
392         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
393             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
394 
395         reqHandle = testServer->CreateMsg(clientHandle, MSG_DEVICE_DEBUG, 0);
396         char buffer[256] = {0};
397         ret = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1,
398             "{ \"app\": %d, \"op\": \"kill\", \"args\": { \"signal\": 9 } }", result.pid);
399         APPSPAWN_CHECK(ret > 0, ret = -1;
400             break, "Failed to snprintf_s devicedebug extra info, err %{public}d", errno);
401         ret = AppSpawnReqMsgAddStringInfo(reqHandle, "devicedebug", buffer);
402         APPSPAWN_CHECK(ret == 0, break, "Failed to add devicedebug extra info %{public}s", buffer);
403 
404         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
405         APPSPAWN_CHECK(ret == 0 && result.result == APPSPAWN_DEVICEDEBUG_ERROR_APP_NOT_DEBUGGABLE, ret = -1;
406             break, "Failed to send MSG_DEVICE_DEBUG, ret %{public}d result %{public}d", ret, result.result);
407     } while (0);
408 
409     AppSpawnClientDestroy(clientHandle);
410     ASSERT_EQ(ret, 0);
411 }
412 
413 /**
414  * @brief appspawn孵化带debug沙箱的应用后，向appspawn发送MSG_UNINSTALL_DEBUG_HAP类型的消息
415  * @note 预期结果：appspawn接收到请求消息，卸载掉指定用户下的所有debug沙箱
416  *
417  */
418 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_UNINSTALL_DEBUG_HAP_001, TestSize.Level0)
419 {
420     int ret = 0;
421     AppSpawnClientHandle clientHandle = nullptr;
422     do {
423         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
424         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
425         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
426         ret = AppSpawnReqMsgAddStringInfo(reqHandle, MSG_EXT_NAME_PROVISION_TYPE, "debug");
427         APPSPAWN_CHECK(ret == 0, break, "Failed to add MSG_EXT_NAME_PROVISION_TYPE %{public}s", "debug");
428 
429         AppSpawnResult result = {};
430         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
431         APPSPAWN_CHECK(ret == 0 && result.pid > 0, ret = -1;
432             break, "Failed to send MSG_APP_SPAWN, ret %{public}d pid %{public}d", ret, result.pid);
433 
434         reqHandle = testServer->CreateMsg(clientHandle, MSG_UNINSTALL_DEBUG_HAP, 0);
435         ret = AppSpawnReqMsgAddStringInfo(reqHandle, MSG_EXT_NAME_USERID, "100");
436         APPSPAWN_CHECK(ret == 0, break, "Failed to add MSG_EXT_NAME_USERID %{public}s", "100");
437 
438         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
439         APPSPAWN_CHECK(ret == 0 && result.result == 0, ret = -1;
440             break, "Failed to send MSG_UNINSTALL_DEBUG_HAP, ret %{public}d result %{public}d", ret, result.result);
441     } while (0);
442 
443     AppSpawnClientDestroy(clientHandle);
444     ASSERT_EQ(ret, 0);
445 }
446 
447 /**
448  * @brief 向appspawn发送MSG_LOCK_STATUS类型的消息
449  * @note 预期结果：appspawn接收到请求消息，根据消息中的传入的解锁状态对lockstatus参数进行设值
450  *
451  */
452 HWTEST_F(AppSpawnServiceTest, App_Spawn_MSG_LOCK_STATUS_001, TestSize.Level0)
453 {
454     int ret = 0;
455     AppSpawnClientHandle clientHandle = nullptr;
456     do {
457         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
458         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
459         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_LOCK_STATUS, 0);
460 
461         char lockstatus[8] = {0};
462         ret = snprintf_s(lockstatus, sizeof(lockstatus), sizeof(lockstatus) - 1, "%u:%d", 100, 0);
463         APPSPAWN_CHECK(ret > 0, ret = -1;
464             break, "Failed to snprintf_s lockstatus extra info, err %{public}d", errno);
465         ret = AppSpawnReqMsgAddStringInfo(reqHandle, "lockstatus", lockstatus);
466         APPSPAWN_CHECK(ret == 0, break, "Failed to add lockstatus extra info %{public}s", lockstatus);
467 
468         AppSpawnResult result = {};
469         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
470         APPSPAWN_CHECK(ret == 0 && result.result == 0, ret = -1;
471             break, "Failed to send MSG_LOCK_STATUS, ret %{public}d result %{public}d", ret, result.result);
472     } while (0);
473 
474     AppSpawnClientDestroy(clientHandle);
475     ASSERT_EQ(ret, 0);
476 }
477 
478 /**
479  * @brief 向appspawn发送MAX_TYPE_INVALID类型的消息
480  * @note 预期结果：不支持创建该类型消息，发送失败，appspawn接收不到该消息请求
481  *
482  */
483 HWTEST_F(AppSpawnServiceTest, App_Spawn_MAX_TYPE_INVALID_001, TestSize.Level0)
484 {
485     int ret = 0;
486     AppSpawnClientHandle clientHandle = nullptr;
487     do {
488         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
489         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
490         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MAX_TYPE_INVALID, 0);
491 
492         AppSpawnResult result = {};
493         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
494         APPSPAWN_CHECK(ret == APPSPAWN_ARG_INVALID, break, "Failed to send MAX_TYPE_INVALID, ret %{public}d", ret);
495     } while (0);
496 
497     AppSpawnClientDestroy(clientHandle);
498     ASSERT_EQ(ret, APPSPAWN_ARG_INVALID);
499 }
500 
501 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_001, TestSize.Level0)
502 {
503     int ret = -1;
504     int socketId = -1;
505     // 没有tlv的消息，返回错误
506     do {
507         socketId = testServer->CreateSocket();
508         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
509 
510         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
511         uint32_t msgLen = 0;
512         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
513         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
514 
515         int len = write(socketId, buffer.data(), msgLen);
516         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
517         // recv
518         APPSPAWN_LOGV("Start recv ... ");
519         len = read(socketId, buffer.data(), buffer.size());
520         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
521             break, "Failed to recv msg errno: %{public}d", errno);
522         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
523         APPSPAWN_LOGV("Recv msg %{public}s result: %{public}d", respMsg->msgHdr.processName, respMsg->result.result);
524         ret = respMsg->result.result;
525     } while (0);
526     if (socketId >= 0) {
527         CloseClientSocket(socketId);
528     }
529     ASSERT_NE(ret, 0);
530 }
531 
RecvMsg(int socketId,uint8_t * buffer,uint32_t buffSize)532 static int RecvMsg(int socketId, uint8_t *buffer, uint32_t buffSize)
533 {
534     ssize_t rLen = TEMP_FAILURE_RETRY(read(socketId, buffer, buffSize));
535     return static_cast<int>(rLen);
536 }
537 
538 /**
539  * @brief 消息不完整，断开连接
540  *
541  */
542 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_002, TestSize.Level0)
543 {
544     int ret = 0;
545     int socketId = -1;
546     do {
547         socketId = testServer->CreateSocket();
548         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
549 
550         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
551         uint32_t msgLen = 0;
552         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
553         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
554 
555         ret = -1;
556         int len = write(socketId, buffer.data(), msgLen - 10);  // 10
557         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
558         // recv timeout
559         len = RecvMsg(socketId, buffer.data(), buffer.size());
560         APPSPAWN_CHECK(len <= 0, break, "Failed to recv msg len: %{public}d", len);
561         ret = 0;
562     } while (0);
563     if (socketId >= 0) {
564         CloseClientSocket(socketId);
565     }
566     ASSERT_EQ(ret, 0);
567 }
568 
569 /**
570  * @brief 测试异常tlv
571  *
572  */
573 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_003, TestSize.Level0)
574 {
575     int ret = -1;
576     int socketId = -1;
577     do {
578         socketId = testServer->CreateSocket();
579         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
580 
581         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
582         uint32_t msgLen = 0;
583         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
584         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
585 
586         int len = write(socketId, buffer.data(), msgLen);
587         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
588         // recv
589         len = RecvMsg(socketId, buffer.data(), buffer.size());
590         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
591             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
592         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
593         APPSPAWN_LOGV("Recv msg %{public}s result: %{public}d", respMsg->msgHdr.processName, respMsg->result.result);
594         ret = respMsg->result.result == APPSPAWN_MSG_INVALID ? 0 : -1;
595     } while (0);
596     if (socketId >= 0) {
597         CloseClientSocket(socketId);
598     }
599     ASSERT_EQ(ret, 0);
600 }
601 
602 /**
603  * @brief 测试小包发送，随机获取发送大小，发送数据。消息20时，按33发送
604  *
605  */
606 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_004, TestSize.Level0)
607 {
608     int ret = -1;
609     int socketId = -1;
610     do {
611         socketId = testServer->CreateSocket();
612         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
613 
614         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
615         uint32_t msgLen = 0;
616         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
617         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
618 
619         // 分片发送
620         uint32_t sendStep = OHOS::AppSpawnTestHelper::GenRandom() % 70;  // 70 一次发送的字节数
621         sendStep = (sendStep < 20) ? 33 : sendStep;                      // 20 33 一次发送的字节数
622         APPSPAWN_LOGV("App_Spawn_Msg_004 msgLen %{public}u sendStep: %{public}u", msgLen, sendStep);
623         uint32_t currIndex = 0;
624         int len = 0;
625         do {
626             if ((currIndex + sendStep) > msgLen) {
627                 break;
628             }
629             len = write(socketId, buffer.data() + currIndex, sendStep);
630             APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
631             usleep(2000);  // wait recv
632             currIndex += sendStep;
633         } while (1);
634         APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
635         if (msgLen > currIndex) {
636             len = write(socketId, buffer.data() + currIndex, msgLen - currIndex);
637             APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
638         }
639 
640         // recv
641         len = RecvMsg(socketId, buffer.data(), buffer.size());
642         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
643             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
644         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
645         APPSPAWN_LOGV("App_Spawn_Msg_004 recv msg %{public}s result: %{public}d",
646             respMsg->msgHdr.processName, respMsg->result.result);
647         ret = respMsg->result.result;
648     } while (0);
649     if (socketId >= 0) {
650         CloseClientSocket(socketId);
651     }
652     ASSERT_EQ(ret, 0);
653 }
654 
655 /**
656  * @brief 测试2个消息一起发送
657  *
658  */
659 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_005, TestSize.Level0)
660 {
661     int ret = -1;
662     int socketId = -1;
663     do {
664         socketId = testServer->CreateSocket();
665         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
666 
667         std::vector<uint8_t> buffer1(1024);  // 1024
668         std::vector<uint8_t> buffer2(1024);  // 1024
669         uint32_t msgLen1 = 0;
670         uint32_t msgLen2 = 0;
671         ret = testServer->CreateSendMsg(buffer1, MSG_APP_SPAWN, msgLen1, {AppSpawnTestHelper::AddBaseTlv});
672         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
673         ret = testServer->CreateSendMsg(buffer2, MSG_APP_SPAWN, msgLen2, {AppSpawnTestHelper::AddBaseTlv});
674         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
675 
676         buffer1.insert(buffer1.begin() + msgLen1, buffer2.begin(), buffer2.end());
677         int len = write(socketId, buffer1.data(), msgLen1 + msgLen2);
678         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
679         // recv
680         sleep(2);
681         len = RecvMsg(socketId, buffer2.data(), buffer2.size());
682         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
683             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
684         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer2.data());
685         APPSPAWN_LOGV("App_Spawn_Msg_005 Recv msg %{public}s result: %{public}d",
686             respMsg->msgHdr.processName, respMsg->result.result);
687         ret = respMsg->result.result;
688         (void)RecvMsg(socketId, buffer2.data(), buffer2.size());
689     } while (0);
690     ret = 0; // test for case
691     if (socketId >= 0) {
692         CloseClientSocket(socketId);
693     }
694     ASSERT_EQ(ret, 0);
695 }
696 
697 /**
698  * @brief 测试连续2个消息，spawn和dump 消息
699  *
700  */
701 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_006, TestSize.Level0)
702 {
703     int ret = -1;
704     int socketId = -1;
705     do {
706         socketId = testServer->CreateSocket();
707         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
708 
709         std::vector<uint8_t> buffer1(2 * 1024);  // 2 * 1024
710         std::vector<uint8_t> buffer2(1024);  // 1024
711         uint32_t msgLen1 = 0;
712         uint32_t msgLen2 = 0;
713         ret = testServer->CreateSendMsg(buffer1, MSG_APP_SPAWN, msgLen1, {AppSpawnTestHelper::AddBaseTlv});
714         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
715         ret = testServer->CreateSendMsg(buffer2, MSG_DUMP, msgLen2, {});
716         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
717 
718         buffer1.insert(buffer1.begin() + msgLen1, buffer2.begin(), buffer2.end());
719         int len = write(socketId, buffer1.data(), msgLen1 + msgLen2);
720         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
721         // recv
722         len = RecvMsg(socketId, buffer2.data(), buffer2.size());
723         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
724             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
725         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer2.data());
726         APPSPAWN_LOGV("App_Spawn_Msg_006 recv msg %{public}s result: %{public}d",
727             respMsg->msgHdr.processName, respMsg->result.result);
728         ret = respMsg->result.result;
729         (void)RecvMsg(socketId, buffer2.data(), buffer2.size());
730     } while (0);
731     if (socketId >= 0) {
732         CloseClientSocket(socketId);
733     }
734     ASSERT_EQ(ret, 0);
735 }
736 
737 /**
738  * @brief 测试连接中断
739  *
740  */
741 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_007, TestSize.Level0)
742 {
743     int ret = -1;
744     int socketId = -1;
745     do {
746         socketId = testServer->CreateSocket();
747         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
748         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
749         uint32_t msgLen = 0;
750         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
751         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
752 
753         int len = write(socketId, buffer.data(), msgLen);
754         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
755         // close socket
756         APPSPAWN_LOGV("CloseClientSocket");
757         CloseClientSocket(socketId);
758         socketId = -1;
759     } while (0);
760     if (socketId >= 0) {
761         CloseClientSocket(socketId);
762     }
763     ASSERT_EQ(ret, 0);
764 }
765 
766 /**
767  * @brief 发送不完整报文，等待超时
768  *
769  */
770 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_008, TestSize.Level0)
771 {
772     int ret = 0;
773     int socketId = -1;
774     do {
775         socketId = testServer->CreateSocket();
776         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
777         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
778         uint32_t msgLen = 0;
779         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
780         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
781         int len = write(socketId, buffer.data(), msgLen - 20);  // 20 test
782         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
783         // recv
784         len = read(socketId, buffer.data(), buffer.size());  // timeout EAGAIN
785         APPSPAWN_CHECK(len <= 0, ret = -1; break, "Can not receive timeout %{public}d", errno);
786     } while (0);
787     if (socketId >= 0) {
788         CloseClientSocket(socketId);
789     }
790     ASSERT_EQ(ret, 0);
791 }
792 
793 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_009, TestSize.Level0)
794 {
795     int ret = 0;
796     AppSpawnClientHandle clientHandle = nullptr;
797     AppSpawnResult result = {};
798     do {
799         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
800         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
801         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
802 
803         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
804         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
805         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
806 
807         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
808         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
809 
810         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
811         ASSERT_NE(app, nullptr);
812 
813         AppSpawnReqMsgHandle reqHandle2;
814         ret = AppSpawnReqMsgCreate(MSG_DEVICE_DEBUG, "devicedebug", &reqHandle2);
815         cJSON *args = cJSON_CreateObject();
816         ASSERT_NE(args, nullptr);
817         cJSON_AddNumberToObject(args, "signal", 9);
818         cJSON *root = cJSON_CreateObject();
819         ASSERT_NE(root, nullptr);
820         cJSON_AddNumberToObject(root, "app", app->pid);
821         cJSON_AddStringToObject(root, "op", "kill");
822         cJSON_AddItemToObject(root, "args", args);
823         char *jsonString = cJSON_Print(root);
824         cJSON_Delete(root);
825         ret = AppSpawnReqMsgAddExtInfo(reqHandle2, "devicedebug", (uint8_t *)jsonString, strlen(jsonString) + 1);
826         ASSERT_EQ(ret, 0);
827         ret = AppSpawnClientSendMsg(clientHandle, reqHandle2, &result);
828         AppSpawnClientDestroy(clientHandle);
829         free(jsonString);
830         APPSPAWN_CHECK(ret == 0 && result.result == 0, break, "Failed to send msg ret:%{public}d, result:%{public}d",
831             ret, result.result);
832         ASSERT_EQ(kill(app->pid, SIGKILL), 0);
833     } while (0);
834 
835     ASSERT_EQ(ret, 0);
836     ASSERT_EQ(result.result, APPSPAWN_DEVICEDEBUG_ERROR_APP_NOT_DEBUGGABLE);
837 }
838 
839 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_010, TestSize.Level0)
840 {
841     int ret = 0;
842     AppSpawnClientHandle clientHandle = nullptr;
843     AppSpawnResult result = {};
844     do {
845         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
846         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
847         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
848 
849         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
850         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
851         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
852         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
853 
854         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
855         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
856 
857         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
858         ASSERT_NE(app, nullptr);
859 
860         AppSpawnReqMsgHandle reqHandle2;
861         ret = AppSpawnReqMsgCreate(MSG_DEVICE_DEBUG, "devicedebug", &reqHandle2);
862         cJSON *args = cJSON_CreateObject();
863         ASSERT_NE(args, nullptr);
864         cJSON_AddNumberToObject(args, "signal", 9);
865         cJSON *root = cJSON_CreateObject();
866         ASSERT_NE(root, nullptr);
867         cJSON_AddNumberToObject(root, "app", app->pid);
868         cJSON_AddStringToObject(root, "op", "kill");
869         cJSON_AddItemToObject(root, "args", args);
870         char *jsonString = cJSON_Print(root);
871         cJSON_Delete(root);
872         ret = AppSpawnReqMsgAddExtInfo(reqHandle2, "devicedebug", (uint8_t *)jsonString, strlen(jsonString) + 1);
873         ASSERT_EQ(ret, 0);
874         ret = AppSpawnClientSendMsg(clientHandle, reqHandle2, &result);
875         AppSpawnClientDestroy(clientHandle);
876         free(jsonString);
877         APPSPAWN_CHECK(ret == 0 && result.result == 0, break, "Failed to send msg ret:%{public}d, result:%{public}d",
878             ret, result.result);
879     } while (0);
880 
881     ASSERT_EQ(ret, 0);
882     ASSERT_EQ(result.result, 0);
883 }
884 
885 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_011, TestSize.Level0)
886 {
887     int ret = 0;
888     AppSpawnClientHandle clientHandle = nullptr;
889     AppSpawnResult result = {};
890     do {
891         int pipefd[2]; // 2 pipe fd
892         char buffer[1024]; //1024 1k
893         APPSPAWN_CHECK(pipe(pipefd) == 0, break, "Failed to pipe fd errno:%{public}d", errno);
894         ret = SpawnListenFdSet(pipefd[0]);
895 
896         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
897         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
898         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
899 
900         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
901         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
902         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
903         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
904 
905         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
906         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
907         AppSpawnClientDestroy(clientHandle);
908         sleep(1); // wait child process stand up
909 
910         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
911         ASSERT_NE(app, nullptr);
912         char commamd[16]; // command len 16
913         APPSPAWN_CHECK(sprintf_s(commamd, 16, "kill -9 %d", app->pid) > 0, break, "sprintf command unsuccess");
914         system(commamd);
915 
916         bool isFind = false;
917         int count = 0;
918         while (count < 10) {
919             if (read(pipefd[1], buffer, sizeof(buffer)) <= 0) {
920                 count++;
921                 continue;
922             }
923             if (strstr(buffer, std::to_string(app->pid).c_str()) != NULL) {
924                 isFind = true;
925                 break;
926             }
927             count++;
928         }
929         close(pipefd[0]);
930         close(pipefd[1]);
931         ASSERT_EQ(isFind, false);
932         SpawnListenCloseSet();
933     } while (0);
934 }
935 
936 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_012, TestSize.Level0)
937 {
938     int ret = 0;
939     AppSpawnClientHandle clientHandle = nullptr;
940     AppSpawnResult result = {};
941     do {
942         int pipefd[2]; // 2 pipe fd
943         char buffer[1024]; //1024 1k
944         APPSPAWN_CHECK(pipe(pipefd) == 0, break, "Failed to pipe fd errno:%{public}d", errno);
945         ret = SpawnListenFdSet(pipefd[1]);
946 
947         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
948         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
949         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
950 
951         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
952         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
953         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
954         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
955 
956         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
957         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
958         AppSpawnClientDestroy(clientHandle);
959         sleep(1); // wait child process stand up
960 
961         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
962         ASSERT_NE(app, nullptr);
963         char commamd[16]; // command len 16
964         APPSPAWN_CHECK(sprintf_s(commamd, 16, "kill -9 %d", app->pid) > 0, break, "sprintf command unsuccess");
965         system(commamd);
966 
967         bool isFind = false;
968         int count = 0;
969         while (count < 10) {
970             if (read(pipefd[0], buffer, sizeof(buffer)) <= 0) {
971                 count++;
972                 continue;
973             }
974             if (strstr(buffer, std::to_string(app->pid).c_str()) != NULL) {
975                 isFind = true;
976                 break;
977             }
978             count++;
979         }
980         close(pipefd[0]);
981         close(pipefd[1]);
982         ASSERT_EQ(isFind, true);
983         SpawnListenCloseSet();
984     } while (0);
985 }
986 
987 /**
988  * @brief 测试子进程退出时，nativespawn通过fd中发送子进程退出状态，发送失败
989  *
990  */
991 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_013, TestSize.Level0)
992 {
993     int ret = 0;
994     AppSpawnClientHandle clientHandle = nullptr;
995     AppSpawnResult result = {};
996     do {
997         int pipefd[2]; // 2 pipe fd
998         char buffer[1024]; // 1024 1k
999         APPSPAWN_CHECK(pipe(pipefd) == 0, break, "Failed to pipe fd errno:%{public}d", errno);
1000         ret = NativeSpawnListenFdSet(pipefd[0]);
1001 
1002         ret = AppSpawnClientInit(NATIVESPAWN_SERVER_NAME, &clientHandle);
1003         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", NATIVESPAWN_SERVER_NAME);
1004         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
1005 
1006         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
1007         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
1008         AppSpawnClientDestroy(clientHandle);
1009         sleep(1); // wait child process stand up
1010 
1011         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
1012         ASSERT_NE(app, nullptr);
1013         char commamd[16]; // command len 16
1014         APPSPAWN_CHECK(sprintf_s(commamd, 16, "kill -9 %d", app->pid) > 0, break, "sprintf command unsuccess");
1015         system(commamd);
1016 
1017         bool isFind = false;
1018         int count = 0;
1019         while (count < 10) {
1020             if (read(pipefd[1], buffer, sizeof(buffer)) <= 0) {
1021                 count++;
1022                 continue;
1023             }
1024             if (strstr(buffer, std::to_string(app->pid).c_str()) != NULL) {
1025                 isFind = true;
1026                 break;
1027             }
1028             count++;
1029         }
1030         close(pipefd[0]);
1031         close(pipefd[1]);
1032         ASSERT_EQ(isFind, false);
1033         NativeSpawnListenCloseSet();
1034     } while (0);
1035 }
1036 
1037 /**
1038  * @brief 测试子进程退出时，nativespawn通过fd中发送子进程退出状态，发送成功
1039  *
1040  */
1041 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_014, TestSize.Level0)
1042 {
1043     int ret = 0;
1044     AppSpawnClientHandle clientHandle = nullptr;
1045     AppSpawnResult result = {};
1046     do {
1047         int pipefd[2]; // 2 pipe fd
1048         char buffer[1024]; // 1024 1k
1049         APPSPAWN_CHECK(pipe(pipefd) == 0, break, "Failed to pipe fd errno:%{public}d", errno);
1050         ret = NativeSpawnListenFdSet(pipefd[1]);
1051 
1052         ret = AppSpawnClientInit(NATIVESPAWN_SERVER_NAME, &clientHandle);
1053         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", NATIVESPAWN_SERVER_NAME);
1054         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
1055 
1056         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
1057         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
1058         AppSpawnClientDestroy(clientHandle);
1059         sleep(1); // wait child process stand up
1060 
1061         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
1062         ASSERT_NE(app, nullptr);
1063         char commamd[16]; // command len 16
1064         APPSPAWN_CHECK(sprintf_s(commamd, 16, "kill -9 %d", app->pid) > 0, break, "sprintf command unsuccess");
1065         system(commamd);
1066 
1067         bool isFind = false;
1068         int count = 0;
1069         while (count < 10) {
1070             if (read(pipefd[0], buffer, sizeof(buffer)) <= 0) {
1071                 count++;
1072                 continue;
1073             }
1074             if (strstr(buffer, std::to_string(app->pid).c_str()) != NULL) {
1075                 isFind = true;
1076                 break;
1077             }
1078             count++;
1079         }
1080         close(pipefd[0]);
1081         close(pipefd[1]);
1082         ASSERT_EQ(isFind, true);
1083         NativeSpawnListenCloseSet();
1084     } while (0);
1085 }
1086 
1087 /**
1088  * @brief 必须最后一个，kill nwebspawn，appspawn的线程结束
1089  *
1090  */
1091 HWTEST_F(AppSpawnServiceTest, App_Spawn_NWebSpawn_001, TestSize.Level0)
1092 {
1093     int ret = 0;
1094     AppSpawnClientHandle clientHandle = nullptr;
1095     do {
1096         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
1097         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
1098         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
1099         AppSpawnResult result = {};
1100         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
1101         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
1102         // kill nwebspawn
1103         APPSPAWN_LOGV("App_Spawn_NWebSpawn_001 Kill nwebspawn");
1104         testServer->KillNWebSpawnServer();
1105     } while (0);
1106     AppSpawnClientDestroy(clientHandle);
1107     ASSERT_EQ(ret, 0);
1108 }
1109 
1110 /**
1111  * @brief 测试环境变量设置是否正确
1112  *
1113  */
1114 HWTEST_F(AppSpawnServiceTest, App_Spawn_InitCommonEnv_001, TestSize.Level0)
1115 {
1116     char *env;
1117 
1118     InitCommonEnv();
1119 
1120     if (IsDeveloperModeOpen() == true) {
1121         env = getenv("HNP_PRIVATE_HOME");
1122         EXPECT_NE(env, nullptr);
1123         if (env != nullptr) {
1124             EXPECT_EQ(strcmp(env, "/data/app"), 0);
1125         }
1126         env = getenv("HNP_PUBLIC_HOME");
1127         EXPECT_NE(env, nullptr);
1128         if (env != nullptr) {
1129             EXPECT_EQ(strcmp(env, "/data/service/hnp"), 0);
1130         }
1131         env = getenv("PATH");
1132         EXPECT_NE(env, nullptr);
1133         if (env != nullptr) {
1134             EXPECT_NE(strstr(env, "/data/app/bin:/data/service/hnp/bin"), nullptr);
1135         }
1136     }
1137     env = getenv("HOME");
1138     EXPECT_NE(env, nullptr);
1139     if (env != nullptr) {
1140         EXPECT_EQ(strcmp(env, "/storage/Users/currentUser"), 0);
1141     }
1142     env = getenv("TMPDIR");
1143     EXPECT_NE(env, nullptr);
1144     if (env != nullptr) {
1145         EXPECT_EQ(strcmp(env, "/data/storage/el2/base/cache"), 0);
1146     }
1147     env = getenv("SHELL");
1148     EXPECT_NE(env, nullptr);
1149     if (env != nullptr) {
1150         EXPECT_EQ(strcmp(env, "/bin/sh"), 0);
1151     }
1152     env = getenv("PWD");
1153     EXPECT_NE(env, nullptr);
1154     if (env != nullptr) {
1155         EXPECT_EQ(strcmp(env, "/storage/Users/currentUser"), 0);
1156     }
1157 }
1158 
1159 /**
1160  * @brief 测试环境变量转换功能是否正常
1161  *
1162  */
1163 HWTEST_F(AppSpawnServiceTest, App_Spawn_ConvertEnvValue_001, TestSize.Level0)
1164 {
1165     char outEnv[MAX_ENV_VALUE_LEN];
1166 
1167     outEnv[0] = 0;
1168     EXPECT_EQ(ConvertEnvValue("/path/to/lib", outEnv, MAX_ENV_VALUE_LEN), 0);
1169     EXPECT_EQ(strcmp(outEnv, "/path/to/lib"), 0);
1170 
1171     EXPECT_EQ(ConvertEnvValue("/path/to/lib/$ENV_TEST_VALUE", outEnv, MAX_ENV_VALUE_LEN), 0);
1172     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/$ENV_TEST_VALUE"), 0);
1173 
1174     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE", outEnv, MAX_ENV_VALUE_LEN), 0);
1175     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/${ENV_TEST_VALUE"), 0);
1176 
1177     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${", outEnv, MAX_ENV_VALUE_LEN), 0);
1178     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/${"), 0);
1179 
1180     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE}", outEnv, MAX_ENV_VALUE_LEN), 0);
1181     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/"), 0);
1182 
1183     EXPECT_EQ(setenv("ENV_TEST_VALUE", "envtest", 1), 0);
1184     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE}", outEnv, MAX_ENV_VALUE_LEN), 0);
1185     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/envtest"), 0);
1186     EXPECT_EQ(unsetenv("ENV_TEST_VALUE"), 0);
1187 }
1188 }  // namespace OHOS
1189