test/test_odr.c

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