tests/tests-skeletons/check-INTEGER.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3
   4 #include <asn_application.h>
   5 #include <INTEGER.h>
   6
   7 #define CHECK_XER(a,b,c)        check_xer(__LINE__, a, b, c)
   8
   9 static char *shared_scratch_start;
  10
  11 static int _print2buf(const void *buf, size_t size, void *key) {
  12         (void)key;
  13         memcpy(shared_scratch_start, buf, size);
  14         shared_scratch_start += size;
  15         *shared_scratch_start = '\0';   /* 0-termination */
  16         return 0;
  17 }
  18
  19 static void
  20 check(uint8_t *buf, size_t size, long check_long, int check_ret) {
  21         char scratch[128];
  22         char verify[32];
  23         INTEGER_t val;
  24         uint8_t *buf_end = buf + size;
  25         int ret;
  26         long rlong = 123;
  27
  28         assert(buf);
  29         assert(size > 0);
  30
  31         val.buf = buf;
  32         val.size = size;
  33
  34         printf("Testing: [");
  35         for(; buf < buf_end; buf++) {
  36                 if(buf != val.buf) printf(":");
  37                 printf("%02x", *buf);
  38         }
  39         printf("]: ");
  40
  41         ret = asn_INTEGER2long(&val, &rlong);
  42         printf(" (%ld, %d) vs (%ld, %d)\n",
  43                 rlong, ret, check_long, check_ret);
  44         assert(ret == check_ret);
  45         printf("%ld %ld\n", rlong, check_long);
  46         assert(rlong == check_long);
  47
  48         if(check_ret == 0) {
  49                 INTEGER_t val2;
  50                 long rlong2;
  51                 val2.buf = 0;
  52                 val2.size = 0;
  53                 ret = asn_long2INTEGER(&val2, rlong);
  54                 assert(ret == 0);
  55                 assert(val2.buf);
  56                 assert(val2.size <= val.size);  /* At least as compact */
  57                 ret = asn_INTEGER2long(&val, &rlong2);
  58                 assert(ret == 0);
  59                 assert(rlong == rlong2);
  60                 ASN_STRUCT_RESET(asn_DEF_INTEGER, &val2);
  61         }
  62
  63         shared_scratch_start = scratch;
  64         ret = INTEGER_print(&asn_DEF_INTEGER, &val, 0, _print2buf, scratch);
  65         assert(shared_scratch_start < scratch + sizeof(scratch));
  66         assert(ret == 0);
  67         ret = snprintf(verify, sizeof(verify), "%ld", check_long);
  68         assert(ret < 0 || (size_t)ret < sizeof(verify));
  69         ret = strcmp(scratch, verify);
  70         printf("         [%s] vs [%s]: %d%s\n",
  71                 scratch, verify, ret,
  72                 (check_ret == -1)?" (expected to fail)":""
  73                 );
  74         if(check_ret == -1) {
  75                 assert(strcmp(scratch, verify));
  76         } else {
  77                 assert(strcmp(scratch, verify) == 0);
  78         }
  79 }
  80
  81 static void
  82 check_unsigned(uint8_t *buf, int size, unsigned long check_long, int check_ret) {
  83         char scratch[128];
  84         char verify[32];
  85         INTEGER_t val;
  86         uint8_t *buf_end = buf + size;
  87         int ret;
  88         unsigned long rlong = 123;
  89
  90         assert(buf);
  91         assert(size >= 0);
  92
  93         val.buf = buf;
  94         val.size = size;
  95
  96         printf("Testing: [");
  97         for(; buf < buf_end; buf++) {
  98                 if(buf != val.buf) printf(":");
  99                 printf("%02x", *buf);
 100         }
 101         printf("]: ");
 102
 103         ret = asn_INTEGER2ulong(&val, &rlong);
 104         printf(" (%lu, %d) vs (%lu, %d)\n",
 105                 rlong, ret, check_long, check_ret);
 106         assert(ret == check_ret);
 107         assert(rlong == check_long);
 108
 109         if(check_ret == 0) {
 110                 INTEGER_t val2;
 111                 unsigned long rlong2;
 112                 val2.buf = 0;
 113                 val2.size = 0;
 114                 ret = asn_ulong2INTEGER(&val2, rlong);
 115                 assert(ret == 0);
 116                 assert(val2.buf);
 117                 if(val2.size > val.size) {
 118                         /* At least as compact */
 119                         printf("val2.size=%d, val.size=%d\n",
 120                                 (int)val2.size, (int)val.size);
 121                         assert(val2.size <= val.size);
 122                 }
 123                 ret = asn_INTEGER2ulong(&val, &rlong2);
 124                 assert(ret == 0);
 125                 assert(rlong == rlong2);
 126                 ASN_STRUCT_RESET(asn_DEF_INTEGER, &val2);
 127         }
 128
 129         return;
 130
 131         shared_scratch_start = scratch;
 132         ret = INTEGER_print(&asn_DEF_INTEGER, &val, 0, _print2buf, scratch);
 133         assert(shared_scratch_start < scratch + sizeof(scratch));
 134         assert(ret == 0);
 135         ret = snprintf(verify, sizeof(verify), "%lu", check_long);
 136         assert(ret < (int)sizeof(verify));
 137         ret = strcmp(scratch, verify);
 138         printf("         [%s] vs [%s]: %d%s\n",
 139                 scratch, verify, ret,
 140                 (check_ret == -1)?" (expected to fail)":""
 141                 );
 142         if(check_ret == -1) {
 143                 assert(strcmp(scratch, verify));
 144         } else {
 145                 assert(strcmp(scratch, verify) == 0);
 146         }
 147 }
 148
 149 static void
 150 check_xer(int lineno, int tofail, char *xmldata, long orig_value) {
 151         INTEGER_t *st = 0;
 152         asn_dec_rval_t rc;
 153         long value;
 154         int ret;
 155
 156         printf("%03d: [%s] vs %ld: ", lineno, xmldata, orig_value);
 157
 158         rc = xer_decode(0, &asn_DEF_INTEGER, (void *)&st,
 159                 xmldata, strlen(xmldata));
 160         if(rc.code != RC_OK) {
 161                 assert(tofail);
 162                 printf("\tfailed, as expected\n");
 163                 ASN_STRUCT_FREE(asn_DEF_INTEGER, st);
 164                 return;
 165         }
 166         if(tofail) {
 167                 printf("\tnot failed, as expected!\n");
 168                 assert(!tofail);
 169         }
 170
 171         ret = asn_INTEGER2long(st, &value);
 172         assert(ret == 0);
 173
 174         printf("\t%ld\n", value);
 175
 176         assert(value == orig_value);
 177
 178         ASN_STRUCT_FREE(asn_DEF_INTEGER, st);
 179 }
 180
 181 int
 182 main() {
 183         uint8_t buf1[] = { 1 };
 184         uint8_t buf2[] = { 0xff };
 185         uint8_t buf3[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 186         uint8_t buf4[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0 };
 187         uint8_t buf5[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 };
 188         uint8_t buf6[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
 189         uint8_t buf7[] = { 0xff, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
 190         uint8_t buf8[] = { 0x7f, 0x7e, 0x7d, 0x7c };
 191         uint8_t buf9[] = { 0, 0x7f, 0x7e, 0x7d, 0x7c };
 192         uint8_t buf10[] = { 0, 0, 0, 0, 0, 0, 0x7f, 0x7e, 0x7d, 0x7c };
 193         uint8_t buf11[] = { 0x80, 0, 0, 0 };
 194         uint8_t buf12[] = { 0x80, 0 };
 195         uint8_t buf13[] = { 0x80 };
 196         uint8_t buf14[] = { 0x00, 0x80, 0x00, 0x00 };
 197         uint8_t buf15[] = { 0x00, 0x80, 0x00, 0x00, 0x00 };
 198         uint8_t buf16[] = { 0x00, 0xff, 0xff, 0x00, 0x00 };
 199
 200 #define UCHECK(buf, val, ret)   check_unsigned(buf, sizeof(buf), val, ret)
 201
 202 #define CHECK(buf, val, ret)    check(buf, sizeof(buf), val, ret)
 203
 204         CHECK(buf1, 1, 0);
 205         CHECK(buf2, -1, 0);
 206         CHECK(buf3, -1, 0);
 207         CHECK(buf4, -16, 0);
 208         CHECK(buf5, 257, 0);
 209         CHECK(buf6, 123, -1);
 210         CHECK(buf7, 123, -1);
 211         CHECK(buf8, 0x7F7E7D7C, 0);
 212         CHECK(buf9, 0x7F7E7D7C, 0);
 213         CHECK(buf10, 0x7F7E7D7C, 0);
 214         UCHECK(buf10, 0x7F7E7D7C, 0);
 215         CHECK(buf11, -2147483647-1, 0); /* 0x80000000 */
 216         CHECK(buf12, -32768, 0);
 217         CHECK(buf13, -128, 0);
 218         UCHECK(buf14, 0x800000, 0);
 219         UCHECK(buf15, 0x80000000UL, 0);
 220         UCHECK(buf16, 0xffff0000UL, 0);
 221
 222         CHECK_XER(-1, "", 0);
 223         CHECK_XER(-1, "<INTEGER></INTEGER>", 0);
 224         CHECK_XER(-1, "<INTEGER> </INTEGER>", 0);
 225         CHECK_XER(-1, "<INTEGER>-</INTEGER>", 0);
 226         CHECK_XER(-1, "<INTEGER>+</INTEGER>", 0);
 227         CHECK_XER(-1, "<INTEGER>+-</INTEGER>", 0);
 228         CHECK_XER(-1, "<INTEGER> -</INTEGER>", 0);
 229         CHECK_XER(-1, "<INTEGER> +</INTEGER>", 0);
 230         CHECK_XER(-1, "<INTEGER> +-</INTEGER>", 0);
 231         CHECK_XER(-1, "<INTEGER>- </INTEGER>", 0);
 232         CHECK_XER(-1, "<INTEGER>+ </INTEGER>", 0);
 233         CHECK_XER(-1, "<INTEGER>+- </INTEGER>", 0);
 234         CHECK_XER(-1, "<INTEGER> - </INTEGER>", 0);
 235         CHECK_XER(-1, "<INTEGER> + </INTEGER>", 0);
 236         CHECK_XER(-1, "<INTEGER> +- </INTEGER>", 0);
 237         CHECK_XER(0, "<INTEGER>+0</INTEGER>", 0);
 238         CHECK_XER(0, "<INTEGER>-0</INTEGER>", 0);
 239         CHECK_XER(0, "<INTEGER>+1</INTEGER>", 1);
 240         CHECK_XER(0, "<INTEGER>-1</INTEGER>", -1);
 241         CHECK_XER(0, "<INTEGER>1</INTEGER>", 1);
 242         CHECK_XER(0, "<INTEGER>-15</INTEGER>", -15);
 243         CHECK_XER(0, "<INTEGER>+15</INTEGER>", 15);
 244         CHECK_XER(0, "<INTEGER>15</INTEGER>", 15);
 245         CHECK_XER(0, "<INTEGER> 15</INTEGER>", 15);
 246         CHECK_XER(0, "<INTEGER> 15 </INTEGER>", 15);
 247         CHECK_XER(0, "<INTEGER>15 </INTEGER>", 15);
 248         CHECK_XER(0, "<INTEGER> +15 </INTEGER>", 15);
 249         CHECK_XER(-1, "<INTEGER> +15 -</INTEGER>", 0);
 250         CHECK_XER(-1, "<INTEGER> +15 1</INTEGER>", 0);
 251         CHECK_XER(-1, "<INTEGER>+ 15</INTEGER>", 0);
 252         CHECK_XER(-1, "<INTEGER>12<z>34</INTEGER>", 0);
 253         CHECK_XER(-1, "<INTEGER>12 <z>34</INTEGER>", 0);
 254         CHECK_XER(-1, "<INTEGER>12 <z></INTEGER>", 0);
 255         CHECK_XER(0, "<INTEGER>1234</INTEGER>", 1234);
 256         CHECK_XER(-1, "<INTEGER>1234 5678</INTEGER>", 0);
 257         CHECK_XER(0, "<INTEGER>-2147483647</INTEGER>", -2147483647);
 258         CHECK_XER(0, "<INTEGER>-2147483648</INTEGER>", -2147483647-1);
 259         CHECK_XER(0, "<INTEGER>+2147483647</INTEGER>", 2147483647);
 260         CHECK_XER(0, "<INTEGER>2147483647</INTEGER>", 2147483647);
 261         if(sizeof(long) == 4) {
 262                 CHECK_XER( 0, "<INTEGER>-2147483648</INTEGER>", -2147483648);
 263                 CHECK_XER(-1, "<INTEGER>-2147483649</INTEGER>", 0);
 264                 CHECK_XER(-1, "<INTEGER>2147483648</INTEGER>", 0);
 265                 CHECK_XER(-1, "<INTEGER>2147483649</INTEGER>", 0);
 266                 CHECK_XER(-1, "<INTEGER>3147483649</INTEGER>", 0);
 267                 CHECK_XER(-1, "<INTEGER>4147483649</INTEGER>", 0);
 268                 CHECK_XER(-1, "<INTEGER>5147483649</INTEGER>", 0); /* special */
 269                 CHECK_XER(-1, "<INTEGER>9147483649</INTEGER>", 0);
 270                 CHECK_XER(-1, "<INTEGER>9999999999</INTEGER>", 0);
 271                 CHECK_XER(-1, "<INTEGER>-5147483649</INTEGER>", 0);/* special */
 272                 CHECK_XER(-1, "<INTEGER>-9147483649</INTEGER>", 0);
 273                 CHECK_XER(-1, "<INTEGER>-9999999999</INTEGER>", 0);
 274         }
 275 #ifdef  TEST_64BIT
 276         if(sizeof(long) == 8) {
 277                 CHECK_XER(0, "<INTEGER>2147483648</INTEGER>", 2147483648);
 278                 CHECK_XER(0, "<INTEGER>2147483649</INTEGER>", 2147483649);
 279                 CHECK_XER(0, "<INTEGER>3147483649</INTEGER>", 3147483649);
 280                 CHECK_XER(0, "<INTEGER>4147483649</INTEGER>", 4147483649);
 281                 CHECK_XER(0, "<INTEGER>5147483649</INTEGER>", 5147483649);
 282                 CHECK_XER(0, "<INTEGER>9147483649</INTEGER>", 9147483649);
 283                 CHECK_XER(0, "<INTEGER>9999999999</INTEGER>", 9999999999);
 284                 CHECK_XER(0, "<INTEGER>9223372036854775807</INTEGER>", 9223372036854775807);
 285                 CHECK_XER(-1, "<INTEGER>9223372036854775808</INTEGER>", 0);
 286                 CHECK_XER(-1, "<INTEGER>10223372036854775807</INTEGER>", 0);
 287                 CHECK_XER(-1, "<INTEGER>50223372036854775807</INTEGER>", 0);
 288                 CHECK_XER(-1, "<INTEGER>100223372036854775807</INTEGER>", 0);
 289                 CHECK_XER(-1, "<INTEGER>500223372036854775807</INTEGER>", 0);
 290                 CHECK_XER(0, "<INTEGER>-9223372036854775808</INTEGER>", -9223372036854775807-1);
 291                 CHECK_XER(-1, "<INTEGER>-9223372036854775809</INTEGER>", 0);
 292                 CHECK_XER(-1, "<INTEGER>-10223372036854775807</INTEGER>", 0);
 293                 CHECK_XER(-1, "<INTEGER>-50223372036854775807</INTEGER>", 0);
 294                 CHECK_XER(-1, "<INTEGER>-100223372036854775807</INTEGER>", 0);
 295                 CHECK_XER(-1, "<INTEGER>-500223372036854775807</INTEGER>", 0);
 296         } else {
 297                 assert(sizeof(long) == 8);
 298         }
 299 #endif
 300
 301         return 0;
 302 }