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 "dev_attribute_serialize.h"
18 #include "hdf_device_desc.h"
19 
20 using namespace testing::ext;
21 
22 namespace OHOS {
23 class DevAttributeSerializeTest : public testing::Test {
24 public:
SetUpTestCase()25     static void SetUpTestCase() {}
TearDownTestCase()26     static void TearDownTestCase() {}
27 
SetUp()28     void SetUp() {};
TearDown()29     void TearDown() {};
30 };
31 
32 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest001, TestSize.Level1)
33 {
34     bool ret = DeviceAttributeSerialize(nullptr, nullptr);
35     ASSERT_FALSE(ret);
36 }
37 
38 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest002, TestSize.Level1)
39 {
40     struct HdfDeviceInfo *attribute = HdfDeviceInfoNewInstance();
41     ASSERT_NE(attribute, nullptr);
42     bool ret = DeviceAttributeSerialize(attribute, nullptr);
43     ASSERT_FALSE(ret);
44     HdfDeviceInfoFreeInstance(attribute);
45     attribute = nullptr;
46 }
47 
48 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest003, TestSize.Level1)
49 {
50     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
51     ASSERT_NE(buf, nullptr);
52 
53     bool ret = DeviceAttributeSerialize(nullptr, buf);
54     ASSERT_FALSE(ret);
55     HdfSbufRecycle(buf);
56     buf = nullptr;
57 }
58 
59 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest004, TestSize.Level1)
60 {
61     struct HdfDeviceInfo *attribute = HdfDeviceInfoNewInstance();
62     ASSERT_NE(attribute, nullptr);
63     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
64     ASSERT_NE(buf, nullptr);
65 
66     bool ret = DeviceAttributeSerialize(attribute, buf);
67     ASSERT_FALSE(ret);
68     HdfDeviceInfoFreeInstance(attribute);
69     attribute = nullptr;
70     HdfSbufRecycle(buf);
71     buf = nullptr;
72 }
73 
74 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest005, TestSize.Level1)
75 {
76     struct HdfDeviceInfo *attribute = HdfDeviceInfoNewInstance();
77     ASSERT_NE(attribute, nullptr);
78 
79     attribute->moduleName = strdup("test_module");
80     attribute->svcName = strdup("test_service");
81     attribute->deviceName = strdup("test_device");
82 
83     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
84     ASSERT_NE(buf, nullptr);
85 
86     bool ret = DeviceAttributeSerialize(attribute, buf);
87     ASSERT_TRUE(ret);
88 
89     HdfDeviceInfoFreeInstance(attribute);
90     attribute = nullptr;
91     HdfSbufRecycle(buf);
92     buf = nullptr;
93 }
94 
95 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest006, TestSize.Level1)
96 {
97     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(nullptr);
98     ASSERT_EQ(attribute, nullptr);
99 }
100 
101 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest007, TestSize.Level1)
102 {
103     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
104     ASSERT_NE(buf, nullptr);
105 
106     // read deviceId failed
107     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
108     ASSERT_EQ(attribute, nullptr);
109 
110     HdfSbufRecycle(buf);
111     buf = nullptr;
112 }
113 
114 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest008, TestSize.Level1)
115 {
116     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
117     ASSERT_NE(buf, nullptr);
118 
119     // write deviceId
120     bool ret = HdfSbufWriteUint32(buf, 0);
121     ASSERT_TRUE(ret);
122 
123     // read policy failed
124     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
125     ASSERT_EQ(attribute, nullptr);
126 
127     HdfSbufRecycle(buf);
128     buf = nullptr;
129 }
130 
131 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest009, TestSize.Level1)
132 {
133     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
134     ASSERT_NE(buf, nullptr);
135 
136     // write deviceId
137     bool ret = HdfSbufWriteUint32(buf, 0);
138     ASSERT_TRUE(ret);
139     // write policy
140     ret = HdfSbufWriteUint16(buf, SERVICE_POLICY_INVALID);
141     ASSERT_TRUE(ret);
142 
143     // read svcName failed
144     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
145     ASSERT_EQ(attribute, nullptr);
146 
147     HdfSbufRecycle(buf);
148     buf = nullptr;
149 }
150 
151 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest010, TestSize.Level1)
152 {
153     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
154     ASSERT_NE(buf, nullptr);
155 
156     // write deviceId
157     bool ret = HdfSbufWriteUint32(buf, 0);
158     ASSERT_TRUE(ret);
159     // write policy
160     ret = HdfSbufWriteUint16(buf, SERVICE_POLICY_INVALID);
161     ASSERT_TRUE(ret);
162     // write svcName
163     ret = HdfSbufWriteString(buf, "test_service");
164     ASSERT_TRUE(ret);
165 
166     // read moduleName failed
167     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
168     ASSERT_EQ(attribute, nullptr);
169 
170     HdfSbufRecycle(buf);
171     buf = nullptr;
172 }
173 
174 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest011, TestSize.Level1)
175 {
176     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
177     ASSERT_NE(buf, nullptr);
178 
179     // write deviceId
180     bool ret = HdfSbufWriteUint32(buf, 0);
181     ASSERT_TRUE(ret);
182     // write policy
183     ret = HdfSbufWriteUint16(buf, SERVICE_POLICY_INVALID);
184     ASSERT_TRUE(ret);
185     // write svcName
186     ret = HdfSbufWriteString(buf, "test_service");
187     ASSERT_TRUE(ret);
188     // write moduleName
189     ret = HdfSbufWriteString(buf, "test_module");
190     ASSERT_TRUE(ret);
191 
192     // read deviceName failed
193     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
194     ASSERT_EQ(attribute, nullptr);
195 
196     HdfSbufRecycle(buf);
197     buf = nullptr;
198 }
199 
200 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest012, TestSize.Level1)
201 {
202     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
203     ASSERT_NE(buf, nullptr);
204 
205     // write deviceId
206     bool ret = HdfSbufWriteUint32(buf, 0);
207     ASSERT_TRUE(ret);
208     // write policy
209     ret = HdfSbufWriteUint16(buf, SERVICE_POLICY_INVALID);
210     ASSERT_TRUE(ret);
211     // write svcName
212     ret = HdfSbufWriteString(buf, "test_service");
213     ASSERT_TRUE(ret);
214     // write moduleName
215     ret = HdfSbufWriteString(buf, "test_module");
216     ASSERT_TRUE(ret);
217     // write deviceName
218     ret = HdfSbufWriteString(buf, "test_device");
219     ASSERT_TRUE(ret);
220 
221     // read length failed
222     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
223     ASSERT_EQ(attribute, nullptr);
224 
225     HdfSbufRecycle(buf);
226     buf = nullptr;
227 }
228 
229 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest013, TestSize.Level1)
230 {
231     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
232     ASSERT_NE(buf, nullptr);
233 
234     // write deviceId
235     bool ret = HdfSbufWriteUint32(buf, 0);
236     ASSERT_TRUE(ret);
237     // write policy
238     ret = HdfSbufWriteUint16(buf, SERVICE_POLICY_INVALID);
239     ASSERT_TRUE(ret);
240     // write svcName
241     ret = HdfSbufWriteString(buf, "test_service");
242     ASSERT_TRUE(ret);
243     // write moduleName
244     ret = HdfSbufWriteString(buf, "test_module");
245     ASSERT_TRUE(ret);
246     // write deviceName
247     ret = HdfSbufWriteString(buf, "test_device");
248     ASSERT_TRUE(ret);
249     // write length
250     ret = HdfSbufWriteUint32(buf, 1);
251     ASSERT_TRUE(ret);
252 
253     // read deviceMatchAttr failed
254     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
255     ASSERT_EQ(attribute, nullptr);
256 
257     HdfSbufRecycle(buf);
258     buf = nullptr;
259 }
260 
261 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest014, TestSize.Level1)
262 {
263     struct HdfSBuf *buf = HdfSbufTypedObtain(SBUF_IPC);
264     ASSERT_NE(buf, nullptr);
265 
266     // write deviceId
267     bool ret = HdfSbufWriteUint32(buf, 0);
268     ASSERT_TRUE(ret);
269     // write policy
270     ret = HdfSbufWriteUint16(buf, SERVICE_POLICY_INVALID);
271     ASSERT_TRUE(ret);
272     // write svcName
273     ret = HdfSbufWriteString(buf, "test_service");
274     ASSERT_TRUE(ret);
275     // write moduleName
276     ret = HdfSbufWriteString(buf, "test_module");
277     ASSERT_TRUE(ret);
278     // write deviceName
279     ret = HdfSbufWriteString(buf, "test_device");
280     ASSERT_TRUE(ret);
281     // write invalid length
282     ret = HdfSbufWriteUint32(buf, 0);
283     ASSERT_TRUE(ret);
284 
285     // read success
286     struct HdfDeviceInfo *attribute = DeviceAttributeDeserialize(buf);
287     ASSERT_NE(attribute, nullptr);
288 
289     HdfDeviceInfoFreeInstance(attribute);
290     HdfSbufRecycle(buf);
291     buf = nullptr;
292 }
293 
294 HWTEST_F(DevAttributeSerializeTest, DevAttributeSerializeTest015, TestSize.Level1)
295 {
296     DeviceSerializedAttributeRelease(nullptr);
297     struct HdfDeviceInfo *attribute = HdfDeviceInfoNewInstance();
298     ASSERT_NE(attribute, nullptr);
299     DeviceSerializedAttributeRelease(attribute);
300 }
301 } // namespace OHOS