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 AppSpawnSandboxMgrTest : 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 AppSpawnSandboxCfg
49  *
50  */
51 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_AppSpawnSandboxCfg_001, TestSize.Level0)
52 {
53     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
54     EXPECT_EQ(mgr != nullptr, 1);
55 
56     AppSpawnSandboxCfg *sandbox = GetAppSpawnSandbox(mgr);
57     EXPECT_EQ(sandbox == nullptr, 1);
58 
59     sandbox = CreateAppSpawnSandbox();
60     EXPECT_EQ(sandbox != nullptr, 1);
61     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
62 
63     sandbox = GetAppSpawnSandbox(mgr);
64     EXPECT_EQ(sandbox != nullptr, 1);
65 
66     // dump
67     DumpAppSpawnSandboxCfg(sandbox);
68 
69     // delete
70     DeleteAppSpawnSandbox(sandbox);
71     // get none
72     sandbox = GetAppSpawnSandbox(mgr);
73     EXPECT_EQ(sandbox == nullptr, 1);
74     DumpAppSpawnSandboxCfg(sandbox);
75 
76     DeleteAppSpawnMgr(mgr);
77     sandbox = GetAppSpawnSandbox(nullptr);
78     EXPECT_EQ(sandbox == nullptr, 1);
79 }
80 
81 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_AppSpawnSandboxCfg_002, TestSize.Level0)
82 {
83     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
84     EXPECT_EQ(mgr != nullptr, 1);
85 
86     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
87     EXPECT_EQ(sandbox != nullptr, 1);
88     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
89 
90     // for appspawn
91     int ret = LoadAppSandboxConfig(sandbox, MODE_FOR_APP_SPAWN);
92     EXPECT_EQ(ret, 0);
93     ret = LoadAppSandboxConfig(sandbox, MODE_FOR_APP_SPAWN);  // 重复load
94     EXPECT_EQ(ret, 0);
95 
96     DeleteAppSpawnSandbox(sandbox);
97     DeleteAppSpawnMgr(mgr);
98 
99     ret = LoadAppSandboxConfig(nullptr, MODE_FOR_APP_SPAWN);
100     EXPECT_NE(ret, 0);
101 }
102 
103 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_AppSpawnSandboxCfg_003, TestSize.Level0)
104 {
105     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
106     EXPECT_EQ(mgr != nullptr, 1);
107 
108     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
109     EXPECT_EQ(sandbox != nullptr, 1);
110     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
111     int ret = 0;
112 #ifdef APPSPAWN_SANDBOX_NEW
113     // for nwebspawn
114     ret = LoadAppSandboxConfig(sandbox, MODE_FOR_NWEB_SPAWN);
115     EXPECT_EQ(ret, 0);
116     ret = LoadAppSandboxConfig(sandbox, MODE_FOR_NWEB_SPAWN);  // 重复load
117     EXPECT_EQ(ret, 0);
118     ret = LoadAppSandboxConfig(sandbox, MODE_FOR_NWEB_SPAWN);  // 重复load
119     EXPECT_EQ(ret, 0);
120 #else
121     // for nwebspawn
122     ret = LoadAppSandboxConfig(sandbox, MODE_FOR_NWEB_SPAWN);
123     EXPECT_EQ(ret, 0);
124     ret = LoadAppSandboxConfig(sandbox, MODE_FOR_NWEB_SPAWN);  // 重复load
125     EXPECT_EQ(ret, 0);
126 #endif
127     DeleteAppSpawnSandbox(sandbox);
128     DeleteAppSpawnMgr(mgr);
129 
130     ret = LoadAppSandboxConfig(nullptr, MODE_FOR_NWEB_SPAWN);
131     EXPECT_NE(ret, 0);
132 }
133 
134 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxSection_001, TestSize.Level0)
135 {
136     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
137     EXPECT_EQ(mgr != nullptr, 1);
138 
139     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
140     EXPECT_EQ(sandbox != nullptr, 1);
141     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
142 
143     const uint32_t nameCount = 3;
144     const uint32_t lenCount = 7;
145     const char *inputName[nameCount] = {"test-001", nullptr, ""};
146     const uint32_t inputDataLen[lenCount] = {
147         0,
148         sizeof(SandboxSection),
149         sizeof(SandboxPackageNameNode),
150         sizeof(SandboxFlagsNode),
151         sizeof(SandboxNameGroupNode),
152         sizeof(SandboxPermissionNode),
153         sizeof(SandboxNameGroupNode) + 100
154     };
155     int result[lenCount] = {0};
156     result[1] = 1;
157     result[2] = 1;
158     result[3] = 1;
159     result[4] = 1;
160     result[5] = 1;
__anona643db180102(const char *name, uint32_t len, size_t nameIndex, size_t lenIndex) 161     auto testFunc = [result](const char *name, uint32_t len, size_t nameIndex, size_t lenIndex) {
162         for (size_t type = SANDBOX_TAG_PERMISSION; type <= SANDBOX_TAG_REQUIRED; type++) {
163             SandboxSection *section = CreateSandboxSection(name, len, type);
164             EXPECT_EQ(section != nullptr, nameIndex == 0 && result[lenIndex]);
165             if (section) {
166                 EXPECT_EQ(GetSectionType(section), type);
167                 free(section->name);
168                 free(section);
169             }
170         }
171     };
172     for (size_t i = 0; i < nameCount; i++) {
173         for (size_t j = 0; j < lenCount; j++) {
174             testFunc(inputName[i], inputDataLen[j], i, j);
175         }
176     }
177     DeleteAppSpawnSandbox(sandbox);
178     DeleteAppSpawnMgr(mgr);
179 }
180 
181 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxSection_002, TestSize.Level0)
182 {
183     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
184     EXPECT_EQ(mgr != nullptr, 1);
185 
186     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
187     EXPECT_EQ(sandbox != nullptr, 1);
188     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
189 
190     const uint32_t nameCount = 3;
191     const uint32_t lenCount = 7;
192     const char *inputName[nameCount] = {"test-001", nullptr, ""};
193     const uint32_t inputDataLen[lenCount] = {
194         0,
195         sizeof(SandboxSection),
196         sizeof(SandboxPackageNameNode),
197         sizeof(SandboxFlagsNode),
198         sizeof(SandboxNameGroupNode),
199         sizeof(SandboxPermissionNode),
200         sizeof(SandboxNameGroupNode) + 100
201     };
202     for (size_t i = 0; i < nameCount; i++) {
203         for (size_t j = 0; j < lenCount; j++) {
204             SandboxSection *section = CreateSandboxSection(inputName[i], inputDataLen[j], 0);
205             EXPECT_EQ(section == nullptr, 1);
206             section = CreateSandboxSection(inputName[i], inputDataLen[j], 1);
207             EXPECT_EQ(section == nullptr, 1);
208             section = CreateSandboxSection(inputName[i], inputDataLen[j], SANDBOX_TAG_INVALID);
209             EXPECT_EQ(section == nullptr, 1);
210             section = CreateSandboxSection(inputName[i], inputDataLen[j], SANDBOX_TAG_INVALID + 1);
211             EXPECT_EQ(section == nullptr, 1);
212         }
213     }
214     DeleteAppSpawnSandbox(sandbox);
215     DeleteAppSpawnMgr(mgr);
216 }
217 
218 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxSection_003, TestSize.Level0)
219 {
220     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
221     EXPECT_EQ(mgr != nullptr, 1);
222 
223     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
224     EXPECT_EQ(sandbox != nullptr, 1);
225     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
226 
227     SandboxSection *section = CreateSandboxSection("system-const", sizeof(SandboxSection), SANDBOX_TAG_SYSTEM_CONST);
228     EXPECT_EQ(section != nullptr, 1);
229     AddSandboxSection(section, &sandbox->requiredQueue);
230     // GetSandboxSection
231     section = GetSandboxSection(&sandbox->requiredQueue, "system-const");
232     EXPECT_EQ(section != nullptr, 1);
233     // DeleteSandboxSection
234     DeleteSandboxSection(section);
235 
236     // GetSandboxSection has deleted
237     section = GetSandboxSection(&sandbox->requiredQueue, "system-const");
238     EXPECT_EQ(section != nullptr, 0);
239 
240     DeleteAppSpawnSandbox(sandbox);
241     DeleteAppSpawnMgr(mgr);
242 }
243 
244 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxSection_004, TestSize.Level0)
245 {
246     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
247     EXPECT_EQ(mgr != nullptr, 1);
248 
249     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
250     EXPECT_EQ(sandbox != nullptr, 1);
251     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
252 
253     AddSandboxSection(nullptr, &sandbox->requiredQueue);
254     AddSandboxSection(nullptr, nullptr);
255 
256     // GetSandboxSection
257     SandboxSection *section = GetSandboxSection(nullptr, "system-const");
258     EXPECT_EQ(section == nullptr, 1);
259     section = GetSandboxSection(nullptr, "");
260     EXPECT_EQ(section == nullptr, 1);
261     section = GetSandboxSection(nullptr, nullptr);
262     EXPECT_EQ(section == nullptr, 1);
263     section = GetSandboxSection(&sandbox->requiredQueue, "");
264     EXPECT_EQ(section == nullptr, 1);
265     section = GetSandboxSection(&sandbox->requiredQueue, nullptr);
266     EXPECT_EQ(section == nullptr, 1);
267 
268     // DeleteSandboxSection
269     DeleteSandboxSection(section);
270     DeleteSandboxSection(nullptr);
271 
272     // GetSandboxSection has deleted
273     section = GetSandboxSection(&sandbox->requiredQueue, "system-const");
274     EXPECT_EQ(section == nullptr, 1);
275 
276     EXPECT_EQ(GetSectionType(nullptr), SANDBOX_TAG_INVALID);
277 
278     DeleteAppSpawnSandbox(sandbox);
279     DeleteAppSpawnMgr(mgr);
280 }
281 
282 /**
283  * @brief SandboxMountNode
284  *
285  */
286 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxMountNode_001, TestSize.Level0)
287 {
288     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
289     EXPECT_EQ(mgr != nullptr, 1);
290 
291     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
292     EXPECT_EQ(sandbox != nullptr, 1);
293     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
294 
295     SandboxSection *section = CreateSandboxSection("system-const", sizeof(SandboxSection), SANDBOX_TAG_SYSTEM_CONST);
296     EXPECT_EQ(section != nullptr, 1);
297     AddSandboxSection(section, &sandbox->requiredQueue);
298 
299     const uint32_t lenCount = 4;
300     const uint32_t inputDataLen[lenCount] = {
301         0,
302         sizeof(PathMountNode),
303         sizeof(SymbolLinkNode),
304         sizeof(SymbolLinkNode) + 100
305     };
306     int result[lenCount] = {0, 1, 1, 0};
307     for (size_t i = 0; i < lenCount; i++) {
308         for (size_t j = 0; j < SANDBOX_TAG_INVALID; j++) {
309             SandboxMountNode *path = CreateSandboxMountNode(inputDataLen[i], j);
310             EXPECT_EQ(path != nullptr, result[i]);
311             if (path) {
312                 free(path);
313             }
314         }
315     }
316 
317     DeleteAppSpawnSandbox(sandbox);
318     DeleteAppSpawnMgr(mgr);
319 }
320 
321 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxMountNode_002, TestSize.Level0)
322 {
323     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
324     EXPECT_EQ(mgr != nullptr, 1);
325 
326     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
327     EXPECT_EQ(sandbox != nullptr, 1);
328     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
329 
330     SandboxSection *section = CreateSandboxSection("system-const", sizeof(SandboxSection), SANDBOX_TAG_SYSTEM_CONST);
331     EXPECT_EQ(section != nullptr, 1);
332     AddSandboxSection(section, &sandbox->requiredQueue);
333 
334     SandboxMountNode *path = CreateSandboxMountNode(sizeof(PathMountNode), SANDBOX_TAG_MOUNT_PATH);
335     EXPECT_EQ(path != nullptr, 1);
336     AddSandboxMountNode(path, section);
337 
338     path = GetFirstSandboxMountNode(section);
339     EXPECT_EQ(path != nullptr, 1);
340     DeleteSandboxMountNode(path);
341     path = GetFirstSandboxMountNode(section);
342     EXPECT_EQ(path == nullptr, 1);
343 
344     path = GetFirstSandboxMountNode(nullptr);
345     EXPECT_EQ(path == nullptr, 1);
346     DeleteSandboxMountNode(nullptr);
347 
348     DeleteAppSpawnSandbox(sandbox);
349     DeleteAppSpawnMgr(mgr);
350 }
351 
352 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxMountNode_003, TestSize.Level0)
353 {
354     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
355     EXPECT_EQ(mgr != nullptr, 1);
356 
357     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
358     EXPECT_EQ(sandbox != nullptr, 1);
359     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
360 
361     SandboxSection *section = CreateSandboxSection("system-const", sizeof(SandboxSection), SANDBOX_TAG_SYSTEM_CONST);
362     EXPECT_EQ(section != nullptr, 1);
363     AddSandboxSection(section, &sandbox->requiredQueue);
364 
365     SandboxMountNode *path = CreateSandboxMountNode(sizeof(PathMountNode), SANDBOX_TAG_MOUNT_PATH);
366     EXPECT_EQ(path != nullptr, 1);
367     PathMountNode *pathNode = reinterpret_cast<PathMountNode *>(path);
368     const char *testPath = "xxx/xxx/xxx";
369     pathNode->source = strdup(testPath);
370     pathNode->target = strdup(testPath);
371     AddSandboxMountNode(path, section);
372 
373     pathNode = GetPathMountNode(section, SANDBOX_TAG_MOUNT_PATH, testPath, testPath);
374     EXPECT_EQ(pathNode != nullptr, 1);
375 
376     // 异常
377     for (size_t j = 0; j < SANDBOX_TAG_INVALID; j++) {
378         pathNode = GetPathMountNode(section, j, testPath, testPath);
379         EXPECT_EQ(pathNode != nullptr, j == SANDBOX_TAG_MOUNT_PATH);
380         pathNode = GetPathMountNode(section, j, nullptr, testPath);
381         EXPECT_EQ(pathNode != nullptr, 0);
382         pathNode = GetPathMountNode(section, j, nullptr, nullptr);
383         EXPECT_EQ(pathNode != nullptr, 0);
384         pathNode = GetPathMountNode(section, j, testPath, nullptr);
385         EXPECT_EQ(pathNode != nullptr, 0);
386 
387         EXPECT_EQ(pathNode != nullptr, 0);
388         pathNode = GetPathMountNode(nullptr, j, nullptr, testPath);
389         EXPECT_EQ(pathNode != nullptr, 0);
390         pathNode = GetPathMountNode(nullptr, j, nullptr, nullptr);
391         EXPECT_EQ(pathNode != nullptr, 0);
392         pathNode = GetPathMountNode(nullptr, j, testPath, nullptr);
393         EXPECT_EQ(pathNode != nullptr, 0);
394     }
395 
396     DeleteAppSpawnSandbox(sandbox);
397     DeleteAppSpawnMgr(mgr);
398 }
399 
400 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_SandboxMountNode_004, TestSize.Level0)
401 {
402     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
403     EXPECT_EQ(mgr != nullptr, 1);
404 
405     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
406     EXPECT_EQ(sandbox != nullptr, 1);
407     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
408 
409     SandboxSection *section = CreateSandboxSection("system-const", sizeof(SandboxSection), SANDBOX_TAG_SYSTEM_CONST);
410     EXPECT_EQ(section != nullptr, 1);
411     AddSandboxSection(section, &sandbox->requiredQueue);
412 
413     SandboxMountNode *path = CreateSandboxMountNode(sizeof(SymbolLinkNode), SANDBOX_TAG_SYMLINK);
414     EXPECT_EQ(path != nullptr, 1);
415     SymbolLinkNode *pathNode = reinterpret_cast<SymbolLinkNode *>(path);
416     const char *testPath = "xxx/xxx/xxx";
417     pathNode->linkName = strdup(testPath);
418     pathNode->target = strdup(testPath);
419     AddSandboxMountNode(path, section);
420 
421     pathNode = GetSymbolLinkNode(section, testPath, testPath);
422     EXPECT_EQ(pathNode != nullptr, 1);
423 
424     // 异常
425     pathNode = GetSymbolLinkNode(section, testPath, testPath);
426     EXPECT_EQ(pathNode != nullptr, 1);
427     pathNode = GetSymbolLinkNode(section, nullptr, testPath);
428     EXPECT_EQ(pathNode != nullptr, 0);
429     pathNode = GetSymbolLinkNode(section, nullptr, nullptr);
430     EXPECT_EQ(pathNode != nullptr, 0);
431     pathNode = GetSymbolLinkNode(section, testPath, nullptr);
432     EXPECT_EQ(pathNode != nullptr, 0);
433 
434     EXPECT_EQ(pathNode != nullptr, 0);
435     pathNode = GetSymbolLinkNode(nullptr, nullptr, testPath);
436     EXPECT_EQ(pathNode != nullptr, 0);
437     pathNode = GetSymbolLinkNode(nullptr, nullptr, nullptr);
438     EXPECT_EQ(pathNode != nullptr, 0);
439     pathNode = GetSymbolLinkNode(nullptr, testPath, nullptr);
440     EXPECT_EQ(pathNode != nullptr, 0);
441 
442     DeleteAppSpawnSandbox(sandbox);
443     DeleteAppSpawnMgr(mgr);
444 }
445 
446 /**
447  * @brief mount
448  *
449  */
TestCreateAppSpawningCtx()450 static AppSpawningCtx *TestCreateAppSpawningCtx()
451 {
452     // get from buffer
453     AppSpawnTestHelper testHelper;
454     std::vector<uint8_t> buffer(1024 * 2);  // 1024 * 2  max buffer
455     uint32_t msgLen = 0;
456     int ret = testHelper.CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
457     EXPECT_EQ(0, ret);
458 
459     AppSpawnMsgNode *outMsg = nullptr;
460     uint32_t msgRecvLen = 0;
461     uint32_t reminder = 0;
462     ret = GetAppSpawnMsgFromBuffer(buffer.data(), msgLen, &outMsg, &msgRecvLen, &reminder);
463     EXPECT_EQ(0, ret);
464     EXPECT_EQ(msgLen, msgRecvLen);
465     EXPECT_EQ(memcmp(buffer.data() + sizeof(AppSpawnMsg), outMsg->buffer, msgLen - sizeof(AppSpawnMsg)), 0);
466     EXPECT_EQ(0, reminder);
467     ret = DecodeAppSpawnMsg(outMsg);
468     EXPECT_EQ(0, ret);
469     AppSpawningCtx *appCtx = CreateAppSpawningCtx();
470     EXPECT_EQ(appCtx != nullptr, 1);
471     appCtx->message = outMsg;
472     return appCtx;
473 }
474 
475 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Mount_001, TestSize.Level0)
476 {
477     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
478     EXPECT_EQ(mgr != nullptr, 1);
479 
480     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
481     EXPECT_EQ(sandbox != nullptr, 1);
482     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
483 
484     AppSpawningCtx *property = TestCreateAppSpawningCtx();
485     EXPECT_EQ(property != nullptr, 1);
486 
487     // 只做异常测试，正常流程需要基于业务流进行测试
488     const AppSpawningCtx *inputAppSpawningCtx[2] = {property, nullptr};
489     const AppSpawnSandboxCfg *inputAppSpawnSandboxCfg[2] = {sandbox, nullptr};
490     uint32_t inputSpawn[3] = {0, 1, 2};
491     int ret = 0;
492     for (uint32_t i = 0; i < 2; i++) {          // 2
493         for (uint32_t j = 0; j < 2; j++) {      // 2
494             for (uint32_t k = 0; k < 2; k++) {  // 2
495                 ret = MountSandboxConfigs(inputAppSpawnSandboxCfg[i], inputAppSpawningCtx[j], inputSpawn[k]);
496                 EXPECT_EQ(ret == 0, i == 0 && j == 0);
497             }
498         }
499     }
500 
501     for (uint32_t i = 0; i < 2; i++) {          // 2
502         for (uint32_t j = 0; j < 2; j++) {      // 2
503             for (uint32_t k = 0; k < 2; k++) {  // 2
504                 ret = StagedMountSystemConst(inputAppSpawnSandboxCfg[i], inputAppSpawningCtx[j], inputSpawn[k]);
505                 EXPECT_EQ(ret == 0, i == 0 && j == 0);
506             }
507         }
508     }
509 
510     DeleteAppSpawningCtx(property);
511     DeleteAppSpawnSandbox(sandbox);
512     DeleteAppSpawnMgr(mgr);
513 }
514 
515 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Mount_002, TestSize.Level0)
516 {
517     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
518     EXPECT_EQ(mgr != nullptr, 1);
519 
520     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
521     EXPECT_EQ(sandbox != nullptr, 1);
522     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
523 
524     SandboxContext context = {};
525     // 只做异常测试，正常流程需要基于业务流进行测试
526     const SandboxContext *inputContext[2] = {&context, nullptr};
527     const AppSpawnSandboxCfg *inputAppSpawnSandboxCfg[2] = {sandbox, nullptr};
528 
529     int ret = 0;
530     for (uint32_t i = 0; i < 2; i++) {      // 2
531         for (uint32_t j = 0; j < 2; j++) {  // 2
532             ret = StagedMountPreUnShare(inputContext[i], inputAppSpawnSandboxCfg[j]);
533             EXPECT_EQ(ret == 0, i == 0 && j == 0);
534         }
535     }
536 
537     for (uint32_t i = 0; i < 2; i++) {      // 2
538         for (uint32_t j = 0; j < 2; j++) {  // 2
539             ret = StagedMountPostUnshare(inputContext[i], inputAppSpawnSandboxCfg[j]);
540             EXPECT_EQ(ret == 0, i == 0 && j == 0);
541         }
542     }
543 
544     DeleteAppSpawnSandbox(sandbox);
545     DeleteAppSpawnMgr(mgr);
546 }
547 
548 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Mount_003, TestSize.Level0)
549 {
550     AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN);
551     EXPECT_EQ(mgr != nullptr, 1);
552 
553     AppSpawnSandboxCfg *sandbox = CreateAppSpawnSandbox();
554     EXPECT_EQ(sandbox != nullptr, 1);
555     sandbox->rootPath = strdup("/data/appspawn_ut/sandbox/");
556     OH_ListAddTail(&sandbox->extData.node, &mgr->extData);
557 
558     // 只做异常测试，正常流程需要基于业务流进行测试
559     const AppSpawnSandboxCfg *inputAppSpawnSandboxCfg[2] = {sandbox, nullptr};
560     const char *inputName[2] = {"test", nullptr};
561 
562     for (uint32_t k = 0; k < 2; k++) {  // 2
563         int ret = UnmountDepPaths(inputAppSpawnSandboxCfg[k], 0);
564         EXPECT_EQ(ret == 0, k == 0);
565     }
566     for (uint32_t i = 0; i < 2; i++) {      // 2
567         for (uint32_t k = 0; k < 2; k++) {  // 2
568             int ret = UnmountSandboxConfigs(inputAppSpawnSandboxCfg[k], 0, inputName[i]);
569             EXPECT_EQ(ret == 0, k == 0 && i == 0);
570         }
571     }
572     DeleteAppSpawnSandbox(sandbox);
573     DeleteAppSpawnMgr(mgr);
574 }
575 
576 /**
577  * @brief SandboxMountPath
578  *
579  */
580 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Add_App_SandboxMountPath_001, TestSize.Level0)
581 {
582     MountArg arg = {};
583     arg.originPath = "/data/";
584     arg.destinationPath = "/data/appspawn/test";
585     arg.mountSharedFlag = 1;
586 
587     int ret = SandboxMountPath(&arg);
588     EXPECT_EQ(ret, 0);
589     ret = SandboxMountPath(&arg);
590     EXPECT_EQ(ret, 0);
591     ret = SandboxMountPath(nullptr);
592     EXPECT_NE(ret, 0);
593     arg.mountSharedFlag = -1;
594     ret = SandboxMountPath(&arg);
595     EXPECT_EQ(ret, 0);
596 }
597 
598 /**
599  * @brief AddVariableReplaceHandler
600  *
601  */
TestReplaceVarHandler(const SandboxContext * context,const char * buffer,uint32_t bufferLen,uint32_t * realLen,const VarExtraData * extraData)602 static int TestReplaceVarHandler(const SandboxContext *context,
603     const char *buffer, uint32_t bufferLen, uint32_t *realLen, const VarExtraData *extraData)
604 {
605     return 0;
606 }
607 
608 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_AddVariableReplaceHandler_001, TestSize.Level0)
609 {
610     int ret = AddVariableReplaceHandler(nullptr, nullptr);
611     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
612     ret = AddVariableReplaceHandler("xxx", nullptr);
613     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
614     ret = AddVariableReplaceHandler(nullptr, TestReplaceVarHandler);
615     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
616 
617     ret = AddVariableReplaceHandler("global", TestReplaceVarHandler);
618     EXPECT_EQ(ret, 0);
619     ret = AddVariableReplaceHandler("global", TestReplaceVarHandler);
620     EXPECT_EQ(ret, APPSPAWN_NODE_EXIST);
621 
622     ret = AddVariableReplaceHandler("<Test-Var-005>", TestReplaceVarHandler);
623     EXPECT_EQ(ret, 0);
624 }
625 
626 /**
627  * @brief RegisterExpandSandboxCfgHandler
628  *
629  */
TestProcessExpandSandboxCfg(const SandboxContext * context,const AppSpawnSandboxCfg * appSandBox,const char * name)630 static int TestProcessExpandSandboxCfg(const SandboxContext *context,
631     const AppSpawnSandboxCfg *appSandBox, const char *name)
632 {
633     return 0;
634 }
635 
636 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_RegisterExpandSandboxCfgHandler_001, TestSize.Level0)
637 {
638     int ret = RegisterExpandSandboxCfgHandler(nullptr, 0, nullptr);
639     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
640     ret = RegisterExpandSandboxCfgHandler("test", 0, nullptr);
641     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
642     ret = RegisterExpandSandboxCfgHandler(nullptr, 0, TestProcessExpandSandboxCfg);
643     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
644 
645     ret = RegisterExpandSandboxCfgHandler("test-001", 0, TestProcessExpandSandboxCfg);
646     EXPECT_EQ(ret, 0);
647     ret = RegisterExpandSandboxCfgHandler("test-001", 0, TestProcessExpandSandboxCfg);
648     EXPECT_EQ(ret, APPSPAWN_NODE_EXIST);
649     ret = RegisterExpandSandboxCfgHandler("test-001", -1, TestProcessExpandSandboxCfg);
650     EXPECT_EQ(ret, APPSPAWN_NODE_EXIST);
651 }
652 
653 /**
654  * @brief permission test
655  *
656  */
657 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Permission_001, TestSize.Level0)
658 {
659     int ret = LoadPermission(CLIENT_FOR_APPSPAWN);
660     EXPECT_EQ(ret, 0);
661     ret = LoadPermission(CLIENT_FOR_NWEBSPAWN);
662     EXPECT_EQ(ret, 0);
663     ret = LoadPermission(CLIENT_MAX);
664     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
665 
666     int32_t max = GetPermissionMaxCount();
667     EXPECT_EQ(max >= 0, 1);
668 
669     DeletePermission(CLIENT_FOR_APPSPAWN);
670     DeletePermission(CLIENT_FOR_NWEBSPAWN);
671     DeletePermission(CLIENT_MAX);
672 }
673 
674 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Permission_002, TestSize.Level0)
675 {
676     int ret = LoadPermission(CLIENT_FOR_APPSPAWN);
677     EXPECT_EQ(ret, 0);
678     ret = LoadPermission(CLIENT_FOR_NWEBSPAWN);
679     EXPECT_EQ(ret, 0);
680 
681     int32_t max = GetPermissionMaxCount();
682     EXPECT_EQ(max >= 0, 1);
683 
684     AppSpawnClientHandle clientHandle;
685     ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
686     EXPECT_EQ(ret, 0);
687 
688     max = GetMaxPermissionIndex(clientHandle);
689     int32_t index = GetPermissionIndex(clientHandle, "ohos.permission.ACCESS_BUNDLE_DIR");
690     EXPECT_EQ(index >= 0, 1);
691     EXPECT_EQ(index < max, 1);
692 
693     const char *permission = GetPermissionByIndex(clientHandle, index);
694     EXPECT_EQ(permission != nullptr, 1);
695     EXPECT_EQ(strcmp(permission, "ohos.permission.ACCESS_BUNDLE_DIR") == 0, 1);
696     AppSpawnClientDestroy(clientHandle);
697 }
698 
699 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Permission_003, TestSize.Level0)
700 {
701     int ret = LoadPermission(CLIENT_FOR_APPSPAWN);
702     EXPECT_EQ(ret, 0);
703     ret = LoadPermission(CLIENT_FOR_NWEBSPAWN);
704     EXPECT_EQ(ret, 0);
705     ret = LoadPermission(CLIENT_MAX);
706     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
707 
708     int32_t max = GetPermissionMaxCount();
709     EXPECT_EQ(max >= 0, 1);
710 
711     AppSpawnClientHandle clientHandle;
712     ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle);
713     EXPECT_EQ(ret, 0);
714 
715 #ifndef APPSPAWN_SANDBOX_NEW
716     max = GetMaxPermissionIndex(clientHandle);
717     int32_t index = GetPermissionIndex(clientHandle, "ohos.permission.ACCESS_BUNDLE_DIR");
718     EXPECT_EQ(index >= 0, 1);
719     EXPECT_EQ(max >= index, 1);
720 
721     const char *permission = GetPermissionByIndex(clientHandle, index);
722     EXPECT_EQ(permission != nullptr, 1);
723     EXPECT_EQ(strcmp(permission, "ohos.permission.ACCESS_BUNDLE_DIR") == 0, 1);
724 #else
725     // nweb no permission, so max = 0
726     max = GetMaxPermissionIndex(clientHandle);
727     EXPECT_EQ(max, 0);
728 #endif
729     AppSpawnClientDestroy(clientHandle);
730 }
731 
732 HWTEST_F(AppSpawnSandboxMgrTest, App_Spawn_Permission_004, TestSize.Level0)
733 {
734     int ret = LoadPermission(CLIENT_FOR_APPSPAWN);
735     EXPECT_EQ(ret, 0);
736     ret = LoadPermission(CLIENT_FOR_NWEBSPAWN);
737     EXPECT_EQ(ret, 0);
738     ret = LoadPermission(CLIENT_MAX);
739     EXPECT_EQ(ret, APPSPAWN_ARG_INVALID);
740 
741     int32_t max = GetPermissionMaxCount();
742     EXPECT_EQ(max >= 0, 1);
743 
744     AppSpawnClientHandle clientHandle;
745     ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle);
746     EXPECT_EQ(ret, 0);
747 
748     max = GetMaxPermissionIndex(nullptr);
749     EXPECT_EQ(max >= 0, 1);
750 
751     int32_t index = GetPermissionIndex(clientHandle, nullptr);
752     EXPECT_EQ(index, INVALID_PERMISSION_INDEX);
753     index = GetPermissionIndex(nullptr, "ohos.permission.ACCESS_BUNDLE_DIR");
754     EXPECT_EQ(max >= index, 1);
755     const char *permission = GetPermissionByIndex(clientHandle, INVALID_PERMISSION_INDEX);
756     EXPECT_EQ(permission == nullptr, 1);
757 
758     AppSpawnClientDestroy(clientHandle);
759 }
760 }  // namespace OHOS
761