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 #include <gtest/gtest.h>
16
17 #include "array_usb_device_id_serializer_test.h"
18 #include "edm_constants.h"
19 #include "utils.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace EDM {
25 namespace TEST {
SetUpTestSuite(void)26 void ArrayUsbDeviceIdSerializerTest::SetUpTestSuite(void)
27 {
28 Utils::SetEdmInitialEnv();
29 }
30
TearDownTestSuite(void)31 void ArrayUsbDeviceIdSerializerTest::TearDownTestSuite(void)
32 {
33 Utils::ResetTokenTypeAndUid();
34 ASSERT_TRUE(Utils::IsOriginalUTEnv());
35 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
36 }
37
38 /**
39 * @tc.name: TestSetDifferencePolicyDataEmpty
40 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::SetDifferencePolicy when data is empty
41 * @tc.type: FUNC
42 */
43 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestSetDifferencePolicyDataEmpty, TestSize.Level1)
44 {
45 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
46 std::vector<UsbDeviceId> data;
47 std::vector<UsbDeviceId> currentData;
48 std::vector<UsbDeviceId> res = serializer->SetDifferencePolicyData(data, currentData);
49 ASSERT_TRUE(res.empty());
50 }
51
52 /**
53 * @tc.name: TestSerializeEmpty
54 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::Serialize when jsonString is empty
55 * @tc.type: FUNC
56 */
57 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestSerializeEmpty, TestSize.Level1)
58 {
59 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
60 std::string jsonString;
61 std::vector<UsbDeviceId> dataObj;
62 bool ret = serializer->Serialize(dataObj, jsonString);
63 ASSERT_TRUE(ret);
64 ASSERT_TRUE(jsonString.empty());
65 }
66
67 /**
68 * @tc.name: TestSerializeSuc
69 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::Serialize
70 * @tc.type: FUNC
71 */
72 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestSerializeSuc, TestSize.Level1)
73 {
74 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
75 std::string jsonString;
76 std::vector<UsbDeviceId> dataObj;
77 UsbDeviceId id1;
78 id1.SetVendorId(111);
79 id1.SetProductId(222);
80 dataObj.push_back(id1);
81 bool ret = serializer->Serialize(dataObj, jsonString);
82 ASSERT_TRUE(ret);
83 ASSERT_FALSE(jsonString.empty());
84 }
85
86 /**
87 * @tc.name: TestDeserializeWithEmptyString
88 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::Deserialize jsonString is empty
89 * @tc.type: FUNC
90 */
91 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestDeserializeWithEmptyString, TestSize.Level1)
92 {
93 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
94 std::string jsonString = "";
95 std::vector<UsbDeviceId> dataObj;
96 bool ret = serializer->Deserialize(jsonString, dataObj);
97 ASSERT_TRUE(ret);
98 }
99
100 /**
101 * @tc.name: TestDeserializeRootIsNotArray
102 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::Deserialize RootIsNotArray
103 * @tc.type: FUNC
104 */
105 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestDeserializeRootIsNotArray, TestSize.Level1)
106 {
107 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
108 std::string jsonString = R"({"key": "value"})";
109 std::vector<UsbDeviceId> dataObj;
110 bool ret = serializer->Deserialize(jsonString, dataObj);
111 ASSERT_FALSE(ret);
112 }
113
114 /**
115 * @tc.name: TestDeserializeSuc
116 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::Deserialize
117 * @tc.type: FUNC
118 */
119 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestDeserializeSuc, TestSize.Level1)
120 {
121 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
122 std::string jsonString = R"([{"vendorId": 1234, "productId": 5678}])";
123 std::vector<UsbDeviceId> dataObj;
124 bool ret = serializer->Deserialize(jsonString, dataObj);
125 ASSERT_TRUE(ret);
126 ASSERT_EQ(dataObj.size(), 1);
127 ASSERT_EQ(dataObj[0].GetVendorId(), 1234);
128 ASSERT_EQ(dataObj[0].GetProductId(), 5678);
129 }
130
131 /**
132 * @tc.name: TestDeserializeMalformedJson
133 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::Deserialize MalformedJson
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestDeserializeMalformedJson, TestSize.Level1)
137 {
138 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
139 std::string jsonString = R"([
140 {"vendorId": 1234, "productId": 5678,
141 {"vendorId": 4321, "productId": 8765}
142 ])";
143 std::vector<UsbDeviceId> dataObj;
144 bool ret = serializer->Deserialize(jsonString, dataObj);
145 ASSERT_FALSE(ret);
146 }
147
148 /**
149 * @tc.name: TestGetPolicyOutOfRange
150 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::GetPolicy out of range
151 * @tc.type: FUNC
152 */
153 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestGetPolicyOutOfRange, TestSize.Level1)
154 {
155 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
156 MessageParcel data;
157 data.WriteInt32(EdmConstants::ALLOWED_USB_DEVICES_MAX_SIZE + 1);
158 std::vector<UsbDeviceId> dataObj;
159 bool ret = serializer->GetPolicy(data, dataObj);
160 ASSERT_FALSE(ret);
161 }
162
163 /**
164 * @tc.name: TestGetPolicy
165 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::GetPolicy
166 * @tc.type: FUNC
167 */
168 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestGetPolicy, TestSize.Level1)
169 {
170 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
171 MessageParcel data;
172 std::vector<UsbDeviceId> dataObj;
173 data.WriteInt32(1);
174 data.WriteInt32(111);
175 data.WriteInt32(222);
176 bool ret = serializer->GetPolicy(data, dataObj);
177 ASSERT_TRUE(ret);
178 ASSERT_TRUE(dataObj[0].GetVendorId() == 111);
179 ASSERT_TRUE(dataObj[0].GetProductId() == 222);
180 }
181
182 /**
183 * @tc.name: TestWritePolicy
184 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::WritePolicy
185 * @tc.type: FUNC
186 */
187 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestWritePolicy, TestSize.Level1)
188 {
189 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
190 MessageParcel reply;
191 std::vector<UsbDeviceId> dataObj;
192 UsbDeviceId id1;
193 id1.SetVendorId(111);
194 id1.SetProductId(222);
195 dataObj.push_back(id1);
196 bool ret = serializer->WritePolicy(reply, dataObj);
197 ASSERT_TRUE(ret);
198 ASSERT_TRUE(reply.ReadInt32() == 111);
199 ASSERT_TRUE(reply.ReadInt32() == 222);
200 }
201
202 /**
203 * @tc.name: TestMergePolicy
204 * @tc.desc: Test ArrayUsbDeviceIdSerializerTest::MergePolicy
205 * @tc.type: FUNC
206 */
207 HWTEST_F(ArrayUsbDeviceIdSerializerTest, TestMergePolicy, TestSize.Level1)
208 {
209 auto serializer = ArrayUsbDeviceIdSerializer::GetInstance();
210 std::vector<std::vector<UsbDeviceId>> dataObj;
211 std::vector<UsbDeviceId> data;
212 UsbDeviceId id1;
213 id1.SetVendorId(111);
214 id1.SetProductId(222);
215 data.push_back(id1);
216 dataObj.push_back(data);
217 std::vector<UsbDeviceId> result;
218 serializer->MergePolicy(dataObj, result);
219 ASSERT_TRUE(result.size() == 1);
220 }
221
222 } // namespace TEST
223 } // namespace EDM
224 } // namespace OHOS