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 #include "test.h"
16 #include "ns_config.h"
17 #include "functionalext.h"
18
19 typedef void (*TEST_FUN)(void);
20
21 /**
22 * @tc.name : ns_config_0010
23 * @tc.desc : Set default error callback for configor
24 * @tc.level : Level 1
25 */
ns_config_test_0010(void)26 static void ns_config_test_0010(void)
27 {
28 ns_configor* configor = NULL;
29 configor = configor_init();
30 configor->set_error_callback(NULL);
31 configor_free();
32
33 EXPECT_TRUE(__FUNCTION__, true);
34 }
35
errorback(const char * format,...)36 int errorback(const char* format, ...)
37 {
38 return 0;
39 }
40
41 /**
42 * @tc.name : ns_config_0030
43 * @tc.desc : Set custom error callback for configor
44 * @tc.level : Level 0
45 */
ns_config_test_0020(void)46 static void ns_config_test_0020(void)
47 {
48 ns_configor* configor = NULL;
49 configor = configor_init();
50 configor->set_error_callback(&errorback);
51 configor_free();
52
53 EXPECT_TRUE(__FUNCTION__, true);
54 }
55
56 /**
57 * @tc.name : ns_config_0030
58 * @tc.desc : Test parse with invalid input
59 * @tc.level : Level 2
60 */
ns_config_test_0030(void)61 static void ns_config_test_0030(void)
62 {
63 ns_configor* configor = NULL;
64 configor = configor_init();
65 configor->set_error_callback(NULL);
66 int ret = configor->parse("ttttttttt.txt", "ttttttttt");
67 configor_free();
68 EXPECT_EQ(__FUNCTION__, ret, -2);
69 }
70
71 /**
72 * @tc.name : ns_config_0040
73 * @tc.desc : Test get_namespaces with invalid input
74 * @tc.level : Level 2
75 */
ns_config_test_0040(void)76 static void ns_config_test_0040(void)
77 {
78 ns_configor* configor = NULL;
79 configor = configor_init();
80 strlist *ret = configor->get_namespaces();
81 configor_free();
82 EXPECT_EQ(__FUNCTION__, ret, NULL);
83 }
84
85 /**
86 * @tc.name : ns_config_0050
87 * @tc.desc : Test get_namespaces with invalid input
88 * @tc.level : Level 2
89 */
ns_config_test_0050(void)90 static void ns_config_test_0050(void)
91 {
92 ns_configor* configor = NULL;
93 configor = configor_init();
94 kvlist kv;
95 kv.num = 1;
96 char *key = "a";
97 char *val = "b";
98 kv.key = &key;
99 kv.val = &val;
100 configor->kvs = &kv;
101 strlist *ret = configor->get_namespaces();
102 configor_free();
103 EXPECT_EQ(__FUNCTION__, ret, NULL);
104 }
105
106 /**
107 * @tc.name : ns_config_0060
108 * @tc.desc : Test get_namespaces with invalid input
109 * @tc.level : Level 2
110 */
ns_config_test_0060(void)111 static void ns_config_test_0060(void)
112 {
113 ns_configor* configor = NULL;
114 configor = configor_init();
115 kvlist kv;
116 kv.num = 1;
117 char *key = "added.nslist";
118 char *val = "b";
119 kv.key = &key;
120 kv.val = &val;
121 configor->kvs = &kv;
122 strlist *ret = configor->get_namespaces();
123 configor_free();
124 EXPECT_PTRNE(__FUNCTION__, ret, NULL);
125 }
126
127 /**
128 * @tc.name : ns_config_0070
129 * @tc.desc : Test get_lib_paths with invalid input
130 * @tc.level : Level 2
131 */
ns_config_test_0070(void)132 static void ns_config_test_0070(void)
133 {
134 ns_configor* configor = NULL;
135 configor = configor_init();
136 char* ret = configor->get_lib_paths(NULL);
137 configor_free();
138 EXPECT_EQ(__FUNCTION__, ret, NULL);
139 }
140
141 /**
142 * @tc.name : ns_config_0080
143 * @tc.desc : Test get_lib_paths with invalid input
144 * @tc.level : Level 2
145 */
ns_config_test_0080(void)146 static void ns_config_test_0080(void)
147 {
148 ns_configor* configor = NULL;
149 configor = configor_init();
150 char* ret = configor->get_lib_paths("test");
151 configor_free();
152 EXPECT_EQ(__FUNCTION__, ret, NULL);
153 }
154
155 /**
156 * @tc.name : ns_config_0090
157 * @tc.desc : Test get_asan_lib_paths with invalid input
158 * @tc.level : Level 2
159 */
ns_config_test_0090(void)160 static void ns_config_test_0090(void)
161 {
162 ns_configor* configor = NULL;
163 configor = configor_init();
164 char* ret = configor->get_asan_lib_paths(NULL);
165 configor_free();
166 EXPECT_EQ(__FUNCTION__, ret, NULL);
167 }
168
169 /**
170 * @tc.name : ns_config_0100
171 * @tc.desc : Test get_asan_lib_paths with invalid input
172 * @tc.level : Level 2
173 */
ns_config_test_0100(void)174 static void ns_config_test_0100(void)
175 {
176 ns_configor* configor = NULL;
177 configor = configor_init();
178 char* ret = configor->get_asan_lib_paths("test");
179 configor_free();
180 EXPECT_EQ(__FUNCTION__, ret, NULL);
181 }
182
183 /**
184 * @tc.name : ns_config_0110
185 * @tc.desc : Test get_permitted_paths with invalid input
186 * @tc.level : Level 2
187 */
ns_config_test_0110(void)188 void ns_config_test_0110(void)
189 {
190 ns_configor* configor = NULL;
191 configor = configor_init();
192 char* ret = configor->get_permitted_paths(NULL);
193 configor_free();
194 EXPECT_EQ(__FUNCTION__, ret, NULL);
195 }
196
197 /**
198 * @tc.name : ns_config_0120
199 * @tc.desc : Test get_permitted_paths with normal input
200 * @tc.level : Level 1
201 */
ns_config_test_0120(void)202 void ns_config_test_0120(void)
203 {
204 ns_configor* configor = NULL;
205 configor = configor_init();
206 char* ret = configor->get_permitted_paths("test");
207 configor_free();
208 EXPECT_EQ(__FUNCTION__, ret, NULL);
209 }
210
211 /**
212 * @tc.name : ns_config_0130
213 * @tc.desc : Test get_inherits with invalid input
214 * @tc.level : Level 2
215 */
ns_config_test_0130(void)216 void ns_config_test_0130(void)
217 {
218 ns_configor* configor = NULL;
219 configor = configor_init();
220 strlist* ret = configor->get_inherits(NULL);
221 configor_free();
222 EXPECT_EQ(__FUNCTION__, ret , NULL);
223 }
224
225 /**
226 * @tc.name : ns_config_0140
227 * @tc.desc : Test get_inherits with normal input
228 * @tc.level : Level 1
229 */
ns_config_test_0140(void)230 void ns_config_test_0140(void)
231 {
232 ns_configor* configor = NULL;
233 configor = configor_init();
234 strlist* ret = configor->get_inherits("test");
235 configor_free();
236 EXPECT_EQ(__FUNCTION__, ret, NULL);
237 }
238
239 /**
240 * @tc.name : ns_config_0150
241 * @tc.desc : Test get_separated with invalid input
242 * @tc.level : Level 2
243 */
ns_config_test_0150(void)244 void ns_config_test_0150(void)
245 {
246 ns_configor* configor = NULL;
247 configor = configor_init();
248 bool ret = configor->get_separated(NULL);
249 configor_free();
250 EXPECT_EQ(__FUNCTION__, ret, false);
251 }
252
253 /**
254 * @tc.name : ns_config_0160
255 * @tc.desc : Test get_separated with normal input
256 * @tc.level : Level 1
257 */
ns_config_test_0160(void)258 void ns_config_test_0160(void)
259 {
260 ns_configor* configor = NULL;
261 configor = configor_init();
262 bool ret = configor->get_separated("test");
263 configor_free();
264 EXPECT_EQ(__FUNCTION__, ret, false);
265 }
266
267 /**
268 * @tc.name : ns_config_0170
269 * @tc.desc : Test get_allowed_libs with invalid input
270 * @tc.level : Level 2
271 */
ns_config_test_0170(void)272 void ns_config_test_0170(void)
273 {
274 ns_configor* configor = NULL;
275 configor = configor_init();
276 char* ret = configor->get_allowed_libs(NULL);
277 configor_free();
278 EXPECT_EQ(__FUNCTION__, ret, NULL);
279 }
280
281 /**
282 * @tc.name : ns_config_0180
283 * @tc.desc : Test get_allowed_libs with normal input
284 * @tc.level : Level 1
285 */
ns_config_test_0180(void)286 void ns_config_test_0180(void)
287 {
288 ns_configor* configor = NULL;
289 configor = configor_init();
290 char* ret = configor->get_allowed_libs("test");
291 configor_free();
292 EXPECT_EQ(__FUNCTION__, ret, NULL);
293 }
294
295 /**
296 * @tc.name : ns_config_0180
297 * @tc.desc : Test get_inherit_shared_libs with invalid input
298 * @tc.level : Level 2
299 */
ns_config_test_0190(void)300 void ns_config_test_0190(void)
301 {
302 ns_configor* configor = NULL;
303 configor = configor_init();
304 char* ret = configor->get_inherit_shared_libs(NULL, NULL);
305 configor_free();
306 EXPECT_EQ(__FUNCTION__, ret, NULL);
307 }
308
309 /**
310 * @tc.name : ns_config_0200
311 * @tc.desc : Test get_inherit_shared_libs with normal input
312 * @tc.level : Level 1
313 */
ns_config_test_0200(void)314 void ns_config_test_0200(void)
315 {
316 ns_configor* configor = NULL;
317 configor = configor_init();
318 char* ret = configor->get_inherit_shared_libs("test", "abc");
319 configor_free();
320 EXPECT_EQ(__FUNCTION__, ret, NULL);
321 }
322
323 /**
324 * @tc.name : ns_config_0210
325 * @tc.desc : get_inherit_shared_libs test coverage
326 * @tc.level : Level 1
327 */
ns_config_test_0210(void)328 void ns_config_test_0210(void)
329 {
330 ns_configor* configor = NULL;
331 configor = configor_init();
332 char* ret = configor->get_asan_sys_paths();
333 configor_free();
334 EXPECT_EQ(__FUNCTION__, ret, NULL);
335 }
336
337 /**
338 * @tc.name : ns_config_0220
339 * @tc.desc : Test get_asan_permitted_paths with invalid input
340 * @tc.level : Level 2
341 */
ns_config_test_0220(void)342 void ns_config_test_0220(void)
343 {
344 ns_configor* configor = NULL;
345 configor = configor_init();
346 char* ret = configor->get_asan_permitted_paths(NULL);
347 configor_free();
348 EXPECT_EQ(__FUNCTION__, ret, NULL);
349 }
350
351 /**
352 * @tc.name : ns_config_0230
353 * @tc.desc : Test get_asan_permitted_paths with normal input
354 * @tc.level : Level 1
355 */
ns_config_test_0230(void)356 void ns_config_test_0230(void)
357 {
358 ns_configor* configor = NULL;
359 configor = configor_init();
360 char* ret = configor->get_asan_permitted_paths("test");
361 configor_free();
362 EXPECT_EQ(__FUNCTION__, ret, NULL);
363 }
364
365 /**
366 * @tc.name : ns_config_0240
367 * @tc.desc : Test get_inherit_shared_libs with invalid input
368 * @tc.level : Level 2
369 */
ns_config_test_0240(void)370 void ns_config_test_0240(void)
371 {
372 ns_configor* configor = NULL;
373 configor = configor_init();
374 char* ret = configor->get_inherit_shared_libs(NULL, "test");
375 configor_free();
376 EXPECT_EQ(__FUNCTION__, ret, NULL);
377 }
378
379 /**
380 * @tc.name : ns_config_0250
381 * @tc.desc : Test get_inherit_shared_libs with invalid input
382 * @tc.level : Level 2
383 */
ns_config_test_0250(void)384 void ns_config_test_0250(void)
385 {
386 ns_configor* configor = NULL;
387 configor = configor_init();
388 char* ret = configor->get_inherit_shared_libs("test", NULL);
389 configor_free();
390 EXPECT_EQ(__FUNCTION__, ret, NULL);
391 }
392
393 /**
394 * @tc.name : ns_config_0260
395 * @tc.desc : Test parse with normal input
396 * @tc.level : Level 1
397 */
ns_config_test_0260(void)398 void ns_config_test_0260(void)
399 {
400 ns_configor* configor = NULL;
401 configor = configor_init();
402 configor->set_error_callback(NULL);
403 int ret = configor->parse("/etc/ld-musl-namespace-arm-test.ini", "/data/tests/libc-test/src");
404 configor_free();
405 EXPECT_EQ(__FUNCTION__, ret, 0);
406 }
407
408 /**
409 * @tc.name : ns_config_0270
410 * @tc.desc : Test parse with normal input
411 * @tc.level : Level 1
412 */
ns_config_test_0270(void)413 void ns_config_test_0270(void)
414 {
415 ns_configor* configor = NULL;
416 configor = configor_init();
417 configor->set_error_callback(NULL);
418 int ret = configor->parse(NULL, "/");
419 configor_free();
420 EXPECT_EQ(__FUNCTION__, ret, 0);
421 }
422
423 /**
424 * @tc.name : ns_config_0280
425 * @tc.desc : Test parse with invalid input
426 * @tc.level : Level 2
427 */
ns_config_test_0280(void)428 void ns_config_test_0280(void)
429 {
430 ns_configor* configor = NULL;
431 configor = configor_init();
432 configor->set_error_callback(NULL);
433 int ret = configor->parse("/etc/ld-musl-namespace-arm-test.ini", NULL);
434 configor_free();
435 EXPECT_EQ(__FUNCTION__, ret, -1);
436 }
437
438 // Because below function are static in file and call it difficult through External API, below interfaces are covered by white-box unit testing.
439 #ifdef UNIT_TEST_STATIC
440 void kvlist_realloc(kvlist *kvs);
441 void sections_realloc(section_list *sections);
442
443 /**
444 * @tc.name : ns_config_test_0290
445 * @tc.desc : Test kvlist_realloc with invalid input
446 * @tc.level : Level 2
447 */
ns_config_test_0290(void)448 void ns_config_test_0290(void)
449 {
450 kvlist_realloc(NULL);
451 EXPECT_TRUE(__FUNCTION__, true);
452 }
453
454 /**
455 * @tc.name : ns_config_test_0300
456 * @tc.desc : Test kvlist_realloc with normal input
457 * @tc.level : Level 0
458 */
ns_config_test_0300(void)459 void ns_config_test_0300(void)
460 {
461 kvlist kvs;
462 kvs.size = 1;
463 kvs.key = (char **)calloc(kvs.size, sizeof *kvs.key);
464 kvs.val = (char **)calloc(kvs.size, sizeof *kvs.val);
465 kvlist_realloc(&kvs);
466 EXPECT_EQ(__FUNCTION__, kvs.size, 2);
467 if (kvs.key){
468 free(kvs.key);
469 }
470 if (kvs.val){
471 free(kvs.val);
472 }
473 }
474
475 /**
476 * @tc.name : ns_config_test_0310
477 * @tc.desc : Test sections_realloc with invalid input
478 * @tc.level : Level 2
479 */
ns_config_test_0310(void)480 void ns_config_test_0310(void)
481 {
482 sections_realloc(NULL);
483 EXPECT_TRUE(__FUNCTION__, true);
484 }
485
486 /**
487 * @tc.name : ns_config_test_0320
488 * @tc.desc : Test sections_realloc with normal input
489 * @tc.level : Level 0
490 */
ns_config_test_0320(void)491 void ns_config_test_0320(void)
492 {
493 section_list sections;
494 sections.size = 1;
495 sections.names = (char**)calloc(sections.size, sizeof *sections.names);
496 sections.kvs = (kvlist**)calloc(sections.size, sizeof *sections.kvs);
497 sections_realloc(§ions);
498 EXPECT_EQ(__FUNCTION__, sections.size, 2);
499 if (sections.names){
500 free(sections.names);
501 }
502 if (sections.kvs){
503 free(sections.kvs);
504 }
505 }
506 #endif
507
508 TEST_FUN G_Fun_Array[] = {
509 ns_config_test_0010,
510 ns_config_test_0020,
511 ns_config_test_0030,
512 ns_config_test_0040,
513 ns_config_test_0050,
514 ns_config_test_0060,
515 ns_config_test_0070,
516 ns_config_test_0080,
517 ns_config_test_0090,
518 ns_config_test_0100,
519 ns_config_test_0110,
520 ns_config_test_0120,
521 ns_config_test_0130,
522 ns_config_test_0140,
523 ns_config_test_0150,
524 ns_config_test_0160,
525 ns_config_test_0170,
526 ns_config_test_0180,
527 ns_config_test_0190,
528 ns_config_test_0200,
529 ns_config_test_0210,
530 ns_config_test_0220,
531 ns_config_test_0230,
532 ns_config_test_0240,
533 ns_config_test_0250,
534 ns_config_test_0260,
535 ns_config_test_0270,
536 ns_config_test_0280,
537 #ifdef UNIT_TEST_STATIC
538 ns_config_test_0290,
539 ns_config_test_0300,
540 ns_config_test_0310,
541 ns_config_test_0320,
542 #endif
543 };
544
main(void)545 int main(void)
546 {
547 int num = sizeof(G_Fun_Array) / sizeof(TEST_FUN);
548 for (int pos = 0; pos < num; ++pos) {
549 G_Fun_Array[pos]();
550 }
551
552 return t_status;
553 }