Mercurial > hg > ucx / file comparison

comparison: test/prop_tests.c

test/prop_tests.c

changeset 390
d345541018fa
parent 259
2f5dea574a75
equal deleted inserted replaced
389:92e482410453 390:d345541018fa
1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3 *
4 * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "prop_tests.h"
30 #include <ucx/mempool.h>
31
32 UCX_TEST(test_ucx_properties_new) {
33 UcxProperties *parser = ucx_properties_new();
34
35 UCX_TEST_BEGIN
36
37 UCX_TEST_ASSERT(parser != NULL, "failed");
38 UCX_TEST_ASSERT(parser->buffer == NULL, "parser has buffer");
39 UCX_TEST_ASSERT(parser->tmp == NULL, "parser has tmp buffer");
40
41 UCX_TEST_END
42
43 ucx_properties_free(parser);
44 }
45
46 UCX_TEST(test_ucx_properties_next) {
47 const char *tests[] = {
48 "name = value\n",
49 "name=value\n",
50 "n=value\n",
51 "name=v\n",
52 "n=v\n",
53 "name = value # comment\n",
54 "#comment\nn=v\n",
55 "# comment1\n# comment2\n\n \n\nname = value\n",
56 " name = value\n",
57 "name = value\n\n"
58 };
59
60 const char *names[] = {
61 "name",
62 "name",
63 "n",
64 "name",
65 "n",
66 "name",
67 "n",
68 "name",
69 "name",
70 "name"
71 };
72
73 const char *values[] = {
74 "value",
75 "value",
76 "value",
77 "v",
78 "v",
79 "value",
80 "v",
81 "value",
82 "value",
83 "value"
84 };
85
86 UCX_TEST_BEGIN
87
88 sstr_t name;
89 sstr_t value;
90
91 for(int i=0;i<10;i++) {
92 UcxProperties *parser = ucx_properties_new();
93
94 ucx_properties_fill(parser, (char*)tests[i], strlen(tests[i]));
95 UCX_TEST_ASSERT(parser->buffer == tests[i], "fill failed");
96 UCX_TEST_ASSERT(parser->buflen == strlen(tests[i]), "wrong buflen");
97
98 int r = ucx_properties_next(parser, &name, &value);
99 sstr_t n = sstr((char*)names[i]);
100 sstr_t v = sstr((char*)values[i]);
101 UCX_TEST_ASSERT(r == 1, "next returned 0");
102 UCX_TEST_ASSERT((!sstrcmp(name, n)), "wrong property name");
103 UCX_TEST_ASSERT((!sstrcmp(value, v)), "wrong property value");
104
105 r = ucx_properties_next(parser, &name, &value);
106 UCX_TEST_ASSERT(r == 0, "next returned 1");
107 UCX_TEST_ASSERT(parser->tmp == NULL, "tmp not NULL");
108 UCX_TEST_ASSERT(parser->tmpcap == 0, "tmpcap not NULL");
109 UCX_TEST_ASSERT(parser->tmplen == 0, "tmplen not NULL");
110
111 ucx_properties_free(parser);
112 }
113
114 UCX_TEST_END
115 }
116
117 UCX_TEST(test_ucx_properties_next_multi) {
118 const char *names[] = {
119 "a",
120 "b",
121 "c",
122 "uap",
123 "name",
124 "key1",
125 "key2",
126 "key3"
127 };
128
129 const char *values[] = {
130 "a value",
131 "b value",
132 "core",
133 "core",
134 "ucx",
135 "value1",
136 "value2",
137 "value3"
138 };
139
140 const char *str = "#\n"
141 "# properties\n"
142 "# contains key/value pairs\n"
143 "#\n"
144 "a = a value\n"
145 "b = b value\n"
146 "c = core\n"
147 "\n# test\n"
148 "uap = core\n"
149 "name = ucx\n"
150 "# no = property\n"
151 "key1 = value1\n"
152 "#key1 = wrong value\n"
153 "#key2 = not value 2\n"
154 "key2 = value2\n"
155 "\n\n\n \n key3=value3\n";
156
157 UcxProperties *parser = ucx_properties_new();
158
159 UCX_TEST_BEGIN
160
161 ucx_properties_fill(parser, (char*)str, strlen(str));
162
163 sstr_t name;
164 sstr_t value;
165 for(int i=0;i<8;i++) {
166 int r = ucx_properties_next(parser, &name, &value);
167 UCX_TEST_ASSERT(r == 1, "next returned 0");
168 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)names[i]))), "wrong name");
169 UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)values[i]))),
170 "wrong value");
171 }
172 int r = ucx_properties_next(parser, &name, &value);
173 UCX_TEST_ASSERT(r == 0, "next returned 1");
174
175 UCX_TEST_END
176
177 ucx_properties_free(parser);
178 }
179
180 UCX_TEST(test_ucx_properties_next_part) {
181 UcxProperties *parser = ucx_properties_new();
182 const char *str;
183 int r;
184 sstr_t name;
185 sstr_t value;
186
187 UCX_TEST_BEGIN
188
189 str = "";
190 ucx_properties_fill(parser, (char*)str, strlen(str));
191 r = ucx_properties_next(parser, &name, &value);
192 UCX_TEST_ASSERT(r == 0, "next returned 1");
193
194 str = " \n";
195 ucx_properties_fill(parser, (char*)str, strlen(str));
196 r = ucx_properties_next(parser, &name, &value);
197 UCX_TEST_ASSERT(r == 0, "next returned 1");
198
199 str = "name";
200 ucx_properties_fill(parser, (char*)str, strlen(str));
201 r = ucx_properties_next(parser, &name, &value);
202 UCX_TEST_ASSERT(r == 0, "next returned 1");
203
204 str = " ";
205 ucx_properties_fill(parser, (char*)str, strlen(str));
206 r = ucx_properties_next(parser, &name, &value);
207 UCX_TEST_ASSERT(r == 0, "next returned 1");
208
209 str = "= ";
210 ucx_properties_fill(parser, (char*)str, strlen(str));
211 r = ucx_properties_next(parser, &name, &value);
212 UCX_TEST_ASSERT(r == 0, "next returned 1");
213
214 str = "value";
215 ucx_properties_fill(parser, (char*)str, strlen(str));
216 r = ucx_properties_next(parser, &name, &value);
217 UCX_TEST_ASSERT(r == 0, "next returned 1");
218
219 str = "\n";
220 ucx_properties_fill(parser, (char*)str, strlen(str));
221 r = ucx_properties_next(parser, &name, &value);
222 UCX_TEST_ASSERT(r == 1, "next returned 0");
223 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"name"))), "wrong name");
224 UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"value"))), "wrong value");
225
226 // second round
227 str = "#comment\n";
228 ucx_properties_fill(parser, (char*)str, strlen(str));
229 r = ucx_properties_next(parser, &name, &value);
230 UCX_TEST_ASSERT(r == 0, "next returned 1");
231
232 str = "#comment\nname = ";
233 ucx_properties_fill(parser, (char*)str, strlen(str));
234 r = ucx_properties_next(parser, &name, &value);
235 UCX_TEST_ASSERT(r == 0, "next returned 1");
236
237 str = "value\na = b\n";
238 ucx_properties_fill(parser, (char*)str, strlen(str));
239 r = ucx_properties_next(parser, &name, &value);
240 UCX_TEST_ASSERT(r == 1, "next returned 0");
241 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"name"))), "wrong name");
242 UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"value"))), "wrong value");
243
244 r = ucx_properties_next(parser, &name, &value);
245 UCX_TEST_ASSERT(r == 1, "next returned 0");
246 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"a"))), "wrong name");
247 UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"b"))), "wrong value");
248
249 str = "# comment\n#\n#\ntests = ";
250 ucx_properties_fill(parser, (char*)str, strlen(str));
251 r = ucx_properties_next(parser, &name, &value);
252 UCX_TEST_ASSERT(r == 0, "next returned 1");
253
254 str = "test1 ";
255 ucx_properties_fill(parser, (char*)str, strlen(str));
256 r = ucx_properties_next(parser, &name, &value);
257 UCX_TEST_ASSERT(r == 0, "next returned 1");
258
259 str = "test2 test3 test4\n";
260 sstr_t testv = sstr((char*)"test1 test2 test3 test4");
261 ucx_properties_fill(parser, (char*)str, strlen(str));
262 r = ucx_properties_next(parser, &name, &value);
263 UCX_TEST_ASSERT(r == 1, "next returned 0");
264 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"tests"))), "wrong name");
265 UCX_TEST_ASSERT((!sstrcmp(value, testv)), "wrong value");
266
267 // test if ucx_properties_next finds a name/value after a tmp comment
268 str = "# just a comment";
269 ucx_properties_fill(parser, (char*)str, strlen(str));
270 r = ucx_properties_next(parser, &name, &value);
271 UCX_TEST_ASSERT(r == 0, "next returned 1");
272
273 str = " in 3";
274 ucx_properties_fill(parser, (char*)str, strlen(str));
275 r = ucx_properties_next(parser, &name, &value);
276 UCX_TEST_ASSERT(r == 0, "next returned 1");
277
278 str = " parts\na = 1\n";
279 ucx_properties_fill(parser, (char*)str, strlen(str));
280 r = ucx_properties_next(parser, &name, &value);
281 UCX_TEST_ASSERT(r == 1, "next returned 0");
282 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"a"))), "wrong name");
283 UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"1"))), "wrong value");
284
285 UCX_TEST_END
286
287 ucx_properties_free(parser);
288 }
289
290 UCX_TEST(test_ucx_properties_next_long) {
291 UcxProperties *parser = ucx_properties_new();
292 int r;
293 size_t name_len = 512;
294 char *long_name = (char*)malloc(name_len);
295 memset(long_name, 'a', 70);
296 memset(long_name+70, 'b', 242);
297 memset(long_name+312, 'c', 200);
298
299 size_t value_len = 2048;
300 char *long_value = (char*)malloc(value_len);
301 memset(long_value, 'x', 1024);
302 memset(long_value+1024, 'y', 1024);
303
304 UCX_TEST_BEGIN
305
306 sstr_t name;
307 sstr_t value;
308
309 ucx_properties_fill(parser, long_name, 10);
310 r = ucx_properties_next(parser, &name, &value);
311 UCX_TEST_ASSERT(r == 0, "next returned 1");
312
313 ucx_properties_fill(parser, long_name+10, 202);
314 r = ucx_properties_next(parser, &name, &value);
315 UCX_TEST_ASSERT(r == 0, "next returned 1");
316
317 ucx_properties_fill(parser, long_name+212, 200);
318 r = ucx_properties_next(parser, &name, &value);
319 UCX_TEST_ASSERT(r == 0, "next returned 1");
320
321 ucx_properties_fill(parser, long_name+412, 100);
322 r = ucx_properties_next(parser, &name, &value);
323 UCX_TEST_ASSERT(r == 0, "next returned 1");
324
325 const char *str = " = ";
326 ucx_properties_fill(parser, (char*)str, strlen(str));
327 r = ucx_properties_next(parser, &name, &value);
328 UCX_TEST_ASSERT(r == 0, "next returned 1");
329
330 ucx_properties_fill(parser, long_value, 512);
331 r = ucx_properties_next(parser, &name, &value);
332 UCX_TEST_ASSERT(r == 0, "next returned 1");
333
334 ucx_properties_fill(parser, long_value+512, 1024);
335 r = ucx_properties_next(parser, &name, &value);
336 UCX_TEST_ASSERT(r == 0, "next returned 1");
337
338 ucx_properties_fill(parser, long_value+1536, 512);
339 r = ucx_properties_next(parser, &name, &value);
340 UCX_TEST_ASSERT(r == 0, "next returned 1");
341
342 str = "\n#comment\nkey = value\n";
343 ucx_properties_fill(parser, (char*)str, strlen(str));
344 r = ucx_properties_next(parser, &name, &value);
345 sstr_t n = sstrn(long_name, name_len);
346 sstr_t v = sstrn(long_value, value_len);
347 UCX_TEST_ASSERT(r == 1, "next returned 0");
348 UCX_TEST_ASSERT((!sstrcmp(name, n)), "wrong name");
349 UCX_TEST_ASSERT((!sstrcmp(value, v)), "wrong value");
350
351 r = ucx_properties_next(parser, &name, &value);
352 UCX_TEST_ASSERT(r == 1, "next returned 0");
353 UCX_TEST_ASSERT((!sstrcmp(name, sstr((char*)"key"))), "wrong name");
354 UCX_TEST_ASSERT((!sstrcmp(value, sstr((char*)"value"))), "wrong value");
355
356 r = ucx_properties_next(parser, &name, &value);
357 UCX_TEST_ASSERT(r == 0, "next returned 1");
358
359 UCX_TEST_END
360
361 free(long_name);
362 free(long_value);
363 ucx_properties_free(parser);
364 }
365
366 UCX_TEST(test_ucx_properties2map) {
367 UcxMempool *mp = ucx_mempool_new(64);
368 UcxMap *map = ucx_map_new_a(mp->allocator, 16);
369 UcxProperties *parser = ucx_properties_new();
370
371 UCX_TEST_BEGIN
372
373 const char *str = "key1 = value1\nkey2 = value2\n\n#comment\n\nkey3 = value3\n";
374 ucx_properties_fill(parser, (char*)str, strlen(str));
375
376 int r = ucx_properties2map(parser, map);
377
378 UCX_TEST_ASSERT(r == 0, "properties2map failed");
379 UCX_TEST_ASSERT(map->count == 3, "wrong number of properties");
380
381 char *v1 = (char*)ucx_map_cstr_get(map, "key1");
382 char *v2 = (char*)ucx_map_cstr_get(map, "key2");
383 char *v3 = (char*)ucx_map_cstr_get(map, "key3");
384
385 UCX_TEST_ASSERT(v1, "value for key1 not found");
386 UCX_TEST_ASSERT(v2, "value for key2 not found");
387 UCX_TEST_ASSERT(v3, "value for key3 not found");
388
389 UCX_TEST_ASSERT((!strcmp(v1, "value1")), "wrong value for key1");
390 UCX_TEST_ASSERT((!strcmp(v2, "value2")), "wrong value for key2");
391 UCX_TEST_ASSERT((!strcmp(v3, "value3")), "wrong value for key3");
392
393 // second test
394 ucx_map_free(map);
395 map = ucx_map_new_a(mp->allocator, 16);
396
397 str = "\n#comment\n";
398 ucx_properties_fill(parser, (char*)str, strlen(str));
399
400 r = ucx_properties2map(parser, map);
401 UCX_TEST_ASSERT(r == 0, "properties2map failed");
402 UCX_TEST_ASSERT(map->count == 0, "wrong number of properties");
403
404 str = "key1 = value1\nsyntax error line\n";
405 ucx_properties_fill(parser, (char*)str, strlen(str));
406
407 r = ucx_properties2map(parser, map);
408 UCX_TEST_ASSERT(r == 1, "properties2map should return 1");
409 UCX_TEST_ASSERT(map->count == 1, "wrong number of properties");
410
411 char *v = (char*)ucx_map_cstr_get(map, "key1");
412 UCX_TEST_ASSERT((!strcmp(v, "value1")), "wrong value");
413
414 UCX_TEST_END
415
416 ucx_mempool_destroy(mp);
417 ucx_properties_free(parser);
418 }
419
420 UCX_TEST(test_ucx_properties_load) {
421 UCX_TEST_BEGIN
422 FILE *f = tmpfile();
423 UCX_TEST_ASSERT(f, "test file cannot be opened, test aborted");
424
425 fprintf(f, "# properties file\n\nkey1 = value1\nkey2 = value2\n");
426 fprintf(f, "\n\nkey3 = value3\n\n");
427
428 size_t name_len = 512;
429 char *long_name = (char*)malloc(name_len);
430 memset(long_name, 'k', 512);
431
432 size_t value_len = 2048;
433 char *long_value = (char*)malloc(value_len);
434 memset(long_value, 'v', 2048);
435
436 fwrite(long_name, 1, name_len, f);
437 fprintf(f, " = ");
438 fwrite(long_value, 1, value_len, f);
439 fprintf(f, " \n");
440
441 fprintf(f, "\n\n\n\nlast_key = property value\n");
442
443 fflush(f);
444 fseek(f, 0, SEEK_SET);
445
446 UcxMap *map = ucx_map_new(8);
447 int r = ucx_properties_load(map, f);
448
449 UCX_TEST_ASSERT(r == 0, "ucx_properties_load failed");
450 UCX_TEST_ASSERT(map->count == 5, "wrong number of properties");
451
452 char *v1 = (char*)ucx_map_cstr_get(map, "key1");
453 char *v2 = (char*)ucx_map_cstr_get(map, "key2");
454 char *v3 = (char*)ucx_map_cstr_get(map, "key3");
455 char *lv = (char*)ucx_map_sstr_get(map, sstrn(long_name, name_len));
456 char *lk = (char*)ucx_map_cstr_get(map, "last_key");
457
458 UCX_TEST_ASSERT(v1, "value for key1 not found");
459 UCX_TEST_ASSERT(v2, "value for key2 not found");
460 UCX_TEST_ASSERT(v3, "value for key3 not found");
461 UCX_TEST_ASSERT(lv, "value for long key not found");
462 UCX_TEST_ASSERT(lk, "value for last_key not found");
463
464 UCX_TEST_ASSERT((!strcmp(v1, "value1")), "wrong value for key1");
465 UCX_TEST_ASSERT((!strcmp(v2, "value2")), "wrong value for key2");
466 UCX_TEST_ASSERT((!strcmp(v3, "value3")), "wrong value for key3");
467 sstr_t long1 = sstrn(long_value, value_len);
468 sstr_t long2 = sstr(lv);
469 UCX_TEST_ASSERT((!sstrcmp(long1, long2)), "wrong value for long key");
470 UCX_TEST_ASSERT(!strcmp(lk, "property value"), "wrong value for last_key");
471
472 free(v1);
473 free(v2);
474 free(v3);
475 free(lv);
476 free(lk);
477 ucx_map_free(map);
478 fclose(f);
479
480 free(long_name);
481 free(long_value);
482
483 UCX_TEST_END
484 }
485
486 UCX_TEST(test_ucx_properties_store) {
487 UcxMap *map1 = ucx_map_new(16);
488 ucx_map_cstr_put(map1, "key1", "value1");
489 ucx_map_cstr_put(map1, "key2", "value2");
490 ucx_map_cstr_put(map1, "key3", "value3");
491 ucx_map_cstr_put(map1, "key4", "value4");
492 ucx_map_cstr_put(map1, "property.key1", "some value 1");
493 ucx_map_cstr_put(map1, "property.key2", "some value 2");
494 ucx_map_cstr_put(map1, "property.key3", "some value 3");
495 ucx_map_cstr_put(map1, "property.key4", "some value 4");
496
497 UCX_TEST_BEGIN
498
499 FILE *f = tmpfile();
500 fprintf(f, "#\n# test property file\n#\n#\n");
501 ucx_properties_store(map1, f);
502
503 fflush(f);
504 fseek(f, 0, SEEK_SET);
505 UcxMap *map2 = ucx_map_new(16);
506 ucx_properties_load(map2, f);
507
508 UCX_TEST_ASSERT(map2->count == 8, "wrong number of properties in map2");
509
510 char *v1 = (char*)ucx_map_cstr_get(map2, "key1");
511 char *v2 = (char*)ucx_map_cstr_get(map2, "key2");
512 char *v3 = (char*)ucx_map_cstr_get(map2, "key3");
513 char *v4 = (char*)ucx_map_cstr_get(map2, "key4");
514 char *v5 = (char*)ucx_map_cstr_get(map2, "property.key1");
515 char *v6 = (char*)ucx_map_cstr_get(map2, "property.key2");
516 char *v7 = (char*)ucx_map_cstr_get(map2, "property.key3");
517 char *v8 = (char*)ucx_map_cstr_get(map2, "property.key4");
518
519 UCX_TEST_ASSERT(v1 && v2 && v3 && v4 && v5 && v6 && v7 && v8,
520 "missing values");
521
522 UCX_TEST_ASSERT((!strcmp(v1, "value1")), "wrong value 1");
523 UCX_TEST_ASSERT((!strcmp(v2, "value2")), "wrong value 2");
524 UCX_TEST_ASSERT((!strcmp(v3, "value3")), "wrong value 3");
525 UCX_TEST_ASSERT((!strcmp(v4, "value4")), "wrong value 4");
526 UCX_TEST_ASSERT((!strcmp(v5, "some value 1")), "wrong value 5");
527 UCX_TEST_ASSERT((!strcmp(v6, "some value 2")), "wrong value 6");
528 UCX_TEST_ASSERT((!strcmp(v7, "some value 3")), "wrong value 7");
529 UCX_TEST_ASSERT((!strcmp(v8, "some value 4")), "wrong value 8");
530
531 free(v1);
532 free(v2);
533 free(v3);
534 free(v4);
535 free(v5);
536 free(v6);
537 free(v7);
538 free(v8);
539 ucx_map_free(map2);
540 fclose(f);
541
542 UCX_TEST_END
543
544 ucx_map_free(map1);
545 }

Mercurial Repository: ucx

mercurial