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