test/tstodr.c

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