No unsigned char's in public API (except for iconv)
[yaz-moved-to-github.git] / 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 = (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 = (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