1 /*
2 * Copyright (c) 2022 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 <ipc_skeleton.h>
18
19 #include "edm_ipc_interface_code.h"
20 #include "edm_log.h"
21 #include "func_code_utils.h"
22 #include "array_string_serializer.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::EDM;
26
27 namespace OHOS {
28 namespace EDM {
29 namespace TEST {
30 class UtilsTest : public testing::Test {};
31 const std::string TEST_STRING_INDEX_ZORE = "19216811";
32 const std::string TEST_STRING_INDEX_ONE = "19216812";
33 const std::string TEST_STRING_INDEX_TWO = "19216813";
34 const std::string TEST_STRING_INDEX_THREE = "19216814";
35
36 /**
37 * @tc.name: Test_FuncCodeUtils_ConvertSystemFlag
38 * @tc.desc: Test FuncCodeUtils::ConvertOperateType.
39 * @tc.type: FUNC
40 */
HWTEST_F(UtilsTest, Test_FuncCodeUtils_ConvertSystemFlag, TestSize.Level1)41 HWTEST_F(UtilsTest, Test_FuncCodeUtils_ConvertSystemFlag, TestSize.Level1)
42 {
43 FuncOperateType type = FuncCodeUtils::ConvertOperateType(0);
44 ASSERT_EQ(type, FuncOperateType::GET);
45 type = FuncCodeUtils::ConvertOperateType(1);
46 ASSERT_EQ(type, FuncOperateType::SET);
47 type = FuncCodeUtils::ConvertOperateType(2);
48 ASSERT_EQ(type, FuncOperateType::REMOVE);
49 }
50
51 /**
52 * @tc.name: Test_FuncCodeUtils
53 * @tc.desc: Test FuncCodeUtils functions
54 * @tc.type: FUNC
55 */
HWTEST_F(UtilsTest, Test_FuncCodeUtils, TestSize.Level1)56 HWTEST_F(UtilsTest, Test_FuncCodeUtils, TestSize.Level1)
57 {
58 uint32_t code =
59 FuncCodeUtils::CreateFuncCode(1, (std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
60 ASSERT_TRUE(FuncCodeUtils::IsPolicyFlag(code));
61 ASSERT_FALSE(FuncCodeUtils::IsServiceFlag(code));
62 ASSERT_TRUE(FuncCodeUtils::GetOperateType(code) == FuncOperateType::SET);
63 ASSERT_TRUE(FuncCodeUtils::GetSystemFlag(code) == FuncFlag::POLICY_FLAG);
64 ASSERT_TRUE(FuncCodeUtils::GetPolicyCode(code) == EdmInterfaceCode::SET_DATETIME);
65
66 code = EdmInterfaceCode::ADD_DEVICE_ADMIN;
67 ASSERT_FALSE(FuncCodeUtils::IsPolicyFlag(code));
68 ASSERT_TRUE(FuncCodeUtils::IsServiceFlag(code));
69 }
70
71
72 /**
73 * @tc.name: Test_ArrayPolicyUtils_RemovePolicy
74 * @tc.desc: Test ArrayPolicyUtils::RemovePolicy.
75 * @tc.type: FUNC
76 */
HWTEST_F(UtilsTest, Test_ArrayPolicyUtils_RemovePolicy, TestSize.Level1)77 HWTEST_F(UtilsTest, Test_ArrayPolicyUtils_RemovePolicy, TestSize.Level1)
78 {
79 std::vector<std::string> removeData;
80 std::vector<std::string> currentData;
81
82 removeData = {TEST_STRING_INDEX_ZORE};
83 currentData = {TEST_STRING_INDEX_ZORE, TEST_STRING_INDEX_ONE, TEST_STRING_INDEX_TWO};
84 ArrayPolicyUtils::RemovePolicy(removeData, currentData);
85 ASSERT_TRUE(currentData.size() == 2);
86
87 removeData = {TEST_STRING_INDEX_ZORE};
88 currentData = {};
89 ArrayPolicyUtils::RemovePolicy(removeData, currentData);
90 ASSERT_TRUE(currentData.empty());
91
92 removeData = {};
93 currentData = {TEST_STRING_INDEX_ZORE, TEST_STRING_INDEX_ONE, TEST_STRING_INDEX_TWO};
94 ArrayPolicyUtils::RemovePolicy(removeData, currentData);
95 ASSERT_TRUE(currentData.size() == 3);
96
97 removeData = {TEST_STRING_INDEX_THREE};
98 currentData = {TEST_STRING_INDEX_ZORE, TEST_STRING_INDEX_ONE, TEST_STRING_INDEX_TWO};
99 ArrayPolicyUtils::RemovePolicy(removeData, currentData);
100 ASSERT_TRUE(currentData.size() == 3);
101 }
102
103 /**
104 * @tc.name: Test_ArrayPolicyUtils_ArrayStringContains
105 * @tc.desc: Test ArrayPolicyUtils::ArrayStringContains.
106 * @tc.type: FUNC
107 */
HWTEST_F(UtilsTest, Test_ArrayPolicyUtils_ArrayStringContains, TestSize.Level1)108 HWTEST_F(UtilsTest, Test_ArrayPolicyUtils_ArrayStringContains, TestSize.Level1)
109 {
110 std::vector<std::string> data;
111 std::string find = TEST_STRING_INDEX_ONE;
112 data = {TEST_STRING_INDEX_ZORE, TEST_STRING_INDEX_ONE, TEST_STRING_INDEX_TWO};
113 ASSERT_TRUE(ArrayPolicyUtils::ArrayStringContains(data, find));
114
115 find = TEST_STRING_INDEX_THREE;
116 data = {TEST_STRING_INDEX_ZORE, TEST_STRING_INDEX_ONE, TEST_STRING_INDEX_TWO};
117 ASSERT_FALSE(ArrayPolicyUtils::ArrayStringContains(data, find));
118
119 find = TEST_STRING_INDEX_THREE;
120 data = {};
121 ASSERT_FALSE(ArrayPolicyUtils::ArrayStringContains(data, find));
122 }
123
124 /**
125 * @tc.name: Test_ArrayPolicyUtils_RemovePolicy_002
126 * @tc.desc: Test ArrayPolicyUtils::RemovePolicy.
127 * @tc.type: FUNC
128 */
HWTEST_F(UtilsTest, Test_ArrayPolicyUtils_RemovePolicy_002, TestSize.Level1)129 HWTEST_F(UtilsTest, Test_ArrayPolicyUtils_RemovePolicy_002, TestSize.Level1)
130 {
131 std::vector<std::map<std::string, std::string>> removeData = {
132 {
133 {"id", "1"},
134 {"name", "leon"},
135 },
136 {
137 {"id", "2"},
138 {"name", "james"},
139 }};
140 std::vector<std::map<std::string, std::string>> data = {
141 {
142 {"id", "3"},
143 {"name", "fox"},
144 },
145 {
146 {"id", "1"},
147 {"name", "leon"},
148 },
149 };
150 // leon should be remove
151 ArrayPolicyUtils::RemovePolicy(removeData, data);
152 ASSERT_TRUE(data.size() == 1);
153
154 removeData = {
155 {
156 {"id", "1"},
157 {"name", "leon"},
158 },
159 {
160 {"id", "2"},
161 {"name", "james"},
162 }
163 };
164 data = {
165 {
166 {"id", "3"},
167 {"name", "fox"},
168 },
169 {
170 {"id", "4"},
171 {"name", "leon"},
172 },
173 };
174 ArrayPolicyUtils::RemovePolicy(removeData, data);
175 ASSERT_TRUE(data.size() == 2);
176 }
177
178 /**
179 * @tc.name: Test_ArrayStringSerializer_SetUnionPolicyData
180 * @tc.desc: Test ArrayStringSerializer::SetUnionPolicyData.
181 * @tc.type: FUNC
182 */
HWTEST_F(UtilsTest, Test_ArrayStringSerializer_SetUnionPolicyData, TestSize.Level1)183 HWTEST_F(UtilsTest, Test_ArrayStringSerializer_SetUnionPolicyData, TestSize.Level1)
184 {
185 std::vector<std::string> data = {"1", "2", "3", "4", "5"};
186 std::vector<std::string> currentData = {"3", "4", "5", "6", "7"};
187 auto serializer = ArrayStringSerializer::GetInstance();
188 std::vector<string> mergeData = serializer->SetUnionPolicyData(data, currentData);
189 std::vector<string> resultData;
190 size_t i = 0;
191 size_t j = 0;
192 while (i < data.size() && j < currentData.size()) {
193 if (data[i] == currentData[j]) {
194 resultData.push_back(data[i]);
195 i++;
196 j++;
197 } else if (data[i] < currentData[j]) {
198 resultData.push_back(data[i]);
199 i++;
200 } else {
201 resultData.push_back(currentData[j]);
202 j++;
203 }
204 }
205 while (i < data.size()) {
206 resultData.push_back(data[i]);
207 i++;
208 }
209 while (j < currentData.size()) {
210 resultData.push_back(currentData[j]);
211 j++;
212 }
213 ASSERT_TRUE(resultData.size() == mergeData.size());
214 }
215
216 /**
217 * @tc.name: Test_ArrayStringSerializer_SetDifferencePolicyData
218 * @tc.desc: Test ArrayStringSerializer::SetDifferencePolicyData.
219 * @tc.type: FUNC
220 */
HWTEST_F(UtilsTest, Test_ArrayStringSerializer_SetDifferencePolicyData, TestSize.Level1)221 HWTEST_F(UtilsTest, Test_ArrayStringSerializer_SetDifferencePolicyData, TestSize.Level1)
222 {
223 std::vector<std::string> data = {"1", "2", "3", "4", "5"};
224 std::vector<std::string> currentData = {"3", "4", "5", "6", "7"};
225 auto serializer = ArrayStringSerializer::GetInstance();
226 std::vector<string> mergeData = serializer->SetDifferencePolicyData(currentData, data);
227 size_t len = 0;
228 for (size_t i = 0; i < data.size(); i++) {
229 bool same = false;
230 for (size_t j = 0; j < currentData.size(); j++) {
231 if (data[i] == currentData[j]) {
232 same = true;
233 }
234 }
235 if (!same) {
236 ASSERT_TRUE(len < mergeData.size());
237 ASSERT_TRUE(data[i] == mergeData[len]);
238 len++;
239 }
240 }
241 ASSERT_TRUE(len == mergeData.size());
242 }
243 } // namespace TEST
244 } // namespace EDM
245 } // namespace OHOS
246