1 #include "ejdb2.h"
2 #include "jbl.h"
3 #include "jbl_internal.h"
4 #include <CUnit/Basic.h>
5 #include <memory.h>
6 #include <ejdb2/iowow/iwconv.h>
7
8 #define INT64_FORMAT PRId64
9 #define UINT64_FORMAT PRIu64
10 #define INT64_HEX_FORMAT PRIx64
11
12 typedef unsigned short int u16;
13 typedef unsigned int u32;
14 typedef unsigned long long int u64;
15
init_suite(void)16 int init_suite(void) {
17 int rc = ejdb_init();
18 return rc;
19 }
20
clean_suite(void)21 int clean_suite(void) {
22 return 0;
23 }
24
25 #ifdef _MSC_VER
26 #define snprintf _snprintf
27 #endif
28
29 int MY_DATE;
30 int MY_CURRENCY;
31
32 char tmp[128];
33
memdup(const void * mem,size_t size)34 void *memdup(const void *mem, size_t size) {
35 void *out = malloc(size);
36
37 if (out != NULL) {
38 memcpy(out, mem, size);
39 }
40
41 return out;
42 }
43
i64toa(int64 val,char * buf)44 char *i64toa(int64 val, char *buf) {
45 iwitoa(val, buf, 127);
46 return buf;
47 }
48
49 #ifdef _MSC_VER
50 #define atoi64 _atoi64
51 #else
52 int64 atoi64(char *str);
53
54 #endif
55
56 BOOL AlmostEqualFloats(float A, float B, int maxUlps);
57
58 /*************************************************************************************/
59
60 int vint32;
61 unsigned int vuint32;
62 int64 vint64;
63 uint64 vuint64;
64 short vint16;
65 unsigned short vuint16;
66 signed char vint8;
67 unsigned char vuint8;
68 float vfloat32;
69 double vfloat64;
70 BOOL vbool;
71
72 /*************************************************************************************/
73
stripchr(char * mainstr,int separator)74 char *stripchr(char *mainstr, int separator) {
75 char *ptr;
76
77 if (mainstr == NULL) {
78 return NULL;
79 }
80
81 ptr = strchr(mainstr, separator);
82 if (ptr == 0) {
83 return NULL;
84 }
85 ptr[0] = '\0';
86 ptr++;
87 return ptr;
88 }
89
90 /*************************************************************************************/
91 // MY_DATE
92 // day: 1-31 -> 2^5 -> 5 bits
93 // month: 1-12 -> 2^4 -> 4 bits
94 // year: 16 - 9 bits = 7 bits -> 2^7=128 - from 1900 to 2028
95
str_to_date(char * datestr)96 unsigned short str_to_date(char *datestr) {
97 unsigned short date;
98 int day, month, year;
99 char *next;
100
101 if (datestr == NULL) {
102 return 0;
103 }
104 strcpy(tmp, datestr);
105 datestr = tmp;
106
107 next = stripchr(datestr, '-');
108 year = atoi(datestr) - 1900;
109
110 datestr = next;
111 next = stripchr(datestr, '-');
112 month = atoi(datestr);
113
114 day = atoi(next);
115
116 date = (day << 11) | (month << 7) | year;
117 return date;
118 }
119
120 /*************************************************************************************/
121
date_to_str(unsigned short date)122 char *date_to_str(unsigned short date) {
123 int day, month, year;
124 //char *datestr;
125
126 day = ((date & 0xf800) >> 11);
127 month = ((date & 0x0780) >> 7);
128 year = (date & 0x007f);
129
130 sprintf(tmp, "%.4d-%.2d-%.2d", year + 1900, month, day);
131
132 return tmp;
133 }
134
135 /*************************************************************************************/
136 // MY_CURRENCY
137 // 00000000.0000 <- fixed point
138
139 #define CURRENCY_DECIMAL_DIGITS 4
140 #define CURRENCY_DECIMAL_DIGITS_STR "0000"
141 #define CURRENCY_FACTOR 10000
142
str_to_currency(char * str)143 int64 str_to_currency(char *str) {
144 char *next;
145 int size, i;
146
147 if (str == NULL) {
148 return 0;
149 }
150 strcpy(tmp, str);
151 str = tmp;
152
153 next = strchr(str, '.');
154 if (next) {
155 size = strlen(next + 1);
156 memmove(next, next + 1, size + 1); // include the null terminator
157 if (size <= CURRENCY_DECIMAL_DIGITS) {
158 size = CURRENCY_DECIMAL_DIGITS - size;
159 for (i = 0; i < size; i++) strcat(str, "0");
160 } else {
161 next[CURRENCY_DECIMAL_DIGITS] = 0; // puts a null terminator
162 }
163 } else {
164 strcat(str, CURRENCY_DECIMAL_DIGITS_STR);
165 }
166
167 return atoi64(str);
168 }
169
170 /*************************************************************************************/
171
currency_to_str(int64 value)172 char *currency_to_str(int64 value) {
173 char *str, *ptr;
174 int size, move, i;
175
176 i64toa(value, tmp);
177 str = tmp;
178
179 size = strlen(str);
180 if (size > CURRENCY_DECIMAL_DIGITS) {
181 ptr = str + size - CURRENCY_DECIMAL_DIGITS;
182 memmove(ptr + 1, ptr, CURRENCY_DECIMAL_DIGITS + 1); // include the null terminator
183 ptr[0] = '.'; // include the point
184 } else {
185 move = 2 + CURRENCY_DECIMAL_DIGITS - size;
186 memmove(str + move, str, size + 1); // include the null terminator
187 str[0] = '0'; // include the zero
188 str[1] = '.'; // include the point
189 for (i = 2; i < move; i++) str[i] = '0';
190 }
191
192 return str;
193 }
194
195 /*************************************************************************************/
196
float_to_currency(double value)197 int64 float_to_currency(double value) {
198 char buf[128];
199
200 snprintf(buf, 127, "%.4f", value);
201
202 return str_to_currency(buf);
203 }
204
205 /*************************************************************************************/
206
currency_to_float(int64 value)207 double currency_to_float(int64 value) {
208
209 currency_to_str(value);
210
211 return atof(tmp);
212 }
213
214 /*************************************************************************************/
215
mul_currency(int64 value1,int64 value2)216 int64 mul_currency(int64 value1, int64 value2) {
217 return value1 * value2 / CURRENCY_FACTOR;
218 }
219
220 /*************************************************************************************/
221
div_currency(int64 value1,int64 value2)222 int64 div_currency(int64 value1, int64 value2) {
223 return value1 * CURRENCY_FACTOR / value2;
224 }
225
226 /*************************************************************************************/
227
228 //! this code may not work on processors that does not use the default float standard
229 // original name: AlmostEqual2sComplement
AlmostEqualFloats(float A,float B,int maxUlps)230 BOOL AlmostEqualFloats(float A, float B, int maxUlps) {
231 int aInt, bInt, intDiff;
232 // Make sure maxUlps is non-negative and small enough that the
233 // default NAN won't compare as equal to anything.
234 CU_ASSERT(maxUlps > 0 && maxUlps < 4 * 1024 * 1024);
235 aInt = *(int*) &A;
236 bInt = *(int*) &B;
237 // Make aInt lexicographically ordered as a twos-complement int
238 if (aInt < 0) {
239 aInt = 0x80000000 - aInt;
240 }
241 if (bInt < 0) {
242 bInt = 0x80000000 - bInt;
243 }
244 intDiff = abs(aInt - bInt);
245 if (intDiff <= maxUlps) {
246 return TRUE;
247 }
248 return FALSE;
249 }
250
251 /*************************************************************************************/
252
test_create_object_1(int * psize)253 char *test_create_object_1(int *psize) {
254 binn *obj = INVALID_BINN, *list = INVALID_BINN;
255
256 printf("creating object 1...\n");
257
258 obj = binn_object();
259 CU_ASSERT(obj != NULL);
260
261 vint32 = -12345;
262 CU_ASSERT(binn_object_set(obj, "int32", BINN_INT32, &vint32, 0) == TRUE);
263 vint16 = -258;
264 CU_ASSERT(binn_object_set(obj, "int16", BINN_INT16, &vint16, 0) == TRUE);
265 vint8 = -120;
266 CU_ASSERT(binn_object_set(obj, "int8", BINN_INT8, &vint8, 0) == TRUE);
267 vint64 = -1234567890123;
268 CU_ASSERT(binn_object_set(obj, "int64", BINN_INT64, &vint64, 0) == TRUE);
269
270 vuint32 = 123456;
271 CU_ASSERT(binn_object_set(obj, "uint32", BINN_UINT32, &vuint32, 0) == TRUE);
272 vuint16 = 60500;
273 CU_ASSERT(binn_object_set(obj, "uint16", BINN_UINT16, &vuint16, 0) == TRUE);
274 vuint8 = 250;
275 CU_ASSERT(binn_object_set(obj, "uint8", BINN_UINT8, &vuint8, 0) == TRUE);
276 vuint64 = 1234567890123;
277 CU_ASSERT(binn_object_set(obj, "uint64", BINN_UINT64, &vuint64, 0) == TRUE);
278
279 vfloat32 = -12.345;
280 CU_ASSERT(binn_object_set(obj, "float32", BINN_FLOAT32, &vfloat32, 0) == TRUE);
281 vfloat32 = -12.345;
282 CU_ASSERT(binn_object_set(obj, "single", BINN_SINGLE, &vfloat32, 0) == TRUE);
283 vfloat64 = -123456.7895;
284 CU_ASSERT(binn_object_set(obj, "float64", BINN_FLOAT64, &vfloat64, 0) == TRUE);
285 vfloat64 = -123456.7895;
286 CU_ASSERT(binn_object_set(obj, "double", BINN_DOUBLE, &vfloat64, 0) == TRUE);
287
288 CU_ASSERT(binn_object_set(obj, "str", BINN_STRING, "the value", 0) == TRUE);
289
290 vint32 = TRUE;
291 CU_ASSERT(binn_object_set(obj, "bool_true", BINN_BOOL, &vint32, 0) == TRUE);
292 vint32 = FALSE;
293 CU_ASSERT(binn_object_set(obj, "bool_false", BINN_BOOL, &vint32, 0) == TRUE);
294
295 CU_ASSERT(binn_object_set(obj, "null", BINN_NULL, NULL, 0) == TRUE);
296
297
298 // add a list
299
300 list = binn_list();
301 CU_ASSERT(list != NULL);
302
303 CU_ASSERT(binn_list_add(list, BINN_NULL, NULL, 0) == TRUE);
304 vint32 = 123;
305 CU_ASSERT(binn_list_add(list, BINN_INT32, &vint32, 0) == TRUE);
306 CU_ASSERT(binn_list_add(list, BINN_STRING, "this is a string", 0) == TRUE);
307
308 CU_ASSERT(binn_object_set(obj, "list", BINN_LIST, binn_ptr(list), binn_size(list)) == TRUE);
309
310 binn_free(list);
311 list = INVALID_BINN;
312
313
314 // return the values
315
316 *psize = binn_size(obj);
317 return binn_release(obj);
318 }
319
320 /*************************************************************************************/
321
test_create_object_2(int * psize)322 char *test_create_object_2(int *psize) {
323 binn *obj = INVALID_BINN, *list = INVALID_BINN;
324
325 printf("creating object 2...\n");
326
327 obj = binn_object();
328 CU_ASSERT(obj != NULL);
329
330 CU_ASSERT(binn_object_set_int32(obj, "int32", -12345) == TRUE);
331 CU_ASSERT(binn_object_set_int16(obj, "int16", -258) == TRUE);
332 CU_ASSERT(binn_object_set_int8(obj, "int8", -120) == TRUE);
333 CU_ASSERT(binn_object_set_int64(obj, "int64", -1234567890123) == TRUE);
334
335 CU_ASSERT(binn_object_set_uint32(obj, "uint32", 123456) == TRUE);
336 CU_ASSERT(binn_object_set_int16(obj, "uint16", (short) 60500) == TRUE);
337 CU_ASSERT(binn_object_set_int8(obj, "uint8", (signed char) 250) == TRUE);
338 CU_ASSERT(binn_object_set_uint64(obj, "uint64", 1234567890123) == TRUE);
339
340 CU_ASSERT(binn_object_set_float(obj, "float32", -12.345) == TRUE);
341 vfloat32 = -12.345;
342 CU_ASSERT(binn_object_set(obj, "single", BINN_SINGLE, &vfloat32, 0) == TRUE);
343 CU_ASSERT(binn_object_set_double(obj, "float64", -123456.7895) == TRUE);
344 vfloat64 = -123456.7895;
345 CU_ASSERT(binn_object_set(obj, "double", BINN_DOUBLE, &vfloat64, 0) == TRUE);
346
347 CU_ASSERT(binn_object_set_str(obj, "str", "the value") == TRUE);
348
349 CU_ASSERT(binn_object_set_bool(obj, "bool_true", TRUE) == TRUE);
350 CU_ASSERT(binn_object_set_bool(obj, "bool_false", FALSE) == TRUE);
351
352 CU_ASSERT(binn_object_set_null(obj, "null") == TRUE);
353
354
355 // add a list
356
357 list = binn_list();
358 CU_ASSERT(list != NULL);
359
360 CU_ASSERT(binn_list_add_null(list) == TRUE);
361 CU_ASSERT(binn_list_add_int32(list, 123) == TRUE);
362 CU_ASSERT(binn_list_add_str(list, "this is a string") == TRUE);
363
364 CU_ASSERT(binn_object_set_list(obj, "list", list) == TRUE);
365
366 binn_free(list);
367 list = INVALID_BINN;
368
369
370 // return the values
371
372 *psize = binn_size(obj);
373 return binn_release(obj);
374 }
375
376 /*************************************************************************************/
377
test_binn_read(void * objptr)378 void test_binn_read(void *objptr) {
379 void *listptr;
380 char *ptr;
381 binn value = { 0 };
382
383 printf("OK\nreading:\n");
384
385 vint32 = 0;
386 CU_ASSERT(binn_object_get(objptr, "int32", BINN_INT32, &vint32, NULL) == TRUE);
387 printf("int32: %d\n", vint32);
388 CU_ASSERT(vint32 == -12345);
389
390 vint16 = 0;
391 CU_ASSERT(binn_object_get(objptr, "int16", BINN_INT16, &vint16, NULL) == TRUE);
392 printf("int16: %d\n", vint16);
393 CU_ASSERT(vint16 == -258);
394
395 vint8 = 0;
396 CU_ASSERT(binn_object_get(objptr, "int8", BINN_INT8, &vint8, NULL) == TRUE);
397 printf("int8: %d\n", vint8);
398 CU_ASSERT(vint8 == -120);
399
400 vint64 = 0;
401 CU_ASSERT(binn_object_get(objptr, "int64", BINN_INT64, &vint64, NULL) == TRUE);
402 printf("int64: %" INT64_FORMAT "\n", vint64);
403 CU_ASSERT(vint64 == -1234567890123);
404
405
406 vuint32 = 0;
407 CU_ASSERT(binn_object_get(objptr, "uint32", BINN_UINT32, &vuint32, NULL) == TRUE);
408 printf("uint32: %d\n", vuint32);
409 CU_ASSERT(vuint32 == 123456);
410
411 vuint16 = 0;
412 CU_ASSERT(binn_object_get(objptr, "uint16", BINN_UINT16, &vuint16, NULL) == TRUE);
413 printf("uint16: %d\n", vuint16);
414 CU_ASSERT(vuint16 == 60500);
415
416 vuint8 = 0;
417 CU_ASSERT(binn_object_get(objptr, "uint8", BINN_UINT8, &vuint8, NULL) == TRUE);
418 printf("uint8: %d\n", vuint8);
419 CU_ASSERT(vuint8 == 250);
420
421 vuint64 = 0;
422 CU_ASSERT(binn_object_get(objptr, "uint64", BINN_UINT64, &vuint64, NULL) == TRUE);
423 printf("uint64: %" UINT64_FORMAT "\n", vuint64);
424 CU_ASSERT(vuint64 == 1234567890123);
425
426
427 vfloat32 = 0;
428 CU_ASSERT(binn_object_get(objptr, "float32", BINN_FLOAT32, &vfloat32, NULL) == TRUE);
429 printf("float32: %f\n", vfloat32);
430 CU_ASSERT(AlmostEqualFloats(vfloat32, -12.345, 2) == TRUE);
431
432 vfloat64 = 0;
433 CU_ASSERT(binn_object_get(objptr, "float64", BINN_FLOAT64, &vfloat64, NULL) == TRUE);
434 printf("float64: %f\n", vfloat64);
435 CU_ASSERT(vfloat64 - -123456.7895 < 0.01);
436
437 vfloat32 = 0;
438 CU_ASSERT(binn_object_get(objptr, "single", BINN_SINGLE, &vfloat32, NULL) == TRUE);
439 printf("single: %f\n", vfloat32);
440 CU_ASSERT(AlmostEqualFloats(vfloat32, -12.345, 2) == TRUE);
441
442 vfloat64 = 0;
443 CU_ASSERT(binn_object_get(objptr, "double", BINN_DOUBLE, &vfloat64, NULL) == TRUE);
444 printf("double: %f\n", vfloat64);
445 CU_ASSERT(vfloat64 - -123456.7895 < 0.01);
446
447
448 ptr = 0;
449 CU_ASSERT(binn_object_get(objptr, "str", BINN_STRING, &ptr, NULL) == TRUE);
450 printf("ptr: (%p) '%s'\n", (void*) ptr, ptr);
451 CU_ASSERT(strcmp(ptr, "the value") == 0);
452
453
454 vint32 = 999;
455 CU_ASSERT(binn_object_get(objptr, "bool_true", BINN_BOOL, &vint32, NULL) == TRUE);
456 printf("bool true: %d\n", vint32);
457 CU_ASSERT(vint32 == TRUE);
458
459 vint32 = 999;
460 CU_ASSERT(binn_object_get(objptr, "bool_false", BINN_BOOL, &vint32, NULL) == TRUE);
461 printf("bool false: %d\n", vint32);
462 CU_ASSERT(vint32 == FALSE);
463
464
465 vint32 = 999;
466 CU_ASSERT(binn_object_get(objptr, "null", BINN_NULL, &vint32, NULL) == TRUE);
467 printf("null: %d\n", vint32);
468 //CU_ASSERT(vint32 == 0);
469 CU_ASSERT(binn_object_get(objptr, "null", BINN_NULL, NULL, NULL) == TRUE);
470
471
472 CU_ASSERT(binn_object_get(objptr, "list", BINN_LIST, &listptr, NULL) == TRUE);
473 printf("obj ptr: %p list ptr: %p\n", objptr, listptr);
474 CU_ASSERT(listptr != 0);
475 CU_ASSERT(listptr > objptr);
476
477 vint32 = 0;
478 CU_ASSERT(binn_list_get(listptr, 2, BINN_INT32, &vint32, NULL) == TRUE);
479 printf("int32: %d\n", vint32);
480 CU_ASSERT(vint32 == 123);
481
482 ptr = 0;
483 CU_ASSERT(binn_list_get(listptr, 3, BINN_STRING, &ptr, NULL) == TRUE);
484 printf("ptr: (%p) '%s'\n", (void*) ptr, ptr);
485 CU_ASSERT(strcmp(ptr, "this is a string") == 0);
486
487
488 // short read functions 1
489
490 vint32 = 0;
491 CU_ASSERT(binn_object_get_int32(objptr, "int32", &vint32) == TRUE);
492 printf("int32: %d\n", vint32);
493 CU_ASSERT(vint32 == -12345);
494
495 vint16 = 0;
496 CU_ASSERT(binn_object_get_int16(objptr, "int16", &vint16) == TRUE);
497 printf("int16: %d\n", vint16);
498 CU_ASSERT(vint16 == -258);
499
500 vint8 = 0;
501 CU_ASSERT(binn_object_get_int8(objptr, "int8", &vint8) == TRUE);
502 printf("int8: %d\n", vint8);
503 CU_ASSERT(vint8 == -120);
504
505 vint64 = 0;
506 CU_ASSERT(binn_object_get_int64(objptr, "int64", &vint64) == TRUE);
507 printf("int64: %" INT64_FORMAT "\n", vint64);
508 CU_ASSERT(vint64 == -1234567890123);
509
510
511 vuint32 = 0;
512 CU_ASSERT(binn_object_get_uint32(objptr, "uint32", &vuint32) == TRUE);
513 printf("uint32: %d\n", vuint32);
514 CU_ASSERT(vuint32 == 123456);
515
516 vuint16 = 0;
517 CU_ASSERT(binn_object_get_uint16(objptr, "uint16", &vuint16) == TRUE);
518 printf("uint16: %d\n", vuint16);
519 CU_ASSERT(vuint16 == 60500);
520
521 vuint8 = 0;
522 CU_ASSERT(binn_object_get_uint8(objptr, "uint8", &vuint8) == TRUE);
523 printf("uint8: %d\n", vuint8);
524 CU_ASSERT(vuint8 == 250);
525
526 vuint64 = 0;
527 CU_ASSERT(binn_object_get_uint64(objptr, "uint64", &vuint64) == TRUE);
528 printf("uint64: %" UINT64_FORMAT "\n", vuint64);
529 CU_ASSERT(vuint64 == 1234567890123);
530
531
532 vfloat32 = 0;
533 CU_ASSERT(binn_object_get_float(objptr, "float32", &vfloat32) == TRUE);
534 printf("float32: %f\n", vfloat32);
535 CU_ASSERT(AlmostEqualFloats(vfloat32, -12.345, 2) == TRUE);
536
537 vfloat64 = 0;
538 CU_ASSERT(binn_object_get_double(objptr, "float64", &vfloat64) == TRUE);
539 printf("float64: %f\n", vfloat64);
540 CU_ASSERT(AlmostEqualFloats(vfloat32, -12.345, 2) == TRUE);
541
542
543 ptr = 0;
544 CU_ASSERT(binn_object_get_str(objptr, "str", &ptr) == TRUE);
545 printf("ptr: (%p) '%s'\n", (void*) ptr, ptr);
546 CU_ASSERT(strcmp(ptr, "the value") == 0);
547
548
549 vint32 = 999;
550 CU_ASSERT(binn_object_get_bool(objptr, "bool_true", &vint32) == TRUE);
551 printf("bool true: %d\n", vint32);
552 CU_ASSERT(vint32 == TRUE);
553
554 vint32 = 999;
555 CU_ASSERT(binn_object_get_bool(objptr, "bool_false", &vint32) == TRUE);
556 printf("bool false: %d\n", vint32);
557 CU_ASSERT(vint32 == FALSE);
558
559
560 vbool = FALSE;
561 CU_ASSERT(binn_object_null(objptr, "null") == TRUE);
562
563 CU_ASSERT(binn_object_null(objptr, "bool_true") == FALSE);
564
565
566 CU_ASSERT(binn_object_get_list(objptr, "list", &listptr) == TRUE);
567 printf("obj ptr: %p list ptr: %p\n", objptr, listptr);
568 CU_ASSERT(listptr != 0);
569 CU_ASSERT(listptr > objptr);
570
571 vint32 = 0;
572 CU_ASSERT(binn_list_get_int32(listptr, 2, &vint32) == TRUE);
573 printf("int32: %d\n", vint32);
574 CU_ASSERT(vint32 == 123);
575
576 ptr = 0;
577 CU_ASSERT(binn_list_get_str(listptr, 3, &ptr) == TRUE);
578 printf("ptr: (%p) '%s'\n", (void*) ptr, ptr);
579 CU_ASSERT(strcmp(ptr, "this is a string") == 0);
580
581
582 // short read functions 2
583
584 vint32 = binn_object_int32(objptr, "int32");
585 printf("int32: %d\n", vint32);
586 CU_ASSERT(vint32 == -12345);
587
588 vint16 = binn_object_int16(objptr, "int16");
589 printf("int16: %d\n", vint16);
590 CU_ASSERT(vint16 == -258);
591
592 vint8 = binn_object_int8(objptr, "int8");
593 printf("int8: %d\n", vint8);
594 CU_ASSERT(vint8 == -120);
595
596 vint64 = binn_object_int64(objptr, "int64");
597 printf("int64: %" INT64_FORMAT "\n", vint64);
598 CU_ASSERT(vint64 == -1234567890123);
599
600
601 vuint32 = binn_object_uint32(objptr, "uint32");
602 printf("uint32: %d\n", vuint32);
603 CU_ASSERT(vuint32 == 123456);
604
605 vuint16 = binn_object_uint16(objptr, "uint16");
606 printf("uint16: %d\n", vuint16);
607 CU_ASSERT(vuint16 == 60500);
608
609 vuint8 = binn_object_uint8(objptr, "uint8");
610 printf("uint8: %d\n", vuint8);
611 CU_ASSERT(vuint8 == 250);
612
613 vuint64 = binn_object_uint64(objptr, "uint64");
614 printf("uint64: %" UINT64_FORMAT "\n", vuint64);
615 CU_ASSERT(vuint64 == 1234567890123);
616
617
618 vfloat32 = binn_object_float(objptr, "float32");
619 printf("float32: %f\n", vfloat32);
620 CU_ASSERT(AlmostEqualFloats(vfloat32, -12.345, 2) == TRUE);
621
622 vfloat64 = binn_object_double(objptr, "float64");
623 printf("float64: %f\n", vfloat64);
624 CU_ASSERT(AlmostEqualFloats(vfloat32, -12.345, 2) == TRUE);
625
626
627 ptr = binn_object_str(objptr, "str");
628 printf("ptr: (%p) '%s'\n", (void*) ptr, ptr);
629 CU_ASSERT(strcmp(ptr, "the value") == 0);
630
631
632 vint32 = binn_object_bool(objptr, "bool_true");
633 printf("bool true: %d\n", vint32);
634 CU_ASSERT(vint32 == TRUE);
635
636 vint32 = binn_object_bool(objptr, "bool_false");
637 printf("bool false: %d\n", vint32);
638 CU_ASSERT(vint32 == FALSE);
639
640
641 CU_ASSERT(binn_object_null(objptr, "null") == TRUE);
642 CU_ASSERT(binn_object_null(objptr, "nonull") == FALSE);
643
644
645 listptr = binn_object_list(objptr, "list");
646 printf("obj ptr: %p list ptr: %p\n", objptr, listptr);
647 CU_ASSERT(listptr != 0);
648 CU_ASSERT(listptr > objptr);
649
650 vint32 = binn_list_int32(listptr, 2);
651 printf("int32: %d\n", vint32);
652 CU_ASSERT(vint32 == 123);
653
654 ptr = binn_list_str(listptr, 3);
655 printf("ptr: (%p) '%s'\n", (void*) ptr, ptr);
656 CU_ASSERT(strcmp(ptr, "this is a string") == 0);
657
658
659 // read as value / binn
660
661 CU_ASSERT(binn_object_get_value(objptr, "int32", &value) == TRUE);
662 #ifndef BINN_DISABLE_COMPRESS_INT
663 CU_ASSERT(value.type == BINN_INT16);
664 CU_ASSERT(value.vint16 == -12345);
665 #else
666 CU_ASSERT(value.type == BINN_INT32);
667 CU_ASSERT(value.vint32 == -12345);
668 #endif
669
670 CU_ASSERT(binn_object_get_value(objptr, "int16", &value) == TRUE);
671 CU_ASSERT(value.type == BINN_INT16);
672 CU_ASSERT(value.vint16 == -258);
673
674 CU_ASSERT(binn_object_get_value(objptr, "int8", &value) == TRUE);
675 CU_ASSERT(value.type == BINN_INT8);
676 CU_ASSERT(value.vint8 == -120);
677
678 CU_ASSERT(binn_object_get_value(objptr, "int64", &value) == TRUE);
679 CU_ASSERT(value.type == BINN_INT64);
680 CU_ASSERT(value.vint64 == -1234567890123);
681
682
683 CU_ASSERT(binn_object_get_value(objptr, "uint32", &value) == TRUE);
684 CU_ASSERT(value.type == BINN_UINT32);
685 CU_ASSERT(value.vuint32 == 123456);
686
687 CU_ASSERT(binn_object_get_value(objptr, "uint16", &value) == TRUE);
688 CU_ASSERT(value.type == BINN_UINT16);
689 CU_ASSERT(value.vuint16 == 60500);
690
691 CU_ASSERT(binn_object_get_value(objptr, "uint8", &value) == TRUE);
692 CU_ASSERT(value.type == BINN_UINT8);
693 CU_ASSERT(value.vuint8 == 250);
694
695 CU_ASSERT(binn_object_get_value(objptr, "uint64", &value) == TRUE);
696 CU_ASSERT(value.type == BINN_UINT64);
697 CU_ASSERT(value.vuint64 == 1234567890123);
698
699 puts("reading... OK");
700 }
701
702 /*************************************************************************************/
703
init_udts()704 void init_udts() {
705 binn *obj = INVALID_BINN;
706 unsigned short date;
707 uint64 value;
708 void *ptr;
709
710 puts("testing UDTs...");
711
712 CU_ASSERT(strcmp(date_to_str(str_to_date("1950-08-15")), "1950-08-15") == 0);
713 CU_ASSERT(strcmp(date_to_str(str_to_date("1900-12-01")), "1900-12-01") == 0);
714 CU_ASSERT(strcmp(date_to_str(str_to_date("2000-10-31")), "2000-10-31") == 0);
715 CU_ASSERT(strcmp(date_to_str(str_to_date("2014-03-19")), "2014-03-19") == 0);
716
717 printf("curr=%s\n", currency_to_str(str_to_currency("123.456")));
718 printf("curr=%s\n", currency_to_str(str_to_currency("123.45")));
719 printf("curr=%s\n", currency_to_str(str_to_currency("123.4")));
720 printf("curr=%s\n", currency_to_str(str_to_currency("123.")));
721 printf("curr=%s\n", currency_to_str(str_to_currency("123")));
722 printf("curr=%s\n", currency_to_str(str_to_currency("1.2")));
723 printf("curr=%s\n", currency_to_str(str_to_currency("0.987")));
724 printf("curr=%s\n", currency_to_str(str_to_currency("0.98")));
725 printf("curr=%s\n", currency_to_str(str_to_currency("0.9")));
726 printf("curr=%s\n", currency_to_str(str_to_currency("0.0")));
727 printf("curr=%s\n", currency_to_str(str_to_currency("0")));
728 printf("curr=%s\n", currency_to_str(str_to_currency("123.4567")));
729 printf("curr=%s\n", currency_to_str(str_to_currency("123.45678")));
730 printf("curr=%s\n", currency_to_str(str_to_currency("123.456789")));
731 printf("curr=%s\n", currency_to_str(str_to_currency("0.1234")));
732 printf("curr=%s\n", currency_to_str(str_to_currency(".1234")));
733
734 CU_ASSERT(float_to_currency(2.5) == 25000);
735 CU_ASSERT(float_to_currency(5) == 50000);
736 CU_ASSERT(str_to_currency("1.1") == 11000);
737 CU_ASSERT(str_to_currency("12") == 120000);
738 CU_ASSERT(mul_currency(20000, 20000) == 40000);
739 CU_ASSERT(mul_currency(20000, 25000) == 50000);
740 CU_ASSERT(mul_currency(30000, 40000) == 120000);
741 CU_ASSERT(div_currency(80000, 20000) == 40000);
742 CU_ASSERT(div_currency(120000, 40000) == 30000);
743 CU_ASSERT(div_currency(100000, 40000) == 25000);
744
745 printf("1.1 * 2.5 = %s\n", currency_to_str(mul_currency(str_to_currency("1.1"), float_to_currency(2.5))));
746 printf("12 / 5 = %s\n", currency_to_str(div_currency(str_to_currency("12"), float_to_currency(5))));
747
748
749 //CU_ASSERT(binn_register_type(MY_DATE, BINN_STORAGE_WORD) == TRUE);
750 //CU_ASSERT(binn_register_type(MY_CURRENCY, BINN_STORAGE_QWORD) == TRUE);
751
752 MY_DATE = binn_create_type(BINN_STORAGE_WORD, 0x0a);
753 MY_CURRENCY = binn_create_type(BINN_STORAGE_QWORD, 0x0a);
754
755
756 obj = binn_object();
757 CU_ASSERT(obj != NULL);
758
759 date = str_to_date("1950-08-15");
760 printf(" date 1: %d %s\n", date, date_to_str(date));
761 CU_ASSERT(binn_object_set(obj, "date1", MY_DATE, &date, 0) == TRUE);
762 CU_ASSERT(binn_object_set(obj, "date1", MY_DATE, &date, 0) == FALSE);
763
764 date = str_to_date("1999-12-31");
765 printf(" date 2: %d %s\n", date, date_to_str(date));
766 binn_object_set(obj, "date2", MY_DATE, &date, 0);
767
768
769 value = str_to_currency("123.456");
770 printf(" curr 1: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
771 binn_object_set(obj, "curr1", MY_CURRENCY, &value, 0);
772
773 value = str_to_currency("123.45");
774 printf(" curr 2: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
775 binn_object_set(obj, "curr2", MY_CURRENCY, &value, 0);
776
777 value = str_to_currency("12.5");
778 printf(" curr 3: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
779 binn_object_set(obj, "curr3", MY_CURRENCY, &value, 0);
780
781 value = str_to_currency("5");
782 printf(" curr 4: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
783 binn_object_set(obj, "curr4", MY_CURRENCY, &value, 0);
784
785 value = str_to_currency("0.75");
786 printf(" curr 5: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
787 binn_object_set(obj, "curr5", MY_CURRENCY, &value, 0);
788
789
790 ptr = binn_ptr(obj);
791
792
793 CU_ASSERT(binn_object_get(ptr, "date1", MY_DATE, &date, NULL) == TRUE);
794 printf(" date 1: %d %s\n", date, date_to_str(date));
795
796 CU_ASSERT(binn_object_get(ptr, "date2", MY_DATE, &date, NULL) == TRUE);
797 printf(" date 2: %d %s\n", date, date_to_str(date));
798
799
800 CU_ASSERT(binn_object_get(ptr, "curr1", MY_CURRENCY, &value, NULL) == TRUE);
801 printf(" curr 1: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
802
803 CU_ASSERT(binn_object_get(ptr, "curr2", MY_CURRENCY, &value, NULL) == TRUE);
804 printf(" curr 2: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
805
806 CU_ASSERT(binn_object_get(ptr, "curr3", MY_CURRENCY, &value, NULL) == TRUE);
807 printf(" curr 3: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
808
809 CU_ASSERT(binn_object_get(ptr, "curr4", MY_CURRENCY, &value, NULL) == TRUE);
810 printf(" curr 4: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
811
812 CU_ASSERT(binn_object_get(ptr, "curr5", MY_CURRENCY, &value, NULL) == TRUE);
813 printf(" curr 5: %" UINT64_FORMAT " %s\n", value, currency_to_str(value));
814
815
816 binn_free(obj);
817
818 puts("testing UDTs... OK");
819 }
820
821 /*************************************************************************************/
822
823 BOOL copy_int_value_tests(void *psource, void *pdest, int source_type, int dest_type);
824
test_int_conversion()825 void test_int_conversion() {
826
827 printf("testing integer conversion...");
828
829 // copy negative value to unsigned integer
830
831 vint8 = -110;
832 vuint8 = 0;
833 CU_ASSERT(copy_int_value_tests(&vint8, &vuint8, BINN_INT8, BINN_UINT8) == FALSE);
834 CU_ASSERT(vint8 == -110);
835 CU_ASSERT(vuint8 == 0);
836
837 vint8 = -110;
838 vuint16 = 0;
839 CU_ASSERT(copy_int_value_tests(&vint8, &vuint16, BINN_INT8, BINN_UINT16) == FALSE);
840 CU_ASSERT(vint8 == -110);
841 CU_ASSERT(vuint16 == 0);
842
843 vint8 = -110;
844 vuint32 = 0;
845 CU_ASSERT(copy_int_value_tests(&vint8, &vuint32, BINN_INT8, BINN_UINT32) == FALSE);
846 CU_ASSERT(vint8 == -110);
847 CU_ASSERT(vuint32 == 0);
848
849 vint8 = -110;
850 vuint64 = 0;
851 CU_ASSERT(copy_int_value_tests(&vint8, &vuint64, BINN_INT8, BINN_UINT64) == FALSE);
852 CU_ASSERT(vint8 == -110);
853 CU_ASSERT(vuint64 == 0);
854
855
856 vint16 = -123;
857 vuint8 = 0;
858 CU_ASSERT(copy_int_value_tests(&vint16, &vuint8, BINN_INT16, BINN_UINT8) == FALSE);
859 CU_ASSERT(vint16 == -123);
860 CU_ASSERT(vuint8 == 0);
861
862 vint16 = -123;
863 vuint16 = 0;
864 CU_ASSERT(copy_int_value_tests(&vint16, &vuint16, BINN_INT16, BINN_UINT16) == FALSE);
865 CU_ASSERT(vint16 == -123);
866 CU_ASSERT(vuint16 == 0);
867
868 vint16 = -32000;
869 vuint32 = 0;
870 CU_ASSERT(copy_int_value_tests(&vint16, &vuint32, BINN_INT16, BINN_UINT32) == FALSE);
871 CU_ASSERT(vint16 == -32000);
872 CU_ASSERT(vuint32 == 0);
873
874 vint16 = -32000;
875 vuint64 = 0;
876 CU_ASSERT(copy_int_value_tests(&vint16, &vuint64, BINN_INT16, BINN_UINT64) == FALSE);
877 CU_ASSERT(vint16 == -32000);
878 CU_ASSERT(vuint64 == 0);
879
880
881 vint32 = -123;
882 vuint8 = 0;
883 CU_ASSERT(copy_int_value_tests(&vint32, &vuint8, BINN_INT32, BINN_UINT8) == FALSE);
884 CU_ASSERT(vint32 == -123);
885 CU_ASSERT(vuint8 == 0);
886
887 vint32 = -123;
888 vuint16 = 0;
889 CU_ASSERT(copy_int_value_tests(&vint32, &vuint16, BINN_INT32, BINN_UINT16) == FALSE);
890 CU_ASSERT(vint32 == -123);
891 CU_ASSERT(vuint16 == 0);
892
893 vint32 = -123;
894 vuint32 = 0;
895 CU_ASSERT(copy_int_value_tests(&vint32, &vuint32, BINN_INT32, BINN_UINT32) == FALSE);
896 CU_ASSERT(vint32 == -123);
897 CU_ASSERT(vuint32 == 0);
898
899 vint32 = -123;
900 vuint64 = 0;
901 CU_ASSERT(copy_int_value_tests(&vint32, &vuint64, BINN_INT32, BINN_UINT64) == FALSE);
902 CU_ASSERT(vint32 == -123);
903 CU_ASSERT(vuint64 == 0);
904
905
906 vint64 = -123;
907 vuint8 = 0;
908 CU_ASSERT(copy_int_value_tests(&vint64, &vuint8, BINN_INT64, BINN_UINT8) == FALSE);
909 CU_ASSERT(vint64 == -123);
910 CU_ASSERT(vuint8 == 0);
911
912 vint64 = -123;
913 vuint16 = 0;
914 CU_ASSERT(copy_int_value_tests(&vint64, &vuint16, BINN_INT64, BINN_UINT16) == FALSE);
915 CU_ASSERT(vint64 == -123);
916 CU_ASSERT(vuint16 == 0);
917
918 vint64 = -123;
919 vuint32 = 0;
920 CU_ASSERT(copy_int_value_tests(&vint64, &vuint32, BINN_INT64, BINN_UINT32) == FALSE);
921 CU_ASSERT(vint64 == -123);
922 CU_ASSERT(vuint32 == 0);
923
924 vint64 = -123;
925 vuint64 = 0;
926 CU_ASSERT(copy_int_value_tests(&vint64, &vuint64, BINN_INT64, BINN_UINT64) == FALSE);
927 CU_ASSERT(vint64 == -123);
928 CU_ASSERT(vuint64 == 0);
929
930
931 // copy big negative value to small signed integer
932
933 vint16 = -32000;
934 vint8 = 0;
935 CU_ASSERT(copy_int_value_tests(&vint16, &vint8, BINN_INT16, BINN_INT8) == FALSE);
936 CU_ASSERT(vint16 == -32000);
937 CU_ASSERT(vint8 == 0);
938
939
940 vint32 = -250;
941 vint8 = 0;
942 CU_ASSERT(copy_int_value_tests(&vint32, &vint8, BINN_INT32, BINN_INT8) == FALSE);
943 CU_ASSERT(vint32 == -250);
944 CU_ASSERT(vint8 == 0);
945
946 vint32 = -35000;
947 vint16 = 0;
948 CU_ASSERT(copy_int_value_tests(&vint32, &vint16, BINN_INT32, BINN_INT16) == FALSE);
949 CU_ASSERT(vint32 == -35000);
950 CU_ASSERT(vint16 == 0);
951
952
953 vint64 = -250;
954 vint8 = 0;
955 CU_ASSERT(copy_int_value_tests(&vint64, &vint8, BINN_INT64, BINN_INT8) == FALSE);
956 CU_ASSERT(vint64 == -250);
957 CU_ASSERT(vint8 == 0);
958
959 vint64 = -35000;
960 vint16 = 0;
961 CU_ASSERT(copy_int_value_tests(&vint64, &vint16, BINN_INT64, BINN_INT16) == FALSE);
962 CU_ASSERT(vint64 == -35000);
963 CU_ASSERT(vint16 == 0);
964
965 vint64 = -25470000000;
966 vint32 = 0;
967 CU_ASSERT(copy_int_value_tests(&vint64, &vint32, BINN_INT64, BINN_INT32) == FALSE);
968 CU_ASSERT(vint64 == -25470000000);
969 CU_ASSERT(vint32 == 0);
970
971
972 // copy big positive value to small signed integer
973
974 vint16 = 250;
975 vint8 = 0;
976 CU_ASSERT(copy_int_value_tests(&vint16, &vint8, BINN_INT16, BINN_INT8) == FALSE);
977 CU_ASSERT(vint16 == 250);
978 CU_ASSERT(vint8 == 0);
979
980
981 vint32 = 250;
982 vint8 = 0;
983 CU_ASSERT(copy_int_value_tests(&vint32, &vint8, BINN_INT32, BINN_INT8) == FALSE);
984 CU_ASSERT(vint32 == 250);
985 CU_ASSERT(vint8 == 0);
986
987 vint32 = 35000;
988 vint16 = 0;
989 CU_ASSERT(copy_int_value_tests(&vint32, &vint16, BINN_INT32, BINN_INT16) == FALSE);
990 CU_ASSERT(vint32 == 35000);
991 CU_ASSERT(vint16 == 0);
992
993
994 vint64 = 250;
995 vint8 = 0;
996 CU_ASSERT(copy_int_value_tests(&vint64, &vint8, BINN_INT64, BINN_INT8) == FALSE);
997 CU_ASSERT(vint64 == 250);
998 CU_ASSERT(vint8 == 0);
999
1000 vint64 = 35000;
1001 vint16 = 0;
1002 CU_ASSERT(copy_int_value_tests(&vint64, &vint16, BINN_INT64, BINN_INT16) == FALSE);
1003 CU_ASSERT(vint64 == 35000);
1004 CU_ASSERT(vint16 == 0);
1005
1006 vint64 = 25470000000;
1007 vint32 = 0;
1008 CU_ASSERT(copy_int_value_tests(&vint64, &vint32, BINN_INT64, BINN_INT32) == FALSE);
1009 CU_ASSERT(vint64 == 25470000000);
1010 CU_ASSERT(vint32 == 0);
1011
1012
1013 // copy big positive value to small unsigned integer
1014
1015 vint16 = 300;
1016 vuint8 = 0;
1017 CU_ASSERT(copy_int_value_tests(&vint16, &vuint8, BINN_INT16, BINN_UINT8) == FALSE);
1018 CU_ASSERT(vint16 == 300);
1019 CU_ASSERT(vuint8 == 0);
1020
1021
1022 vint32 = 300;
1023 vuint8 = 0;
1024 CU_ASSERT(copy_int_value_tests(&vint32, &vuint8, BINN_INT32, BINN_UINT8) == FALSE);
1025 CU_ASSERT(vint32 == 300);
1026 CU_ASSERT(vuint8 == 0);
1027
1028 vint32 = 70000;
1029 vuint16 = 0;
1030 CU_ASSERT(copy_int_value_tests(&vint32, &vuint16, BINN_INT32, BINN_UINT16) == FALSE);
1031 CU_ASSERT(vint32 == 70000);
1032 CU_ASSERT(vuint16 == 0);
1033
1034
1035 vint64 = 300;
1036 vuint8 = 0;
1037 CU_ASSERT(copy_int_value_tests(&vint64, &vuint8, BINN_INT64, BINN_UINT8) == FALSE);
1038 CU_ASSERT(vint64 == 300);
1039 CU_ASSERT(vuint8 == 0);
1040
1041 vint64 = 70000;
1042 vuint16 = 0;
1043 CU_ASSERT(copy_int_value_tests(&vint64, &vuint16, BINN_INT64, BINN_UINT16) == FALSE);
1044 CU_ASSERT(vint64 == 70000);
1045 CU_ASSERT(vuint16 == 0);
1046
1047 vint64 = 25470000000;
1048 vuint32 = 0;
1049 CU_ASSERT(copy_int_value_tests(&vint64, &vuint32, BINN_INT64, BINN_UINT32) == FALSE);
1050 CU_ASSERT(vint64 == 25470000000);
1051 CU_ASSERT(vuint32 == 0);
1052
1053
1054 // valid numbers --------------------
1055
1056 // int8 - copy to signed variable
1057
1058 vint8 = 123;
1059 vint16 = 0;
1060 CU_ASSERT(copy_int_value_tests(&vint8, &vint16, BINN_INT8, BINN_INT16) == TRUE);
1061 CU_ASSERT(vint8 == 123);
1062 CU_ASSERT(vint16 == 123);
1063
1064 vint8 = -110;
1065 vint16 = 0;
1066 CU_ASSERT(copy_int_value_tests(&vint8, &vint16, BINN_INT8, BINN_INT16) == TRUE);
1067 CU_ASSERT(vint8 == -110);
1068 CU_ASSERT(vint16 == -110);
1069
1070 vint8 = 123;
1071 vint32 = 0;
1072 CU_ASSERT(copy_int_value_tests(&vint8, &vint32, BINN_INT8, BINN_INT32) == TRUE);
1073 CU_ASSERT(vint8 == 123);
1074 CU_ASSERT(vint32 == 123);
1075
1076 vint8 = -110;
1077 vint32 = 0;
1078 CU_ASSERT(copy_int_value_tests(&vint8, &vint32, BINN_INT8, BINN_INT32) == TRUE);
1079 CU_ASSERT(vint8 == -110);
1080 CU_ASSERT(vint32 == -110);
1081
1082 vint8 = 123;
1083 vint64 = 0;
1084 CU_ASSERT(copy_int_value_tests(&vint8, &vint64, BINN_INT8, BINN_INT64) == TRUE);
1085 CU_ASSERT(vint8 == 123);
1086 CU_ASSERT(vint64 == 123);
1087
1088 vint8 = -120;
1089 vint64 = 0;
1090 CU_ASSERT(copy_int_value_tests(&vint8, &vint64, BINN_INT8, BINN_INT64) == TRUE);
1091 CU_ASSERT(vint8 == -120);
1092 CU_ASSERT(vint64 == -120);
1093
1094
1095 // int8 - copy to unsigned variable
1096
1097 vint8 = 123;
1098 vuint16 = 0;
1099 CU_ASSERT(copy_int_value_tests(&vint8, &vuint16, BINN_INT8, BINN_UINT16) == TRUE);
1100 CU_ASSERT(vint8 == 123);
1101 CU_ASSERT(vuint16 == 123);
1102
1103 vint8 = 123;
1104 vuint32 = 0;
1105 CU_ASSERT(copy_int_value_tests(&vint8, &vuint32, BINN_INT8, BINN_UINT32) == TRUE);
1106 CU_ASSERT(vint8 == 123);
1107 CU_ASSERT(vuint32 == 123);
1108
1109 vint8 = 123;
1110 vuint64 = 0;
1111 CU_ASSERT(copy_int_value_tests(&vint8, &vuint64, BINN_INT8, BINN_UINT64) == TRUE);
1112 CU_ASSERT(vint8 == 123);
1113 CU_ASSERT(vuint64 == 123);
1114
1115
1116 // unsigned int8 - copy to signed variable
1117
1118 vuint8 = 123;
1119 vint16 = 0;
1120 CU_ASSERT(copy_int_value_tests(&vuint8, &vint16, BINN_UINT8, BINN_INT16) == TRUE);
1121 CU_ASSERT(vuint8 == 123);
1122 CU_ASSERT(vint16 == 123);
1123
1124 vuint8 = 250;
1125 vint16 = 0;
1126 CU_ASSERT(copy_int_value_tests(&vuint8, &vint16, BINN_UINT8, BINN_INT16) == TRUE);
1127 CU_ASSERT(vuint8 == 250);
1128 CU_ASSERT(vint16 == 250);
1129
1130 vuint8 = 123;
1131 vint32 = 0;
1132 CU_ASSERT(copy_int_value_tests(&vuint8, &vint32, BINN_UINT8, BINN_INT32) == TRUE);
1133 CU_ASSERT(vuint8 == 123);
1134 CU_ASSERT(vint32 == 123);
1135
1136 vuint8 = 250;
1137 vint32 = 0;
1138 CU_ASSERT(copy_int_value_tests(&vuint8, &vint32, BINN_UINT8, BINN_INT32) == TRUE);
1139 CU_ASSERT(vuint8 == 250);
1140 CU_ASSERT(vint32 == 250);
1141
1142 vuint8 = 123;
1143 vint64 = 0;
1144 CU_ASSERT(copy_int_value_tests(&vuint8, &vint64, BINN_UINT8, BINN_INT64) == TRUE);
1145 CU_ASSERT(vuint8 == 123);
1146 CU_ASSERT(vint64 == 123);
1147
1148 vuint8 = 250;
1149 vint64 = 0;
1150 CU_ASSERT(copy_int_value_tests(&vuint8, &vint64, BINN_UINT8, BINN_INT64) == TRUE);
1151 CU_ASSERT(vuint8 == 250);
1152 CU_ASSERT(vint64 == 250);
1153
1154
1155 // unsigned int8 - copy to unsigned variable
1156
1157 vuint8 = 123;
1158 vuint16 = 0;
1159 CU_ASSERT(copy_int_value_tests(&vuint8, &vuint16, BINN_UINT8, BINN_UINT16) == TRUE);
1160 CU_ASSERT(vuint8 == 123);
1161 CU_ASSERT(vuint16 == 123);
1162
1163 vuint8 = 250;
1164 vuint16 = 0;
1165 CU_ASSERT(copy_int_value_tests(&vuint8, &vuint16, BINN_UINT8, BINN_UINT16) == TRUE);
1166 CU_ASSERT(vuint8 == 250);
1167 CU_ASSERT(vuint16 == 250);
1168
1169 vuint8 = 123;
1170 vuint32 = 0;
1171 CU_ASSERT(copy_int_value_tests(&vuint8, &vuint32, BINN_UINT8, BINN_UINT32) == TRUE);
1172 CU_ASSERT(vuint8 == 123);
1173 CU_ASSERT(vuint32 == 123);
1174
1175 vuint8 = 250;
1176 vuint32 = 0;
1177 CU_ASSERT(copy_int_value_tests(&vuint8, &vuint32, BINN_UINT8, BINN_UINT32) == TRUE);
1178 CU_ASSERT(vuint8 == 250);
1179 CU_ASSERT(vuint32 == 250);
1180
1181 vuint8 = 123;
1182 vuint64 = 0;
1183 CU_ASSERT(copy_int_value_tests(&vuint8, &vuint64, BINN_UINT8, BINN_UINT64) == TRUE);
1184 CU_ASSERT(vuint8 == 123);
1185 CU_ASSERT(vuint64 == 123);
1186
1187 vuint8 = 250;
1188 vuint64 = 0;
1189 CU_ASSERT(copy_int_value_tests(&vuint8, &vuint64, BINN_UINT8, BINN_UINT64) == TRUE);
1190 CU_ASSERT(vuint8 == 250);
1191 CU_ASSERT(vuint64 == 250);
1192
1193
1194 vint16 = 250;
1195 vuint8 = 0;
1196 CU_ASSERT(copy_int_value_tests(&vint16, &vuint8, BINN_INT16, BINN_UINT8) == TRUE);
1197 CU_ASSERT(vint16 == 250);
1198 CU_ASSERT(vuint8 == 250);
1199
1200
1201 vint32 = 250;
1202 vuint8 = 0;
1203 CU_ASSERT(copy_int_value_tests(&vint32, &vuint8, BINN_INT32, BINN_UINT8) == TRUE);
1204 CU_ASSERT(vint32 == 250);
1205 CU_ASSERT(vuint8 == 250);
1206
1207 vint32 = 35000;
1208 vuint16 = 0;
1209 CU_ASSERT(copy_int_value_tests(&vint32, &vuint16, BINN_INT32, BINN_UINT16) == TRUE);
1210 CU_ASSERT(vint32 == 35000);
1211 CU_ASSERT(vuint16 == 35000);
1212
1213
1214 vint64 = 250;
1215 vuint8 = 0;
1216 CU_ASSERT(copy_int_value_tests(&vint64, &vuint8, BINN_INT64, BINN_UINT8) == TRUE);
1217 CU_ASSERT(vint64 == 250);
1218 CU_ASSERT(vuint8 == 250);
1219
1220 vint64 = 35000;
1221 vuint16 = 0;
1222 CU_ASSERT(copy_int_value_tests(&vint64, &vuint16, BINN_INT64, BINN_UINT16) == TRUE);
1223 CU_ASSERT(vint64 == 35000);
1224 CU_ASSERT(vuint16 == 35000);
1225
1226 vint64 = 2147000000;
1227 vuint32 = 0;
1228 CU_ASSERT(copy_int_value_tests(&vint64, &vuint32, BINN_INT64, BINN_UINT32) == TRUE);
1229 CU_ASSERT(vint64 == 2147000000);
1230 CU_ASSERT(vuint32 == 2147000000);
1231
1232
1233 // valid negative values
1234
1235
1236 vint8 = -110;
1237 vint16 = 0;
1238 CU_ASSERT(copy_int_value_tests(&vint8, &vint16, BINN_INT8, BINN_INT16) == TRUE);
1239 CU_ASSERT(vint8 == -110);
1240 CU_ASSERT(vint16 == -110);
1241
1242 vint8 = -110;
1243 vint32 = 0;
1244 CU_ASSERT(copy_int_value_tests(&vint8, &vint32, BINN_INT8, BINN_INT32) == TRUE);
1245 CU_ASSERT(vint8 == -110);
1246 CU_ASSERT(vint32 == -110);
1247
1248 vint8 = -110;
1249 vint64 = 0;
1250 CU_ASSERT(copy_int_value_tests(&vint8, &vint64, BINN_INT8, BINN_INT64) == TRUE);
1251 CU_ASSERT(vint8 == -110);
1252 CU_ASSERT(vint64 == -110);
1253
1254
1255 vint16 = -123;
1256 vint8 = 0;
1257 CU_ASSERT(copy_int_value_tests(&vint16, &vint8, BINN_INT16, BINN_INT8) == TRUE);
1258 CU_ASSERT(vint16 == -123);
1259 CU_ASSERT(vint8 == -123);
1260
1261 vint16 = -32000;
1262 vint32 = 0;
1263 CU_ASSERT(copy_int_value_tests(&vint16, &vint32, BINN_INT16, BINN_INT32) == TRUE);
1264 CU_ASSERT(vint16 == -32000);
1265 CU_ASSERT(vint32 == -32000);
1266
1267 vint16 = -32000;
1268 vint64 = 0;
1269 CU_ASSERT(copy_int_value_tests(&vint16, &vint64, BINN_INT16, BINN_INT64) == TRUE);
1270 CU_ASSERT(vint16 == -32000);
1271 CU_ASSERT(vint64 == -32000);
1272
1273
1274 vint32 = -123;
1275 vint8 = 0;
1276 CU_ASSERT(copy_int_value_tests(&vint32, &vint8, BINN_INT32, BINN_INT8) == TRUE);
1277 CU_ASSERT(vint32 == -123);
1278 CU_ASSERT(vint8 == -123);
1279
1280 vint32 = -123;
1281 vint16 = 0;
1282 CU_ASSERT(copy_int_value_tests(&vint32, &vint16, BINN_INT32, BINN_INT16) == TRUE);
1283 CU_ASSERT(vint32 == -123);
1284 CU_ASSERT(vint16 == -123);
1285
1286 vint32 = -32000;
1287 vint16 = 0;
1288 CU_ASSERT(copy_int_value_tests(&vint32, &vint16, BINN_INT32, BINN_INT16) == TRUE);
1289 CU_ASSERT(vint32 == -32000);
1290 CU_ASSERT(vint16 == -32000);
1291
1292 vint32 = -123;
1293 vint64 = 0;
1294 CU_ASSERT(copy_int_value_tests(&vint32, &vint64, BINN_INT32, BINN_INT64) == TRUE);
1295 CU_ASSERT(vint32 == -123);
1296 CU_ASSERT(vint64 == -123);
1297
1298 vint32 = -2147000000;
1299 vint64 = 0;
1300 CU_ASSERT(copy_int_value_tests(&vint32, &vint64, BINN_INT32, BINN_INT64) == TRUE);
1301 CU_ASSERT(vint32 == -2147000000);
1302 CU_ASSERT(vint64 == -2147000000);
1303
1304
1305 vint64 = -123;
1306 vint8 = 0;
1307 CU_ASSERT(copy_int_value_tests(&vint64, &vint8, BINN_INT64, BINN_INT8) == TRUE);
1308 CU_ASSERT(vint64 == -123);
1309 CU_ASSERT(vint8 == -123);
1310
1311 vint64 = -250;
1312 vint16 = 0;
1313 CU_ASSERT(copy_int_value_tests(&vint64, &vint16, BINN_INT64, BINN_INT16) == TRUE);
1314 CU_ASSERT(vint64 == -250);
1315 CU_ASSERT(vint16 == -250);
1316
1317 vint64 = -35000;
1318 vint32 = 0;
1319 CU_ASSERT(copy_int_value_tests(&vint64, &vint32, BINN_INT64, BINN_INT32) == TRUE);
1320 CU_ASSERT(vint64 == -35000);
1321 CU_ASSERT(vint32 == -35000);
1322
1323
1324 puts("OK");
1325 }
1326
1327 /*************************************************************************************/
1328
test_binn_int_conversion()1329 void test_binn_int_conversion() {
1330 binn *obj = INVALID_BINN;
1331 void *ptr;
1332
1333 printf("testing binn integer read conversion... ");
1334
1335 obj = binn_object();
1336 CU_ASSERT(obj != NULL);
1337
1338 CU_ASSERT(binn_object_set_int8(obj, "int8", -8) == TRUE);
1339 CU_ASSERT(binn_object_set_int16(obj, "int16", -16) == TRUE);
1340 CU_ASSERT(binn_object_set_int32(obj, "int32", -32) == TRUE);
1341 CU_ASSERT(binn_object_set_int64(obj, "int64", -64) == TRUE);
1342
1343 CU_ASSERT(binn_object_set_uint8(obj, "uint8", 111) == TRUE);
1344 CU_ASSERT(binn_object_set_uint16(obj, "uint16", 112) == TRUE);
1345 CU_ASSERT(binn_object_set_uint32(obj, "uint32", 113) == TRUE);
1346 CU_ASSERT(binn_object_set_uint64(obj, "uint64", 114) == TRUE);
1347
1348 ptr = binn_ptr(obj);
1349
1350 CU_ASSERT(binn_object_int8(ptr, "int8") == -8);
1351 CU_ASSERT(binn_object_int8(ptr, "int16") == -16);
1352 CU_ASSERT(binn_object_int8(ptr, "int32") == -32);
1353 CU_ASSERT(binn_object_int8(ptr, "int64") == -64);
1354
1355 CU_ASSERT(binn_object_int16(ptr, "int8") == -8);
1356 CU_ASSERT(binn_object_int16(ptr, "int16") == -16);
1357 CU_ASSERT(binn_object_int16(ptr, "int32") == -32);
1358 CU_ASSERT(binn_object_int16(ptr, "int64") == -64);
1359
1360 CU_ASSERT(binn_object_int32(ptr, "int8") == -8);
1361 CU_ASSERT(binn_object_int32(ptr, "int16") == -16);
1362 CU_ASSERT(binn_object_int32(ptr, "int32") == -32);
1363 CU_ASSERT(binn_object_int32(ptr, "int64") == -64);
1364
1365 CU_ASSERT(binn_object_int64(ptr, "int8") == -8);
1366 CU_ASSERT(binn_object_int64(ptr, "int16") == -16);
1367 CU_ASSERT(binn_object_int64(ptr, "int32") == -32);
1368 CU_ASSERT(binn_object_int64(ptr, "int64") == -64);
1369
1370
1371 CU_ASSERT(binn_object_int8(ptr, "uint8") == 111);
1372 CU_ASSERT(binn_object_int8(ptr, "uint16") == 112);
1373 CU_ASSERT(binn_object_int8(ptr, "uint32") == 113);
1374 CU_ASSERT(binn_object_int8(ptr, "uint64") == 114);
1375
1376 CU_ASSERT(binn_object_int16(ptr, "uint8") == 111);
1377 CU_ASSERT(binn_object_int16(ptr, "uint16") == 112);
1378 CU_ASSERT(binn_object_int16(ptr, "uint32") == 113);
1379 CU_ASSERT(binn_object_int16(ptr, "uint64") == 114);
1380
1381 CU_ASSERT(binn_object_int32(ptr, "uint8") == 111);
1382 CU_ASSERT(binn_object_int32(ptr, "uint16") == 112);
1383 CU_ASSERT(binn_object_int32(ptr, "uint32") == 113);
1384 CU_ASSERT(binn_object_int32(ptr, "uint64") == 114);
1385
1386 CU_ASSERT(binn_object_int64(ptr, "uint8") == 111);
1387 CU_ASSERT(binn_object_int64(ptr, "uint16") == 112);
1388 CU_ASSERT(binn_object_int64(ptr, "uint32") == 113);
1389 CU_ASSERT(binn_object_int64(ptr, "uint64") == 114);
1390
1391
1392 binn_free(obj);
1393
1394 puts("OK");
1395 }
1396
1397 /*************************************************************************************/
1398
test_value_conversion()1399 void test_value_conversion() {
1400 binn *value;
1401 char *ptr, blob[64] = "test blob";
1402 void *pblob;
1403 int size, vint32;
1404 int64 vint64;
1405 double vdouble;
1406 BOOL vbool;
1407
1408 printf("testing binn value conversion... ");
1409
1410 /* test string values */
1411
1412 ptr = "static string";
1413 value = binn_string(ptr, BINN_STATIC);
1414 CU_ASSERT(value != NULL);
1415 CU_ASSERT(value->type == BINN_STRING);
1416 CU_ASSERT(value->ptr != NULL);
1417 CU_ASSERT(value->ptr == ptr);
1418 CU_ASSERT(value->freefn == NULL);
1419 binn_free(value);
1420
1421 ptr = "transient string";
1422 value = binn_string(ptr, BINN_TRANSIENT);
1423 CU_ASSERT(value != NULL);
1424 CU_ASSERT(value->type == BINN_STRING);
1425 CU_ASSERT(value->ptr != NULL);
1426 CU_ASSERT(value->ptr != ptr);
1427 CU_ASSERT(strcmp((char*) value->ptr, ptr) == 0);
1428 CU_ASSERT(value->freefn != NULL);
1429 binn_free(value);
1430
1431 ptr = strdup("dynamic allocated string");
1432 value = binn_string(ptr, free);
1433 CU_ASSERT(value != NULL);
1434 CU_ASSERT(value->type == BINN_STRING);
1435 CU_ASSERT(value->ptr != NULL);
1436 CU_ASSERT(value->ptr == ptr);
1437 CU_ASSERT(value->freefn != NULL);
1438 CU_ASSERT(value->freefn == &free);
1439 binn_free(value);
1440
1441 /* test blob values */
1442
1443 size = 64;
1444 pblob = blob;
1445 value = binn_blob(pblob, size, BINN_STATIC);
1446 CU_ASSERT(value != NULL);
1447 CU_ASSERT(value->type == BINN_BLOB);
1448 CU_ASSERT(value->ptr != NULL);
1449 CU_ASSERT(value->ptr == pblob);
1450 CU_ASSERT(value->freefn == NULL);
1451 binn_free(value);
1452
1453 size = 64;
1454 pblob = blob;
1455 value = binn_blob(pblob, size, BINN_TRANSIENT);
1456 CU_ASSERT(value != NULL);
1457 CU_ASSERT(value->type == BINN_BLOB);
1458 CU_ASSERT(value->ptr != NULL);
1459 CU_ASSERT(value->ptr != pblob);
1460 CU_ASSERT(memcmp(value->ptr, pblob, size) == 0);
1461 CU_ASSERT(value->freefn != NULL);
1462 binn_free(value);
1463
1464 size = 64;
1465 pblob = memdup(blob, size);
1466 value = binn_blob(pblob, size, free);
1467 CU_ASSERT(value != NULL);
1468 CU_ASSERT(value->type == BINN_BLOB);
1469 CU_ASSERT(value->ptr != NULL);
1470 CU_ASSERT(value->ptr == pblob);
1471 CU_ASSERT(value->freefn == &free);
1472 binn_free(value);
1473
1474
1475 /* test conversions */
1476
1477 ptr = "123";
1478 value = binn_string(ptr, BINN_STATIC);
1479 CU_ASSERT(value != NULL);
1480 CU_ASSERT(value->type == BINN_STRING);
1481 CU_ASSERT(value->ptr != NULL);
1482 CU_ASSERT(value->ptr == ptr);
1483 CU_ASSERT(value->freefn == NULL);
1484 //
1485 CU_ASSERT(binn_get_str(value) == ptr);
1486 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1487 CU_ASSERT(vint32 == 123);
1488 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1489 CU_ASSERT(vint64 == 123);
1490 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1491 CU_ASSERT(AlmostEqualFloats(vdouble, 123, 4) == TRUE);
1492 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1493 CU_ASSERT(vbool == TRUE);
1494 // check that the type is the same
1495 CU_ASSERT(value->type == BINN_STRING);
1496 CU_ASSERT(value->ptr != NULL);
1497 CU_ASSERT(value->ptr == ptr);
1498 CU_ASSERT(value->freefn == NULL);
1499 //
1500 binn_free(value);
1501
1502
1503 ptr = "-456";
1504 value = binn_string(ptr, BINN_STATIC);
1505 CU_ASSERT(value != NULL);
1506 CU_ASSERT(value->type == BINN_STRING);
1507 CU_ASSERT(value->ptr != NULL);
1508 CU_ASSERT(value->ptr == ptr);
1509 CU_ASSERT(value->freefn == NULL);
1510 //
1511 CU_ASSERT(binn_get_str(value) == ptr);
1512 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1513 CU_ASSERT(vint32 == -456);
1514 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1515 CU_ASSERT(vint64 == -456);
1516 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1517 CU_ASSERT(AlmostEqualFloats(vdouble, -456, 4) == TRUE);
1518 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1519 CU_ASSERT(vbool == TRUE);
1520 // check that the type is the same
1521 CU_ASSERT(value->type == BINN_STRING);
1522 CU_ASSERT(value->ptr != NULL);
1523 CU_ASSERT(value->ptr == ptr);
1524 CU_ASSERT(value->freefn == NULL);
1525 //
1526 binn_free(value);
1527
1528
1529 ptr = "-4.56";
1530 value = binn_string(ptr, BINN_STATIC);
1531 CU_ASSERT(value != NULL);
1532 CU_ASSERT(value->type == BINN_STRING);
1533 CU_ASSERT(value->ptr != NULL);
1534 CU_ASSERT(value->ptr == ptr);
1535 CU_ASSERT(value->freefn == NULL);
1536 //
1537 CU_ASSERT(binn_get_str(value) == ptr);
1538 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1539 CU_ASSERT(vint32 == -4);
1540 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1541 CU_ASSERT(vint64 == -4);
1542 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1543 CU_ASSERT(AlmostEqualFloats(vdouble, -4.56, 4) == TRUE);
1544 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1545 CU_ASSERT(vbool == TRUE);
1546 // check that the type is the same
1547 CU_ASSERT(value->type == BINN_STRING);
1548 CU_ASSERT(value->ptr != NULL);
1549 CU_ASSERT(value->ptr == ptr);
1550 CU_ASSERT(value->freefn == NULL);
1551 //
1552 binn_free(value);
1553
1554
1555 // to boolean
1556
1557 ptr = "yes";
1558 value = binn_string(ptr, BINN_STATIC);
1559 CU_ASSERT(value != NULL);
1560 CU_ASSERT(binn_get_str(value) == ptr);
1561 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1562 CU_ASSERT(vbool == TRUE);
1563 binn_free(value);
1564
1565 ptr = "no";
1566 value = binn_string(ptr, BINN_STATIC);
1567 CU_ASSERT(value != NULL);
1568 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1569 CU_ASSERT(vbool == FALSE);
1570 binn_free(value);
1571
1572 ptr = "on";
1573 value = binn_string(ptr, BINN_STATIC);
1574 CU_ASSERT(value != NULL);
1575 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1576 CU_ASSERT(vbool == TRUE);
1577 binn_free(value);
1578
1579 ptr = "off";
1580 value = binn_string(ptr, BINN_STATIC);
1581 CU_ASSERT(value != NULL);
1582 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1583 CU_ASSERT(vbool == FALSE);
1584 binn_free(value);
1585
1586 ptr = "true";
1587 value = binn_string(ptr, BINN_STATIC);
1588 CU_ASSERT(value != NULL);
1589 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1590 CU_ASSERT(vbool == TRUE);
1591 binn_free(value);
1592
1593 ptr = "false";
1594 value = binn_string(ptr, BINN_STATIC);
1595 CU_ASSERT(value != NULL);
1596 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1597 CU_ASSERT(vbool == FALSE);
1598 binn_free(value);
1599
1600 ptr = "1";
1601 value = binn_string(ptr, BINN_STATIC);
1602 CU_ASSERT(value != NULL);
1603 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1604 CU_ASSERT(vbool == TRUE);
1605 binn_free(value);
1606
1607 ptr = "0";
1608 value = binn_string(ptr, BINN_STATIC);
1609 CU_ASSERT(value != NULL);
1610 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1611 CU_ASSERT(vbool == FALSE);
1612 binn_free(value);
1613
1614
1615 // from int32
1616
1617 value = binn_int32(-345);
1618 CU_ASSERT(value != NULL);
1619 CU_ASSERT(value->type == BINN_INT32);
1620 CU_ASSERT(value->vint32 == -345);
1621 CU_ASSERT(value->freefn == NULL);
1622 //
1623 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1624 CU_ASSERT(vint32 == -345);
1625 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1626 CU_ASSERT(vint64 == -345);
1627 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1628 CU_ASSERT(AlmostEqualFloats(vdouble, -345, 4) == TRUE);
1629 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1630 CU_ASSERT(vbool == TRUE);
1631 // check that the type is the same
1632 CU_ASSERT(value->type == BINN_INT32);
1633 CU_ASSERT(value->vint32 == -345);
1634 CU_ASSERT(value->freefn == NULL);
1635 // convert the value to string
1636 ptr = binn_get_str(value);
1637 CU_ASSERT(ptr != NULL);
1638 CU_ASSERT(strcmp(ptr, "-345") == 0);
1639 CU_ASSERT(value->type == BINN_STRING);
1640 CU_ASSERT(value->ptr != NULL);
1641 CU_ASSERT(value->ptr == ptr);
1642 CU_ASSERT(value->freefn != NULL);
1643 //
1644 binn_free(value);
1645
1646
1647 value = binn_int32(0);
1648 CU_ASSERT(value != NULL);
1649 CU_ASSERT(value->type == BINN_INT32);
1650 CU_ASSERT(value->vint32 == 0);
1651 CU_ASSERT(value->freefn == NULL);
1652 //
1653 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1654 CU_ASSERT(vint32 == 0);
1655 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1656 CU_ASSERT(vint64 == 0);
1657 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1658 CU_ASSERT(AlmostEqualFloats(vdouble, 0, 4) == TRUE);
1659 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1660 CU_ASSERT(vbool == FALSE);
1661 // check that the type is the same
1662 CU_ASSERT(value->type == BINN_INT32);
1663 CU_ASSERT(value->vint32 == 0);
1664 CU_ASSERT(value->freefn == NULL);
1665 // convert the value to string
1666 ptr = binn_get_str(value);
1667 CU_ASSERT(ptr != NULL);
1668 CU_ASSERT(strcmp(ptr, "0") == 0);
1669 CU_ASSERT(value->type == BINN_STRING);
1670 CU_ASSERT(value->ptr != NULL);
1671 CU_ASSERT(value->ptr == ptr);
1672 CU_ASSERT(value->freefn != NULL);
1673 //
1674 binn_free(value);
1675
1676
1677 // from int64
1678
1679 value = binn_int64(-345678);
1680 CU_ASSERT(value != NULL);
1681 CU_ASSERT(value->type == BINN_INT64);
1682 CU_ASSERT(value->vint64 == -345678);
1683 CU_ASSERT(value->freefn == NULL);
1684 //
1685 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1686 CU_ASSERT(vint32 == -345678);
1687 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1688 CU_ASSERT(vint64 == -345678);
1689 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1690 CU_ASSERT(AlmostEqualFloats(vdouble, -345678, 4) == TRUE);
1691 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1692 CU_ASSERT(vbool == TRUE);
1693 // check that the type is the same
1694 CU_ASSERT(value->type == BINN_INT64);
1695 CU_ASSERT(value->vint64 == -345678);
1696 CU_ASSERT(value->freefn == NULL);
1697 // convert the value to string
1698 ptr = binn_get_str(value);
1699 CU_ASSERT(ptr != NULL);
1700 CU_ASSERT(strcmp(ptr, "-345678") == 0);
1701 CU_ASSERT(value->type == BINN_STRING);
1702 CU_ASSERT(value->ptr != NULL);
1703 CU_ASSERT(value->ptr == ptr);
1704 CU_ASSERT(value->freefn != NULL);
1705 //
1706 binn_free(value);
1707
1708
1709 // from double
1710
1711 value = binn_double(-345.678);
1712 CU_ASSERT(value != NULL);
1713 CU_ASSERT(value->type == BINN_DOUBLE);
1714 CU_ASSERT(value->vdouble == -345.678);
1715 CU_ASSERT(value->freefn == NULL);
1716 //
1717 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1718 CU_ASSERT(vint32 == -345);
1719 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1720 CU_ASSERT(vint64 == -345);
1721 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1722 CU_ASSERT(AlmostEqualFloats(vdouble, -345.678, 4) == TRUE);
1723 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1724 CU_ASSERT(vbool == TRUE);
1725 // check that the type is the same
1726 CU_ASSERT(value->type == BINN_DOUBLE);
1727 CU_ASSERT(value->vdouble == -345.678);
1728 CU_ASSERT(value->freefn == NULL);
1729 // convert the value to string
1730 ptr = binn_get_str(value);
1731 CU_ASSERT(ptr != NULL);
1732 CU_ASSERT(strcmp(ptr, "-345.678") == 0);
1733 CU_ASSERT(value->type == BINN_STRING);
1734 CU_ASSERT(value->ptr != NULL);
1735 CU_ASSERT(value->ptr == ptr);
1736 CU_ASSERT(value->freefn != NULL);
1737 //
1738 binn_free(value);
1739
1740
1741 value = binn_double(0.0);
1742 CU_ASSERT(value != NULL);
1743 CU_ASSERT(value->type == BINN_DOUBLE);
1744 CU_ASSERT(value->vdouble == 0.0);
1745 CU_ASSERT(value->freefn == NULL);
1746 //
1747 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1748 CU_ASSERT(vint32 == 0);
1749 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1750 CU_ASSERT(vint64 == 0);
1751 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1752 CU_ASSERT(AlmostEqualFloats(vdouble, 0, 4) == TRUE);
1753 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1754 CU_ASSERT(vbool == FALSE);
1755 // check that the type is the same
1756 CU_ASSERT(value->type == BINN_DOUBLE);
1757 CU_ASSERT(value->vdouble == 0.0);
1758 CU_ASSERT(value->freefn == NULL);
1759 // convert the value to string
1760 ptr = binn_get_str(value);
1761 CU_ASSERT(ptr != NULL);
1762 CU_ASSERT(strcmp(ptr, "0") == 0);
1763 CU_ASSERT(value->type == BINN_STRING);
1764 CU_ASSERT(value->ptr != NULL);
1765 CU_ASSERT(value->ptr == ptr);
1766 CU_ASSERT(value->freefn != NULL);
1767 //
1768 binn_free(value);
1769
1770
1771 // from bool
1772
1773 value = binn_bool(FALSE);
1774 CU_ASSERT(value != NULL);
1775 CU_ASSERT(value->type == BINN_BOOL);
1776 CU_ASSERT(value->vbool == FALSE);
1777 CU_ASSERT(value->freefn == NULL);
1778 //
1779 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1780 CU_ASSERT(vint32 == 0);
1781 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1782 CU_ASSERT(vint64 == 0);
1783 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1784 CU_ASSERT(AlmostEqualFloats(vdouble, 0, 4) == TRUE);
1785 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1786 CU_ASSERT(vbool == FALSE);
1787 // check that the type is the same
1788 CU_ASSERT(value->type == BINN_BOOL);
1789 CU_ASSERT(value->vbool == FALSE);
1790 CU_ASSERT(value->freefn == NULL);
1791 // convert the value to string
1792 ptr = binn_get_str(value);
1793 CU_ASSERT(ptr != NULL);
1794 CU_ASSERT(strcmp(ptr, "false") == 0);
1795 CU_ASSERT(value->type == BINN_STRING);
1796 CU_ASSERT(value->ptr != NULL);
1797 CU_ASSERT(value->ptr == ptr);
1798 CU_ASSERT(value->freefn != NULL);
1799 //
1800 binn_free(value);
1801
1802
1803 value = binn_bool(TRUE);
1804 CU_ASSERT(value != NULL);
1805 CU_ASSERT(value->type == BINN_BOOL);
1806 CU_ASSERT(value->vbool == TRUE);
1807 CU_ASSERT(value->freefn == NULL);
1808 //
1809 CU_ASSERT(binn_get_int32(value, &vint32) == TRUE);
1810 CU_ASSERT(vint32 == 1);
1811 CU_ASSERT(binn_get_int64(value, &vint64) == TRUE);
1812 CU_ASSERT(vint64 == 1);
1813 CU_ASSERT(binn_get_double(value, &vdouble) == TRUE);
1814 CU_ASSERT(AlmostEqualFloats(vdouble, 1, 4) == TRUE);
1815 CU_ASSERT(binn_get_bool(value, &vbool) == TRUE);
1816 CU_ASSERT(vbool == TRUE);
1817 // check that the type is the same
1818 CU_ASSERT(value->type == BINN_BOOL);
1819 CU_ASSERT(value->vbool == TRUE);
1820 CU_ASSERT(value->freefn == NULL);
1821 // convert the value to string
1822 ptr = binn_get_str(value);
1823 CU_ASSERT(ptr != NULL);
1824 CU_ASSERT(strcmp(ptr, "true") == 0);
1825 CU_ASSERT(value->type == BINN_STRING);
1826 CU_ASSERT(value->ptr != NULL);
1827 CU_ASSERT(value->ptr == ptr);
1828 CU_ASSERT(value->freefn != NULL);
1829 //
1830 binn_free(value);
1831
1832
1833 puts("OK");
1834 }
1835
1836 /*************************************************************************************/
1837
test_value_copy()1838 void test_value_copy() {
1839
1840 printf("testing binn value copy... ");
1841
1842 //TODO
1843
1844 puts("TODO!!!");
1845 }
1846
1847 /*************************************************************************************/
1848
test_virtual_types()1849 void test_virtual_types() {
1850 binn *list = INVALID_BINN;
1851 void *ptr;
1852 int storage_type, extra_type;
1853 BOOL value;
1854
1855 printf("testing binn virtual types... ");
1856
1857 CU_ASSERT(binn_get_type_info(BINN_BOOL, &storage_type, &extra_type) == TRUE);
1858 CU_ASSERT(storage_type == BINN_STORAGE_DWORD);
1859 CU_ASSERT(extra_type == 1);
1860
1861 list = binn_list();
1862 CU_ASSERT(list != NULL);
1863
1864 CU_ASSERT(binn_list_add_bool(list, TRUE) == TRUE);
1865 CU_ASSERT(binn_list_add_bool(list, FALSE) == TRUE);
1866 CU_ASSERT(binn_list_add_null(list) == TRUE);
1867
1868 ptr = binn_ptr(list);
1869 CU_ASSERT(ptr != 0);
1870
1871 CU_ASSERT(binn_list_get_bool(ptr, 1, &value) == TRUE);
1872 CU_ASSERT(value == TRUE);
1873
1874 CU_ASSERT(binn_list_get_bool(ptr, 2, &value) == TRUE);
1875 CU_ASSERT(value == FALSE);
1876
1877 CU_ASSERT(binn_list_null(ptr, 3) == TRUE);
1878
1879 // invalid values
1880 CU_ASSERT(binn_list_null(ptr, 1) == FALSE);
1881 CU_ASSERT(binn_list_null(ptr, 2) == FALSE);
1882 CU_ASSERT(binn_list_get_bool(ptr, 3, &value) == FALSE);
1883
1884 binn_free(list);
1885
1886 puts("OK");
1887 }
1888
1889 /*************************************************************************************/
1890
test_binn_iter()1891 void test_binn_iter() {
1892 binn *list, *map, *obj;
1893 binn *list2, *copy = NULL;
1894 binn_iter iter, iter2;
1895 binn value, value2;
1896 int blob_size, id, id2, list2size;
1897 void *ptr, *blob_ptr;
1898 char key[256], key2[256];
1899
1900 blob_ptr = "key\0value\0\0";
1901 blob_size = 11;
1902
1903 printf("testing binn sequential read");
1904
1905 // create the
1906
1907 list = binn_list();
1908 list2 = binn_list();
1909 map = binn_map();
1910 obj = binn_object();
1911
1912 CU_ASSERT(list != NULL);
1913 CU_ASSERT(list2 != NULL);
1914 CU_ASSERT(map != NULL);
1915 CU_ASSERT(obj != NULL);
1916
1917 CU_ASSERT(binn_list_add_int32(list2, 250) == TRUE);
1918 CU_ASSERT(binn_list_add_null(list2) == TRUE);
1919 CU_ASSERT(binn_list_add_str(list2, "l1st2") == TRUE);
1920 CU_ASSERT(binn_list_add_bool(list2, TRUE) == TRUE);
1921
1922 list2size = binn_size(list2);
1923
1924 CU_ASSERT(binn_list_add_int8(list, 111) == TRUE);
1925 CU_ASSERT(binn_list_add_int32(list, 123456789) == TRUE);
1926 CU_ASSERT(binn_list_add_int16(list, -123) == TRUE);
1927 CU_ASSERT(binn_list_add_int64(list, 9876543210) == TRUE);
1928 CU_ASSERT(binn_list_add_float(list, 1.25) == TRUE);
1929 CU_ASSERT(binn_list_add_double(list, 25.987654321) == TRUE);
1930 CU_ASSERT(binn_list_add_bool(list, TRUE) == TRUE);
1931 CU_ASSERT(binn_list_add_bool(list, FALSE) == TRUE);
1932 CU_ASSERT(binn_list_add_null(list) == TRUE);
1933 CU_ASSERT(binn_list_add_str(list, "testing...") == TRUE);
1934 CU_ASSERT(binn_list_add_blob(list, (char*) blob_ptr, blob_size) == TRUE);
1935 CU_ASSERT(binn_list_add_list(list, list2) == TRUE);
1936
1937 CU_ASSERT(binn_object_set_int8(obj, "a", 111) == TRUE);
1938 CU_ASSERT(binn_object_set_int32(obj, "b", 123456789) == TRUE);
1939 CU_ASSERT(binn_object_set_int16(obj, "c", -123) == TRUE);
1940 CU_ASSERT(binn_object_set_int64(obj, "d", 9876543210) == TRUE);
1941 CU_ASSERT(binn_object_set_float(obj, "e", 1.25) == TRUE);
1942 CU_ASSERT(binn_object_set_double(obj, "f", 25.987654321) == TRUE);
1943 CU_ASSERT(binn_object_set_bool(obj, "g", TRUE) == TRUE);
1944 CU_ASSERT(binn_object_set_bool(obj, "h", FALSE) == TRUE);
1945 CU_ASSERT(binn_object_set_null(obj, "i") == TRUE);
1946 CU_ASSERT(binn_object_set_str(obj, "j", "testing...") == TRUE);
1947 CU_ASSERT(binn_object_set_blob(obj, "k", (char*) blob_ptr, blob_size) == TRUE);
1948 CU_ASSERT(binn_object_set_list(obj, "l", list2) == TRUE);
1949
1950 CU_ASSERT(binn_map_set_int8(map, 55010, 111) == TRUE);
1951 CU_ASSERT(binn_map_set_int32(map, 55020, 123456789) == TRUE);
1952 CU_ASSERT(binn_map_set_int16(map, 55030, -123) == TRUE);
1953 CU_ASSERT(binn_map_set_int64(map, 55040, 9876543210) == TRUE);
1954 CU_ASSERT(binn_map_set_float(map, 55050, 1.25) == TRUE);
1955 CU_ASSERT(binn_map_set_double(map, 55060, 25.987654321) == TRUE);
1956 CU_ASSERT(binn_map_set_bool(map, 55070, TRUE) == TRUE);
1957 CU_ASSERT(binn_map_set_bool(map, 55080, FALSE) == TRUE);
1958 CU_ASSERT(binn_map_set_null(map, 55090) == TRUE);
1959 CU_ASSERT(binn_map_set_str(map, 55100, "testing...") == TRUE);
1960 CU_ASSERT(binn_map_set_blob(map, 55110, (char*) blob_ptr, blob_size) == TRUE);
1961 CU_ASSERT(binn_map_set_list(map, 55120, list2) == TRUE);
1962
1963
1964 // read list sequentially - using value
1965
1966 /*
1967 CU_ASSERT(binn_iter_init(&iter, binn_ptr(list), BINN_LIST));
1968
1969 while (binn_list_next(&iter, &value)) {
1970 ...
1971 }
1972 */
1973
1974 ptr = binn_ptr(list);
1975 CU_ASSERT(ptr != 0);
1976 CU_ASSERT(binn_iter_init(&iter, ptr, BINN_LIST));
1977 CU_ASSERT(iter.pnext > (unsigned char*) ptr);
1978 CU_ASSERT(iter.plimit > (unsigned char*) ptr);
1979 CU_ASSERT(iter.count == 12);
1980 CU_ASSERT(iter.current == 0);
1981
1982 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
1983 CU_ASSERT(iter.pnext > (unsigned char*) ptr);
1984 CU_ASSERT(iter.plimit > (unsigned char*) ptr);
1985 CU_ASSERT(iter.count == 12);
1986 CU_ASSERT(iter.current == 1);
1987 CU_ASSERT(value.type == BINN_INT8);
1988 CU_ASSERT(value.vint8 == 111);
1989
1990 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
1991 CU_ASSERT(iter.current == 2);
1992
1993 CU_ASSERT(value.type == BINN_UINT32);
1994 CU_ASSERT(value.vint32 == 123456789);
1995
1996 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
1997 CU_ASSERT(iter.current == 3);
1998
1999 CU_ASSERT(value.type == BINN_INT8);
2000 CU_ASSERT(value.vint8 == -123);
2001
2002 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2003 CU_ASSERT(iter.current == 4);
2004 CU_ASSERT(value.type == BINN_INT64);
2005 CU_ASSERT(value.vint64 == 9876543210);
2006
2007 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2008 CU_ASSERT(iter.current == 5);
2009 CU_ASSERT(value.type == BINN_FLOAT32);
2010 CU_ASSERT(AlmostEqualFloats(value.vfloat, 1.25, 2));
2011
2012 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2013 CU_ASSERT(iter.current == 6);
2014 CU_ASSERT(value.type == BINN_FLOAT64);
2015 CU_ASSERT(value.vdouble - 25.987654321 < 0.00000001);
2016
2017 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2018 CU_ASSERT(iter.current == 7);
2019 CU_ASSERT(value.type == BINN_BOOL);
2020 CU_ASSERT(value.vbool == TRUE);
2021
2022 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2023 CU_ASSERT(iter.current == 8);
2024 CU_ASSERT(value.type == BINN_BOOL);
2025 CU_ASSERT(value.vbool == FALSE);
2026
2027 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2028 CU_ASSERT(iter.current == 9);
2029 CU_ASSERT(value.type == BINN_NULL);
2030
2031 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2032 CU_ASSERT(iter.current == 10);
2033 CU_ASSERT(value.type == BINN_STRING);
2034 CU_ASSERT(strcmp((char*) value.ptr, "testing...") == 0);
2035
2036 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2037 CU_ASSERT(iter.current == 11);
2038 CU_ASSERT(value.type == BINN_BLOB);
2039 CU_ASSERT(memcmp(value.ptr, blob_ptr, blob_size) == 0);
2040
2041 CU_ASSERT(binn_list_next(&iter, &value) == TRUE);
2042 CU_ASSERT(iter.current == 12);
2043 CU_ASSERT(value.type == BINN_LIST);
2044 CU_ASSERT(value.size == list2size);
2045 CU_ASSERT(value.count == 4);
2046 CU_ASSERT(value.ptr != 0);
2047 CU_ASSERT(binn_list_int32(value.ptr, 1) == 250);
2048 CU_ASSERT(binn_list_null(value.ptr, 2) == TRUE);
2049 ptr = binn_list_str(value.ptr, 3);
2050 CU_ASSERT(ptr != 0);
2051 CU_ASSERT(strcmp((char*) ptr, "l1st2") == 0);
2052 CU_ASSERT(binn_list_bool(value.ptr, 4) == TRUE);
2053
2054 CU_ASSERT(binn_list_next(&iter, &value) == FALSE);
2055 //CU_ASSERT(iter.current == 13);
2056 //CU_ASSERT(iter.count == 12);
2057
2058 CU_ASSERT(binn_list_next(&iter, &value) == FALSE);
2059 //CU_ASSERT(iter.current == 13); // must keep the same position
2060 //CU_ASSERT(iter.count == 12);
2061
2062
2063 // read object sequentially - using value
2064
2065 ptr = binn_ptr(obj);
2066 CU_ASSERT(ptr != 0);
2067 CU_ASSERT(binn_iter_init(&iter, ptr, BINN_OBJECT));
2068 CU_ASSERT(iter.pnext > (unsigned char*) ptr);
2069 CU_ASSERT(iter.plimit > (unsigned char*) ptr);
2070 CU_ASSERT(iter.count == 12);
2071 CU_ASSERT(iter.current == 0);
2072
2073 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2074 CU_ASSERT(iter.pnext > (unsigned char*) ptr);
2075 CU_ASSERT(iter.plimit > (unsigned char*) ptr);
2076 CU_ASSERT(iter.count == 12);
2077 CU_ASSERT(iter.current == 1);
2078 CU_ASSERT(value.type == BINN_INT8);
2079 CU_ASSERT(value.vint8 == 111);
2080 //printf("%s ", key);
2081 CU_ASSERT(strcmp(key, "a") == 0);
2082
2083 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2084 CU_ASSERT(iter.current == 2);
2085 CU_ASSERT(value.type == BINN_UINT32);
2086 CU_ASSERT(value.vint32 == 123456789);
2087 //printf("%s ", key);
2088 CU_ASSERT(strcmp(key, "b") == 0);
2089
2090 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2091 CU_ASSERT(iter.current == 3);
2092
2093 CU_ASSERT(value.type == BINN_INT8);
2094 CU_ASSERT(value.vint8 == -123);
2095
2096 //printf("%s ", key);
2097 CU_ASSERT(strcmp(key, "c") == 0);
2098
2099 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2100 CU_ASSERT(iter.current == 4);
2101 CU_ASSERT(value.type == BINN_INT64);
2102 CU_ASSERT(value.vint64 == 9876543210);
2103 //printf("%s ", key);
2104 CU_ASSERT(strcmp(key, "d") == 0);
2105
2106 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2107 CU_ASSERT(iter.current == 5);
2108 CU_ASSERT(value.type == BINN_FLOAT32);
2109 CU_ASSERT(AlmostEqualFloats(value.vfloat, 1.25, 2));
2110 //printf("%s ", key);
2111 CU_ASSERT(strcmp(key, "e") == 0);
2112
2113 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2114 CU_ASSERT(iter.current == 6);
2115 CU_ASSERT(value.type == BINN_FLOAT64);
2116 CU_ASSERT(value.vdouble - 25.987654321 < 0.00000001);
2117 //printf("%s ", key);
2118 CU_ASSERT(strcmp(key, "f") == 0);
2119
2120 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2121 CU_ASSERT(iter.current == 7);
2122 CU_ASSERT(value.type == BINN_BOOL);
2123 CU_ASSERT(value.vbool == TRUE);
2124 //printf("%s ", key);
2125 CU_ASSERT(strcmp(key, "g") == 0);
2126
2127 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2128 CU_ASSERT(iter.current == 8);
2129 CU_ASSERT(value.type == BINN_BOOL);
2130 CU_ASSERT(value.vbool == FALSE);
2131 //printf("%s ", key);
2132 CU_ASSERT(strcmp(key, "h") == 0);
2133
2134 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2135 CU_ASSERT(iter.current == 9);
2136 CU_ASSERT(value.type == BINN_NULL);
2137 //printf("%s ", key);
2138 CU_ASSERT(strcmp(key, "i") == 0);
2139
2140 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2141 CU_ASSERT(iter.current == 10);
2142 CU_ASSERT(value.type == BINN_STRING);
2143 CU_ASSERT(strcmp((char*) value.ptr, "testing...") == 0);
2144 //printf("%s ", key);
2145 CU_ASSERT(strcmp(key, "j") == 0);
2146
2147 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2148 CU_ASSERT(iter.current == 11);
2149 CU_ASSERT(value.type == BINN_BLOB);
2150 CU_ASSERT(memcmp(value.ptr, blob_ptr, blob_size) == 0);
2151 //printf("%s ", key);
2152 CU_ASSERT(strcmp(key, "k") == 0);
2153
2154 CU_ASSERT(binn_object_next(&iter, key, &value) == TRUE);
2155 CU_ASSERT(iter.current == 12);
2156 CU_ASSERT(value.type == BINN_LIST);
2157 CU_ASSERT(value.size == list2size);
2158 CU_ASSERT(value.count == 4);
2159 CU_ASSERT(value.ptr != 0);
2160 CU_ASSERT(binn_list_int32(value.ptr, 1) == 250);
2161 CU_ASSERT(binn_list_null(value.ptr, 2) == TRUE);
2162 ptr = binn_list_str(value.ptr, 3);
2163 CU_ASSERT(ptr != 0);
2164 CU_ASSERT(strcmp((char*) ptr, "l1st2") == 0);
2165 CU_ASSERT(binn_list_bool(value.ptr, 4) == TRUE);
2166 //printf("%s ", key);
2167 CU_ASSERT(strcmp(key, "l") == 0);
2168
2169 CU_ASSERT(binn_object_next(&iter, key, &value) == FALSE);
2170 //CU_ASSERT(iter.current == 13);
2171 //CU_ASSERT(iter.count == 12);
2172
2173 CU_ASSERT(binn_object_next(&iter, key, &value) == FALSE);
2174 //CU_ASSERT(iter.current == 13); // must keep the same position
2175 //CU_ASSERT(iter.count == 12);
2176
2177
2178 // read map sequentially - using value
2179
2180 ptr = binn_ptr(map);
2181 CU_ASSERT(ptr != 0);
2182 CU_ASSERT(binn_iter_init(&iter, ptr, BINN_MAP));
2183 CU_ASSERT(iter.pnext > (unsigned char*) ptr);
2184 CU_ASSERT(iter.plimit > (unsigned char*) ptr);
2185 CU_ASSERT(iter.count == 12);
2186 CU_ASSERT(iter.current == 0);
2187
2188 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2189 CU_ASSERT(iter.pnext > (unsigned char*) ptr);
2190 CU_ASSERT(iter.plimit > (unsigned char*) ptr);
2191 CU_ASSERT(iter.count == 12);
2192 CU_ASSERT(iter.current == 1);
2193 CU_ASSERT(value.type == BINN_INT8);
2194 CU_ASSERT(value.vint8 == 111);
2195 CU_ASSERT(id == 55010);
2196
2197 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2198 CU_ASSERT(iter.current == 2);
2199
2200 CU_ASSERT(value.type == BINN_UINT32);
2201
2202 CU_ASSERT(value.vint32 == 123456789);
2203 CU_ASSERT(id == 55020);
2204
2205 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2206 CU_ASSERT(iter.current == 3);
2207
2208 CU_ASSERT(value.type == BINN_INT8);
2209 CU_ASSERT(value.vint8 == -123);
2210
2211 CU_ASSERT(id == 55030);
2212
2213 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2214 CU_ASSERT(iter.current == 4);
2215 CU_ASSERT(value.type == BINN_INT64);
2216 CU_ASSERT(value.vint64 == 9876543210);
2217 CU_ASSERT(id == 55040);
2218
2219 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2220 CU_ASSERT(iter.current == 5);
2221 CU_ASSERT(value.type == BINN_FLOAT32);
2222 CU_ASSERT(AlmostEqualFloats(value.vfloat, 1.25, 2));
2223 CU_ASSERT(id == 55050);
2224
2225 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2226 CU_ASSERT(iter.current == 6);
2227 CU_ASSERT(value.type == BINN_FLOAT64);
2228 CU_ASSERT(value.vdouble - 25.987654321 < 0.00000001);
2229 CU_ASSERT(id == 55060);
2230
2231 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2232 CU_ASSERT(iter.current == 7);
2233 CU_ASSERT(value.type == BINN_BOOL);
2234 CU_ASSERT(value.vbool == TRUE);
2235 CU_ASSERT(id == 55070);
2236
2237 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2238 CU_ASSERT(iter.current == 8);
2239 CU_ASSERT(value.type == BINN_BOOL);
2240 CU_ASSERT(value.vbool == FALSE);
2241 CU_ASSERT(id == 55080);
2242
2243 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2244 CU_ASSERT(iter.current == 9);
2245 CU_ASSERT(value.type == BINN_NULL);
2246 CU_ASSERT(id == 55090);
2247
2248 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2249 CU_ASSERT(iter.current == 10);
2250 CU_ASSERT(value.type == BINN_STRING);
2251 CU_ASSERT(strcmp((char*) value.ptr, "testing...") == 0);
2252 CU_ASSERT(id == 55100);
2253
2254 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2255 CU_ASSERT(iter.current == 11);
2256 CU_ASSERT(value.type == BINN_BLOB);
2257 CU_ASSERT(memcmp(value.ptr, blob_ptr, blob_size) == 0);
2258 CU_ASSERT(id == 55110);
2259
2260 CU_ASSERT(binn_map_next(&iter, &id, &value) == TRUE);
2261 CU_ASSERT(iter.current == 12);
2262 CU_ASSERT(value.type == BINN_LIST);
2263 CU_ASSERT(value.size == list2size);
2264 CU_ASSERT(value.count == 4);
2265 CU_ASSERT(value.ptr != 0);
2266 CU_ASSERT(binn_list_int32(value.ptr, 1) == 250);
2267 CU_ASSERT(binn_list_null(value.ptr, 2) == TRUE);
2268 ptr = binn_list_str(value.ptr, 3);
2269 CU_ASSERT(ptr != 0);
2270 CU_ASSERT(strcmp((char*) ptr, "l1st2") == 0);
2271 CU_ASSERT(binn_list_bool(value.ptr, 4) == TRUE);
2272 CU_ASSERT(id == 55120);
2273
2274 CU_ASSERT(binn_map_next(&iter, &id, &value) == FALSE);
2275 //CU_ASSERT(iter.current == 13);
2276 //CU_ASSERT(iter.count == 12);
2277
2278 CU_ASSERT(binn_map_next(&iter, &id, &value) == FALSE);
2279 //CU_ASSERT(iter.current == 13); // must keep the same position
2280 //CU_ASSERT(iter.count == 12);
2281
2282
2283 // test binn copy
2284
2285 copy = binn_copy(list);
2286 CU_ASSERT(copy != NULL);
2287 CU_ASSERT(binn_type(copy) == binn_type(list));
2288 CU_ASSERT(binn_count(copy) == binn_count(list));
2289 CU_ASSERT(binn_size(copy) == binn_size(list));
2290 CU_ASSERT(binn_iter_init(&iter, list, BINN_LIST));
2291 CU_ASSERT(binn_iter_init(&iter2, copy, BINN_LIST));
2292 while (binn_list_next(&iter, &value)) {
2293 CU_ASSERT(binn_list_next(&iter2, &value2) == TRUE);
2294 CU_ASSERT(value.type == value2.type);
2295 //CU_ASSERT(value.vint32 == value.vint32);
2296 }
2297 CU_ASSERT(binn_list_add_str(copy, "testing...") == TRUE);
2298 CU_ASSERT(binn_type(copy) == binn_type(list));
2299 CU_ASSERT(binn_count(copy) == binn_count(list) + 1);
2300 CU_ASSERT(binn_size(copy) > binn_size(list));
2301 binn_free(copy);
2302
2303 copy = binn_copy(map);
2304 CU_ASSERT(copy != NULL);
2305 CU_ASSERT(binn_type(copy) == binn_type(map));
2306 CU_ASSERT(binn_count(copy) == binn_count(map));
2307 CU_ASSERT(binn_size(copy) == binn_size(map));
2308 CU_ASSERT(binn_iter_init(&iter, map, BINN_MAP));
2309 CU_ASSERT(binn_iter_init(&iter2, copy, BINN_MAP));
2310 while (binn_map_next(&iter, &id, &value)) {
2311 CU_ASSERT(binn_map_next(&iter2, &id2, &value2) == TRUE);
2312 CU_ASSERT(id == id2);
2313 CU_ASSERT(value.type == value2.type);
2314 //CU_ASSERT(value.vint32 == value.vint32);
2315 }
2316 CU_ASSERT(binn_map_set_int32(copy, 5600, 123) == TRUE);
2317 CU_ASSERT(binn_type(copy) == binn_type(map));
2318 CU_ASSERT(binn_count(copy) == binn_count(map) + 1);
2319 CU_ASSERT(binn_size(copy) > binn_size(map));
2320 binn_free(copy);
2321
2322 copy = binn_copy(obj);
2323 CU_ASSERT(copy != NULL);
2324 CU_ASSERT(binn_type(copy) == binn_type(obj));
2325 CU_ASSERT(binn_count(copy) == binn_count(obj));
2326 CU_ASSERT(binn_size(copy) == binn_size(obj));
2327 CU_ASSERT(binn_iter_init(&iter, obj, BINN_OBJECT));
2328 CU_ASSERT(binn_iter_init(&iter2, copy, BINN_OBJECT));
2329 while (binn_object_next(&iter, key, &value)) {
2330 CU_ASSERT(binn_object_next(&iter2, key2, &value2) == TRUE);
2331 CU_ASSERT(strcmp(key, key2) == 0);
2332 CU_ASSERT(value.type == value2.type);
2333 //CU_ASSERT(value.vint32 == value.vint32);
2334 }
2335 CU_ASSERT(binn_object_set_int32(copy, "another", 123) == TRUE);
2336 CU_ASSERT(binn_type(copy) == binn_type(obj));
2337 CU_ASSERT(binn_count(copy) == binn_count(obj) + 1);
2338 CU_ASSERT(binn_size(copy) > binn_size(obj));
2339 binn_free(copy);
2340
2341
2342 // test binn copy reading from buffer
2343
2344 ptr = binn_ptr(list);
2345 copy = binn_copy(ptr);
2346 CU_ASSERT(copy != NULL);
2347 CU_ASSERT(binn_type(copy) == binn_type(list));
2348 CU_ASSERT(binn_count(copy) == binn_count(list));
2349 CU_ASSERT(binn_size(copy) == binn_size(list));
2350 CU_ASSERT(binn_iter_init(&iter, ptr, BINN_LIST));
2351 CU_ASSERT(binn_iter_init(&iter2, copy, BINN_LIST));
2352 while (binn_list_next(&iter, &value)) {
2353 CU_ASSERT(binn_list_next(&iter2, &value2) == TRUE);
2354 CU_ASSERT(value.type == value2.type);
2355 //CU_ASSERT(value.vint32 == value.vint32);
2356 }
2357 CU_ASSERT(binn_list_add_str(copy, "testing...") == TRUE);
2358 CU_ASSERT(binn_type(copy) == binn_type(list));
2359 CU_ASSERT(binn_count(copy) == binn_count(list) + 1);
2360 CU_ASSERT(binn_size(copy) > binn_size(list));
2361 binn_free(copy);
2362
2363 ptr = binn_ptr(map);
2364 copy = binn_copy(ptr);
2365 CU_ASSERT(copy != NULL);
2366 CU_ASSERT(binn_type(copy) == binn_type(map));
2367 CU_ASSERT(binn_count(copy) == binn_count(map));
2368 CU_ASSERT(binn_size(copy) == binn_size(map));
2369 CU_ASSERT(binn_iter_init(&iter, ptr, BINN_MAP));
2370 CU_ASSERT(binn_iter_init(&iter2, copy, BINN_MAP));
2371 while (binn_map_next(&iter, &id, &value)) {
2372 CU_ASSERT(binn_map_next(&iter2, &id2, &value2) == TRUE);
2373 CU_ASSERT(id == id2);
2374 CU_ASSERT(value.type == value2.type);
2375 //CU_ASSERT(value.vint32 == value.vint32);
2376 }
2377 CU_ASSERT(binn_map_set_int32(copy, 5600, 123) == TRUE);
2378 CU_ASSERT(binn_type(copy) == binn_type(map));
2379 CU_ASSERT(binn_count(copy) == binn_count(map) + 1);
2380 CU_ASSERT(binn_size(copy) > binn_size(map));
2381 binn_free(copy);
2382
2383 ptr = binn_ptr(obj);
2384 copy = binn_copy(ptr);
2385 CU_ASSERT(copy != NULL);
2386 CU_ASSERT(binn_type(copy) == binn_type(obj));
2387 CU_ASSERT(binn_count(copy) == binn_count(obj));
2388 CU_ASSERT(binn_size(copy) == binn_size(obj));
2389 CU_ASSERT(binn_iter_init(&iter, ptr, BINN_OBJECT));
2390 CU_ASSERT(binn_iter_init(&iter2, copy, BINN_OBJECT));
2391 while (binn_object_next(&iter, key, &value)) {
2392 CU_ASSERT(binn_object_next(&iter2, key2, &value2) == TRUE);
2393 CU_ASSERT(strcmp(key, key2) == 0);
2394 CU_ASSERT(value.type == value2.type);
2395 //CU_ASSERT(value.vint32 == value.vint32);
2396 }
2397 CU_ASSERT(binn_object_set_int32(copy, "another", 123) == TRUE);
2398 CU_ASSERT(binn_type(copy) == binn_type(obj));
2399 CU_ASSERT(binn_count(copy) == binn_count(obj) + 1);
2400 CU_ASSERT(binn_size(copy) > binn_size(obj));
2401 binn_free(copy);
2402
2403
2404 binn_free(list);
2405 binn_free(list2);
2406 binn_free(map);
2407 binn_free(obj);
2408
2409 puts("OK");
2410 }
2411
2412 /*************************************************************************************/
2413
test_binn2()2414 void test_binn2() {
2415 char *obj1ptr, *obj2ptr;
2416 int obj1size, obj2size;
2417
2418 test_virtual_types();
2419
2420 test_int_conversion();
2421 test_binn_int_conversion();
2422 test_value_conversion();
2423 test_value_copy();
2424
2425 init_udts();
2426
2427 obj1ptr = test_create_object_1(&obj1size);
2428 obj2ptr = test_create_object_2(&obj2size);
2429
2430 CU_ASSERT(obj1ptr != NULL);
2431 CU_ASSERT(obj2ptr != NULL);
2432
2433 printf("obj1size=%d obj2size=%d\n", obj1size, obj2size);
2434 CU_ASSERT(obj1size == obj2size);
2435
2436 test_binn_read(obj1ptr);
2437
2438 free(obj1ptr);
2439 free(obj2ptr);
2440
2441 test_binn_iter();
2442 }
2443
2444 /*************************************************************************************/
2445
main()2446 int main() {
2447 CU_pSuite pSuite = NULL;
2448 if (CUE_SUCCESS != CU_initialize_registry()) {
2449 return CU_get_error();
2450 }
2451 pSuite = CU_add_suite("jbl_test_binn2", init_suite, clean_suite);
2452 if (NULL == pSuite) {
2453 CU_cleanup_registry();
2454 return CU_get_error();
2455 }
2456 if (
2457 (NULL == CU_add_test(pSuite, "test_binn2", test_binn2))) {
2458 CU_cleanup_registry();
2459 return CU_get_error();
2460 }
2461 CU_basic_set_mode(CU_BRM_VERBOSE);
2462 CU_basic_run_tests();
2463 int ret = CU_get_error() || CU_get_number_of_failures();
2464 CU_cleanup_registry();
2465 return ret;
2466 }
2467