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
16 #include <gtest/gtest.h>
17 #include "edm_constants.h"
18 #include "edm_ipc_interface_code.h"
19 #include "parameters.h"
20 #include "set_watermark_image_plugin.h"
21 #include "utils.h"
22 #include "watermark_image_serializer.h"
23
24 using namespace testing::ext;
25 using namespace testing;
26
27 namespace OHOS {
28 namespace EDM {
29 namespace TEST {
30
31 class SetWatermarkImagePluginTest : public testing::Test {
32 protected:
33 static void SetUpTestSuite(void);
34
35 static void TearDownTestSuite(void);
36 };
37
SetUpTestSuite(void)38 void SetWatermarkImagePluginTest::SetUpTestSuite(void)
39 {
40 Utils::SetEdmInitialEnv();
41 }
42
TearDownTestSuite(void)43 void SetWatermarkImagePluginTest::TearDownTestSuite(void)
44 {
45 Utils::ResetTokenTypeAndUid();
46 ASSERT_TRUE(Utils::IsOriginalUTEnv());
47 std::cout << "now ut process is original ut env : " << Utils::IsOriginalUTEnv() << std::endl;
48 }
49
50 /**
51 * @tc.name: TestSetSingleWatermarkImageEmpty
52 * @tc.desc: Test SetWatermarkImagePlugin::SetSingleWatermarkImage function when param is null.
53 * @tc.type: FUNC
54 */
55 HWTEST_F(SetWatermarkImagePluginTest, TestSetSingleWatermarkImageEmpty, TestSize.Level1)
56 {
57 SetWatermarkImagePlugin plugin;
58 std::uint32_t funcCode =
59 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::WATERMARK_IMAGE);
60 MessageParcel data;
61 data.WriteString(EdmConstants::SecurityManager::SET_SINGLE_WATERMARK_TYPE);
62 MessageParcel reply;
63 HandlePolicyData policyData;
64 ErrCode ret = plugin.OnHandlePolicy(funcCode, data, reply, policyData, 100);
65 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
66 }
67
68 /**
69 * @tc.name: TestSetSingleWatermarkImageMax
70 * @tc.desc: Test SetWatermarkImagePlugin::SetSingleWatermarkImage function when policy over max num.
71 * @tc.type: FUNC
72 */
73 HWTEST_F(SetWatermarkImagePluginTest, TestSetSingleWatermarkImageMax, TestSize.Level1)
74 {
75 SetWatermarkImagePlugin plugin;
76 std::uint32_t funcCode =
77 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::WATERMARK_IMAGE);
78 MessageParcel data;
79 MessageParcel reply;
80 HandlePolicyData policyData;
81
82 data.WriteString(EdmConstants::SecurityManager::SET_SINGLE_WATERMARK_TYPE);
83 data.WriteString("testBundleName");
84 data.WriteInt32(100);
85 data.WriteInt32(400);
86 data.WriteInt32(400);
87 int32_t size = 200;
88 data.WriteInt32(size);
89 void* pixels = malloc(size);
90 ASSERT_TRUE(pixels != nullptr);
91 data.WriteRawData(pixels, size);
92
93 std::map<std::pair<std::string, int32_t>, WatermarkImageType> currentData;
94 for (int32_t i = 101; i <= 200; i++) {
95 currentData[{"testBundleName", i}] = WatermarkImageType{"testFileName", 100, 100};
96 }
97 auto serializer = WatermarkImageSerializer::GetInstance();
98 serializer->Serialize(currentData, policyData.policyData);
99
100 ErrCode ret = plugin.OnHandlePolicy(funcCode, data, reply, policyData, 100);
101 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
102 }
103
104 /**
105 * @tc.name: TestSetSingleWatermarkImage
106 * @tc.desc: Test SetWatermarkImagePlugin::SetSingleWatermarkImage function.
107 * @tc.type: FUNC
108 */
109 HWTEST_F(SetWatermarkImagePluginTest, TestSetSingleWatermarkImage, TestSize.Level1)
110 {
111 SetWatermarkImagePlugin plugin;
112 std::uint32_t funcCode =
113 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::WATERMARK_IMAGE);
114 MessageParcel data;
115 data.WriteString(EdmConstants::SecurityManager::SET_SINGLE_WATERMARK_TYPE);
116 data.WriteString("testBundleName");
117 data.WriteInt32(100);
118 data.WriteInt32(400);
119 data.WriteInt32(400);
120 int32_t size = 200;
121 data.WriteInt32(size);
122 void* pixels = malloc(size);
123 ASSERT_TRUE(pixels != nullptr);
124 data.WriteRawData(pixels, size);
125 MessageParcel reply;
126 HandlePolicyData policyData;
127 ErrCode ret = plugin.OnHandlePolicy(funcCode, data, reply, policyData, 100);
128 std::string deviceType = system::GetParameter("const.product.devicetype", "");
129 if (deviceType != "2in1") {
130 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
131 } else {
132 ASSERT_TRUE(ret == ERR_OK);
133 ASSERT_FALSE(policyData.policyData.empty());
134 }
135 }
136
137 /**
138 * @tc.name: TestCancelWatermarkImageEmpty
139 * @tc.desc: Test SetWatermarkImagePlugin::CancelWatermarkImage function when param is null.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(SetWatermarkImagePluginTest, TestCancelWatermarkImageEmpty, TestSize.Level1)
143 {
144 SetWatermarkImagePlugin plugin;
145 std::uint32_t funcCode =
146 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::WATERMARK_IMAGE);
147 MessageParcel data;
148 MessageParcel reply;
149 HandlePolicyData policyData;
150 ErrCode ret = plugin.OnHandlePolicy(funcCode, data, reply, policyData, 100);
151 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
152 }
153
154 /**
155 * @tc.name: TestCancelWatermarkImage
156 * @tc.desc: Test SetWatermarkImagePlugin::CancelWatermarkImage function.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(SetWatermarkImagePluginTest, TestCancelWatermarkImage, TestSize.Level1)
160 {
161 SetWatermarkImagePlugin plugin;
162 std::uint32_t funcCode =
163 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::WATERMARK_IMAGE);
164 MessageParcel data;
165 data.WriteString("testBundleName");
166 data.WriteInt32(100);
167 MessageParcel reply;
168 HandlePolicyData policyData;
169 std::map<std::pair<std::string, int32_t>, WatermarkImageType> currentData;
170 currentData[{"testBundleName", 100}] = WatermarkImageType{"testFileName", 400, 400};
171 auto serializer = WatermarkImageSerializer::GetInstance();
172 serializer->Serialize(currentData, policyData.policyData);
173 ErrCode ret = plugin.OnHandlePolicy(funcCode, data, reply, policyData, 100);
174 std::string deviceType = system::GetParameter("const.product.devicetype", "");
175 if (deviceType != "2in1") {
176 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
177 } else {
178 ASSERT_TRUE(ret == ERR_OK);
179 ASSERT_TRUE(policyData.policyData.empty());
180 }
181 }
182
183 } // namespace TEST
184 } // namespace EDM
185 } // namespace OHOS