1 /*
2 * %CopyrightBegin%
3 *
4 * Copyright Ericsson AB 2004-2016. All Rights Reserved.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * %CopyrightEnd%
19 */
20
21 #ifdef VXWORKS
22 #include "reclaim.h"
23 #endif
24
25 #include "ei_runner.h"
26
27 /*
28 * Purpose: Tests the ei_format() function.
29 * Author: Kent
30 */
31
32 #define EI_ENCODE_0(FUNC) \
33 { \
34 char buf[1024]; \
35 int size1 = 0; \
36 int size2 = 0; \
37 int err; \
38 message("ei_" #FUNC " encoded as "); \
39 err = ei_ ## FUNC(NULL, &size1); \
40 if (err != 0) { \
41 if (err != -1) { \
42 fail("size calculation returned non zero but not -1"); \
43 return; \
44 } else { \
45 fail("size calculation returned non zero"); \
46 return; \
47 } \
48 } \
49 err = ei_ ## FUNC(buf, &size2); \
50 if (err != 0) { \
51 if (err != -1) { \
52 fail("returned non zero but not -1"); \
53 } else { \
54 fail("returned non zero"); \
55 } \
56 return; \
57 } \
58 if (size1 != size2) { \
59 fail("size differs when arg is NULL or buf"); \
60 return; \
61 } \
62 if (size1 < 1) { \
63 fail("size is < 1"); \
64 return; \
65 } \
66 send_buffer(buf, size1); \
67 } \
68 { \
69 ei_x_buff arg; \
70 int err; \
71 message("ei_x_" #FUNC " encoded as "); \
72 ei_x_new(&arg); \
73 err = ei_x_ ## FUNC(&arg); \
74 if (err != 0) { \
75 if (err != -1) { \
76 fail("returned non zero but not -1"); \
77 } else { \
78 fail("returned non zero"); \
79 } \
80 ei_x_free(&arg); \
81 return; \
82 } \
83 if (arg.index < 1) { \
84 fail("size is < 1"); \
85 ei_x_free(&arg); \
86 return; \
87 } \
88 send_buffer(arg.buff, arg.index); \
89 ei_x_free(&arg); \
90 }
91
92 #define EI_ENCODE_1(FUNC,ARG) \
93 { \
94 char buf[1024]; \
95 int size1 = 0; \
96 int size2 = 0; \
97 int err; \
98 message("ei_" #FUNC " " #ARG " encoded as "); \
99 err = ei_ ## FUNC(NULL, &size1, ARG); \
100 if (err != 0) { \
101 if (err != -1) { \
102 fail("size calculation returned non zero but not -1"); \
103 return; \
104 } else { \
105 fail("size calculation returned non zero"); \
106 return; \
107 } \
108 } \
109 err = ei_ ## FUNC(buf, &size2, ARG); \
110 if (err != 0) { \
111 if (err != -1) { \
112 fail("returned non zero but not -1"); \
113 } else { \
114 fail("returned non zero"); \
115 } \
116 return; \
117 } \
118 if (size1 != size2) { \
119 fail("size differs when arg is NULL or buf"); \
120 return; \
121 } \
122 if (size1 < 1) { \
123 fail("size is < 1"); \
124 return; \
125 } \
126 send_buffer(buf, size1); \
127 } \
128 { \
129 ei_x_buff arg; \
130 int err; \
131 message("ei_x_" #FUNC " " #ARG " encoded as "); \
132 ei_x_new(&arg); \
133 err = ei_x_ ## FUNC(&arg, ARG); \
134 if (err != 0) { \
135 if (err != -1) { \
136 fail("returned non zero but not -1"); \
137 } else { \
138 fail("returned non zero"); \
139 } \
140 ei_x_free(&arg); \
141 return; \
142 } \
143 if (arg.index < 1) { \
144 fail("size is < 1"); \
145 ei_x_free(&arg); \
146 return; \
147 } \
148 send_buffer(arg.buff, arg.index); \
149 ei_x_free(&arg); \
150 }
151
152 #define EI_ENCODE_2(FUNC,ARG1,ARG2) \
153 { \
154 char buf[1024]; \
155 int size1 = 0; \
156 int size2 = 0; \
157 int err; \
158 message("ei_" #FUNC " " #ARG1 " " #ARG2 " encoded as "); \
159 err = ei_ ## FUNC(NULL, &size1, ARG1, ARG2); \
160 if (err != 0) { \
161 if (err != -1) { \
162 fail("size calculation returned non zero but not -1"); \
163 return; \
164 } else { \
165 fail("size calculation returned non zero"); \
166 return; \
167 } \
168 } \
169 err = ei_ ## FUNC(buf, &size2, ARG1, ARG2); \
170 if (err != 0) { \
171 if (err != -1) { \
172 fail("returned non zero but not -1"); \
173 } else { \
174 fail("returned non zero"); \
175 } \
176 return; \
177 } \
178 if (size1 != size2) { \
179 fail("size differs when arg is NULL or buf"); \
180 return; \
181 } \
182 if (size1 < 1) { \
183 fail("size is < 1"); \
184 return; \
185 } \
186 send_buffer(buf, size1); \
187 } \
188 { \
189 ei_x_buff arg; \
190 int err; \
191 message("ei_x_" #FUNC " " #ARG1 " " #ARG2 " encoded as "); \
192 ei_x_new(&arg); \
193 err = ei_x_ ## FUNC(&arg, ARG1, ARG2); \
194 if (err != 0) { \
195 if (err != -1) { \
196 fail("returned non zero but not -1"); \
197 } else { \
198 fail("returned non zero"); \
199 } \
200 ei_x_free(&arg); \
201 return; \
202 } \
203 if (arg.index < 1) { \
204 fail("size is < 1"); \
205 ei_x_free(&arg); \
206 return; \
207 } \
208 send_buffer(arg.buff, arg.index); \
209 ei_x_free(&arg); \
210 }
211
212 #define EI_ENCODE_3(FUNC,ARG1,ARG2,ARG3) \
213 { \
214 char buf[1024]; \
215 int size1 = 0; \
216 int size2 = 0; \
217 int err; \
218 message("ei_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " encoded as "); \
219 err = ei_ ## FUNC(NULL, &size1, ARG1, ARG2, ARG3); \
220 if (err != 0) { \
221 if (err != -1) { \
222 fail("size calculation returned non zero but not -1"); \
223 return; \
224 } else { \
225 fail("size calculation returned non zero"); \
226 return; \
227 } \
228 } \
229 err = ei_ ## FUNC(buf, &size2, ARG1, ARG2, ARG3); \
230 if (err != 0) { \
231 if (err != -1) { \
232 fail("returned non zero but not -1"); \
233 } else { \
234 fail("returned non zero"); \
235 } \
236 return; \
237 } \
238 if (size1 != size2) { \
239 fail("size differs when arg is NULL or buf"); \
240 return; \
241 } \
242 if (size1 < 1) { \
243 fail("size is < 1"); \
244 return; \
245 } \
246 send_buffer(buf, size1); \
247 } \
248 { \
249 ei_x_buff arg; \
250 int err; \
251 message("ei_x_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " encoded as "); \
252 ei_x_new(&arg); \
253 err = ei_x_ ## FUNC(&arg, ARG1, ARG2, ARG3); \
254 if (err != 0) { \
255 if (err != -1) { \
256 fail("returned non zero but not -1"); \
257 } else { \
258 fail("returned non zero"); \
259 } \
260 ei_x_free(&arg); \
261 return; \
262 } \
263 if (arg.index < 1) { \
264 fail("size is < 1"); \
265 ei_x_free(&arg); \
266 return; \
267 } \
268 send_buffer(arg.buff, arg.index); \
269 ei_x_free(&arg); \
270 }
271
272 #define EI_ENCODE_3_FAIL(FUNC,ARG1,ARG2,ARG3) \
273 { \
274 char buf[1024]; \
275 int size1 = 0; \
276 int size2 = 0; \
277 int err; \
278 message("ei_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " encoded as "); \
279 err = ei_ ## FUNC(NULL, &size1, ARG1, ARG2, ARG3); \
280 if (err != -1) { \
281 fail("size calculation returned non -1"); \
282 return; \
283 } \
284 err = ei_ ## FUNC(buf, &size2, ARG1, ARG2, ARG3); \
285 if (err != -1) { \
286 fail("returned non -1"); \
287 } \
288 if (size1 != size2) { \
289 fail("size differs when arg is NULL or buf"); \
290 return; \
291 } \
292 } \
293 { \
294 ei_x_buff arg; \
295 int err; \
296 message("ei_x_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " encoded as "); \
297 ei_x_new(&arg); \
298 err = ei_x_ ## FUNC(&arg, ARG1, ARG2, ARG3); \
299 if (err != -1) { \
300 fail("returned non -1"); \
301 ei_x_free(&arg); \
302 return; \
303 } \
304 ei_x_free(&arg); \
305 }
306
307 #define EI_ENCODE_4(FUNC,ARG1,ARG2,ARG3,ARG4) \
308 { \
309 char buf[1024]; \
310 int size1 = 0; \
311 int size2 = 0; \
312 int err; \
313 message("ei_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " " #ARG4 " encoded as "); \
314 err = ei_ ## FUNC(NULL, &size1, ARG1, ARG2, ARG3, ARG4); \
315 if (err != 0) { \
316 if (err != -1) { \
317 fail("size calculation returned non zero but not -1"); \
318 return; \
319 } else { \
320 fail("size calculation returned non zero"); \
321 return; \
322 } \
323 } \
324 err = ei_ ## FUNC(buf, &size2, ARG1, ARG2, ARG3, ARG4); \
325 if (err != 0) { \
326 if (err != -1) { \
327 fail("returned non zero but not -1"); \
328 } else { \
329 fail("returned non zero"); \
330 } \
331 return; \
332 } \
333 if (size1 != size2) { \
334 fail("size differs when arg is NULL or buf"); \
335 return; \
336 } \
337 if (size1 < 1) { \
338 fail("size is < 1"); \
339 return; \
340 } \
341 send_buffer(buf, size1); \
342 } \
343 { \
344 ei_x_buff arg; \
345 int err; \
346 message("ei_x_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " " #ARG4 " encoded as "); \
347 ei_x_new(&arg); \
348 err = ei_x_ ## FUNC(&arg, ARG1, ARG2, ARG3, ARG4); \
349 if (err != 0) { \
350 if (err != -1) { \
351 fail("returned non zero but not -1"); \
352 } else { \
353 fail("returned non zero"); \
354 } \
355 ei_x_free(&arg); \
356 return; \
357 } \
358 if (arg.index < 1) { \
359 fail("size is < 1"); \
360 ei_x_free(&arg); \
361 return; \
362 } \
363 send_buffer(arg.buff, arg.index); \
364 ei_x_free(&arg); \
365 }
366
367 #define EI_ENCODE_4_FAIL(FUNC,ARG1,ARG2,ARG3,ARG4) \
368 { \
369 char buf[1024]; \
370 int size1 = 0; \
371 int size2 = 0; \
372 int err; \
373 message("ei_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " " #ARG4 " encoded as "); \
374 err = ei_ ## FUNC(NULL, &size1, ARG1, ARG2, ARG3, ARG4); \
375 if (err != -1) { \
376 fail("size calculation returned non -1"); \
377 return; \
378 } \
379 err = ei_ ## FUNC(buf, &size2, ARG1, ARG2, ARG3, ARG4); \
380 if (err != -1) { \
381 fail("returned non -1"); \
382 } \
383 if (size1 != size2) { \
384 fail("size differs when arg is NULL or buf"); \
385 return; \
386 } \
387 } \
388 { \
389 ei_x_buff arg; \
390 int err; \
391 message("ei_x_" #FUNC " " #ARG1 " " #ARG2 " " #ARG3 " " #ARG4 " encoded as "); \
392 ei_x_new(&arg); \
393 err = ei_x_ ## FUNC(&arg, ARG1, ARG2, ARG3, ARG4); \
394 if (err != -1) { \
395 fail("returned non -1"); \
396 ei_x_free(&arg); \
397 return; \
398 } \
399 ei_x_free(&arg); \
400 }
401
402 /* ******************************************************************** */
403
TESTCASE(test_ei_encode_long)404 TESTCASE(test_ei_encode_long)
405 {
406 ei_init();
407
408 EI_ENCODE_1(encode_long, 0);
409
410 EI_ENCODE_1(encode_long, 255);
411
412 EI_ENCODE_1(encode_long, 256);
413
414 EI_ENCODE_1(encode_long, -1);
415
416 EI_ENCODE_1(encode_long, 0x07ffffff);
417
418 EI_ENCODE_1(encode_long, -ll(0x08000000));
419
420 EI_ENCODE_1(encode_long, 0x07ffffff+1);
421
422 EI_ENCODE_1(encode_long, -ll(0x08000000)-1);
423
424 EI_ENCODE_1(encode_long, 0x7fffffff);
425
426 EI_ENCODE_1(encode_long, -ll(0x80000000));
427
428 report(1);
429 }
430
431 /* ******************************************************************** */
432
TESTCASE(test_ei_encode_ulong)433 TESTCASE(test_ei_encode_ulong)
434 {
435 ei_init();
436
437 EI_ENCODE_1(encode_ulong, 0);
438
439 EI_ENCODE_1(encode_ulong, 255);
440
441 EI_ENCODE_1(encode_ulong, 256);
442
443 EI_ENCODE_1(encode_ulong, 0x07ffffff);
444
445 EI_ENCODE_1(encode_ulong, 0x07ffffff+1);
446
447 EI_ENCODE_1(encode_ulong, 0x7fffffff);
448
449 EI_ENCODE_1(encode_ulong, 0x80000000);
450
451 EI_ENCODE_1(encode_ulong, 0xffffffff);
452
453 report(1);
454 }
455
456 /* ******************************************************************** */
457
458
TESTCASE(test_ei_encode_longlong)459 TESTCASE(test_ei_encode_longlong)
460 {
461 ei_init();
462
463 #ifndef VXWORKS
464
465 EI_ENCODE_1(encode_longlong, 0);
466
467 EI_ENCODE_1(encode_longlong, 255);
468
469 EI_ENCODE_1(encode_longlong, 256);
470
471 EI_ENCODE_1(encode_longlong, -1);
472
473 EI_ENCODE_1(encode_longlong, 0x07ffffff);
474
475 EI_ENCODE_1(encode_longlong, -ll(0x08000000));
476
477 EI_ENCODE_1(encode_longlong, 0x07ffffff+1);
478
479 EI_ENCODE_1(encode_longlong, -ll(0x08000000)-1);
480
481 EI_ENCODE_1(encode_longlong, 0x7fffffff);
482
483 EI_ENCODE_1(encode_longlong, -ll(0x80000000));
484
485 EI_ENCODE_1(encode_longlong, ll(0x7fffffffffff));
486
487 EI_ENCODE_1(encode_longlong, -ll(0x800000000000));
488
489 EI_ENCODE_1(encode_longlong, ll(0x7fffffffffffffff));
490
491 EI_ENCODE_1(encode_longlong, -ll(0x8000000000000000));
492
493 #endif /* !VXWORKS */
494
495 report(1);
496 }
497
498 /* ******************************************************************** */
499
TESTCASE(test_ei_encode_ulonglong)500 TESTCASE(test_ei_encode_ulonglong)
501 {
502 ei_init();
503
504 #ifndef VXWORKS
505
506 EI_ENCODE_1(encode_ulonglong, 0);
507
508 EI_ENCODE_1(encode_ulonglong, 255);
509
510 EI_ENCODE_1(encode_ulonglong, 256);
511
512 EI_ENCODE_1(encode_ulonglong, 0x07ffffff);
513
514 EI_ENCODE_1(encode_ulonglong, 0x07ffffff+1);
515
516 EI_ENCODE_1(encode_ulonglong, 0x7fffffff);
517
518 EI_ENCODE_1(encode_ulonglong, 0x80000000);
519
520 EI_ENCODE_1(encode_ulonglong, 0xffffffff);
521
522 EI_ENCODE_1(encode_ulonglong, ll(0xffffffffffff));
523
524 EI_ENCODE_1(encode_ulonglong, ll(0xffffffffffffffff));
525
526 #endif /* !VXWORKS */
527
528 report(1);
529 }
530
531
532 /* ******************************************************************** */
533
TESTCASE(test_ei_encode_char)534 TESTCASE(test_ei_encode_char)
535 {
536 ei_init();
537
538 EI_ENCODE_1(encode_char, 0);
539
540 EI_ENCODE_1(encode_char, 0x7f);
541
542 EI_ENCODE_1(encode_char, 0xff);
543
544 report(1);
545 }
546
547 /* ******************************************************************** */
548
TESTCASE(test_ei_encode_misc)549 TESTCASE(test_ei_encode_misc)
550 {
551 ei_init();
552
553 EI_ENCODE_0(encode_version);
554
555 EI_ENCODE_1(encode_double, 0.0);
556
557 EI_ENCODE_1(encode_double, -1.0);
558
559 EI_ENCODE_1(encode_double, 1.0);
560
561 EI_ENCODE_1(encode_boolean, 0) /* Only case it should be false */;
562
563 EI_ENCODE_1(encode_boolean, 1);
564
565 EI_ENCODE_1(encode_boolean, 42);
566
567 EI_ENCODE_1(encode_boolean, -1);
568
569 EI_ENCODE_1(encode_atom, "foo");
570 EI_ENCODE_2(encode_atom_len, "foo", 3);
571
572 EI_ENCODE_1(encode_atom, "");
573 EI_ENCODE_2(encode_atom_len, "", 0);
574
575 EI_ENCODE_1(encode_atom, "������");
576 EI_ENCODE_2(encode_atom_len, "������", 6);
577
578 EI_ENCODE_1(encode_string, "foo");
579 EI_ENCODE_2(encode_string_len, "foo", 3);
580
581 EI_ENCODE_1(encode_string, "");
582 EI_ENCODE_2(encode_string_len, "", 0);
583
584 EI_ENCODE_1(encode_string, "������");
585 EI_ENCODE_2(encode_string_len, "������", 6);
586
587 EI_ENCODE_2(encode_binary, "foo", 3);
588 EI_ENCODE_2(encode_binary, "", 0);
589 EI_ENCODE_2(encode_binary, "������", 6);
590
591 /* FIXME check \0 in strings and atoms */
592
593 EI_ENCODE_1(encode_tuple_header, 0);
594
595 EI_ENCODE_0(encode_empty_list);
596
597 report(1);
598 }
599
600 /* ******************************************************************** */
601
TESTCASE(test_ei_encode_fails)602 TESTCASE(test_ei_encode_fails)
603 {
604 char buf[1024];
605 int index;
606
607 ei_init();
608
609 /* FIXME the ei_x versions are not tested */
610
611 index = 0;
612 if (ei_encode_atom(buf, &index, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") != 0) {
613 fail("could not encode atom with 255 chars");
614 }
615 message("Encoding atom with 255 chars, encoded %d",index);
616 if (index != 255+3) {
617 fail("encoded with incorrect size");
618 }
619 send_buffer(buf, index);
620
621 index = 0;
622 if (ei_encode_atom_len(buf, &index, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", 255) != 0) {
623 fail("could not encode atom with 255 chars");
624 }
625 message("Encoding atom with 255 chars, encoded %d",index);
626 if (index != 255+3) {
627 fail("encoded with incorrect size");
628 }
629 send_buffer(buf, index);
630
631 index = 0;
632 if (ei_encode_atom(buf, &index, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy") != 0) {
633 fail("could not encode atom with 256 chars, truncated to 255");
634 }
635 message("Encoding atom with 256 chars, encoded %d",index);
636 if (index != 255+3) {
637 fail("did not truncate at 255 chars");
638 }
639 send_buffer(buf, index);
640
641 index = 0;
642 if (ei_encode_atom_len(buf, &index, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy", 256) != 0) {
643 fail("could not encode atom with 256 chars, truncated to 255");
644 }
645 message("Encoding atom with 256 chars, encoded %d",index);
646 if (index != 255+3) {
647 fail("did not truncate at 255 chars");
648 }
649 send_buffer(buf, index);
650
651 /* ---------------------------------------------------------------------- */
652
653 index = 0;
654 if (ei_encode_tuple_header(buf, &index, 1) != 0) {
655 fail("could not create tuple header arity 1, take 1");
656 }
657 if (ei_encode_tuple_header(buf, &index, 1) != 0) {
658 fail("could not create tuple header arity 1, take 2");
659 }
660 if (ei_encode_tuple_header(buf, &index, 1) != 0) {
661 fail("could not create tuple header arity 1, take 3");
662 }
663 if (ei_encode_tuple_header(buf, &index, 0) != 0) {
664 fail("could not create tuple header arity 0");
665 }
666 send_buffer(buf, index);
667
668 report(1);
669 }
670
671 /* ******************************************************************** */
672
TESTCASE(test_ei_encode_utf8_atom)673 TESTCASE(test_ei_encode_utf8_atom)
674 {
675 ei_init();
676
677 EI_ENCODE_3(encode_atom_as, "�", ERLANG_LATIN1, ERLANG_UTF8);
678 EI_ENCODE_3(encode_atom_as, "�", ERLANG_LATIN1, ERLANG_LATIN1);
679 EI_ENCODE_3(encode_atom_as, "\303\205",
680 ERLANG_UTF8, ERLANG_LATIN1);
681 EI_ENCODE_3(encode_atom_as, "\303\205",
682 ERLANG_UTF8, ERLANG_UTF8);
683
684 EI_ENCODE_3(encode_atom_as, "A", ERLANG_ASCII, ERLANG_UTF8);
685 EI_ENCODE_3(encode_atom_as, "A", ERLANG_ASCII, ERLANG_LATIN1);
686
687 EI_ENCODE_3_FAIL(encode_atom_as, "�", ERLANG_UTF8, ERLANG_UTF8);
688 EI_ENCODE_3_FAIL(encode_atom_as, "�", ERLANG_UTF8, ERLANG_LATIN1);
689 EI_ENCODE_3_FAIL(encode_atom_as, "�", ERLANG_ASCII, ERLANG_UTF8);
690 EI_ENCODE_3_FAIL(encode_atom_as, "�", ERLANG_ASCII, ERLANG_LATIN1);
691
692 EI_ENCODE_3_FAIL(encode_atom_as, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy", ERLANG_ASCII, ERLANG_LATIN1);
693 EI_ENCODE_3_FAIL(encode_atom_as, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy", ERLANG_LATIN1, ERLANG_LATIN1);
694
695 EI_ENCODE_3_FAIL(encode_atom_as, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy", ERLANG_UTF8, ERLANG_LATIN1);
696
697 report(1);
698 }
699
TESTCASE(test_ei_encode_utf8_atom_len)700 TESTCASE(test_ei_encode_utf8_atom_len)
701 {
702 ei_init();
703
704 EI_ENCODE_4(encode_atom_len_as, "���", 1, ERLANG_LATIN1, ERLANG_UTF8);
705 EI_ENCODE_4(encode_atom_len_as, "���", 2, ERLANG_LATIN1, ERLANG_LATIN1);
706 EI_ENCODE_4(encode_atom_len_as, "\303\205\303\204\303\226", 2,
707 ERLANG_UTF8, ERLANG_LATIN1);
708 EI_ENCODE_4(encode_atom_len_as, "\303\205\303\204\303\226", 4,
709 ERLANG_UTF8, ERLANG_UTF8);
710
711 EI_ENCODE_4(encode_atom_len_as, "ABC", 1, ERLANG_ASCII, ERLANG_UTF8);
712 EI_ENCODE_4(encode_atom_len_as, "ABC", 2, ERLANG_ASCII, ERLANG_LATIN1);
713
714 EI_ENCODE_4_FAIL(encode_atom_len_as, "���", 1, ERLANG_UTF8, ERLANG_UTF8);
715 EI_ENCODE_4_FAIL(encode_atom_len_as, "���", 2, ERLANG_UTF8, ERLANG_LATIN1);
716 EI_ENCODE_4_FAIL(encode_atom_len_as, "���", 3, ERLANG_ASCII, ERLANG_UTF8);
717 EI_ENCODE_4_FAIL(encode_atom_len_as, "���", 4, ERLANG_ASCII, ERLANG_LATIN1);
718
719 EI_ENCODE_4(encode_atom_len_as, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy", 255, ERLANG_ASCII, ERLANG_LATIN1);
720
721 EI_ENCODE_4_FAIL(encode_atom_len_as, "\303\205\303\204\303\226", 1,
722 ERLANG_UTF8, ERLANG_LATIN1);
723
724 report(1);
725 }
726