1 /*
2 * Copyright (c) 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 <cstdio>
17 #include <cstring>
18 #include <cstdlib>
19
20 #include "netstack_hash_map.h"
21 #include "net_http_inner_types.h"
22 #include "netstack_log.h"
23 #include "gtest/gtest.h"
24
25 #define NETSTACK_HASH_FACTOR 31
26
27 class NetstackHashMapTest : public testing::Test {
28 public:
SetUpTestCase()29 static void SetUpTestCase() {}
30
TearDownTestCase()31 static void TearDownTestCase() {}
32
SetUp()33 virtual void SetUp() {}
34
TearDown()35 virtual void TearDown() {}
36 };
37
38 namespace {
39 using namespace std;
40 using namespace testing::ext;
41
SimpleDestoryStub(void * value)42 static void SimpleDestoryStub(void *value)
43 {
44 NETSTACK_LOGE("SimpleDestoryStub");
45 }
46
47
48 HWTEST_F(NetstackHashMapTest, CreateMapTest001, TestSize.Level1)
49 {
50 Netstack_HashMap *map = CreateMap();
51
52 EXPECT_EQ(map->capacity, DEFAULT_MAP_CAPACITY);
53 EXPECT_EQ(map->size, 0);
54 Netstack_DestroyMap(map);
55 }
56
57 HWTEST_F(NetstackHashMapTest, NetstackInvalidMapTest001, TestSize.Level1)
58 {
59 Netstack_HashMap *map = CreateMap();
60 map = nullptr;
61 const char *value = "value";
62 uint32_t ret = Netstack_PutMapEntry(map, "key", (void *)value);
63 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
64 Netstack_DestroyMap(map);
65 }
66
67 HWTEST_F(NetstackHashMapTest, NetstackInvalidMapTest002, TestSize.Level1)
68 {
69 Netstack_HashMap *map = CreateMap();
70 map->entries = nullptr;
71 char *value = strdup("value");
72 uint32_t ret = Netstack_PutMapEntry(map, "key", value);
73 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
74 Netstack_DestroyMap(map);
75 }
76
77 HWTEST_F(NetstackHashMapTest, NetstackInvalidMapTest003, TestSize.Level1)
78 {
79 Netstack_HashMap *map = CreateMap();
80 map->capacity = DEFAULT_MAP_CAPACITY - 1;
81 const char *value = "value";
82 uint32_t ret = Netstack_PutMapEntry(map, "key", (void *)value);
83 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
84 Netstack_DestroyMap(map);
85 }
86
87 HWTEST_F(NetstackHashMapTest, NetstackInvalidMapTest004, TestSize.Level1)
88 {
89 Netstack_HashMap *map = CreateMap();
90 map->capacity = MAX_MAP_CAPACITY + 1;
91 const char *value = "value";
92 uint32_t ret = Netstack_PutMapEntry(map, "key", (void *)value);
93 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
94 Netstack_DestroyMap(map);
95 }
96
97 HWTEST_F(NetstackHashMapTest, NetstackResizeMapTest001, TestSize.Level1)
98 {
99 Netstack_HashMap *map = CreateMap();
100 EXPECT_TRUE(map != nullptr);
101 map->entries[0] = nullptr;
102 const char *value = "value";
103 Netstack_PutMapEntry(map, "key", (void *)value);
104 Netstack_DestroyMap(map);
105 }
106
107 HWTEST_F(NetstackHashMapTest, NetstackResizeMapTest002, TestSize.Level1)
108 {
109 Netstack_HashMap *map = CreateMap();
110 EXPECT_TRUE(map != nullptr);
111 map->entries[0] = (Netstack_HashMapEntry *)calloc(1, sizeof(Netstack_HashMapEntry));
112 map->entries[0]->key = nullptr;
113 const char *value = "value";
114 Netstack_PutMapEntry(map, "key", (void *)value);
115 Netstack_DestroyMap(map);
116 }
117
118 HWTEST_F(NetstackHashMapTest, NetstackPutMapEntryTest001, TestSize.Level1)
119 {
120 Netstack_HashMap *map = CreateMap();
121 EXPECT_TRUE(map != nullptr);
122 char *key = nullptr;
123 const char *value = "value";
124 EXPECT_EQ(Netstack_PutMapEntry(map, key, (void *)value), OH_HTTP_PARAMETER_ERROR);
125 Netstack_DestroyMap(map);
126 }
127
128 HWTEST_F(NetstackHashMapTest, NetstackPutMapEntryTest002, TestSize.Level1)
129 {
130 Netstack_HashMap *map = CreateMap();
131 map = nullptr;
132 const char *key = "key";
133 const char *value = "value";
134 EXPECT_EQ(Netstack_PutMapEntry(map, key, (void *)value), OH_HTTP_PARAMETER_ERROR);
135 Netstack_DestroyMap(map);
136 }
137
138 HWTEST_F(NetstackHashMapTest, NetstackPutMapEntryTest003, TestSize.Level1)
139 {
140 Netstack_HashMap *map = CreateMap();
141 map->size = DEFAULT_MAP_CAPACITY;
142 map->capacity = DEFAULT_MAP_CAPACITY;
143 const char *key = "key";
144 const char *value = "value";
145 Netstack_PutMapEntry(map, key, (void *)value);
146 EXPECT_EQ(map->capacity, DEFAULT_MAP_CAPACITY * 2);
147 Netstack_DestroyMap(map);
148 }
149
150 HWTEST_F(NetstackHashMapTest, NetstackPutMapEntryTest004, TestSize.Level1)
151 {
152 Netstack_HashMap *map = CreateMap();
153 const char *key = "key";
154 const char *value = "value";
155 EXPECT_EQ(Netstack_PutMapEntry(map, key, (void *)value), OH_HTTP_RESULT_OK);
156 Netstack_DestroyMap(map);
157 }
158
159 HWTEST_F(NetstackHashMapTest, NetstackPutMapEntryTest005, TestSize.Level1)
160 {
161 Netstack_HashMap *map = CreateMap();
162 const char *key = "key";
163 const char *value = "value";
164 const char *value2 = "value2";
165 Netstack_PutMapEntry(map, key, (void *)value2);
166 EXPECT_EQ(Netstack_PutMapEntry(map, key, (void *)value), OH_HTTP_RESULT_OK);
167 EXPECT_EQ(Netstack_GetMapEntry(map, key), "value");
168 Netstack_DestroyMap(map);
169 }
170
171 HWTEST_F(NetstackHashMapTest, NetstackGetMapEntryTest001, TestSize.Level1)
172 {
173 Netstack_HashMap *map = CreateMap();
174 const char *key = nullptr;
175 EXPECT_EQ(Netstack_GetMapEntry(map, key), nullptr);
176 Netstack_DestroyMap(map);
177 }
178
179 HWTEST_F(NetstackHashMapTest, NetstackGetMapEntryTest002, TestSize.Level1)
180 {
181 Netstack_HashMap *map = CreateMap();
182 const char *key = "a";
183 const char *value = "value";
184 Netstack_PutMapEntry(map, key, (void *)value);
185 EXPECT_EQ(Netstack_GetMapEntry(map, key), value);
186 Netstack_DestroyMap(map);
187 }
188
189 HWTEST_F(NetstackHashMapTest, NetstackGetMapEntryTest003, TestSize.Level1)
190 {
191 Netstack_HashMap *map = CreateMap();
192 const char *key = "a";
193 EXPECT_EQ(Netstack_GetMapEntry(map, key), nullptr);
194 Netstack_DestroyMap(map);
195 }
196
197 HWTEST_F(NetstackHashMapTest, NetstackDeleteMapEntryTest001, TestSize.Level1)
198 {
199 Netstack_HashMap *map = CreateMap();
200 map->capacity = MAX_MAP_CAPACITY + 1;
201 const char *key = "a";
202 EXPECT_EQ(Netstack_DeleteMapEntry(map, key), OH_HTTP_PARAMETER_ERROR);
203 Netstack_DestroyMap(map);
204 }
205
206 HWTEST_F(NetstackHashMapTest, NetstackDeleteMapEntryTest002, TestSize.Level1)
207 {
208 Netstack_HashMap *map = CreateMap();
209 char *key = nullptr;
210 EXPECT_EQ(Netstack_DeleteMapEntry(map, key), OH_HTTP_PARAMETER_ERROR);
211 Netstack_DestroyMap(map);
212 }
213
214 HWTEST_F(NetstackHashMapTest, NetstackDeleteMapEntryTest003, TestSize.Level1)
215 {
216 Netstack_HashMap *map = CreateMap();
217 const char *key = "a";
218 const char *value = "value";
219 Netstack_PutMapEntry(map, key, (void *)value);
220 int tempSize = map->size;
221 EXPECT_EQ(Netstack_DeleteMapEntry(map, key), OH_HTTP_RESULT_OK);
222 EXPECT_EQ(tempSize, map->size + 1);
223 Netstack_DestroyMap(map);
224 }
225
226 //capacity=3
227 HWTEST_F(NetstackHashMapTest, NetstackDeleteMapEntryTest004, TestSize.Level1)
228 {
229 Netstack_HashMap *map = CreateMap();
230 const char *key1 = "da";
231 const char *key2 = "eb";
232 const char *key3 = "fc";
233 const char *value = "value";
234 Netstack_PutMapEntry(map, key1, (void *)value);
235 Netstack_PutMapEntry(map, key2, (void *)value);
236 Netstack_PutMapEntry(map, key3, (void *)value);
237 int tempSize = map->size;
238 EXPECT_EQ(Netstack_DeleteMapEntry(map, key1), OH_HTTP_RESULT_OK);
239 EXPECT_EQ(tempSize, map->size);
240 Netstack_DestroyMap(map);
241 }
242
243 HWTEST_F(NetstackHashMapTest, NetstackDestroyMapWithValueTest001, TestSize.Level1)
244 {
245 Netstack_HashMap *map = CreateMap();
246 EXPECT_TRUE(map != nullptr);
247 map->capacity = MAX_MAP_CAPACITY + 1;
248 Netstack_DestroyMapWithValue(map, nullptr);
249 }
250
251 HWTEST_F(NetstackHashMapTest, NetstackDestroyMapWithValueTest002, TestSize.Level1)
252 {
253 Netstack_HashMap *map = CreateMap();
254 EXPECT_TRUE(map != nullptr);
255 const char *key1 = "key1";
256 const char *value1 = "123";
257 Netstack_PutMapEntry(map, key1, (void *)value1);
258
259 Netstack_DestroyMapWithValue(map, SimpleDestoryStub);
260 }
261
262 HWTEST_F(NetstackHashMapTest, NetstackCreateMapIteratorTest001, TestSize.Level1)
263 {
264 Netstack_HashMap *map = CreateMap();
265 map->capacity = MAX_MAP_CAPACITY + 1;
266 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
267 EXPECT_EQ(iterator, nullptr);
268 Netstack_DestroyMap(map);
269 }
270
271 HWTEST_F(NetstackHashMapTest, NetstackCreateMapIteratorTest002, TestSize.Level1)
272 {
273 Netstack_HashMap *map = CreateMap();
274 const char *key1 = "da";
275 const char *key2 = "eb";
276 const char *key3 = "fc";
277 const char *value = "value";
278 Netstack_PutMapEntry(map, key1, (void *)value);
279 Netstack_PutMapEntry(map, key2, (void *)value);
280 Netstack_PutMapEntry(map, key3, (void *)value);
281 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
282 EXPECT_FALSE(iterator == nullptr);
283 Netstack_DestroyMapIterator(iterator);
284 Netstack_DestroyMap(map);
285 }
286
287 HWTEST_F(NetstackHashMapTest, NetstackCreateMapIteratorTest003, TestSize.Level1)
288 {
289 Netstack_HashMap *map = CreateMap();
290 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
291 EXPECT_EQ(iterator, nullptr);
292 Netstack_DestroyMap(map);
293 }
294
295 HWTEST_F(NetstackHashMapTest, NetstackMapIterateNextTest001, TestSize.Level1)
296 {
297 Netstack_MapIterateNext(nullptr);
298
299 Netstack_HashMap *map = CreateMap();
300 EXPECT_TRUE(map != nullptr);
301 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
302 Netstack_MapIterateNext(iterator);
303
304 map->capacity = MAX_MAP_CAPACITY + 1;
305 const char *key1 = "a";
306 const char *key2 = "q";
307 const char *value = "value";
308 Netstack_PutMapEntry(map, key1, (void *)value);
309 Netstack_PutMapEntry(map, key2, (void *)value);
310 iterator = Netstack_CreateMapIterator(map);
311 Netstack_MapIterateNext(iterator);
312
313 Netstack_DestroyMapIterator(iterator);
314 Netstack_DestroyMap(map);
315 }
316
317 HWTEST_F(NetstackHashMapTest, NetstackMapIterateNextTest002, TestSize.Level1)
318 {
319 Netstack_HashMap *map = CreateMap();
320 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
321 EXPECT_TRUE(iterator == nullptr);
322 Netstack_DestroyMapIterator(iterator);
323 Netstack_DestroyMap(map);
324 }
325
326 HWTEST_F(NetstackHashMapTest, NetstackMapIterateNextTest003, TestSize.Level1)
327 {
328 Netstack_HashMap *map = CreateMap();
329 EXPECT_TRUE(map != nullptr);
330 const char *key1 = "da";
331 const char *key2 = "eb";
332 const char *key3 = "fc";
333 const char *value = "value";
334 Netstack_PutMapEntry(map, key1, (void *)value);
335 Netstack_PutMapEntry(map, key2, (void *)value);
336 Netstack_PutMapEntry(map, key3, (void *)value);
337 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
338 Netstack_MapIterateNext(iterator);
339
340 Netstack_DestroyMapIterator(iterator);
341 Netstack_DestroyMap(map);
342 }
343
344 HWTEST_F(NetstackHashMapTest, NetstackMapIterateNextTest004, TestSize.Level1)
345 {
346 Netstack_HashMap *map = CreateMap();
347 EXPECT_TRUE(map != nullptr);
348 const char *key1 = "a";
349 const char *key2 = "q";
350 const char *value = "value";
351 Netstack_PutMapEntry(map, key1, (void *)value);
352 Netstack_PutMapEntry(map, key2, (void *)value);
353 Netstack_MapIterator *iterator = Netstack_CreateMapIterator(map);
354 Netstack_MapIterateNext(iterator);
355
356 Netstack_DestroyMapIterator(iterator);
357 Netstack_DestroyMap(map);
358 }
359 }