From 1c550a46829b38ad3e441019f189813b3e14e976 Mon Sep 17 00:00:00 2001 From: YinZong Date: Wed, 9 Apr 2025 08:54:17 +0000 Subject: [PATCH] update frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp. Signed-off-by: YinZong --- .../unittest/src/sandbox_manager_kit_test.cpp | 416 ++++++++++++++++++ 1 file changed, 416 insertions(+) diff --git a/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp b/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp index fb52e55..2ec9eb0 100644 --- a/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp +++ b/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp @@ -137,6 +137,7 @@ void SandboxManagerKitTest::SetUpTestCase() g_selfTokenId = GetSelfTokenID(); SetDeny("/A"); SetDeny("/C/D"); + SetDeny("/data/temp"); } void SandboxManagerKitTest::TearDownTestCase() @@ -835,6 +836,421 @@ HWTEST_F(SandboxManagerKitTest, PersistPolicy016, TestSize.Level1) } #endif +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest001 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest001, TestSize.Level0) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persistbytoken/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + + std::vector ret; + const uint32_t tokenId = 654321; // 123456 is a mocked tokenid. + auto start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(tokenId, policy, policyFlag, ret)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl; + + ASSERT_EQ(policySize, ret.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, ret[i]); + } + std::vector result; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(tokenId, policy, result)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl; + + ASSERT_EQ(policySize, result.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_TRUE(result[i]); + } +} +#endif + +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest002 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest002, TestSize.Level1) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persistbytoken/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + + std::vector ret; + const uint32_t tokenId = 654321; // 123456 is a mocked tokenid. + auto start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(tokenId, policy, policyFlag, ret)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl; + + ASSERT_EQ(policySize, ret.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, ret[i]); + } + + std::vector policyResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(tokenId, policy, policyResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, policyResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, policyResult[i]); + } + + std::vector checkResult1; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(tokenId, policy, checkResult1)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, checkResult1.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_TRUE(checkResult1[i]); + } +} +#endif + +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest003 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest003, TestSize.Level1) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persistbytoken/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + + std::vector ret; + const uint32_t tokenId = 654321; // 123456 is a mocked tokenid. + auto start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(tokenId, policy, policyFlag, ret)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, ret.size()); + + std::vector policyResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(tokenId, policy, policyResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, policyResult.size()); + + std::vector unPersistResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnPersistPolicy(tokenId, policy, unPersistResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "UnPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, unPersistResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, unPersistResult[i]); + } + + std::vector checkResult2; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(tokenId, policy, checkResult2)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, checkResult2.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_FALSE(checkResult2[i]); + } +} +#endif + +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest004 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest004, TestSize.Level1) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persist/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + + std::vector ret; + auto start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(g_mockToken, policy, policyFlag, ret)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, ret.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, ret[i]); + } + + std::vector policyResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(policy, policyResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, policyResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, policyResult[i]); + } + + std::vector checkResult1; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(g_mockToken, policy, checkResult1)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, checkResult1.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_TRUE(checkResult1[i]); + } +} +#endif + +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest005 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest005, TestSize.Level1) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persist/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + + std::vector ret; + auto start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(g_mockToken, policy, policyFlag, ret)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, ret.size()); + + std::vector policyResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(policy, policyResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, policyResult.size()); + + std::vector unPersistResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnPersistPolicy(policy, unPersistResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "UnPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, unPersistResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, unPersistResult[i]); + } + + std::vector checkResult2; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(g_mockToken, policy, checkResult2)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, unPersistResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_FALSE(checkResult2[i]); + } +} +#endif + +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest006 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest006, TestSize.Level1) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/async_accessing/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicyAsync(g_mockToken, policy, policyFlag)); + sleep(5); + + std::vector retType; + auto start = std::chrono::high_resolution_clock::now(); + EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(g_mockToken, policy, retType)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, retType.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, retType[i]); + } + + start = std::chrono::high_resolution_clock::now(); + EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnSetPolicyAsync(g_mockToken, policy[0])); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "UnSetPolicyAsync cost " << duration.count() << "s" << std::endl; + sleep(1); + + start = std::chrono::high_resolution_clock::now(); + EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::StartAccessingPolicy(policy, retType)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "StartAccessingPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, retType.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, retType[i]); + } + + std::vector result; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(g_mockToken, policy, result)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, result.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_TRUE(result[i]); + } +} +#endif + +#ifdef DEC_ENABLED +/** + * @tc.name: MassiveIPCTest007 + * @tc.desc: IPC with massive policyinfos. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(SandboxManagerKitTest, MassiveIPCTest007, TestSize.Level1) +{ + std::vector policy; + uint64_t policySize = 90000; + uint64_t policyFlag = 1; + + for (uint64_t i = 0; i < policySize; i++) { + PolicyInfo info; + info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + char path[1024]; + sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/stop_access/%d", i); + info.path.assign(path); + policy.emplace_back(info); + } + std::vector result; + auto start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(g_mockToken, policy, policyFlag, result)); + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration duration = end - start; + std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, result.size()); + + std::vector persistResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(policy, persistResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, persistResult.size()); + + std::vector startResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::StopAccessingPolicy(policy, startResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "StopAccessingPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, startResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, startResult[i]); + } + + std::vector unPersistResult; + start = std::chrono::high_resolution_clock::now(); + ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnPersistPolicy(policy, unPersistResult)); + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + std::cout << "UnPersistPolicy cost " << duration.count() << "s" << std::endl; + ASSERT_EQ(policySize, unPersistResult.size()); + for (uint64_t i = 0; i < policySize; i++) { + EXPECT_EQ(OPERATE_SUCCESSFULLY, unPersistResult[i]); + } +} +#endif + #ifdef DEC_ENABLED /** * @tc.name: CheckPolicyTest001 -- Gitee