1 /*
2 * Copyright (c) 2024-2025 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
18 #include "cJSON.h"
19
20 #include "constants.h"
21 #include "capability_info.h"
22 #include "capability_utils.h"
23
24 using namespace testing::ext;
25 using namespace std;
26
27 namespace OHOS {
28 namespace DistributedHardware {
29 class CapabilityInfoTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 };
36
SetUp()37 void CapabilityInfoTest::SetUp() {}
38
TearDown()39 void CapabilityInfoTest::TearDown() {}
40
SetUpTestCase()41 void CapabilityInfoTest::SetUpTestCase() {}
42
TearDownTestCase()43 void CapabilityInfoTest::TearDownTestCase() {}
44
45 HWTEST_F(CapabilityInfoTest, ToJson_001, TestSize.Level0)
46 {
47 cJSON *jsonObject = nullptr;
48 CapabilityInfo capability;
49 ToJson(jsonObject, capability);
50 EXPECT_TRUE(capability.GetDHId().empty());
51 }
52
53 HWTEST_F(CapabilityInfoTest, FromJson_001, TestSize.Level0)
54 {
55 cJSON *jsonObject = nullptr;
56 CapabilityInfo capability;
57 FromJson(jsonObject, capability);
58 EXPECT_TRUE(capability.GetDHId().empty());
59 }
60
61 HWTEST_F(CapabilityInfoTest, FromJson_002, TestSize.Level0)
62 {
63 cJSON *jsonObj = cJSON_CreateObject();
64 ASSERT_TRUE(jsonObj != nullptr);
65 cJSON_AddNumberToObject(jsonObj, DH_ID.c_str(), 1);
66 char* cjson = cJSON_PrintUnformatted(jsonObj);
67 if (cjson == nullptr) {
68 cJSON_Delete(jsonObj);
69 return;
70 }
71 std::string jsonStr(cjson);
72 CapabilityInfo capability;
73 FromJson(jsonObj, capability);
74 cJSON_free(cjson);
75 cJSON_Delete(jsonObj);
76 EXPECT_TRUE(capability.GetDeviceId().empty());
77 }
78
79 HWTEST_F(CapabilityInfoTest, FromJson_003, TestSize.Level0)
80 {
81 cJSON *jsonObj = cJSON_CreateObject();
82 ASSERT_TRUE(jsonObj != nullptr);
83 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
84 cJSON_AddNumberToObject(jsonObj, DEV_ID.c_str(), 1);
85 char* cjson = cJSON_PrintUnformatted(jsonObj);
86 if (cjson == nullptr) {
87 cJSON_Delete(jsonObj);
88 return;
89 }
90 std::string jsonStr(cjson);
91 CapabilityInfo capability;
92 FromJson(jsonObj, capability);
93 cJSON_free(cjson);
94 cJSON_Delete(jsonObj);
95 EXPECT_FALSE(capability.GetDHId().empty());
96 }
97
98 HWTEST_F(CapabilityInfoTest, FromJson_004, TestSize.Level0)
99 {
100 cJSON *jsonObj = cJSON_CreateObject();
101 ASSERT_TRUE(jsonObj != nullptr);
102 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
103 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "devid_test");
104 cJSON_AddNumberToObject(jsonObj, DEV_NAME.c_str(), 1);
105 char* cjson = cJSON_PrintUnformatted(jsonObj);
106 if (cjson == nullptr) {
107 cJSON_Delete(jsonObj);
108 return;
109 }
110 std::string jsonStr(cjson);
111 CapabilityInfo capability;
112 FromJson(jsonObj, capability);
113 cJSON_free(cjson);
114 cJSON_Delete(jsonObj);
115 EXPECT_FALSE(capability.GetDHId().empty());
116 }
117
118 HWTEST_F(CapabilityInfoTest, FromJson_005, TestSize.Level0)
119 {
120 cJSON *jsonObj = cJSON_CreateObject();
121 ASSERT_TRUE(jsonObj != nullptr);
122 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
123 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "devid_test");
124 cJSON_AddStringToObject(jsonObj, DEV_NAME.c_str(), "devname_test");
125 cJSON_AddStringToObject(jsonObj, DEV_TYPE.c_str(), "devtype_test");
126 char* cjson = cJSON_PrintUnformatted(jsonObj);
127 if (cjson == nullptr) {
128 cJSON_Delete(jsonObj);
129 return;
130 }
131 std::string jsonStr(cjson);
132 CapabilityInfo capability;
133 FromJson(jsonObj, capability);
134 cJSON_free(cjson);
135 cJSON_Delete(jsonObj);
136 EXPECT_FALSE(capability.GetDHId().empty());
137 }
138
139 HWTEST_F(CapabilityInfoTest, FromJson_006, TestSize.Level0)
140 {
141 const uint16_t devType = 1;
142 cJSON *jsonObj = cJSON_CreateObject();
143 ASSERT_TRUE(jsonObj != nullptr);
144 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
145 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "devid_test");
146 cJSON_AddStringToObject(jsonObj, DEV_NAME.c_str(), "devname_test");
147 cJSON_AddNumberToObject(jsonObj, DEV_TYPE.c_str(), devType);
148 cJSON_AddStringToObject(jsonObj, DH_TYPE.c_str(), "dhtype_test");
149 char* cjson = cJSON_PrintUnformatted(jsonObj);
150 if (cjson == nullptr) {
151 cJSON_Delete(jsonObj);
152 return;
153 }
154 std::string jsonStr(cjson);
155 CapabilityInfo capability;
156 FromJson(jsonObj, capability);
157 cJSON_free(cjson);
158 cJSON_Delete(jsonObj);
159 EXPECT_FALSE(capability.GetDHId().empty());
160 }
161
162 HWTEST_F(CapabilityInfoTest, FromJson_007, TestSize.Level0)
163 {
164 const uint16_t devType = 1;
165 const uint32_t dhType = 1;
166 cJSON *jsonObj = cJSON_CreateObject();
167 ASSERT_TRUE(jsonObj != nullptr);
168 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
169 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "devid_test");
170 cJSON_AddStringToObject(jsonObj, DEV_NAME.c_str(), "devname_test");
171 cJSON_AddNumberToObject(jsonObj, DEV_TYPE.c_str(), devType);
172 cJSON_AddNumberToObject(jsonObj, DH_TYPE.c_str(), dhType);
173 cJSON_AddNumberToObject(jsonObj, DH_ATTRS.c_str(), 1);
174 char* cjson = cJSON_PrintUnformatted(jsonObj);
175 if (cjson == nullptr) {
176 cJSON_Delete(jsonObj);
177 return;
178 }
179 std::string jsonStr(cjson);
180 CapabilityInfo capability;
181 FromJson(jsonObj, capability);
182 cJSON_free(cjson);
183 cJSON_Delete(jsonObj);
184 EXPECT_FALSE(capability.GetDHId().empty());
185 }
186
187 HWTEST_F(CapabilityInfoTest, FromJson_008, TestSize.Level0)
188 {
189 const uint16_t devType = 1;
190 const uint32_t dhType = 1;
191 cJSON *jsonObj = cJSON_CreateObject();
192 ASSERT_TRUE(jsonObj != nullptr);
193 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
194 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "devid_test");
195 cJSON_AddStringToObject(jsonObj, DEV_NAME.c_str(), "devname_test");
196 cJSON_AddNumberToObject(jsonObj, DEV_TYPE.c_str(), devType);
197 cJSON_AddNumberToObject(jsonObj, DH_TYPE.c_str(), dhType);
198 cJSON_AddStringToObject(jsonObj, DH_ATTRS.c_str(), "dhattrs_test");
199 cJSON_AddNumberToObject(jsonObj, DH_SUBTYPE.c_str(), 1);
200 char* cjson = cJSON_PrintUnformatted(jsonObj);
201 if (cjson == nullptr) {
202 cJSON_Delete(jsonObj);
203 return;
204 }
205 std::string jsonStr(cjson);
206 CapabilityInfo capability;
207 FromJson(jsonObj, capability);
208 cJSON_free(cjson);
209 cJSON_Delete(jsonObj);
210 EXPECT_FALSE(capability.GetDHId().empty());
211 }
212
213 HWTEST_F(CapabilityInfoTest, FromJson_009, TestSize.Level0)
214 {
215 const uint16_t devType = 1;
216 const uint32_t dhType = 1;
217 cJSON *jsonObj = cJSON_CreateObject();
218 ASSERT_TRUE(jsonObj != nullptr);
219 cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), "dhid_test");
220 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "devid_test");
221 cJSON_AddStringToObject(jsonObj, DEV_NAME.c_str(), "devname_test");
222 cJSON_AddNumberToObject(jsonObj, DEV_TYPE.c_str(), devType);
223 cJSON_AddNumberToObject(jsonObj, DH_TYPE.c_str(), dhType);
224 cJSON_AddStringToObject(jsonObj, DH_ATTRS.c_str(), "dhattrs_test");
225 cJSON_AddStringToObject(jsonObj, DH_SUBTYPE.c_str(), "dhsubtype_test");
226 char* cjson = cJSON_PrintUnformatted(jsonObj);
227 if (cjson == nullptr) {
228 cJSON_Delete(jsonObj);
229 return;
230 }
231 std::string jsonStr(cjson);
232 CapabilityInfo capability;
233 FromJson(jsonObj, capability);
234 cJSON_free(cjson);
235 cJSON_Delete(jsonObj);
236 EXPECT_FALSE(capability.GetDHId().empty());
237 }
238
239 HWTEST_F(CapabilityInfoTest, IsCapKeyMatchDeviceId_001, TestSize.Level0)
240 {
241 std::string key = "";
242 std::string deviceId = "";
243 auto ret = IsCapKeyMatchDeviceId(key, deviceId);
244 EXPECT_EQ(false, ret);
245
246 key = "key###123";
247 ret = IsCapKeyMatchDeviceId(key, deviceId);
248 EXPECT_EQ(false, ret);
249
250 key = "";
251 deviceId = "123456";
252 ret = IsCapKeyMatchDeviceId(key, deviceId);
253 EXPECT_EQ(false, ret);
254
255 key = "key_test";
256 ret = IsCapKeyMatchDeviceId(key, deviceId);
257 EXPECT_EQ(false, ret);
258 }
259 }
260 }