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 "array_int_serializer.h" 17 18 #include <gtest/gtest.h> 19 20 using namespace testing::ext; 21 22 namespace OHOS { 23 namespace EDM { 24 namespace TEST { 25 class ArrayIntSerializerTest : public testing::Test {}; 26 /** 27 * @tc.name: TestGetPolicy001 28 * @tc.desc: Test ArrayIntSerializer::GetPolicy func. 29 * @tc.type: FUNC 30 */ 31 HWTEST_F(ArrayIntSerializerTest, TestGetPolicy001, TestSize.Level1) 32 { 33 auto serializer = ArrayIntSerializer::GetInstance(); 34 MessageParcel data; 35 std::vector<int32_t> inputData; 36 inputData.push_back(1); 37 inputData.push_back(2); 38 data.WriteInt32Vector(inputData); 39 40 std::vector<int32_t> outputData; 41 bool ret = serializer->GetPolicy(data, outputData); 42 ASSERT_TRUE(ret); 43 EXPECT_TRUE(outputData.size() == 2); 44 } 45 46 /** 47 * @tc.name: TestGetPolicy002 48 * @tc.desc: Test ArrayIntSerializer::GetPolicy repeat data func. 49 * @tc.type: FUNC 50 */ 51 HWTEST_F(ArrayIntSerializerTest, TestGetPolicy002, TestSize.Level1) 52 { 53 auto serializer = ArrayIntSerializer::GetInstance(); 54 MessageParcel data; 55 std::vector<int32_t> inputData; 56 inputData.push_back(2); 57 inputData.push_back(2); 58 data.WriteInt32Vector(inputData); 59 60 std::vector<int32_t> outputData; 61 bool ret = serializer->GetPolicy(data, outputData); 62 ASSERT_TRUE(ret); 63 EXPECT_TRUE(outputData.size() == 1); 64 } 65 66 /** 67 * @tc.name: TestGetPolicy003 68 * @tc.desc: Test ArrayIntSerializer::GetPolicy func. 69 * @tc.type: FUNC 70 */ 71 HWTEST_F(ArrayIntSerializerTest, TestGetPolicy003, TestSize.Level1) 72 { 73 auto serializer = ArrayIntSerializer::GetInstance(); 74 MessageParcel data; 75 std::vector<std::string> inputData; 76 data.WriteStringVector(inputData); 77 78 std::vector<int32_t> outputData; 79 serializer->GetPolicy(data, outputData); 80 EXPECT_TRUE(outputData.size() == 0); 81 } 82 83 /** 84 * @tc.name: TestSetDifferencePolicyData001 85 * @tc.desc: Test ArrayIntSerializerTest::SetDifferencePolicyData when data is empty 86 * @tc.type: FUNC 87 */ 88 HWTEST_F(ArrayIntSerializerTest, TestSetDifferencePolicyData001, TestSize.Level1) 89 { 90 auto serializer = ArrayIntSerializer::GetInstance(); 91 std::vector<int32_t> data; 92 std::vector<int32_t> currentData; 93 std::vector<int32_t> res = serializer->SetDifferencePolicyData(data, currentData); 94 ASSERT_TRUE(res.empty()); 95 } 96 97 /** 98 * @tc.name: TestSetDifferencePolicyData002 99 * @tc.desc: Test ArrayIntSerializerTest::SetDifferencePolicyData func 100 * @tc.type: FUNC 101 */ 102 HWTEST_F(ArrayIntSerializerTest, TestSetDifferencePolicyData002, TestSize.Level1) 103 { 104 auto serializer = ArrayIntSerializer::GetInstance(); 105 std::vector<int32_t> data; 106 data.push_back(1); 107 data.push_back(2); 108 std::vector<int32_t> currentData; 109 currentData.push_back(2); 110 currentData.push_back(3); 111 std::vector<int32_t> res = serializer->SetDifferencePolicyData(data, currentData); 112 ASSERT_TRUE(res.size() == 1); 113 } 114 115 /** 116 * @tc.name: TestSetUnionPolicyData001 117 * @tc.desc: Test ArrayIntSerializerTest::SetUnionPolicyData when data is empty 118 * @tc.type: FUNC 119 */ 120 HWTEST_F(ArrayIntSerializerTest, TestSetUnionPolicyData001, TestSize.Level1) 121 { 122 auto serializer = ArrayIntSerializer::GetInstance(); 123 std::vector<int32_t> data; 124 std::vector<int32_t> currentData; 125 std::vector<int32_t> res = serializer->SetUnionPolicyData(data, currentData); 126 ASSERT_TRUE(res.empty()); 127 } 128 129 /** 130 * @tc.name: TestSetUnionPolicyData002 131 * @tc.desc: Test ArrayIntSerializerTest::SetUnionPolicyData func 132 * @tc.type: FUNC 133 */ 134 HWTEST_F(ArrayIntSerializerTest, TestSetUnionPolicyData002, TestSize.Level1) 135 { 136 auto serializer = ArrayIntSerializer::GetInstance(); 137 std::vector<int32_t> data; 138 data.push_back(1); 139 data.push_back(2); 140 std::vector<int32_t> currentData; 141 currentData.push_back(2); 142 currentData.push_back(3); 143 std::vector<int32_t> res = serializer->SetUnionPolicyData(data, currentData); 144 ASSERT_TRUE(res.size() == 3); 145 } 146 147 /** 148 * @tc.name: TestSerialize001 149 * @tc.desc: Test ArrayIntSerializerTest::Serialize when jsonString is empty 150 * @tc.type: FUNC 151 */ 152 HWTEST_F(ArrayIntSerializerTest, TestSerialize001, TestSize.Level1) 153 { 154 auto serializer = ArrayIntSerializer::GetInstance(); 155 std::string jsonString; 156 std::vector<int32_t> dataObj; 157 bool ret = serializer->Serialize(dataObj, jsonString); 158 ASSERT_TRUE(ret); 159 ASSERT_TRUE(jsonString.empty()); 160 } 161 162 /** 163 * @tc.name: TestSerialize002 164 * @tc.desc: Test ArrayIntSerializerTest::Serialize func 165 * @tc.type: FUNC 166 */ 167 HWTEST_F(ArrayIntSerializerTest, TestSerialize002, TestSize.Level1) 168 { 169 auto serializer = ArrayIntSerializer::GetInstance(); 170 std::string jsonString; 171 std::vector<int32_t> data; 172 data.push_back(1); 173 data.push_back(2); 174 bool ret = serializer->Serialize(data, jsonString); 175 ASSERT_TRUE(ret); 176 ASSERT_FALSE(jsonString.empty()); 177 } 178 179 /** 180 * @tc.name: TestDeserialize001 181 * @tc.desc: Test ArrayIntSerializerTest::Deserialize when jsonString is empty 182 * @tc.type: FUNC 183 */ 184 HWTEST_F(ArrayIntSerializerTest, TestDeserialize001, TestSize.Level1) 185 { 186 auto serializer = ArrayIntSerializer::GetInstance(); 187 std::string jsonString = ""; 188 std::vector<int32_t> dataObj; 189 bool ret = serializer->Deserialize(jsonString, dataObj); 190 ASSERT_TRUE(ret); 191 } 192 193 /** 194 * @tc.name: TestDeserialize002 195 * @tc.desc: Test ArrayIntSerializerTest::Deserialize RootIsNotArray 196 * @tc.type: FUNC 197 */ 198 HWTEST_F(ArrayIntSerializerTest, TestDeserialize002, TestSize.Level1) 199 { 200 auto serializer = ArrayIntSerializer::GetInstance(); 201 std::string jsonString = R"({"key": "value"})"; 202 std::vector<int32_t> dataObj; 203 bool ret = serializer->Deserialize(jsonString, dataObj); 204 ASSERT_FALSE(ret); 205 } 206 207 /** 208 * @tc.name: TestDeserialize003 209 * @tc.desc: Test ArrayIntSerializerTest::Deserialize func 210 * @tc.type: FUNC 211 */ 212 HWTEST_F(ArrayIntSerializerTest, TestDeserialize003, TestSize.Level1) 213 { 214 auto serializer = ArrayIntSerializer::GetInstance(); 215 std::string jsonString = R"([1])"; 216 std::vector<int32_t> dataObj; 217 serializer->Deserialize(jsonString, dataObj); 218 ASSERT_TRUE(dataObj.size() == 1); 219 } 220 221 /** 222 * @tc.name: TestMergePolicy 223 * @tc.desc: Test ArrayIntSerializerTest::MergePolicy 224 * @tc.type: FUNC 225 */ 226 HWTEST_F(ArrayIntSerializerTest, TestMergePolicy, TestSize.Level1) 227 { 228 auto serializer = ArrayIntSerializer::GetInstance(); 229 std::vector<std::vector<int32_t>> dataObj; 230 std::vector<int32_t> data; 231 data.push_back(1); 232 dataObj.push_back(data); 233 std::vector<int32_t> result; 234 serializer->MergePolicy(dataObj, result); 235 ASSERT_TRUE(result.size() == 1); 236 } 237 238 /** 239 * @tc.name: TestSetIntersectionPolicyData001 240 * @tc.desc: Test ArrayIntSerializerTest::SetIntersectionPolicyData when data is empty 241 * @tc.type: FUNC 242 */ 243 HWTEST_F(ArrayIntSerializerTest, TestSetIntersectionPolicyData001, TestSize.Level1) 244 { 245 auto serializer = ArrayIntSerializer::GetInstance(); 246 std::vector<int32_t> data; 247 std::vector<int32_t> currentData; 248 std::vector<int32_t> res = serializer->SetIntersectionPolicyData(data, currentData); 249 ASSERT_TRUE(res.empty()); 250 } 251 252 /** 253 * @tc.name: TestSetIntersectionPolicyData002 254 * @tc.desc: Test ArrayIntSerializerTest::SetIntersectionPolicyData func 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(ArrayIntSerializerTest, TestSetIntersectionPolicyData002, TestSize.Level1) 258 { 259 auto serializer = ArrayIntSerializer::GetInstance(); 260 std::vector<int32_t> data; 261 data.push_back(1); 262 data.push_back(2); 263 std::vector<int32_t> currentData; 264 currentData.push_back(2); 265 currentData.push_back(3); 266 std::vector<int32_t> res = serializer->SetIntersectionPolicyData(data, currentData); 267 ASSERT_TRUE(res.size() == 1); 268 } 269 } // namespace TEST 270 } // namespace EDM 271 } // namespace OHOS 272