← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/erl_interface/test/ei_decode_SUITE_data/ei_decode_test.c

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/erl_interface/test/ei_decode_SUITE_data/ei_decode_test.c
 
1
/*
 
2
 * %CopyrightBegin%
 
3
 *
 
4
 * Copyright Ericsson AB 2004-2010. All Rights Reserved.
 
5
 *
 
6
 * The contents of this file are subject to the Erlang Public License,
 
7
 * Version 1.1, (the "License"); you may not use this file except in
 
8
 * compliance with the License. You should have received a copy of the
 
9
 * Erlang Public License along with this software. If not, it can be
 
10
 * retrieved online at http://www.erlang.org/.
 
11
 *
 
12
 * Software distributed under the License is distributed on an "AS IS"
 
13
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 
14
 * the License for the specific language governing rights and limitations
 
15
 * under the License.
 
16
 *
 
17
 * %CopyrightEnd%
 
18
 */
 
19
 
 
20
#ifdef VXWORKS
 
21
#include "reclaim.h"
 
22
#endif
 
23
 
 
24
#include "ei_runner.h"
 
25
 
 
26
/*
 
27
 * Purpose: Tests the ei_format() function.
 
28
 * Author:  Kent
 
29
 */
 
30
 
 
31
#ifdef VXWORKS
 
32
#define MESSAGE_BACK(SIZE) \
 
33
    message("err = %d, size2 = %d, expected size = %d", \
 
34
             err, size1, SIZE); 
 
35
#else
 
36
#define MESSAGE_BACK(SIZE) \
 
37
    message("err = %d, size2 = %d, expected size = %d, long long val = %lld", \
 
38
             err, size1, SIZE, (EI_LONGLONG)p); 
 
39
#endif
 
40
 
 
41
#define EI_DECODE_2(FUNC,SIZE,TYPE,VAL) \
 
42
  { \
 
43
    TYPE p; \
 
44
    char *buf; \
 
45
    int size1 = 0; \
 
46
    int size2 = 0; \
 
47
    int err; \
 
48
    message("ei_" #FUNC " " #TYPE " should be " #VAL); \
 
49
    buf = read_packet(NULL); \
 
50
\
 
51
    err = ei_ ## FUNC(buf+1, &size1, NULL); \
 
52
    message("err = %d, size1 = %d, expected size = %d", \
 
53
             err, size1, SIZE); \
 
54
    if (err != 0) { \
 
55
      if (err != -1) { \
 
56
        fail("returned non zero but not -1 if NULL pointer"); \
 
57
      } else { \
 
58
        fail("returned non zero if NULL pointer"); \
 
59
      } \
 
60
      return; \
 
61
    } \
 
62
\
 
63
    err = ei_ ## FUNC(buf+1, &size2, &p); \
 
64
    MESSAGE_BACK(SIZE) \
 
65
    if (err != 0) { \
 
66
      if (err != -1) { \
 
67
        fail("returned non zero but not -1"); \
 
68
      } else { \
 
69
        fail("returned non zero"); \
 
70
      } \
 
71
      return; \
 
72
    } \
 
73
    if (p != (TYPE)VAL) { \
 
74
      fail("value is not correct"); \
 
75
      return; \
 
76
    } \
 
77
\
 
78
    if (size1 != size2) { \
 
79
      fail("size with and without pointer differs"); \
 
80
      return; \
 
81
    } \
 
82
\
 
83
    if (size1 != SIZE) { \
 
84
      fail("size of encoded data is incorrect"); \
 
85
      return; \
 
86
    } \
 
87
  } \
 
88
 
 
89
#define EI_DECODE_2_FAIL(FUNC,SIZE,TYPE,VAL) \
 
90
  { \
 
91
    TYPE p, saved_p; \
 
92
    char *buf; \
 
93
    int size1 = 0; \
 
94
    int size2 = 0; \
 
95
    int err; \
 
96
    message("ei_" #FUNC " " #TYPE " should fail"); \
 
97
    memset(&p,'\0',sizeof(p)); \
 
98
    saved_p = p; \
 
99
    buf = read_packet(NULL); \
 
100
\
 
101
    err = ei_ ## FUNC(buf+1, &size1, NULL); \
 
102
    message("err = %d, size1 = %d, expected size = %d", \
 
103
             err, size1, SIZE); \
 
104
    if (err != -1) { \
 
105
      fail("should return -1 if NULL pointer"); \
 
106
      return; \
 
107
    } \
 
108
\
 
109
    err = ei_ ## FUNC(buf+1, &size2, &p); \
 
110
    message("err = %d, size2 = %d, expected size = %d", \
 
111
             err, size1, SIZE); \
 
112
    if (err != -1) { \
 
113
      fail("should return -1"); \
 
114
      return; \
 
115
    } \
 
116
    if (p != saved_p) { \
 
117
      fail("p argument was modified"); \
 
118
      return; \
 
119
    } \
 
120
\
 
121
    if (size1 != 0) { \
 
122
      fail("size of encoded data should be 0 if NULL"); \
 
123
      return; \
 
124
    } \
 
125
\
 
126
    if (size2 != 0) { \
 
127
      fail("size of encoded data should be 0"); \
 
128
      return; \
 
129
    } \
 
130
  } \
 
131
 
 
132
#define EI_DECODE_STRING(FUNC,SIZE,VAL) \
 
133
  { \
 
134
    char p[1024]; \
 
135
    char *buf; \
 
136
    int size1 = 0; \
 
137
    int size2 = 0; \
 
138
    int err; \
 
139
    message("ei_" #FUNC " should be " #VAL); \
 
140
    buf = read_packet(NULL); \
 
141
\
 
142
    err = ei_ ## FUNC(buf+1, &size1, NULL); \
 
143
    message("err = %d, size = %d, expected size = %d\n",err,size1,SIZE); \
 
144
    if (err != 0) { \
 
145
      if (err != -1) { \
 
146
        fail("returned non zero but not -1 if NULL pointer"); \
 
147
      } else { \
 
148
        fail("returned non zero if NULL pointer"); \
 
149
      } \
 
150
      return; \
 
151
    } \
 
152
\
 
153
    err = ei_ ## FUNC(buf+1, &size2, p); \
 
154
    message("err = %d, size = %d, expected size = %d\n",err,size2,SIZE); \
 
155
    if (err != 0) { \
 
156
      if (err != -1) { \
 
157
        fail("returned non zero but not -1"); \
 
158
      } else { \
 
159
        fail("returned non zero"); \
 
160
      } \
 
161
      return; \
 
162
    } \
 
163
\
 
164
    if (strcmp(p,VAL) != 0) { \
 
165
      fail("value is not correct"); \
 
166
      return; \
 
167
    } \
 
168
\
 
169
    if (size1 != size2) { \
 
170
      fail("size with and without pointer differs"); \
 
171
      return; \
 
172
    } \
 
173
\
 
174
    if (size1 != SIZE) { \
 
175
      fail("size of encoded data is incorrect"); \
 
176
      return; \
 
177
    } \
 
178
  } \
 
179
 
 
180
#define EI_DECODE_BIN(FUNC,SIZE,VAL,LEN) \
 
181
  { \
 
182
    char p[1024]; \
 
183
    char *buf; \
 
184
    long len; \
 
185
    int size1 = 0; \
 
186
    int size2 = 0; \
 
187
    int err; \
 
188
    message("ei_" #FUNC " should be " #VAL); \
 
189
    buf = read_packet(NULL); \
 
190
    err = ei_ ## FUNC(buf+1, &size1, NULL, &len); \
 
191
    message("err = %d, size = %d, len = %d, expected size = %d, expected len = %d\n",\
 
192
            err,size1,len,SIZE,LEN); \
 
193
    if (err != 0) { \
 
194
      if (err != -1) { \
 
195
        fail("returned non zero but not -1 if NULL pointer"); \
 
196
      } else { \
 
197
        fail("returned non zero"); \
 
198
      } \
 
199
      return; \
 
200
    } \
 
201
\
 
202
    if (len != LEN) { \
 
203
      fail("size is not correct"); \
 
204
      return; \
 
205
    } \
 
206
\
 
207
    err = ei_ ## FUNC(buf+1, &size2, p, &len); \
 
208
    message("err = %d, size = %d, len = %d, expected size = %d, expected len = %d\n",\
 
209
            err,size2,len,SIZE,LEN); \
 
210
    if (err != 0) { \
 
211
      if (err != -1) { \
 
212
        fail("returned non zero but not -1 if NULL pointer"); \
 
213
      } else { \
 
214
        fail("returned non zero"); \
 
215
      } \
 
216
      return; \
 
217
    } \
 
218
\
 
219
    if (len != LEN) { \
 
220
      fail("size is not correct"); \
 
221
      return; \
 
222
    } \
 
223
\
 
224
    if (strncmp(p,VAL,LEN) != 0) { \
 
225
      fail("value is not correct"); \
 
226
      return; \
 
227
    } \
 
228
\
 
229
    if (size1 != size2) { \
 
230
      fail("size with and without pointer differs"); \
 
231
      return; \
 
232
    } \
 
233
\
 
234
    if (size1 != SIZE) { \
 
235
      fail("size of encoded data is incorrect"); \
 
236
      return; \
 
237
    } \
 
238
  } \
 
239
 
 
240
/* ******************************************************************** */
 
241
 
 
242
TESTCASE(test_ei_decode_long)
 
243
{
 
244
    EI_DECODE_2     (decode_long,  2, long, 0);
 
245
    EI_DECODE_2     (decode_long,  2, long, 255);
 
246
    EI_DECODE_2     (decode_long,  5, long, 256);
 
247
    EI_DECODE_2     (decode_long,  5, long, -1);
 
248
 
 
249
    /* Old 28 bit limits for INTEGER_EXT */
 
250
    EI_DECODE_2     (decode_long,  5, long,  0x07ffffff);
 
251
    EI_DECODE_2     (decode_long,  5, long, -0x08000000);
 
252
    EI_DECODE_2     (decode_long,  5, long,  0x08000000);  
 
253
    EI_DECODE_2     (decode_long,  5, long, -0x08000001);
 
254
 
 
255
    /* New 32 bit limits for INTEGER_EXT */
 
256
    EI_DECODE_2     (decode_long,  5, long,     0x7fffffff);
 
257
    EI_DECODE_2     (decode_long,  5, long, -ll(0x80000000)); /* Strange :-( */
 
258
    if (sizeof(long) > 4) {
 
259
        EI_DECODE_2(decode_long,  7, long,     0x80000000);
 
260
        EI_DECODE_2(decode_long,  7, long, -ll(0x80000001));
 
261
    }
 
262
    else {
 
263
        EI_DECODE_2_FAIL(decode_long,  7, long,     0x80000000);
 
264
        EI_DECODE_2_FAIL(decode_long,  7, long, -ll(0x80000001));       
 
265
    }
 
266
 
 
267
    EI_DECODE_2_FAIL(decode_long,  7, long,  0x80000000);
 
268
    EI_DECODE_2_FAIL(decode_long,  7, long,  0xffffffff);
 
269
 
 
270
    EI_DECODE_2_FAIL(decode_long,  9, long,  ll(0x7fffffffffff));
 
271
    EI_DECODE_2_FAIL(decode_long,  9, long, -ll(0x800000000000));
 
272
    EI_DECODE_2_FAIL(decode_long,  9, long,  ll(0xffffffffffff));
 
273
    EI_DECODE_2_FAIL(decode_long, 11, long,  ll(0x7fffffffffffffff));
 
274
    EI_DECODE_2_FAIL(decode_long, 11, long, -ll(0x8000000000000000));
 
275
    EI_DECODE_2_FAIL(decode_long, 11, long,  ll(0xffffffffffffffff));
 
276
 
 
277
    EI_DECODE_2_FAIL(decode_long,  1, long,  0); /* Illegal type sent */
 
278
 
 
279
    report(1);
 
280
}
 
281
 
 
282
/* ******************************************************************** */
 
283
 
 
284
TESTCASE(test_ei_decode_ulong)
 
285
{
 
286
    EI_DECODE_2     (decode_ulong,  2, unsigned long, 0);
 
287
    EI_DECODE_2     (decode_ulong,  2, unsigned long, 255);
 
288
    EI_DECODE_2     (decode_ulong,  5, unsigned long, 256);
 
289
    EI_DECODE_2_FAIL(decode_ulong,  5, unsigned long, -1);
 
290
 
 
291
    EI_DECODE_2     (decode_ulong,  5, unsigned long,  0x07ffffff);
 
292
    EI_DECODE_2_FAIL(decode_ulong,  5, unsigned long, -0x08000000);
 
293
    EI_DECODE_2     (decode_ulong,  5, unsigned long,  0x08000000);
 
294
    EI_DECODE_2_FAIL(decode_ulong,  5, unsigned long, -0x08000001);
 
295
 
 
296
    EI_DECODE_2     (decode_ulong,  5, unsigned long,     0x7fffffff);
 
297
    EI_DECODE_2_FAIL(decode_ulong,  5, unsigned long, -ll(0x80000000));
 
298
    EI_DECODE_2     (decode_ulong,  7, unsigned long,     0x80000000);
 
299
    EI_DECODE_2_FAIL(decode_ulong,  7, unsigned long, -ll(0x80000001));
 
300
 
 
301
    if (sizeof(long) > 4) {
 
302
      EI_DECODE_2     (decode_ulong,  11, unsigned long,  ll(0x8000000000000000));
 
303
      EI_DECODE_2     (decode_ulong,  11, unsigned long,  ll(0xffffffffffffffff));
 
304
    } else {
 
305
      EI_DECODE_2     (decode_ulong,  7, unsigned long,  0x80000000);
 
306
      EI_DECODE_2     (decode_ulong,  7, unsigned long,  0xffffffff);
 
307
    }
 
308
 
 
309
    EI_DECODE_2_FAIL(decode_ulong,  9, unsigned long,  ll(0x7fffffffffff));
 
310
    EI_DECODE_2_FAIL(decode_ulong,  9, unsigned long, -ll(0x800000000000));
 
311
    EI_DECODE_2_FAIL(decode_ulong,  9, unsigned long,  ll(0xffffffffffff));
 
312
    EI_DECODE_2_FAIL(decode_ulong, 11, unsigned long,  ll(0x7fffffffffffffff));
 
313
    EI_DECODE_2_FAIL(decode_ulong, 11, unsigned long, -ll(0x8000000000000000));
 
314
    EI_DECODE_2_FAIL(decode_ulong, 11, unsigned long,  ll(0xffffffffffffffff));
 
315
 
 
316
    EI_DECODE_2_FAIL(decode_ulong,  1, unsigned long,  0); /* Illegal type */
 
317
 
 
318
    report(1);
 
319
}
 
320
 
 
321
/* ******************************************************************** */
 
322
 
 
323
 
 
324
TESTCASE(test_ei_decode_longlong)
 
325
{
 
326
#ifndef VXWORKS
 
327
    EI_DECODE_2     (decode_longlong,  2, EI_LONGLONG, 0);
 
328
    EI_DECODE_2     (decode_longlong,  2, EI_LONGLONG, 255);
 
329
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG, 256);
 
330
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG, -1);
 
331
 
 
332
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG,  0x07ffffff);
 
333
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG, -0x08000000);
 
334
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG,  0x08000000);
 
335
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG, -0x08000001);
 
336
 
 
337
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG,  0x7fffffff);
 
338
    EI_DECODE_2     (decode_longlong,  5, EI_LONGLONG, -ll(0x80000000));
 
339
    EI_DECODE_2     (decode_longlong,  7, EI_LONGLONG,  0x80000000);
 
340
    EI_DECODE_2     (decode_longlong,  7, EI_LONGLONG, -ll(0x80000001));
 
341
 
 
342
    EI_DECODE_2     (decode_longlong,  7, EI_LONGLONG,  0xffffffff);
 
343
 
 
344
    EI_DECODE_2     (decode_longlong,  9, EI_LONGLONG,  ll(0x7fffffffffff));
 
345
    EI_DECODE_2     (decode_longlong,  9, EI_LONGLONG, -ll(0x800000000000));
 
346
    EI_DECODE_2     (decode_longlong,  9, EI_LONGLONG,  ll(0xffffffffffff));
 
347
    EI_DECODE_2     (decode_longlong, 11, EI_LONGLONG,  ll(0x7fffffffffffffff));
 
348
    EI_DECODE_2     (decode_longlong, 11, EI_LONGLONG, -ll(0x8000000000000000));
 
349
    EI_DECODE_2_FAIL(decode_longlong, 11, EI_LONGLONG,  ll(0xffffffffffffffff));
 
350
 
 
351
    EI_DECODE_2_FAIL(decode_longlong,  1, EI_LONGLONG,  0); /* Illegal type */
 
352
#endif
 
353
    report(1);
 
354
}
 
355
 
 
356
/* ******************************************************************** */
 
357
 
 
358
TESTCASE(test_ei_decode_ulonglong)
 
359
{
 
360
#ifndef VXWORKS
 
361
    EI_DECODE_2     (decode_ulonglong, 2, EI_ULONGLONG, 0);
 
362
    EI_DECODE_2     (decode_ulonglong, 2, EI_ULONGLONG, 255);
 
363
    EI_DECODE_2     (decode_ulonglong, 5, EI_ULONGLONG, 256);
 
364
    EI_DECODE_2_FAIL(decode_ulonglong, 5, EI_ULONGLONG, -1);
 
365
 
 
366
    EI_DECODE_2     (decode_ulonglong, 5, EI_ULONGLONG,  0x07ffffff);
 
367
    EI_DECODE_2_FAIL(decode_ulonglong, 5, EI_ULONGLONG, -0x08000000);
 
368
    EI_DECODE_2     (decode_ulonglong, 5, EI_ULONGLONG,  0x08000000);
 
369
    EI_DECODE_2_FAIL(decode_ulonglong, 5, EI_ULONGLONG, -0x08000001);
 
370
 
 
371
    EI_DECODE_2     (decode_ulonglong, 5, EI_ULONGLONG,  0x7fffffff);
 
372
    EI_DECODE_2_FAIL(decode_ulonglong, 5, EI_ULONGLONG, -ll(0x80000000));
 
373
    EI_DECODE_2     (decode_ulonglong, 7, EI_ULONGLONG,  0x80000000);
 
374
    EI_DECODE_2_FAIL(decode_ulonglong, 7, EI_ULONGLONG, -0x80000001);
 
375
 
 
376
    EI_DECODE_2     (decode_ulonglong, 7, EI_ULONGLONG,  0xffffffff);
 
377
 
 
378
    EI_DECODE_2     (decode_ulonglong, 9, EI_ULONGLONG,  ll(0x7fffffffffff));
 
379
    EI_DECODE_2_FAIL(decode_ulonglong, 9, EI_ULONGLONG, -ll(0x800000000000));
 
380
    EI_DECODE_2     (decode_ulonglong, 9, EI_ULONGLONG,  ll(0xffffffffffff));
 
381
    EI_DECODE_2     (decode_ulonglong,11, EI_ULONGLONG,  ll(0x7fffffffffffffff));
 
382
    EI_DECODE_2_FAIL(decode_ulonglong,11, EI_ULONGLONG, -ll(0x8000000000000000));
 
383
    EI_DECODE_2     (decode_ulonglong,11, EI_ULONGLONG,  ll(0xffffffffffffffff));
 
384
 
 
385
    EI_DECODE_2_FAIL(decode_ulonglong, 1, EI_ULONGLONG, 0); /* Illegal type */
 
386
#endif
 
387
    report(1);
 
388
}
 
389
 
 
390
 
 
391
/* ******************************************************************** */
 
392
 
 
393
TESTCASE(test_ei_decode_char)
 
394
{
 
395
    EI_DECODE_2(decode_char, 2, char, 0);
 
396
    EI_DECODE_2(decode_char, 2, char, 0x7f);
 
397
    EI_DECODE_2(decode_char, 2, char, 0xff);
 
398
 
 
399
    EI_DECODE_2_FAIL(decode_char, 1, char, 0); /* Illegal type */
 
400
 
 
401
    report(1);
 
402
}
 
403
 
 
404
/* ******************************************************************** */
 
405
 
 
406
TESTCASE(test_ei_decode_nonoptimal)
 
407
{
 
408
    EI_DECODE_2(decode_char,  2, char, 42);
 
409
    EI_DECODE_2(decode_char,  5, char, 42);
 
410
    EI_DECODE_2(decode_char,  4, char, 42);
 
411
    EI_DECODE_2(decode_char,  5, char, 42);
 
412
    EI_DECODE_2(decode_char,  7, char, 42);
 
413
    EI_DECODE_2(decode_char,  7, char, 42);
 
414
    EI_DECODE_2(decode_char,  8, char, 42);
 
415
    EI_DECODE_2(decode_char,  9, char, 42);
 
416
    EI_DECODE_2(decode_char, 12, char, 42);
 
417
 
 
418
/*  EI_DECODE_2(decode_char, char, -42); */
 
419
/*  EI_DECODE_2(decode_char, char, -42); */
 
420
/*  EI_DECODE_2(decode_char, char, -42); */
 
421
/*  EI_DECODE_2(decode_char, char, -42); */
 
422
/*  EI_DECODE_2(decode_char, char, -42); */
 
423
/*  EI_DECODE_2(decode_char, char, -42); */
 
424
/*  EI_DECODE_2(decode_char, char, -42); */
 
425
/*  EI_DECODE_2(decode_char, char, -42); */
 
426
/*  EI_DECODE_2(decode_char, char, -42); */
 
427
 
 
428
    /* ---------------------------------------------------------------- */
 
429
 
 
430
    EI_DECODE_2(decode_long,  2, long, 42);
 
431
    EI_DECODE_2(decode_long,  5, long, 42);
 
432
    EI_DECODE_2(decode_long,  4, long, 42);
 
433
    EI_DECODE_2(decode_long,  5, long, 42);
 
434
    EI_DECODE_2(decode_long,  7, long, 42);
 
435
    EI_DECODE_2(decode_long,  7, long, 42);
 
436
    EI_DECODE_2(decode_long,  8, long, 42);
 
437
    EI_DECODE_2(decode_long,  9, long, 42);
 
438
    EI_DECODE_2(decode_long, 12, long, 42);
 
439
 
 
440
/*  EI_DECODE_2(decode_long,  2, long, -42); */
 
441
    EI_DECODE_2(decode_long,  5, long, -42);
 
442
    EI_DECODE_2(decode_long,  4, long, -42);
 
443
    EI_DECODE_2(decode_long,  5, long, -42);
 
444
    EI_DECODE_2(decode_long,  7, long, -42);
 
445
    EI_DECODE_2(decode_long,  7, long, -42);
 
446
    EI_DECODE_2(decode_long,  8, long, -42);
 
447
    EI_DECODE_2(decode_long,  9, long, -42);
 
448
    EI_DECODE_2(decode_long, 12, long, -42);
 
449
 
 
450
    /* ---------------------------------------------------------------- */
 
451
 
 
452
    EI_DECODE_2(decode_ulong,  2, unsigned long, 42);
 
453
    EI_DECODE_2(decode_ulong,  5, unsigned long, 42);
 
454
    EI_DECODE_2(decode_ulong,  4, unsigned long, 42);
 
455
    EI_DECODE_2(decode_ulong,  5, unsigned long, 42);
 
456
    EI_DECODE_2(decode_ulong,  7, unsigned long, 42);
 
457
    EI_DECODE_2(decode_ulong,  7, unsigned long, 42);
 
458
    EI_DECODE_2(decode_ulong,  8, unsigned long, 42);
 
459
    EI_DECODE_2(decode_ulong,  9, unsigned long, 42);
 
460
    EI_DECODE_2(decode_ulong, 12, unsigned long, 42);
 
461
 
 
462
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
463
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
464
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
465
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
466
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
467
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
468
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
469
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
470
/*  EI_DECODE_2(decode_ulong, unsigned long, -42); */
 
471
 
 
472
    /* ---------------------------------------------------------------- */
 
473
 
 
474
#ifndef VXWORKS
 
475
 
 
476
    EI_DECODE_2(decode_longlong,  2, EI_LONGLONG, 42);
 
477
    EI_DECODE_2(decode_longlong,  5, EI_LONGLONG, 42);
 
478
    EI_DECODE_2(decode_longlong,  4, EI_LONGLONG, 42);
 
479
    EI_DECODE_2(decode_longlong,  5, EI_LONGLONG, 42);
 
480
    EI_DECODE_2(decode_longlong,  7, EI_LONGLONG, 42);
 
481
    EI_DECODE_2(decode_longlong,  7, EI_LONGLONG, 42);
 
482
    EI_DECODE_2(decode_longlong,  8, EI_LONGLONG, 42);
 
483
    EI_DECODE_2(decode_longlong,  9, EI_LONGLONG, 42);
 
484
    EI_DECODE_2(decode_longlong, 12, EI_LONGLONG, 42);
 
485
 
 
486
/*  EI_DECODE_2(decode_longlong,  2, EI_LONGLONG, -42); */
 
487
    EI_DECODE_2(decode_longlong,  5, EI_LONGLONG, -42);
 
488
    EI_DECODE_2(decode_longlong,  4, EI_LONGLONG, -42);
 
489
    EI_DECODE_2(decode_longlong,  5, EI_LONGLONG, -42);
 
490
    EI_DECODE_2(decode_longlong,  7, EI_LONGLONG, -42);
 
491
    EI_DECODE_2(decode_longlong,  7, EI_LONGLONG, -42);
 
492
    EI_DECODE_2(decode_longlong,  8, EI_LONGLONG, -42);
 
493
    EI_DECODE_2(decode_longlong,  9, EI_LONGLONG, -42);
 
494
    EI_DECODE_2(decode_longlong, 12, EI_LONGLONG, -42);
 
495
 
 
496
    /* ---------------------------------------------------------------- */
 
497
 
 
498
    EI_DECODE_2(decode_ulonglong,  2, EI_ULONGLONG, 42);
 
499
    EI_DECODE_2(decode_ulonglong,  5, EI_ULONGLONG, 42);
 
500
    EI_DECODE_2(decode_ulonglong,  4, EI_ULONGLONG, 42);
 
501
    EI_DECODE_2(decode_ulonglong,  5, EI_ULONGLONG, 42);
 
502
    EI_DECODE_2(decode_ulonglong,  7, EI_ULONGLONG, 42);
 
503
    EI_DECODE_2(decode_ulonglong,  7, EI_ULONGLONG, 42);
 
504
    EI_DECODE_2(decode_ulonglong,  8, EI_ULONGLONG, 42);
 
505
    EI_DECODE_2(decode_ulonglong,  9, EI_ULONGLONG, 42);
 
506
    EI_DECODE_2(decode_ulonglong, 12, EI_ULONGLONG, 42);
 
507
 
 
508
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
509
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
510
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
511
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
512
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
513
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
514
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
515
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
516
/*  EI_DECODE_2(decode_ulonglong, EI_ULONGLONG, -42); */
 
517
 
 
518
#endif /* !VXWORKS */
 
519
 
 
520
    /* ---------------------------------------------------------------- */
 
521
 
 
522
    report(1);
 
523
}
 
524
 
 
525
/* ******************************************************************** */
 
526
 
 
527
TESTCASE(test_ei_decode_misc)
 
528
{
 
529
/*
 
530
    EI_DECODE_0(decode_version);
 
531
*/
 
532
    EI_DECODE_2(decode_double, 32, double, 0.0);
 
533
    EI_DECODE_2(decode_double, 32, double, -1.0);
 
534
    EI_DECODE_2(decode_double, 32, double, 1.0);
 
535
 
 
536
    EI_DECODE_2(decode_boolean, 8, int, 0);
 
537
    EI_DECODE_2(decode_boolean, 7, int, 1);
 
538
 
 
539
    EI_DECODE_STRING(decode_atom, 6, "foo");
 
540
    EI_DECODE_STRING(decode_atom, 3, "");
 
541
    EI_DECODE_STRING(decode_atom, 9, "������");
 
542
 
 
543
    EI_DECODE_STRING(decode_string, 6, "foo");
 
544
    EI_DECODE_STRING(decode_string, 1, "");
 
545
    EI_DECODE_STRING(decode_string, 9, "������");
 
546
 
 
547
    EI_DECODE_BIN(decode_binary,  8, "foo", 3);
 
548
    EI_DECODE_BIN(decode_binary,  5, "", 0);
 
549
    EI_DECODE_BIN(decode_binary, 11, "������", 6);
 
550
 
 
551
    /* FIXME check \0 in strings and atoms? */
 
552
/*
 
553
    EI_ENCODE_1(decode_tuple_header, 0);
 
554
 
 
555
    EI_ENCODE_0(decode_empty_list);
 
556
*/
 
557
    report(1);
 
558
}
 
559
 
 
560
/* ******************************************************************** */
 
561