test/test_odr.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2013 Index Data
   3  * See the file LICENSE for details.
   4  */
   5 #if HAVE_CONFIG_H
   6 #include <config.h>
   7 #endif
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <yaz/oid_util.h>
  11 #include "test_odrcodec.h"
  12
  13 #include <yaz/test.h>
  14
  15 #define MYOID  "1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19"
  16
  17 void tst_MySequence1(ODR encode, ODR decode)
  18 {
  19     int ret;
  20     char *ber_buf;
  21     int ber_len;
  22     Yc_MySequence *s = (Yc_MySequence *) odr_malloc(encode, sizeof(*s));
  23     Yc_MySequence *t;
  24
  25     YAZ_CHECK(s);
  26     s->first = odr_intdup(encode, 12345);
  27     s->second = (Odr_oct *) odr_malloc(encode, sizeof(*s->second));
  28     s->second->buf = (unsigned char *) "hello";
  29     s->second->len = 5;
  30 #if OCT_SIZE
  31     s->second->size = 0;
  32 #endif
  33     s->third = odr_booldup(encode, 1);
  34     s->fourth = odr_nullval();
  35     s->fifth = odr_intdup(encode, YC_MySequence_enum1);
  36
  37     s->myoid = odr_getoidbystr(decode, MYOID);
  38
  39     ret = yc_MySequence(encode, &s, 0, 0);
  40     YAZ_CHECK(ret);
  41     if (!ret)
  42         return;
  43
  44     ber_buf = odr_getbuf(encode, &ber_len, 0);
  45
  46     odr_setbuf(decode, ber_buf, ber_len, 0);
  47
  48     ret = yc_MySequence(decode, &t, 0, 0);
  49     YAZ_CHECK(ret);
  50     if (!ret)
  51         return;
  52
  53     YAZ_CHECK(t);
  54
  55     YAZ_CHECK(t->first && *t->first == 12345);
  56
  57     YAZ_CHECK(t->second && t->second->buf && t->second->len == 5);
  58
  59     YAZ_CHECK(t->second && t->second->buf && t->second->len == 5 &&
  60               memcmp(t->second->buf, "hello", t->second->len) == 0);
  61
  62     YAZ_CHECK(t->third && *t->third == 1);
  63
  64     YAZ_CHECK(t->fourth);
  65
  66     YAZ_CHECK(t->fifth && *t->fifth == YC_MySequence_enum1);
  67
  68     YAZ_CHECK(t->myoid);
  69     if (t->myoid)
  70     {
  71         Odr_oid *myoid = odr_getoidbystr(decode, MYOID);
  72
  73         YAZ_CHECK(oid_oidcmp(myoid, t->myoid) == 0);
  74     }
  75 }
  76
  77 void tst_MySequence2(ODR encode, ODR decode)
  78 {
  79     int ret;
  80     Yc_MySequence *s = (Yc_MySequence *) odr_malloc(encode, sizeof(*s));
  81
  82     YAZ_CHECK(s);
  83     s->first = 0;  /* deliberately miss this .. */
  84     s->second = (Odr_oct *) odr_malloc(encode, sizeof(*s->second));
  85     s->second->buf = (unsigned char *) "hello";
  86     s->second->len = 5;
  87 #if OCT_SIZE
  88     s->second->size = 0;
  89 #endif
  90     s->third = odr_booldup(encode, 1);
  91     s->fourth = odr_nullval();
  92     s->fifth = odr_intdup(encode, YC_MySequence_enum1);
  93     s->myoid = odr_getoidbystr(encode, MYOID);
  94
  95     ret = yc_MySequence(encode, &s, 0, 0); /* should fail */
  96     YAZ_CHECK(!ret);
  97
  98     YAZ_CHECK(odr_geterror(encode) == OREQUIRED);
  99
 100     YAZ_CHECK(strcmp(odr_getelement(encode), "first") == 0);
 101     odr_reset(encode);
 102
 103     YAZ_CHECK(odr_geterror(encode) == ONONE);
 104
 105     YAZ_CHECK(strcmp(odr_getelement(encode), "") == 0);
 106 }
 107
 108 void tst_MySequence3(ODR encode, ODR decode)
 109 {
 110     char buf[40];
 111     int i;
 112     Yc_MySequence *t;
 113
 114     srand(123);
 115     for (i = 0; i < 1000; i++)
 116     {
 117         int j;
 118         for (j = 0; j < (int) sizeof(buf); j++)
 119             buf[j] = rand();
 120
 121         for (j = 1; j < (int) sizeof(buf); j++)
 122         {
 123             odr_setbuf(decode, buf, j, 0);
 124             yc_MySequence(decode, &t, 0, 0);
 125             odr_reset(decode);
 126         }
 127     }
 128 }
 129
 130 static void tst_berint32(ODR encode, ODR decode)
 131 {
 132     char *buf = 0;
 133     int len = 0;
 134     Odr_int val;
 135     Odr_int ret_val;
 136     int r;
 137
 138     val = 0;
 139     odr_reset(encode);
 140     r = ber_integer(encode, &val);
 141     YAZ_CHECK_EQ(r, 1);
 142     buf = odr_getbuf(encode, &len, 0);
 143     YAZ_CHECK(buf);
 144     YAZ_CHECK_EQ(len, 2);
 145     YAZ_CHECK_EQ(buf[0], 1);
 146     YAZ_CHECK_EQ(buf[1], 0);
 147
 148     odr_reset(decode);
 149     odr_setbuf(decode, buf, len, 0);
 150     ber_integer(decode, &ret_val);
 151     YAZ_CHECK_EQ(ret_val, 0);
 152
 153     val = 1;
 154     odr_reset(encode);
 155     r = ber_integer(encode, &val);
 156     YAZ_CHECK_EQ(r, 1);
 157     buf = odr_getbuf(encode, &len, 0);
 158     YAZ_CHECK(buf);
 159     YAZ_CHECK_EQ(len, 2);
 160     YAZ_CHECK_EQ(buf[0], 1);
 161     YAZ_CHECK_EQ(buf[1], 1);
 162
 163     odr_reset(decode);
 164     odr_setbuf(decode, buf, len, 0);
 165     ber_integer(decode, &ret_val);
 166     YAZ_CHECK_EQ(ret_val, 1);
 167
 168     val = -1;
 169     odr_reset(encode);
 170     r = ber_integer(encode, &val);
 171     YAZ_CHECK_EQ(r, 1);
 172     buf = odr_getbuf(encode, &len, 0);
 173     YAZ_CHECK(buf);
 174     YAZ_CHECK_EQ(len, 2);
 175     YAZ_CHECK_EQ(buf[0], 1);
 176     YAZ_CHECK_EQ((unsigned char) buf[1], 255);
 177
 178     odr_reset(decode);
 179     odr_setbuf(decode, buf, len, 0);
 180     ber_integer(decode, &ret_val);
 181     YAZ_CHECK_EQ(ret_val, -1);
 182
 183     val = 127;
 184     odr_reset(encode);
 185     r = ber_integer(encode, &val);
 186     YAZ_CHECK_EQ(r, 1);
 187     buf = odr_getbuf(encode, &len, 0);
 188     YAZ_CHECK(buf);
 189     YAZ_CHECK_EQ(len, 2);
 190     YAZ_CHECK_EQ(buf[0], 1);
 191     YAZ_CHECK_EQ(buf[1], 127);
 192
 193     odr_reset(decode);
 194     odr_setbuf(decode, buf, len, 0);
 195     ber_integer(decode, &ret_val);
 196     YAZ_CHECK_EQ(ret_val, 127);
 197
 198
 199     val = 128;
 200     odr_reset(encode);
 201     r = ber_integer(encode, &val);
 202     YAZ_CHECK_EQ(r, 1);
 203     buf = odr_getbuf(encode, &len, 0);
 204     YAZ_CHECK(buf);
 205     YAZ_CHECK_EQ(len, 3);
 206     YAZ_CHECK_EQ(buf[0], 2);
 207     YAZ_CHECK_EQ(buf[1], 0);
 208     YAZ_CHECK_EQ(((unsigned char *) buf)[2], 128);
 209
 210     odr_reset(decode);
 211     odr_setbuf(decode, buf, len, 0);
 212     ber_integer(decode, &ret_val);
 213     YAZ_CHECK_EQ(ret_val, 128);
 214
 215     val = 2147483647; /* 2^31-1 */
 216     odr_reset(encode);
 217     r = ber_integer(encode, &val);
 218     YAZ_CHECK_EQ(r, 1);
 219     buf = odr_getbuf(encode, &len, 0);
 220     YAZ_CHECK(buf);
 221     YAZ_CHECK_EQ(len, 5);
 222     YAZ_CHECK_EQ(buf[0], 4);
 223     YAZ_CHECK_EQ(buf[1], 127);
 224     YAZ_CHECK_EQ((unsigned char) buf[2], 255);
 225     YAZ_CHECK_EQ((unsigned char) buf[3], 255);
 226     YAZ_CHECK_EQ((unsigned char) buf[4], 255);
 227
 228     odr_reset(decode);
 229     odr_setbuf(decode, buf, len, 0);
 230     ber_integer(decode, &ret_val);
 231     YAZ_CHECK_EQ(ret_val, 2147483647);
 232
 233     val = -2147483647L -1; /* -2^31 */
 234     odr_reset(encode);
 235     r = ber_integer(encode, &val);
 236     YAZ_CHECK_EQ(r, 1);
 237     buf = odr_getbuf(encode, &len, 0);
 238     YAZ_CHECK(buf);
 239     YAZ_CHECK_EQ(len, 5);
 240     YAZ_CHECK_EQ(buf[0], 4);
 241     YAZ_CHECK_EQ((unsigned char) buf[1], 128);
 242     YAZ_CHECK_EQ(buf[2], 0);
 243     YAZ_CHECK_EQ(buf[3], 0);
 244     YAZ_CHECK_EQ(buf[4], 0);
 245
 246     odr_reset(decode);
 247     odr_setbuf(decode, buf, len, 0);
 248     ber_integer(decode, &ret_val);
 249     YAZ_CHECK_EQ(ret_val, (Odr_int) -2147483647L -1);
 250 }
 251
 252 static void tst_berint64(ODR encode, ODR decode)
 253 {
 254 #if NMEM_64
 255     char *buf = 0;
 256     int len = 0;
 257     Odr_int val;
 258     Odr_int ret_val;
 259     int r;
 260
 261     val = (Odr_int) 2 * 2147483648UL; /* 2^32 */
 262     odr_reset(encode);
 263     r = ber_integer(encode, &val);
 264     YAZ_CHECK_EQ(r, 1);
 265     buf = odr_getbuf(encode, &len, 0);
 266     YAZ_CHECK(buf);
 267     YAZ_CHECK_EQ(len, 6);
 268     YAZ_CHECK_EQ(buf[0], 5);
 269     YAZ_CHECK_EQ(buf[1], 1);
 270     YAZ_CHECK_EQ(buf[2], 0);
 271     YAZ_CHECK_EQ(buf[3], 0);
 272     YAZ_CHECK_EQ(buf[4], 0);
 273     YAZ_CHECK_EQ(buf[5], 0);
 274
 275     odr_reset(decode);
 276     odr_setbuf(decode, buf, len, 0);
 277     ber_integer(decode, &ret_val);
 278     YAZ_CHECK_EQ(ret_val, val);
 279
 280     val = (Odr_int) -2 * 2147483648UL; /* -2^32 */
 281     odr_reset(encode);
 282     r = ber_integer(encode, &val);
 283     YAZ_CHECK_EQ(r, 1);
 284     buf = odr_getbuf(encode, &len, 0);
 285     YAZ_CHECK(buf);
 286     YAZ_CHECK_EQ(len, 6);
 287     YAZ_CHECK_EQ(buf[0], 5);
 288     YAZ_CHECK_EQ((unsigned char) buf[1], 255);
 289     YAZ_CHECK_EQ(buf[2], 0);
 290     YAZ_CHECK_EQ(buf[3], 0);
 291     YAZ_CHECK_EQ(buf[4], 0);
 292     YAZ_CHECK_EQ(buf[5], 0);
 293
 294     odr_reset(decode);
 295     odr_setbuf(decode, buf, len, 0);
 296     ber_integer(decode, &ret_val);
 297     YAZ_CHECK_EQ(ret_val, val);
 298
 299     val = (Odr_int) 1000 * 1000000000L; /* 10^12 */
 300     odr_reset(encode);
 301     r = ber_integer(encode, &val);
 302     YAZ_CHECK_EQ(r, 1);
 303     buf = odr_getbuf(encode, &len, 0);
 304     YAZ_CHECK(buf);
 305     YAZ_CHECK_EQ(len, 7);
 306     YAZ_CHECK_EQ(buf[0], 6);
 307     YAZ_CHECK_EQ(buf[1], 0);
 308     YAZ_CHECK_EQ((unsigned char) buf[2], 232);
 309     YAZ_CHECK_EQ((unsigned char) buf[3], 212);
 310     YAZ_CHECK_EQ((unsigned char) buf[4], 165);
 311     YAZ_CHECK_EQ(buf[5], 16);
 312     YAZ_CHECK_EQ(buf[6], 0);
 313
 314     odr_reset(decode);
 315     odr_setbuf(decode, buf, len, 0);
 316     ber_integer(decode, &ret_val);
 317     YAZ_CHECK_EQ(ret_val, val);
 318 #endif
 319 }
 320
 321 static void tst(void)
 322 {
 323     ODR odr_encode = odr_createmem(ODR_ENCODE);
 324     ODR odr_decode = odr_createmem(ODR_DECODE);
 325
 326     YAZ_CHECK(odr_encode);
 327     YAZ_CHECK(odr_decode);
 328
 329     tst_MySequence1(odr_encode, odr_decode);
 330     tst_MySequence2(odr_encode, odr_decode);
 331     tst_MySequence3(odr_encode, odr_decode);
 332
 333     tst_berint32(odr_encode, odr_decode);
 334     tst_berint64(odr_encode, odr_decode);
 335
 336     odr_destroy(odr_encode);
 337     odr_destroy(odr_decode);
 338 }
 339
 340 /* example from documentation.. 'Using Odr' */
 341 void do_nothing_useful(Odr_int value)
 342 {
 343     ODR encode, decode;
 344     Odr_int *valp, *resvalp;
 345     char *bufferp;
 346     int len;
 347
 348     /* allocate streams */
 349     if (!(encode = odr_createmem(ODR_ENCODE)))
 350         return;
 351     if (!(decode = odr_createmem(ODR_DECODE)))
 352         return;
 353
 354     valp = &value;
 355     if (odr_integer(encode, &valp, 0, 0) == 0)
 356     {
 357         printf("encoding went bad\n");
 358         return;
 359     }
 360     bufferp = odr_getbuf(encode, &len, 0);
 361     printf("length of encoded data is %d\n", len);
 362
 363     /* now let's decode the thing again */
 364     odr_setbuf(decode, bufferp, len, 0);
 365     if (odr_integer(decode, &resvalp, 0, 0) == 0)
 366     {
 367         printf("decoding went bad\n");
 368         return;
 369     }
 370     /* ODR_INT_PRINTF format for printf (such as %d) */
 371     printf("the value is " ODR_INT_PRINTF "\n", *resvalp);
 372
 373     /* clean up */
 374     odr_destroy(encode);
 375     odr_destroy(decode);
 376 }
 377
 378 int main(int argc, char **argv)
 379 {
 380     YAZ_CHECK_INIT(argc, argv);
 381     tst();
 382     YAZ_CHECK_TERM;
 383 }
 384
 385 /*
 386  * Local variables:
 387  * c-basic-offset: 4
 388  * c-file-style: "Stroustrup"
 389  * indent-tabs-mode: nil
 390  * End:
 391  * vim: shiftwidth=4 tabstop=8 expandtab
 392  */
 393