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  */
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  */
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  */
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  */
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  */
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  */
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  */
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